dtk-dsl 1.0.0

data/lib/dsl/input_output_common/hash.rb

@@ -0,0 +1,44 @@
+#
+# 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 InputOutputCommon
+    class Hash < ::Hash
+      def initialize(parent_class, hash = nil)
+        super()
+        replace(reify(parent_class, hash)) if hash
+      end
+
+      private
+      
+      def reify(parent_class, obj)
+        if obj.kind_of?(self.class)
+          obj
+        elsif obj.kind_of?(::Hash)
+          obj.inject(self.class.new(parent_class)) { |h, (k, v)| h.merge(k => reify(parent_class, v)) }
+        elsif obj.kind_of?(::Array)
+          parent_class::Array.new(parent_class, obj)
+        else
+          obj
+        end
+      end
+      
+    end
+  end
+end
+
+

data/lib/dsl/input_output_common/output_class_mixin.rb

@@ -0,0 +1,34 @@
+#
+# 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 InputOutputCommon
+    module OutputClassMixin
+      # opts can have keys
+      #  :output_type
+      #  :input
+      # In both cases an empty object is created using :output_type or type of :input to determine its type
+      def create(opts = {})
+        unless opts[:output_type] or opts[:input]
+          raise Error, "opts must have one of the keys :output_type or :input"
+        end
+        obj_type = opts[:output_type] || obj_type(opts[:input])
+        create_aux(obj_type)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+#
+# 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 InputOutputCommon
+    module SemanticParse
+      class Hash < Canonical::Hash
+        include Mixin
+        # opts can have keys
+        #  :qualified_key
+        def initialize(parent_class, opts = {})
+          super(parent_class)
+          initialize_semantic_parse(opts)      
+        end
+      end
+    end
+  end
+end
+

data/lib/dsl/input_output_common/semantic_parse/mixin.rb

@@ -0,0 +1,44 @@
+#
+# 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 InputOutputCommon
+    module SemanticParse
+      module Mixin
+        # opts can have keys
+        #  :qualified_key
+        def initialize_semantic_parse(opts = {})
+          @qualified_key = opts[:qualified_key]
+        end
+        private :initialize_semantic_parse
+
+        def qualified_key
+          @qualified_key || fail(Error, "Unexepcetd that @qualified_key is nil")
+        end
+
+        def name 
+          qualified_key.relative_distinguished_name
+        end
+
+        def qualified_name
+          qualified_key.print_form
+        end
+      end
+    end
+  end
+end
+

data/lib/dsl/input_output_common/semantic_parse.rb

@@ -0,0 +1,26 @@
+#
+# 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 InputOutputCommon
+    module SemanticParse
+      require_relative('semantic_parse/mixin')
+      # mixin needs to go before hash
+      require_relative('semantic_parse/hash')
+    end
+  end
+end

data/lib/dsl/input_output_common.rb

@@ -0,0 +1,60 @@
+#
+# 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
+  # Base classes for getting input from file to map to canonical form and to store canonical form that 
+  # is used for generation
+  class InputOutputCommon
+    require_relative('input_output_common/output_class_mixin')
+    require_relative('input_output_common/hash')
+    require_relative('input_output_common/array')
+    # hash and array must go before canonical
+    require_relative('input_output_common/canonical')
+    # semantic_parse needs to go before canonical
+    require_relative('input_output_common/semantic_parse')
+
+    private
+    
+    def self.obj_type(obj)
+      if obj.kind_of?(::Hash)
+        :hash
+      elsif obj.kind_of?(::Array)
+        :array
+      elsif obj.kind_of?(::String)
+        :string
+      else
+        raise Error, "Unexpected type '#{obj.class}'"
+      end
+    end
+    
+    def self.create_aux(type, obj = nil)
+      case type
+      when :hash 
+        # if obj.class not ::Hash then reified already
+        (obj.nil? or obj.class == ::Hash) ? self::Hash.new(self, obj) : obj
+      when :array 
+        # if obj.class not ::Array then reified already
+        (obj.nil? or obj.class == ::Array) ? self::Array.new(self, obj) : obj
+      when :string 
+        # no reification for string
+        ::String.new(obj || '') 
+      else 
+        raise Error, "Unexpected type '#{type}'"
+      end
+    end
+  end
+end

data/lib/dsl/qualified_key.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
+  module DSL
+    class QualifiedKey 
+      Element = Struct.new(:type, :key)
+      def initialize(elements_to_copy = [])
+        @key_elements = copy(elements_to_copy)
+      end
+
+      def create_with_new_element?(type, key)
+        new_key_elements = key.nil? ? @key_elements : @key_elements + [Element.new(type, key)]
+        self.class.new(new_key_elements)
+      end
+
+      QUALIFIED_KEY_DELIM = '/'
+      def print_form
+        @key_elements.inject('') do |s, el|
+          s.empty? ? el.key : s + QUALIFIED_KEY_DELIM + el.key
+        end
+      end
+
+      def relative_distinguished_name
+        unless last = @key_elements.last
+          fail Error, "Unexpected that @key_elements is empty" 
+        end
+        last.key
+      end
+
+      private
+
+      def copy(key_elements)
+        ret = []
+        key_elements.each { |el| ret << Element.new(el.type, el.key) }
+        ret
+      end
+      
+    end
+  end
+end

data/lib/dsl/template/constant_class_mixin.rb

@@ -0,0 +1,91 @@
+#
+# 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
+    # assumption is that where this included could have a Variations module
+    module ClassMixin
+      module Constant
+        def matches?(object, constant)
+          unless object.nil?
+            variations = variations(constant)
+            if object.is_a?(Hash)
+              hash_value_of_matching_key?(object, variations)
+            elsif object.is_a?(String) || object.is_a?(Symbol)
+               variations.include?(object.to_s)
+            else
+              fail Error.new("Unexpected object class (#{object.class})")
+            end
+          end
+        end
+
+        def matching_key_and_value?(hash, constant)
+          variations = variations(constant)
+          if matching_key = hash_key_if_match?(hash, variations)
+            { matching_key => hash[matching_key] }
+          end
+        end
+
+        def all_string_variations(*constants)
+          constants.flat_map { |constant| variations(constant, string_only: true) }.uniq
+        end
+
+        def its_legal_values(constant)
+          single_or_set = variations(constant, string_only: true)
+          if single_or_set.is_a?(Array)
+            "its legal values are: #{single_or_set.join(',')}"
+          else
+            "its legal value is: #{single_or_set}"
+          end
+        end
+
+        def canonical_value(constant)
+          # self. is important beacuse want to evalute wrt to class that calls this
+          begin
+            self.const_get(constant.to_s)
+          rescue
+            raise Error, "Illegal Input parsing constant '#{constant}'"
+          end
+        end
+
+        private
+
+        def variations(constant, opts = {})
+          # use of self:: and self. are important because want to evalute wrt to module that pulls this in
+          variations = self::Variations.const_get(constant.to_s)
+          string_variations = variations.map(&:to_s)
+          opts[:string_only] ? string_variations : string_variations + variations.map(&:to_sym)
+         rescue
+          # if Variations not defined
+          term = canonical_value(constant)
+          opts[:string_only] ? [term.to_s] : [term.to_s, term.to_sym]
+        end
+
+        def hash_key_if_match?(hash, variations)
+          variations.find { |key| hash.key?(key) }
+        end
+
+        def hash_value_of_matching_key?(hash, variations)
+          if matching_key = hash_key_if_match?(hash, variations)
+            hash[matching_key]
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+#
+# 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
+    module Generation
+      module ClassMixin
+        # Main template-specific generate call; Concrete classes overwrite this
+        def generate_elements(_content_elements, _parent)
+          raise Error::NoMethodForConcreteClass.new(self)
+        end
+
+        private
+
+        def generate_element(content, parent)
+          create_for_generation(content, :filter => parent.filter).generate_yaml_object
+        end
+
+        def generate_element?(content, parent)
+          create_for_generation(content, :filter => parent.filter).generate_yaml_object?
+        end
+
+      end
+    end
+  end
+end

data/lib/dsl/template/generation/mixin.rb

@@ -0,0 +1,134 @@
+#
+# 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
+    module Generation
+      module Mixin
+        # Main template-specific generate call; Concrete classes overwrite this
+        def generate!
+          raise Error::NoMethodForConcreteClass.new(self.class)
+        end
+
+        # This is overwritten if template can conditionally generate elements
+        def generate?
+          generate!
+        end
+
+        attr_reader :filter
+
+        # opts can have keys
+        #  :content (required)
+        #  :filter
+        def generation_initialize(opts = {})
+          unless content = opts[:content]
+            raise Error, "Unexpected that opts[:content] is nil"
+          end
+          @content     = content
+          @filter      = opts[:filter]
+          @yaml_object = empty_yaml_object(content)
+        end
+        private :generation_initialize
+
+        # generate_yaml_object? can be ovewritten
+        def generate_yaml_object?
+          generate?
+          is_empty?(@yaml_object) ? nil : @yaml_object
+        end
+
+        def generate_yaml_object
+          generate!
+          @yaml_object
+        end
+        
+        def generate_yaml_text
+          self.generate!
+          YamlHelper.generate(@yaml_object)
+        end
+
+        # The methods yaml_object_type can be set on concrete class; it wil be set if input and output types are different
+        def yaml_object_type
+          nil
+        end
+        
+        private
+
+        def generate_child(parse_template_type, content)
+          if content.nil?
+            nil
+          else
+            template_class(parse_template_type).create_for_generation(content, :filter => @filter).generate_yaml_object
+          end
+        end
+        
+        def generate_child_elements(parse_template_type, content_elements)
+          unless content_elements.nil?
+            template_class(parse_template_type).generate_elements(content_elements, self)
+          end
+        end
+
+        def empty_yaml_object(content_input)
+          if self.yaml_object_type
+            FileGenerator::YamlObject.create(:output_type => yaml_object_type)
+          else
+            FileGenerator::YamlObject.create(:input => content_input)
+          end
+        end
+
+        def set_generation_hash(hash, constant, val)
+          unless val.nil? or is_empty?(val)
+            hash[canonical_key(constant)] = val
+          end
+        end
+
+        def is_empty?(obj)
+          obj.respond_to?(:empty?) and obj.empty?
+        end
+
+        def skip_for_generation?
+          @content.skip_for_generation?
+        end
+
+        def generation_set(constant, val)
+          set_generation_hash(@yaml_object, constant, val)
+        end
+
+        def generation_set_scalar(scalar)
+          @yaml_object = scalar
+        end
+
+        def generation_merge(hash)
+          @yaml_object.merge!(hash)
+        end        
+
+        def generation_add(array_element)
+          @yaml_object << array_element
+        end
+
+        def generation_val(key)
+          @content.val(key)
+        end
+
+        def generation_req(key)
+          @content.req(key)
+        end
+
+      end
+    end
+  end
+end
+

data/lib/dsl/template/generation.rb

@@ -0,0 +1,26 @@
+#
+# 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
+    module Generation
+      require_relative('generation/mixin')
+      require_relative('generation/class_mixin')
+    end
+  end
+end
+

data/lib/dsl/template/loader.rb

@@ -0,0 +1,66 @@
+#
+# 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
+    class Loader
+      TEMPLATE_VERSIONS = [1]
+
+      # opts can have keys
+      #  :dsl_version
+      #  :template_version
+      def self.template_class(template_type, opts = {})
+        template_version = opts[:template_version] || template_version(opts[:dsl_version])
+        load_version(template_version) unless version_loaded?(template_version)
+        template_class_aux(template_type, template_version)
+      end
+      
+      private
+      
+      def self.version_loaded?(template_version)
+        @loaded_versions and @loaded_versions.include?(template_version)
+      end
+      
+      def self.template_version(_dsl_version)
+        # TODO: when have multiple versions thn want a mapping between
+        # dsl version and template version, which could also be per template type
+        # (i.e., same dsl version can map to different template versions depending on template_type)
+        raise Error, "Unsupported when have multiple template versions" unless TEMPLATE_VERSIONS.size == 1
+        TEMPLATE_VERSIONS.first
+      end
+      
+      def self.load_version(template_version)
+        require_relative("v#{template_version}")
+        (@loaded_versions ||= []) << template_version
+      end
+      
+      def self.template_class_aux(template_type, template_version)
+        base_class = Template.const_get("V#{template_version}")
+        begin 
+          base_class.const_get(::DTK::Common::Aux.snake_to_camel_case(template_type.to_s))
+        rescue
+          raise Error, "Invalid template_type '#{template_type}'"
+        end
+      end
+    end
+  end
+end
+
+
+
+