dtk-dsl 1.0.6 → 1.1.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ODIxODM3OTNiZmFmM2FhOTg0YzI5OWQ0ZjE5MTk1MmZjN2U3MGI4OQ==
-  data.tar.gz: !binary |-
-    MGVhNTI3NzIwMGFkOTkyZGUyMjM4ZmUxYWM5MzU1YTRjOTNkOWZkNg==
+SHA1:
+  metadata.gz: 4d895f877404ae93dfc322386df042ec6c5708b6
+  data.tar.gz: 8e4bbc8ff03582fdc14619fbca4eaffcdf01600f
 SHA512:
-  metadata.gz: !binary |-
-    NmQ3YzYxYzEzYzBmZDI5NmZjZTUwM2M1YmMzMTBhMDY4NTYyOTY4NzAwM2Q3
-    M2VmZDA2NjNkMzMxMjIyMzZmNjEyYTI2MTIyMTBmNTMwODdjYThiN2M5MTQ1
-    OWUzMTkzMGU0YWUzNTdjYWJlMmNkZGRhM2YzMmE1N2ZmMDUxZTE=
-  data.tar.gz: !binary |-
-    MGE0YjM5MmUwZWRjYzRlNDg4NmYzMWFjN2FmZmI1NTQ3ODQ0YmFlZGU0NDcy
-    Y2FmOTI3NjEyY2Y3ZDY5OWQ5NGYwZjRkNDFkNTQ3Y2IzMDZjYTY2NTAzYWZh
-    NzI5YjAxZGY0MTM4ZDJmMzA4NDRlOTlmNjJhYTczMWMxMTVmODA=
+  metadata.gz: 19a0e962cdfccc33ee683f7817b70d44045a564d4871b9f9c16c400068c9d88236edbc15f60b33683e1850485a6f9d14cc838cbdc0ab03dce3ebd5d4828425ab
+  data.tar.gz: 37484780d4ae0127076c4dc7018edb359da0101b2fe4bc8395613aaf5b7f707f3449bb2180762acb9079acda6b15468bce3236d74fb736418b06fc47c090b24a

data/lib/dsl/input_output_common/canonical/hash.rb

@@ -30,6 +30,10 @@ module DTK::DSL
         def set?(output_key, val)
           set(output_key, val) unless val.nil?
         end
+
+        def delete_key(output_key)
+          delete(canonical_key_form_from_output_key(output_key))
+        end
         
         # value at index output_key
         def val(output_key)

data/lib/dsl/input_output_common/canonical/hash_key.rb

@@ -35,6 +35,9 @@ module DTK::DSL
       Module = :module
       Version = :version      
 
+      # Used in component links
+      ExternalServiceName = :external_service_name
+
       # Used in workflows
       Subtasks          = :subtasks
       SubtaskOrder      = :subtask_order

data/lib/dsl/template/parsing/class_mixin.rb

@@ -50,6 +50,10 @@ module DTK::DSL
           end
         end
 
+        def empty_input_hash
+          FileParser::Input::Hash.new(self)
+        end
+
         private
 
         def input_hash?(input)

data/lib/dsl/template/v1/component.rb

@@ -27,10 +27,12 @@ module DTK::DSL
           
           extend ClassMixin::Constant
 
-          Attributes     = 'attributes'
-          ComponentLinks = 'component_links'
-          Links          = 'links'
-          Variations::ComponentLinks = ['links','component_links', 'component_link']
+          Components        = 'components'
+          Attributes        = 'attributes'
+          Links             = 'links'
+          ComponentLinks    = 'component_links'
+          Variations::ComponentLinks = ['links', 'component_links', 'component_link']
+
         end
 
         ### For parsing
@@ -82,10 +84,9 @@ module DTK::DSL
 
         def generate_component_hash
           ret = {}
-
           set_generation_hash(ret, :Attributes, generate_child_elements(:attribute, val(:Attributes)))
           set_generation_hash(ret, :Links, generate_child_elements(:component_link, val(:ComponentLinks)))
-
+          set_generation_hash(ret, :Components, generate_child_elements(:component, val(:Components)))
           ret
         end
         
@@ -116,19 +117,38 @@ module DTK::DSL
           end
 
           properties = input_hash.values.first
-          if attributes = properties['attributes']
-            set? :Attributes, parse_child_elements?(:attribute, :Attributes, :input_hash => { 'attributes' => attributes })
-          end
 
-          if component_links = properties['component_links']
-            set? :Links, parse_child_elements?(:component_link, :ComponentLinks, :input_hash => { 'component_links' => component_links})
-          end
+          # removes from peroperties so we can simply merge keys not processed
+          parse_set_property_value_and_remove!(properties, :Attributes)
+          parse_set_property_value_and_remove__component_links!(properties)
+          parse_set_property_value_and_remove!(properties, :Components)
+          merge properties unless properties.empty?
+        end
 
-          # handle keys not processed
-          properties.delete(Constant::Attributes)
-          properties.delete(Constant::ComponentLinks)
+        # opts can have keys: 
+        #   :matching_key_value
+        def parse_set_property_value_and_remove!(properties, constant, opts = {})
+          if matching_key_value = opts[:matching_key_value] || constant_class.matching_key_and_value?(properties, constant)
+            key_in_properties   = matching_key_value.keys.first
+            value               = matching_key_value.values.first
+            canonical_key       = constant_class.canonical_value(constant) # this is string
+            parse_template_type = canonical_key.sub(/s$/, '').to_sym
+
+            # example what below looks like set? :Components, parse_child_elements?(:component, :Components, :input_hash => { 'components' => components})
+            set? constant, parse_child_elements?(parse_template_type, constant, :input_hash => { canonical_key => value })
+            properties.delete(key_in_properties)
+          end
+        end
 
-          merge properties unless properties.empty?
+        # This method handles synatic varaints where component links may be an array and can have array elements that are simple term meaning that
+        #   the link name is the component type
+        def parse_set_property_value_and_remove__component_links!(properties)
+          constant = :ComponentLinks
+          return unless matching_key_value = constant_class.matching_key_and_value?(properties, constant)
+          key   = matching_key_value.keys.first
+          value = matching_key_value.values.first
+          transformed_value = ComponentLink.parse_transform_to_hash_form(value, self)
+          parse_set_property_value_and_remove!(properties, constant, matching_key_value: { key => transformed_value })
         end
 
       end

data/lib/dsl/template/v1/component_link.rb

@@ -15,60 +15,100 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-class DTK::DSL::Template
-  class V1
-    class ComponentLink < self
-      require_relative('component_link/semantic_parse')
-
-      module Constant
-        module Variations
+module DTK::DSL
+  class Template
+    class V1
+      class ComponentLink < self
+        require_relative('component_link/semantic_parse')
+        require_relative('component_link/implicit_link_name')
+        require_relative('component_link/external_service_name')
+        
+        module Constant
+          module Variations
+          end
+          
+          extend ClassMixin::Constant
+          Value = 'value'
+          
+        end
+        
+        ### For parsing
+        def parser_output_type
+          :hash
+        end
+        
+        # Canonical form is an array
+        def self.elements_collection_type
+          :hash
+        end
+        
+        def self.parse_elements(input_hash, parent_info)
+          input_hash.inject(file_parser_output_hash) do |h, (name, value)|
+            h.merge(name => parse_element({ 'value' => value}, parent_info, :index => name))
+          end
+        end
+        
+        def parse!
+          dependency, external_service_name = parse_value
+          set :Value, dependency
+          set? :ExternalServiceName, external_service_name
+        end
+        
+        def self.parse_transform_to_hash_form(input_links, parent)
+          if input_links.kind_of?(::Hash)
+            input_links
+          elsif input_links.kind_of?(::Array)
+            input_links.inject(empty_input_hash) { |h, link| h.merge(ComponentLink.parse_transform_link_to_hash_form(link, parent)) }
+          else
+            raise parent.parsing_error(:WrongObjectType, input_links, [::Hash, ::Array])
+          end
+        end
+        
+        ### For generation
+        def self.generate_elements(component_links_content, parent)
+          # Parsing form can be a hash, but canonical form is an array 
+          component_links_content.map { |link_name, component_link| generate_canonical_element(link_name, component_link) }
         end
 
-        extend ClassMixin::Constant
-        Value = 'value'
-      end
-
-      ### For parsing
-      def parser_output_type
-        :hash
-      end
-
-      def self.elements_collection_type
-        :hash
-      end
-
-      def self.parse_elements(input_hash, parent_info)
-        input_hash.inject(file_parser_output_hash) do |h, (name, value)|
-          h.merge(name => parse_element({ 'value' => value}, parent_info, :index => name))
+        private
+        
+        def self.parse_transform_link_to_hash_form(link_input, parent)
+          if link_input.kind_of?(::Hash)
+            link_input
+          elsif link_input.kind_of?(::String)
+            { ImplicitLinkName.parse(link_input, parent: parent) => link_input }
+          else
+            parent.parsing_error(:WrongObjectType, link_input, [::Hash, ::String])
+          end
         end
-      end
 
-      def parse!
-        # using 'input_key_value?' (i.e., with '?') in case null value
-        set :Value, input_key_value?(:Value)
-      end
+        # returns [dependency, external_service_name]; second can be nil
+        def parse_value
+          dependency = external_service_name = nil
+          string = input_key_value(:Value)
+          dependency, external_service_name = ExternalServiceName.parse?(string)
+          dependency ||= string
+          [dependency, external_service_name]
+        end        
 
-      ### For generation
-      def self.generate_elements(component_links_content, parent)
-        component_links_content.inject({}) do |h, (component_link_name, component_link)| 
-          component_link.set(:Name, component_link_name)
-          element = generate_element?(component_link, parent)
-          element.nil? ? h : h.merge(element)
+        def self.generate_canonical_element(link_name, component_link)
+          dependent_ref = dependent_component_ref(component_link)
+          if ImplicitLinkName.implicit_link_name(dependent_ref) == link_name
+            dependent_ref
+          else
+            { link_name => dependent_ref }
+          end
         end
-      end
 
-      def generate!
-        value = val(:Value)
-        unless value.nil?
-          merge(req(:Name) => val(:Value))
-          self
+        def self.dependent_component_ref(component_link)
+          component_ref = component_link.req(:Value)
+          if external_service_name = component_link.val(:ExternalServiceName)
+            ExternalServiceName.dependent_component_ref(external_service_name, component_ref)
+          else
+            component_ref
+          end
         end
       end
-
-      def generate?
-        generate! unless skip_for_generation?
-      end
-
     end
   end
 end

data/lib/dsl/template/v1/component_link/external_service_name.rb

@@ -0,0 +1,55 @@
+#
+# 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::DSL
+  class Template::V1::ComponentLink
+    module ExternalServiceName
+      SERVICE_NAME_VAR = '*'
+      COMPONENT_VAR = '+'
+      MAPPINGS = {
+        short_form: {
+          generate: "#{SERVICE_NAME_VAR}/#{COMPONENT_VAR}",
+          parse_regexp: /^([^\/\]\[]+)\/(.+$)/
+        },
+        long_form: {
+          generate: "service[#{SERVICE_NAME_VAR}]/#{COMPONENT_VAR}",
+          parse_regexp:  /^service\[([^\]]+)\]\/(.+$)/
+            }
+      }
+      PARSE_REGEXPS = MAPPINGS.values.map { |info| info[:parse_regexp] }
+      
+      CANONICAL_FORM = :short_form
+      
+      def self.dependent_component_ref(external_service_name, component_ref)
+        MAPPINGS[CANONICAL_FORM][:generate].sub(SERVICE_NAME_VAR, external_service_name).sub(COMPONENT_VAR, component_ref)
+      end
+      
+      # returns [dependency, external_service_name] or nil if no external_service_name
+      def self.parse?(input_string)
+        # assume that cant have form ATOMIC-TERM/... where ATOMIC-TERM is not a external name
+        PARSE_REGEXPS.each do |regexp|
+          if input_string =~ regexp
+            external_service_name, dependency = [$1, $2]
+            return [dependency, external_service_name]
+          end
+        end
+        nil
+      end
+      
+    end
+  end
+end

data/lib/dsl/template/v1/component_link/implicit_link_name.rb

@@ -0,0 +1,46 @@
+#
+# 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::DSL
+  class Template::V1::ComponentLink
+    module ImplicitLinkName
+      # opts can have keys:
+      #   :parent
+      #   :donot_raise_error
+      def self.parse(dependent_component_ref, opts = {})
+        last_component = dependent_component_ref.split('/').last
+        # remove title if it exists
+        title_split = last_component.split('[')
+        case title_split.size
+        when 1
+          return last_component
+        when 2
+          return title_split[0] if title_split[1] =~ /\]$/
+        end
+        unless opts[:donot_raise_error]
+          raise opts[:parent].parsing_error("The term '#{dependent_component_ref}' is an ill-formed component link dependency reference")
+        end
+        nil
+      end
+
+      def self.implicit_link_name(dependent_component_ref)
+        # This should not return nil, but allowing it to be more robust
+        parse(dependent_component_ref, donot_raise_error: true)
+      end
+    end
+  end
+end    

data/lib/dsl/template/v1/component_link/semantic_parse.rb

@@ -19,6 +19,14 @@ module DTK::DSL
   class Template::V1
     class ComponentLink
       class SemanticParse < InputOutputCommon::SemanticParse::Hash
+        def value
+          val(:Value) || fail(Error, "Unexpected that val(:Value) is nil")
+        end 
+
+        def external_service_name?
+          val(:ExternalServiceName)
+        end
+
       end
     end
   end

data/lib/dsl/template/v1/node.rb

@@ -36,7 +36,8 @@ class DTK::DSL::Template
 
       def self.parse_elements(input_hash, parent_info)
         input_hash.inject(file_parser_output_hash) do |h, (name, content)|
-          h.merge(name => parse_element(content, parent_info, :index => name))
+          # The term' content || {}' is in case node has no attributes or components
+          h.merge(name => parse_element(content || {}, parent_info, :index => name))
         end
       end
 

data/lib/dsl/version.rb

@@ -1,6 +1,6 @@
 module DTK
   module DSL
-    VERSION="1.0.6"
+    VERSION="1.1.0"
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dtk-dsl
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.1.0
 platform: ruby
 authors:
 - Reactor8
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-24 00:00:00.000000000 Z
+date: 2017-05-23 00:00:00.000000000 Z
 dependencies: []
 description: Library for parsing DT DSL files.
 email: support@reactor8.com
@@ -16,7 +16,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - README.md
 - dtk-dsl.gemspec
@@ -115,6 +115,8 @@ files:
 - lib/dsl/template/v1/component_def.rb
 - lib/dsl/template/v1/component_def/semantic_parse.rb
 - lib/dsl/template/v1/component_link.rb
+- lib/dsl/template/v1/component_link/external_service_name.rb
+- lib/dsl/template/v1/component_link/implicit_link_name.rb
 - lib/dsl/template/v1/component_link/semantic_parse.rb
 - lib/dsl/template/v1/dependency.rb
 - lib/dsl/template/v1/module_ref.rb
@@ -139,17 +141,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.4.1
 signing_key: 
 specification_version: 4
 summary: Library for parsing DT DSL files.