dtk-common 0.5.15 → 0.5.16

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    N2I5MWQxMzAwMWI0MjdjNTEwNjc3NjhkYjU5OTliMTFiMjYxMjk2NQ==
+    ZmIxNGJmODM0YmY0NTRiMmFmZGQwM2I4OTg1Zjc0NTVjZTI2ZjI0ZA==
   data.tar.gz: !binary |-
-    M2ZhODkzZjNhOTI3ODk4MGE5M2FiMzJjMGYwMDIwYThlYTRlYmFiMg==
+    ZGM5OGZlMTNmNDU4MjQwOWZiYmFkMDc2ZDZkNWFhZDQ5ZTAxN2U3Mw==
 SHA512:
   metadata.gz: !binary |-
-    NDk3ZjRlMGExNTE2MWEyYTg5NDkzOGE3MzI5OTY3NDFlYjM3MDU2OTUxYmM2
-    ZmQ3OWZmZGEwMjFkOWY3Nzg3YzhlZDVmMzdhMDI4NWIwOWUzOGRhMjQ0NDYx
-    YzgyNmU2ZTJiZTY4ZDk5NGY0Y2YxYmQ0NmQxMTBkNTUxMDE1NDg=
+    YTZkNGUzNjk4NzBiMDg1YzVkYTMwMjE5MDAzMWUwMGRiNzQxMDg4MWUzYThj
+    ODAzZTM0OWJlYTQwZmQyMzVlMjEwNThhNzIzZWQxY2FmZmE1NGNmYmFiN2Mw
+    YWJkMWRjNjZlNTU2ZGJjY2U4YjYwMWQ2NDc3OTgwMTMwZmQ2NGE=
   data.tar.gz: !binary |-
-    MmJhZmE0YTk0M2JhOGE3OThmODI3NWUwNDA0Y2M2NGQ4MmUyMzg1OThjNDJm
-    MTlmNGY5ZWNlMzlmYTE4MTNmNzcwNDI5OGVjMzFlMjJhMmU5Yjk1YWZkZmU5
-    NmJhZTRhOWVlMzc5NDQxZGY5YjJjODY3NzhiZWU4ZmFiMTVhMWU=
+    OWZjZmQwMWVmZDZjZjU2MjA3NzBiM2Y0M2ZjZWJjODFhYjUxNzEyOGQyZjY2
+    N2Y5MzA2OTk1ZWQ3ZjBhM2IxYzJjZjA3OGY5ZDljYzg1M2M3ZjdlNGMxNTYy
+    ODk4NGJiMGM0MTFlY2Y5OWM2MjIyMjBjYWNjMjQ5M2UxNTkwMTc=

data/lib/dsl/directory_parser.rb

@@ -23,7 +23,7 @@ module DtkCommon
       #if file_type is given returns DtkCommon::DSL::FileParser::OutputArray
       #otherwise returns hash at top level taht is indexed by file types found
       def parse_directory(file_type=nil,opts={})
-        pruned_file_info = 
+        pruned_file_info =
           if file_type
             matches = @file_info.select{|r|r[:file_type] == file_type}
             if matches.empty?
@@ -45,10 +45,28 @@ module DtkCommon
         file_type.nil? ? ret : ret[file_type]
       end
 
+      def self.default_rel_path?(directory_type,file_type)
+        if match = file_info_single_match?(directory_type,file_type)
+          match[:default_rel_path]
+        end
+      end
      private
-      def file_info(directory_type)
+      def self.file_info_single_match?(directory_type,file_type)
+        matches = file_info(directory_type).select{|r|r[:file_type] == file_type}
+        if matches.empty? then nil
+        elsif matches.size == 1 then matches.first
+        else
+          raise Error.new("Unexpected to get multiple matches")
+        end
+      end
+      def self.file_info(directory_type)
         DirectoryTypeFiles[directory_type]
       end
+
+      def file_info(directory_type)
+        self.class.file_info(directory_type)
+      end
+
       def instantiate_rel_path_patterns(rel_file_info)
         ret = Array.new
         all_files_from_root = nil
@@ -56,24 +74,44 @@ module DtkCommon
           if rel_path = r[:rel_path]
             ret << r
           else
-            rel_path_pattern = r[:rel_path_pattern]
-            
-            (all_files_from_root ||= all_files_from_root()).each do |f|
-              if f =~ rel_path_pattern
-                file_key = $1
-                ret << {:rel_path => f, :file_type => r[:file_type], :key => file_key}
-              end
+            all_files_from_root ||= all_files_from_root()
+            ret += find_rel_path_matches(r,all_files_from_root)
+          end
+        end
+        ret
+      end
+
+      def find_rel_path_matches(r,all_files_from_root)
+        ret = Array.new
+        unless r[:rel_path_pattern]
+          return ret
+        end
+
+        rel_path_pattern = r[:rel_path_pattern]
+        rel_path_patterns = (rel_path_pattern.kind_of?(Array) ? rel_path_pattern : [rel_path_pattern])
+        rel_path_patterns.each do |pat|
+          all_files_from_root.each do |f|
+            if f =~ pat
+              file_key = $1
+              ret << {:rel_path => f, :file_type => r[:file_type], :key => file_key}
             end
           end
+          return ret unless ret.empty?
         end
         ret
       end
-      #TODO: may put version info here too
       DirectoryTypeFiles = {
-        :service_module => 
+        :service_module =>
         [
-         {:rel_path => "global_module_refs.json", :file_type => :component_module_refs},
-         {:rel_path_pattern => /^assemblies\/([^\/]+)\/assembly\.yaml$/, :file_type => :assembly}
+         {
+           :file_type => :component_module_refs,
+           :rel_path_pattern => [/(^module_refs.yaml$)/,/(^global_module_refs.json$)/],
+           :default_rel_path => 'module_refs.yaml',
+         },
+         {
+           :file_type => :assembly,
+           :rel_path_pattern => /^assemblies\/([^\/]+)\/assembly\.yaml$/
+         }
         ]
       }
     end

data/lib/dsl/file_parser/file_types/component_module_refs/v1/component_module_refs.rb

@@ -13,7 +13,13 @@ module DtkCommon; module DSL; class FileParser
           parse_error = true
           if v.kind_of?(InputHash) and v.only_has_keys?(:version,:remote_namespace,:namespace) and not v.empty?()
             parse_error = false
-            new_el.merge_non_empty!(:version_info => v[:version], :remote_namespace => v[:remote_namespace]||v[:namespace])
+            # v[index] if index not found returns empty InputHash, not nil
+            new_el.merge_non_empty!(:version_info => v[:version])
+            namespace = v[:namespace]
+            namespace = v[:remote_namespace] if namespace.empty? # TODO: for legacy
+            # TODO: change this to new_el.merge_non_empty!(:namespace => namespace) while coordinating with users
+            # of api
+            new_el.merge_non_empty!(:remote_namespace => namespace)
           elsif v.kind_of?(String)
             parse_error = false
             new_el.merge_non_empty!(:version_info => v)

data/lib/dtk-common/version.rb

@@ -1,3 +1,3 @@
 module DtkCommon
-  VERSION = "0.5.15"
+  VERSION = "0.5.16"
 end

data/lib/module_parser/module_parser.rb

@@ -0,0 +1,130 @@
+require 'yaml'
+
+module DTK
+  module Common
+
+    class ModuleParser
+
+      MODULE_REFS_FILE   = 'module_refs.yaml'
+
+      def initialize(module_name, module_namespace, repos_path, module_type=:service_module, is_server=false, dtk_username=nil)
+        @module_name      = module_name
+        @module_namespace = module_namespace
+        @module_type      = module_type
+        @repos_path       = repos_path
+        @is_server        = is_server
+        @dtk_username     = dtk_username
+        @dependency_map   = nil
+        @errors           = []
+      end
+
+      def calculate!()
+        @dependency_map = recursive_calculation(@module_name, @module_namespace, @module_type)
+        @dependency_map
+      end
+
+      #
+      # Errors will return latest calculated changes
+      #
+      def errors()
+        @dependency_map ||= recursive_calculation(@module_name, @module_namespace, @module_type)
+        @errors
+      end
+
+    private
+
+      def recursive_calculation(cm_name, cm_namespace, cm_type, chain_link = [])
+        # if namespace not found user parent namespace (service namespace)
+        cm_namespace = @module_namespace
+
+        chain_identifier = "#{cm_namespace}::#{cm_name}(#{ModuleParser.resolve_module_type(cm_type)})"
+
+        # !CHECK ERROR DETECTED CIRCUALAR DEPENDENCY
+        if chain_link.include?(chain_identifier)
+          return element(cm_name, cm_namespace, cm_type, chain_link, "Circular dependency detected for '#{chain_identifier}'!")
+        end
+
+        # STARTING PROCESSING (ID ADDED)
+        chain_link << chain_identifier
+
+        # READ COMPONENT MODULE FILE
+        repo_path = ModuleParser.resolve_module_path(cm_type, cm_name, cm_namespace, @repos_path, @is_server, @dtk_username)
+
+        begin
+          module_refs = Gitolite::Git::FileAccess.new(repo_path).file_content(MODULE_REFS_FILE)
+        rescue Exception => e
+          return element(cm_name, cm_namespace, cm_type, chain_link, "Repo module '#{chain_identifier}' cannot be found")
+        end
+
+        # !CHECK ERROR MODEL DESCRIPTION IS MISSING
+        unless module_refs
+          return element(cm_name, cm_namespace, cm_type)
+        end
+
+        module_refs = YAML.load(module_refs)
+
+        module_refs_cm = module_refs['component_modules']||[]
+        module_refs_tm = module_refs['test_modules']||[]
+
+        cm_results = []
+        tm_results = []
+
+        module_refs_cm.each do |cm_name, cm_values|
+          cm_results << recursive_calculation(cm_name, cm_values['namespace'], :component_module, chain_link.dup)
+        end
+
+        module_refs_tm.each do |cm_name, cm_values|
+          tm_results << recursive_calculation(cm_name, cm_values['namespace'], :test_module, chain_link.dup)
+        end
+
+        element = element(cm_name, cm_namespace, cm_type)
+        element[:component_modules] = cm_results
+        element[:test_modules] = tm_results
+
+        element
+      end
+
+      def element(module_name, module_namespace, module_type, chain_info = [], error = nil)
+        if error
+          error_string =  error
+          error_string += ", dependency location #{chain_info.join(' >> ')}" unless chain_info.empty?
+          @errors << error_string
+        end
+
+        {
+          :module_name => module_name,
+          :module_namespace => module_namespace,
+          :module_type => module_type,
+          :location    => chain_info.empty? ? nil : chain_info.join(' >> '),
+          :error => error
+        }
+      end
+
+      def self.resolve_module_path(module_type, module_name, module_namespace, repos_path, is_server=false, dtk_username=nil)
+        if is_server
+          repo_name = "#{dtk_username}-#{module_namespace}-#{module_name}.git"
+          repo_name = "#{resolve_module_type(module_type)}-#{repo_name}" unless module_type == :component_module
+        else
+          repo_name = "#{module_namespace}--#{resolve_module_type(module_type)}--#{module_name}.git"
+        end
+
+        File.join(repos_path, repo_name)
+      end
+
+      def self.resolve_module_type(module_type)
+        case module_type
+        when :service_module
+          'sm'
+        when :component_module
+          'cm'
+        when :test_module
+          'tm'
+        else
+          raise "Not supported module type when resolving dependnecies #{module_type}"
+        end
+      end
+
+
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dtk-common
 version: !ruby/object:Gem::Version
-  version: 0.5.15
+  version: 0.5.16
 platform: ruby
 authors:
 - Rich PELAVIN
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-14 00:00:00.000000000 Z
+date: 2014-09-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rugged
@@ -97,6 +97,7 @@ files:
 - lib/grit_adapter/file_access/diff.rb
 - lib/grit_adapter/file_access/status.rb
 - lib/grit_adapter/object_access.rb
+- lib/module_parser/module_parser.rb
 - lib/module_version.rb
 - lib/require_first.rb
 - rich_tests/README.md
@@ -177,7 +178,6 @@ files:
 - rich_tests/fixtures/rugged_test1/repo1.git/refs/heads/branch1
 - rich_tests/fixtures/rugged_test1/repo1.git/refs/heads/master
 - rich_tests/rugged_test1.rb
-- test.rb
 homepage: https://github.com/rich-reactor8/dtk-common
 licenses:
 - GPL-3.0

data/test.rb

@@ -1,13 +0,0 @@
-require File.expand_path('lib/gitolite/init.rb', File.dirname(__FILE__))
-
-
-manager = Gitolite::Manager.new('/home/git/gitolite-admin')
-
-# DEBUG SNIPPET >>>> REMOVE <<<<
-require 'pp'
-pp "Start >>>"
-
-pp manager.open_repo('r8--cm--bootstrap')
-
-
-pp "DOne!"