dtk-client 0.10.2 → 0.10.3

data/lib/client/operation/module/install.rb

@@ -18,63 +18,105 @@
 module DTK::Client
   class Operation::Module
     class Install < self
-      require_relative('install/external_module')
+      require_relative('install/mixin')
+      # mixin must go first
+      require_relative('install/print_helper')
+      require_relative('install/module_ref')
+      require_relative('install/dependent_modules')
       require_relative('install/common_module')
 
+      def initialize(file_obj, module_ref, has_remote_repo)
+        @file_obj         = file_obj
+        @base_module_ref  = module_ref
+        @parsed_module    = file_obj.parse_content(:common_module_summary)
+        @has_remote_repo  = has_remote_repo
+        @print_helper     = PrintHelper.new(:module_ref => @base_module_ref, :source => has_remote_repo ? :remote : :local)
+      end
+      private :initialize
+
       def self.execute(args = Args.new)
         wrap_operation(args) do |args|
-          if args[:flag]
+          module_ref             = args.required(:module_ref) 
+          base_dsl_file_obj      = args.required(:base_dsl_file_obj)
+          has_directory_param    = args[:has_directory_param]
+          skip_prompt            = args[:skip_prompt]
+          has_remote_repo        = args[:has_remote_repo]
+
+          if has_directory_param
             file_obj = args.required(:base_dsl_file_obj).raise_error_if_no_content_flag(:module_ref)
           else
             file_obj = args.required(:base_dsl_file_obj).raise_error_if_no_content
           end
 
-          new(file_obj, args.required(:module_ref)).install(:skip_prompt => args[:skip_prompt])
+          new(file_obj, module_ref, has_remote_repo).install(:skip_prompt => skip_prompt)
         end
       end
-      
+
+      # opts can have keys:
+      #   :skip_prompt
       def install(opts = {})
         unless @base_module_ref
           raise Error::Usage, "No base module reference #{dsl_path_ref}"
         end
 
-        if module_exists?(@base_module_ref, { :type => :common_module })
-          raise Error::Usage, "Module #{@base_module_ref.print_form} exists already"
+        if module_version_exists?(@base_module_ref, { :type => :common_module })
+          raise Error::Usage, "Module '#{@base_module_ref.print_form}' exists already"
         end
 
         unless dependent_modules.empty?
-          OsUtil.print_info('Auto-importing dependencies')
-          ExternalModule.install_dependent_modules(dependent_modules, opts)
+          begin 
+            DependentModules.install(@base_module_ref, dependent_modules, :skip_prompt => opts[:skip_prompt])
+          rescue TerminateInstall
+            @print_helper.print_terminated_installation
+            return nil
+          end
         end
 
-        opts = {
-          :namespace   => @base_module_ref.namespace,
-          :version     => @base_module_ref.version
-        }
-        CommonModule.install(@base_module_ref, @file_obj)
-        OsUtil.print_info("Successfully imported '#{DTK::Common::PrettyPrintForm.module_ref(@base_module_ref.module_name, opts)}'")
+        @print_helper.print_continuation_installing_base_module
+        CommonModule.install(@base_module_ref, @file_obj, :has_remote_repo => @has_remote_repo)
+        @print_helper.print_done_message
         nil
       end
       
-      private
-
-      def initialize(file_obj, module_ref)      
-        @file_obj         = file_obj
-        @base_module_ref  = module_ref
-        @parsed_module    = file_obj.parse_content(:common_module_summary)
+      class TerminateInstall < ::Exception
       end
 
+      private
+
       def dependent_modules
         @dependent_modules ||= compute_dependent_modules
       end
 
       def compute_dependent_modules
-        (@parsed_module.val(:DependentModules) || []).map do |parsed_module_ref| 
-          namespace   = parsed_module_ref.req(:Namespace)
-          module_name = parsed_module_ref.req(:ModuleName)
-          version     = parsed_module_ref.val(:ModuleVersion)
-          ModuleRef.new(:namespace => namespace, :module_name => module_name, :version => version)
+        base_component_module_found = false 
+        ret = (@parsed_module.val(:DependentModules) || []).map do |parsed_module_ref| 
+          dep_module_name = parsed_module_ref.req(:ModuleName)
+          dep_namespace   = parsed_module_ref.req(:Namespace)
+          dep_version     = parsed_module_ref.val(:ModuleVersion)
+          if is_base_module = (dep_module_name == module_name)
+            # This is for legacy modules
+            base_component_module_found = true
+          end
+          ModuleRef.new(:namespace => dep_namespace, :module_name => dep_module_name, :version => dep_version, :is_base_module => is_base_module)
         end
+        unless base_component_module_found
+          if module_version_exists?(@base_module_ref, :type => :component_module)
+            ret << ModuleRef.new(:namespace => namespace, :module_name => module_name, :version => version, :is_base_module => true)
+          end
+        end
+        ret
+      end
+
+      def namespace  
+        @base_module_ref.namespace
+      end
+
+      def module_name 
+        @base_module_ref.module_name
+      end
+
+      def version  
+        @base_module_ref.version
       end
 
       def components
@@ -89,6 +131,7 @@ module DTK::Client
           "in the dsl file"
         end
       end
+
     end
   end
 end

data/lib/client/operation/module/install_from_catalog.rb

@@ -18,6 +18,16 @@
 module DTK::Client
   class Operation::Module
     class InstallFromCatalog < self
+      attr_reader :version, :module_ref, :target_repo_dir
+      def initialize(catalog, module_ref, directory_path, version)
+        @catalog          = catalog
+        @module_ref       = module_ref
+        @directory_path   = directory_path
+        @target_repo_dir  = ClientModuleDir.create_module_dir_from_path(directory_path || OsUtil.current_dir)
+        @version          = version # if nil wil be dynamically updated along with version attribute of @module_ref
+      end
+      private :initialize
+
       def self.execute(args = Args.new)
         wrap_operation(args) do |args|
           module_ref     = args.required(:module_ref)
@@ -25,55 +35,36 @@ module DTK::Client
           directory_path = args[:directory_path]
 
           # will create different classes for different catalog types when we add support for them
-          new('dtkn', module_ref, directory_path, version).install
+          new('dtkn', module_ref, directory_path, version).install_from_catalog
         end
       end
       
-      def install
-        if module_exists?(@module_ref, :type => :common_module)
-          raise Error::Usage, "Module #{@module_ref.print_form} exists already"
-        end
-
-        target_repo_dir = ClientModuleDir.create_module_dir_from_path(@directory_path || OsUtil.current_dir)
-
+      def install_from_catalog
         query_string_hash = QueryStringHash.new(
           :module_name => @module_ref.module_name,
           :namespace   => @module_ref.namespace,
           :rsa_pub_key => SSHUtil.rsa_pub_key_content,
           :version?    => @version
         )
-        module_info = rest_get "#{BaseRoute}/remote_module_info", query_string_hash
 
-        # unless version is explicitly provided, use latest version instead of master
+        remote_module_info = rest_get "#{BaseRoute}/remote_module_info", query_string_hash
+
         unless @version
-          @version = module_info.required(:latest_version)
+          @version = remote_module_info.required(:version)
+          @module_ref.version = @version
         end
 
-        git_repo_args = {
-          :repo_dir      => target_repo_dir,
-          :repo_url      => module_info.required(:remote_repo_url),
-          :remote_branch => (@version && !@version.eql?('master')) ? "v#{@version}" : 'master'
-        }
-        ClientModuleDir::GitRepo.create_add_remote_and_pull(git_repo_args)
-
-        module_content_hash = ContentGenerator.new(target_repo_dir, @module_ref, @version).generate_module_content
+        if module_version_exists?(@module_ref, :type => :common_module)
+          raise Error::Usage, "Module '#{@module_ref.print_form}' exists already"
+        end
 
-        # delete old files
-        Operation::ClientModuleDir.delete_directory_content(target_repo_dir)
+        create_repo_opts = { :repo_dir => @target_repo_dir, :commit_msg => "DTK client initialize" }
+        Operation::ClientModuleDir::GitRepo.create_repo_with_empty_commit(create_repo_opts)
+        LoadSource.fetch_transform_and_merge(remote_module_info, self)
 
-        # generate dtk.module.yaml file from parsed assemblies and module_refs
-        Operation::ClientModuleDir.create_file_with_content("#{target_repo_dir}/dtk.module.yaml", self.class.hash_to_yaml(module_content_hash))
-        {:target_repo_dir => target_repo_dir}
+        {:target_repo_dir => @target_repo_dir}
       end
-      
-      private
 
-      def initialize(catalog, module_ref, directory_path, version)
-        @catalog        = catalog
-        @module_ref     = module_ref
-        @directory_path = directory_path
-        @version        = version
-      end
     end
   end
 end

data/lib/client/operation/module/list.rb

@@ -22,7 +22,10 @@ module DTK::Client
         wrap_operation(args) do |_args|
           # defaults
           query_string_hash = QueryStringHash.new(
-            :detail_to_include => ['remotes', 'versions']
+            :detail_to_include => [
+              'remotes',
+              'versions'
+            ]
           )
           rest_get("#{BaseRoute}/list", query_string_hash)
         end.set_render_as_table!

data/lib/client/operation/module/publish.rb

@@ -0,0 +1,78 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client
+  class Operation::Module
+    class Publish < self
+      attr_reader :module_ref, :target_repo_dir, :version
+      def initialize(catalog, module_ref, directory_path)
+        @catalog         = catalog
+        @module_ref      = module_ref
+        @target_repo_dir = directory_path || module_ref.client_dir_path
+        @version         = module_ref.version
+      end
+      private :initialize
+
+      def self.execute(args = Args.new)
+        wrap_operation(args) do |args|
+          module_ref        = args.required(:module_ref)
+          directory_path    = args[:directory_path]
+          new('dtkn', module_ref, directory_path).publish
+        end
+      end
+      
+      def publish
+        unless module_version_exists?(module_ref, :type => :common_module)
+          raise Error::Usage, "Module #{module_ref.print_form} does not exist on server"
+        end
+
+        error_msg = "To allow publish to go through, invoke 'dtk push' to push the changes to server before invoking publish again"
+        GitRepo.modified_with_diff?(target_repo_dir, { :error_msg => error_msg })
+
+        post_body = PostBody.new(
+          :module_name => module_ref.module_name,
+          :namespace   => module_ref.namespace,
+          :version     => @version,
+          :rsa_pub_key => SSHUtil.rsa_pub_key_content
+        )
+
+        response = rest_post "#{BaseRoute}/publish_to_remote", post_body
+
+        query_string_hash = QueryStringHash.new(
+          :module_name => module_ref.module_name,
+          :namespace   => module_ref.namespace,
+          :rsa_pub_key => SSHUtil.rsa_pub_key_content,
+          :version?    => @version
+        )
+        remote_module_info = rest_get "#{BaseRoute}/remote_module_info", query_string_hash
+
+        unless @version
+          @version = remote_module_info.required(:version)
+          @module_ref.version = @version
+        end
+
+        # this is temporary until we implement push-dtkn from server instead of from client
+        # this part will fetch remote branches from repo manager after publish from server is finished
+        LoadSource.fetch_from_remote(remote_module_info, self)
+
+        nil
+      end
+    end
+  end
+end
+
+

data/lib/client/operation/module/pull_dtkn.rb

@@ -0,0 +1,76 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client
+  class Operation::Module
+    class PullDtkn < self
+      attr_reader :version, :module_ref, :target_repo_dir, :base_dsl_file_obj
+      def initialize(catalog, module_ref, directory_path, version, base_dsl_file_obj)
+        @catalog           = catalog
+        @module_ref        = module_ref
+        @directory_path    = directory_path
+        @target_repo_dir   = directory_path || base_dsl_file_obj.parent_dir
+        @version           = version # if nil wil be dynamically updated
+        @base_dsl_file_obj = base_dsl_file_obj
+      end
+      private :initialize
+
+      def self.execute(args = Args.new)
+        wrap_operation(args) do |args|
+          module_ref        = args.required(:module_ref)
+          version           = args[:version] || module_ref.version
+          base_dsl_file_obj = args[:base_dsl_file_obj]
+          directory_path    = args[:directory_path]
+          new('dtkn', module_ref, directory_path, version, base_dsl_file_obj).pull_dtkn
+        end
+      end
+      
+      def pull_dtkn
+        # TODO: DTK-2765: not sure if we need module to exist on server to do push-dtkn
+        unless module_version_exists?(@module_ref, :type => :common_module)
+          raise Error::Usage, "Module #{@module_ref.print_form} does not exist on server"
+        end
+
+        if ref_version = @version || module_ref.version
+          raise Error::Usage, "You are not allowed to pull module version '#{ref_version}'!" unless ref_version.eql?('master')
+        end
+
+        error_msg = "To allow pull-dtkn to go through, invoke 'dtk push' to push the changes to server before invoking pull-dtkn again"
+        GitRepo.modified_with_diff?(@target_repo_dir, { :error_msg => error_msg })
+
+        query_string_hash = QueryStringHash.new(
+          :module_name => @module_ref.module_name,
+          :namespace   => @module_ref.namespace,
+          :rsa_pub_key => SSHUtil.rsa_pub_key_content,
+          :version?    => @version
+        )
+        remote_module_info = rest_get "#{BaseRoute}/remote_module_info", query_string_hash
+
+        unless @version
+          @version = remote_module_info.required(:version)
+          @module_ref.version = @version
+        end
+
+        LoadSource.fetch_transform_and_merge(remote_module_info, self, :stage_and_commit_steps => true)
+        nil
+      end
+
+    end
+  end
+end
+
+

data/lib/client/operation/module/push.rb

@@ -26,7 +26,7 @@ module DTK::Client
             raise Error, "Not implemented yet; need to make sure module_ref.client_dir_path is set when client_dir_path given"
           end
 
-          unless module_info = module_exists?(module_ref, :type => :common_module)
+          unless module_info = module_version_exists?(module_ref, :type => :common_module)
             raise Error::Usage, "DTK module '#{module_ref.print_form}' does not exist."
           end
 
@@ -51,10 +51,24 @@ module DTK::Client
             :commit_sha  => git_repo_response.data(:head_sha)
           )
 
-          rest_post("#{BaseRoute}/update_from_repo", post_body)
+          response = rest_post("#{BaseRoute}/update_from_repo", post_body)
+          # TODO: DTK-2786; uncomment out to see what diffs is returning for different examples of what is deleted, added or modified before push
+          # pp [:debug_diffs, response.data(:diffs)]
+          process_semantic_diffs(response.data(:diffs))
+
+          # if diffs is nil then indicate no diffs, otherwise render diffs in yaml
+          OsUtil.print_info("No Diffs to be pushed.") if response.data(:diffs).nil?
           nil
         end
       end
+      
+      def self.process_semantic_diffs(diffs)
+        return if (diffs || {}).empty?
+        OsUtil.print_info("\nDiffs that were pushed:")
+
+        diffs.each { |v| diffs.delete(v[0]) if v[1].nil? }
+        OsUtil.print(hash_to_yaml(diffs).gsub("---\n", ""))
+      end
     end
   end
 end

data/lib/client/operation/module/push_dtkn/convert_source/component_info.rb

@@ -0,0 +1,42 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client
+  class Operation::Module::PushDtkn
+    class ConvertSource
+      class ComponentInfo < self
+        # attr_reader :parsed_common_module
+
+        def transform_info
+          transform_to_component_info
+        end
+        
+        private
+        
+        def self.info_type
+          :component_info
+        end
+        
+        def transform_to_component_info
+          info_processor.read_inputs_and_compute_outputs!
+          info_processor.file_path__content_array
+        end
+
+      end
+    end
+  end
+end

data/lib/client/operation/module/push_dtkn/convert_source/service_info.rb

@@ -0,0 +1,47 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client
+  class Operation::Module::PushDtkn
+    class ConvertSource
+      class ServiceInfo < self
+        def transform_info
+          transform_to_service_info
+        end
+
+        def legacy_assemblies?
+          info_processor.legacy_assemblies?
+        end
+        
+        private
+        
+        def self.info_type
+          :service_info
+        end
+        
+        def transform_to_service_info
+          info_processor.read_inputs_and_compute_outputs!
+          info_processor.file_path__content_array
+          # delete old files
+          # TODO: just delete the input files
+          # Operation::ClientModuleDir.delete_directory_content(target_repo_dir)
+        end
+        
+      end
+    end
+  end
+end

data/lib/client/operation/module/push_dtkn/convert_source.rb

@@ -0,0 +1,155 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client; class Operation::Module
+  class PushDtkn
+    class ConvertSource
+      require_relative('convert_source/service_info')
+      require_relative('convert_source/component_info')
+
+      def initialize(transform_helper, info_type, remote_repo_url, parent)
+        @info_processor   = transform_helper.info_processor(info_type)
+        @info_type        = info_type
+        @remote_repo_url  = remote_repo_url
+        @target_repo_dir  = parent.target_repo_dir
+        @version          = parent.version
+      end
+      private :initialize
+
+      def self.transform_and_commit(remote_module_info, parent)
+        target_repo_dir      = parent.target_repo_dir
+        parsed_common_module = parent.base_dsl_file_obj.parse_content(:common_module)
+        local_branch         = Operation::ClientModuleDir::GitRepo.current_branch(:path => target_repo_dir).data(:branch)
+
+        if service_info = remote_module_info.data(:service_info)
+          transform_service_info(target_repo_dir, parent, service_info, parsed_common_module, local_branch)
+        end
+
+        if component_info = remote_module_info.data(:component_info)
+          transform_component_info(target_repo_dir, parent, component_info, parsed_common_module, local_branch)
+        end
+      end
+
+      def self.transform_info(transform_helper, remote_repo_url, parent)
+        new(transform_helper, info_type, remote_repo_url, parent).transform_info
+      end
+
+      def self.transform_service_info(target_repo_dir, parent, service_info, parsed_common_module, local_branch = 'master')
+        transform_helper = ServiceAndComponentInfo::TransformTo.new(target_repo_dir, parent.module_ref, parent.version, parsed_common_module)
+        service_file_path__content_array = ServiceInfo.transform_info(transform_helper, service_info['remote_repo_url'], parent)
+
+        repo = checkout_branch__return_repo(target_repo_dir, "remotes/dtkn/master").data(:repo)
+        FileUtils.mkdir_p("#{target_repo_dir}/assemblies") unless File.exists?("#{target_repo_dir}/assemblies")
+
+        args = [transform_helper, ServiceInfo.info_type, service_info['remote_repo_url'], parent]
+        service_file_path__content_array.each { |file| Operation::ClientModuleDir.create_file_with_content("#{service_file_path(target_repo_dir, file, *args)}", file[:content]) }
+
+        commit_and_push_to_remote(repo, target_repo_dir, "master", "dtkn", local_branch)
+      end
+
+      def self.transform_component_info(target_repo_dir, parent, component_info, parsed_common_module, local_branch = 'master')
+        transform_helper = ServiceAndComponentInfo::TransformTo.new(target_repo_dir, parent.module_ref, parent.version, parsed_common_module)
+        component_file_path__content_array = ComponentInfo.transform_info(transform_helper, component_info['remote_repo_url'], parent)
+
+        repo = checkout_branch__return_repo(target_repo_dir, "remotes/dtkn-component-info/master").data(:repo)
+        component_file_path__content_array.each { |file| Operation::ClientModuleDir.create_file_with_content("#{file_path(target_repo_dir, file)}", file[:content]) }
+
+        commit_and_push_to_remote(repo, target_repo_dir, "master", "dtkn-component-info", local_branch)
+      end
+      
+      private
+
+      attr_reader :info_processor, :target_repo_dir, :parent
+
+      def self.write_output_path_text_pairs(transform_helper, target_repo_dir, info_types_processed)
+      end
+
+      def self.file_path(target_repo_dir, file)
+        file[:full_path] ? file[:path] : "#{target_repo_dir}/#{file[:path]}"
+      end
+
+      def self.service_file_path(target_repo_dir, file, *args)
+        @new_service_info  ||= ServiceInfo.new(*args)
+        @legacy_assemblies ||= @new_service_info.legacy_assemblies?
+
+        if @legacy_assemblies && !file[:path].include?('module_refs.yaml')
+          convert_to_legacy_assebmly(target_repo_dir, file)
+        else
+          file_path(target_repo_dir, file)
+        end
+      end
+
+      def self.convert_to_legacy_assebmly(target_repo_dir, file)
+        return file[:path] if file[:full_path]
+
+        file_path     = file[:path]
+        file_name     = file_path.split('/').last
+        assembly_name = file_name.split('.').first
+
+        "#{target_repo_dir}/assemblies/#{assembly_name}/assembly.yaml"
+      end
+
+      def self.checkout_branch__return_repo(target_repo_dir, branch)
+        git_repo_args = {
+          :repo_dir     => target_repo_dir,
+          :local_branch => branch
+        }
+        git_repo_operation.checkout_branch__return_repo(git_repo_args)
+      end
+
+      def self.commit_and_push_to_remote(repo, target_repo_dir, branch, remote, local_branch)
+        repo.stage_and_commit("Add auto-generated files from push-dtkn")
+        repo.push_from_cached_branch(remote, branch, { :force => true })
+        repo.checkout(local_branch)
+      end
+
+      def self.stage_and_commit(target_repo_dir, commit_msg = nil)
+        git_repo_args = {
+          :repo_dir          => target_repo_dir,
+          :commit_msg        => commit_msg,
+          :local_branch_type => :dtkn
+        }
+        git_repo_operation.stage_and_commit(git_repo_args)
+      end
+
+      def self.commit_msg(info_types_processed)
+        msg = "Added "
+        count = 0
+        types = info_types_processed #info
+        if types.include?(ServiceInfo.info_type)
+          msg << 'service '
+          count +=1
+        end
+        if types.include?(ComponentInfo.info_type)
+          msg << 'and ' if count > 0
+          msg << 'component'
+          count +=1
+        end
+        msg << 'info'
+        msg
+      end
+
+      def self.git_repo_operation
+        Operation::ClientModuleDir::GitRepo
+      end
+      def git_repo_operation
+        self.class.git_repo_operation
+      end
+
+    end
+  end
+end; end