lib/kite/module.rb in kite-1.0.10 vs lib/kite/module.rb in kite-1.1.1

@@ -1,34 +1,42 @@
 module Kite
   class Module < Base
     include Kite::Helpers
 
     method_option :env,     type: :string, desc: "Environment", required: true, default: ENV['KITE_ENV']
-    method_option :version, type: :string, desc: "Version", required: false
+    method_option :version, type: :string, desc: "Version", aliases: '-v', required: false
+    method_option :method,  type: :string, desc: "Module import method", enum: %w{copy submodule}, default: "submodule"
     desc 'init https://github.com/foo/bar-module', 'Initialize a kite module and render its vars.module.yml'
     def init(path)
-      @env     = options[:env]
-      @path    = path
-      @name    = path.gsub(/(.*:|.git)/, '').split('/').last
-      @cloud   = parse_cloud_config(@env)
-      @version = options[:version]
+      @env = options[:env]
+      @module_name = path.gsub(/(.*:|.git)/, '').split('/').last
+      @module_path = "modules/#{ @module_name }"
 
-      unless File.exist? path
-        @uri  = path
-        @path = "modules/#{@name}"
-
-        clone_module
-        unless @version.nil?
-          checkout_version
+      if File.exist?(@module_path)
+        overwrite = ask "#{ @module_path } already exists! Overwrite? (y/N)"
+        if overwrite.downcase == 'y'
+          say "Remove existing files"
+          remove_dir(@module_path)
+        else
+          say "Skipping module init"
+          return
         end
+      end
 
-        say "Use git submodule add #{@path} to be able to commit this module as a submodule", :yellow
+      case options[:method]
+      when"submodule"
+        clone_module(path, @module_path, options[:version])
+      when "copy"
+        FileUtils.mkdir_p("modules")
+        FileUtils.cp_r(path, @module_path)
+      else
+        raise "Unsupported method #{ method }"
       end
 
-      render_vars
-
-      say "Rendered successfully, please fill out config/environments/#{@env}/vars.#{@name}.yml with correct values", :green
+      @cloud = parse_cloud_config(@env)
+      vars_output = render_vars(@module_name, @module_path)
+      say "Rendered successfully #{ vars_output }, please edit this file with correct values", :green
     end
 
     method_option :env, type: :string, desc: "Environment", required: true, default: ENV['KITE_ENV']
     desc 'render PATH', 'Render kite module files using vars.*module*.yml'
     def render(path)
@@ -45,55 +53,40 @@
     no_commands do
       def kite_env
         @env
       end
 
-      def clone_module
+      def clone_module(uri, path, version)
         say "Cloning the module"
-
-        if File.exist? @path
-          overwrite = ask "#{@path} already contains a module! Overwrite? (y/N)"
-
-          if overwrite.downcase == 'y'
-            remove_dir @path
-            Git.clone(@uri, @path)
-            say "Successfully cloned the fresh #{@name}!", :green
-          else
-            say "Keeping the current module revision"
+        run! "git submodule add #{ uri } #{ path }"
+        run! "git submodule init"
+        run! "git submodule update"
+        unless version.to_s.empty?
+          Dir.chdir(path) do
+            run! "git checkout #{ version }"
           end
-        else
-          Git.clone(@uri, @path)
+          run! "git add #{ path }"
         end
+        say "Successfully init #{ path }!", :green
       end
 
-      def checkout_version
-        module_git = Git.open(@path)
-
-        say "Switching to #{@version}"
-        if @version =~ /\d+\.\d+\.\d+/ && module_git.tags.any? { |t| t.name == @version }
-          module_git.checkout("tags/#{@version}")
-        elsif module_git.is_remote_branch? @version
-          module_git.checkout("origin/#{@version}")
-        else
-          say "#{@version} tag/branch was not found in the module, keeping the current one", :red
-        end
+      def render_vars(module_name, module_path)
+        output_file = "config/environments/#{ @env }/vars.#{ module_name }.yml"
+        create_file output_file, YAML.dump(manifest(module_path)['variables'])
+        output_file
       end
 
-      def render_vars
-        create_file "config/environments/#{@env}/vars.#{@name}.yml", YAML.dump(manifest['variables'])
-      end
-
       def render_templates
         directory "#{@path}/templates", ".", mode: :preserve
         chmod     "bin", 0755
       end
 
       def load_vars
         YAML.load(File.open("config/environments/#{@env}/vars.#{@name}.yml"))
       end
 
-      def manifest
-        YAML.load(ERB.new(File.read("#{@path}/manifest.yml.tt")).result(binding))
+      def manifest(module_path)
+        YAML.load(ERB.new(File.read("#{module_path}/manifest.yml.tt")).result(binding))
       end
     end
 
   end
 end