dtk-dsl 1.0.0

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

@@ -0,0 +1,67 @@
+#
+# 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 Parsing
+      module ClassMixin
+        # Main template-specific parse call; Concrete classes overwrite this
+        def parse_elements(_input_elements, _parent_info)
+          raise Error::NoMethodForConcreteClass.new(self)
+        end
+
+        # Indicates whether collection of elements to parse is a hash or array
+        # This can be overwritten
+        def elements_collection_type
+          nil
+        end
+        
+        private
+
+
+        # opts can have keys
+        #  :index
+        def parse_element(input, parent_info, opts = {})
+          if input.nil?
+            nil
+          else
+            file_obj   = parent_info.parent.file_obj 
+            parent_key = ParentKey.parent_key(parent_info, opts[:index])
+            create_for_parsing(input, :file_obj => file_obj, :parent_key => parent_key).parse
+          end
+        end
+
+        def file_parser_output_array
+          FileParser::Output.create(:output_type => :array)
+        end
+        
+        def file_parser_output_hash
+          FileParser::Output.create(:output_type => :hash)
+        end
+
+        def input_hash?(input)
+          input.kind_of?(FileParser::Input::Hash)
+        end
+
+        def input_array?(input)
+          input.kind_of?(FileParser::Input::Array)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,214 @@
+#
+# 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 Parsing
+      module Mixin
+        # Main template-specific parse call; Concrete classes overwrite this
+        def parse!
+          raise Error::NoMethodForConcreteClass.new(self.class)
+        end
+        private :parse!
+
+        attr_reader :file_obj, :parent_key
+
+        # opts can have keys:
+        #   :raw_input
+        #   :file_obj
+        #   :parent_key
+        def parsing_initialize(opts = {})
+          unless raw_input = opts[:raw_input]
+            raise Error, "Unexpected that opts[:raw_input] is nil"
+          end
+          parent_key = opts[:parent_key]
+
+          @input      = FileParser::Input.create(raw_input)
+          @output     = empty_parser_output(@input, parent_key)
+          @file_obj   = opts[:file_obj]
+          @parent_key = parent_key
+        end
+        private :parsing_initialize
+
+        def parse
+          parse!
+          @output
+        end
+
+        # The method parser_output_type can be set on concrete class; it wil be set if input and output types are different
+        def parser_output_type
+          nil
+        end
+
+        private
+        
+        def empty_parser_output(input, parent_key)
+          if self.class.const_defined? 'SemanticParse'
+            qualified_key = parent_key && parent_key.create_qualified_key
+            self.class::SemanticParse.new(FileParser::Output, :qualified_key => qualified_key)
+          elsif parser_output_type 
+            FileParser::Output.create(:output_type => parser_output_type)
+          else
+            FileParser::Output.create(:input => input)
+          end
+        end
+
+        # opts can have key
+        #   :key_type
+        def parse_child_elements(parse_template_type, key_constant, opts = {})
+          unless key_and_value = input_key_and_value?(key_constant, opts)
+            nil
+          else
+            template_class = template_class(parse_template_type)
+            input = check_type_and_ret_input(template_class, key_and_value)
+            key_type = opts[:key_type] || parse_template_type
+            template_class.parse_elements(input, ParentInfo.new(self, key_type))
+          end
+        end
+
+        def parse_child_elements?(parse_template_type, key_constant, opts = {})
+          ret = parse_child_elements(parse_template_type, key_constant, opts)
+          (ret.nil? or ret.empty?) ? nil : ret
+        end
+
+        # opts can have keys
+        #  :parent_key
+        def parse_child(parse_template_type, input, opts = {})
+          if input.nil?
+            nil
+          else
+            template_class(parse_template_type).create_for_parsing(input, opts.merge(:file_obj => @file_obj)).parse
+          end
+        end
+
+        # This cannot be used for an assignment that can have with nil values
+        # opts can have key
+        #  :input_hash
+        def input_key_value(constant, opts = {})
+          ret = input_key_value?(constant, opts)
+          raise_missing_key_value(constant) if ret.nil?
+          ret
+        end
+        def input_key_value?(constant, opts = {})
+          input_hash = opts[:input_hash] || input_hash()
+          constant_class.matches?(input_hash, constant)
+        end
+
+        # returns nil or {key => value}
+        # opts can have keys
+        #   :input_hash
+        def input_key_and_value?(constant, opts = {})
+          input_hash = opts[:input_hash] || input_hash()
+          constant_class.matching_key_and_value?(input_hash, constant)
+        end
+
+        def parsing_set(constant, val)
+          @output.set(constant, val)
+        end
+
+        def parsing_merge(hash)
+          @output.merge!(hash)
+        end
+
+        def parsing_add(array_element)
+          @output << array_element
+        end
+
+        def check_type_and_ret_input(template_class, key_and_value)
+          input = key_and_value.values.first
+          key = key_and_value.keys.first
+
+          case template_class.elements_collection_type
+          when :hash
+            raise_input_error(::Hash, :input => input, :key => key) unless input_hash?(input)
+          when :array
+            raise_input_error(::Array, :input => input, :key => key) unless input_array?(input)
+          end
+          input
+        end
+
+        def input_hash?(input = nil)
+          (input || @input).kind_of?(FileParser::Input::Hash) 
+        end
+
+        def input_hash
+          @input_hash ||= input_hash? ? @input : raise_input_error(::Hash)
+        end
+        
+        def input_array?(input = nil)
+          (input || @input).kind_of?(FileParser::Input::Array)
+        end
+
+        def input_array
+          @input_array ||= input_array? ? @input : raise_input_error(::Array)
+        end
+        
+        def input_string?
+          @input.kind_of?(::String)
+        end
+
+        def input_string
+          @input_string ||= input_string? ? @input : raise_input_error(::String)
+        end
+
+        # opts can have keys
+        #   :input
+        #   :key
+        # correct_ruby_types can also be scalar
+        def raise_input_error(correct_ruby_types, opts = {})
+          input = opts[:input] || @input
+          raise parsing_error_with_opts([:WrongObjectType, input, correct_ruby_types], opts)
+        end
+        
+        def raise_missing_key_value(constant)
+          key = canonical_key(constant)
+          raise parsing_error(:MissingKeyValue, key)
+        end
+
+        # args can have form 
+        #  (:ParsingErrorName,*parsing_error_params) or
+        #  (*parsing_error_params)
+        def parsing_error(*args)
+          parsing_error_with_opts(args)
+        end
+
+        # opts can have keys
+        #   :key
+        def parsing_error_with_opts(args, opts = {})
+          qualified_key = qualified_key(opts[:key]) 
+          if error_class = ParsingError.error_class?(args)
+            error_params = args[1..args.size-1]
+            error_class.new(*error_params, :file_obj => @file_obj, :qualified_key => qualified_key)
+          else
+            ParsingError.new(*args, :file_obj => @file_obj, :qualified_key => qualified_key)
+          end
+        end
+
+        def qualified_key(key = nil)
+          if key.nil?
+            @parent_key
+          else
+            # TODO: find common function that appends keys
+            @parent_key.nil? ? key : "#{@parent_key}/#{key}"
+          end
+        end
+
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,82 @@
+#
+# 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 Parsing
+      class ParentKey < ::String
+        DELIM = '/'
+        def self.parent_key(parent_info, index)
+          ret = new
+          ret << "#{parent_info.parent.parent_key}"
+          ret << DELIM unless ret.empty?
+          ret << parent_info.key_type.to_s
+          ret << Index.with_delims(index) unless index.nil?
+          ret
+        end
+
+        def create_qualified_key
+          QualifiedKey.new(qualified_key_elements) 
+        end
+
+        private
+
+        UNKNOWN_INDEX = '*'
+        def qualified_key_elements
+          split(DELIM).map do |key_seqment| 
+            type, index = Index.parse_segment(key_seqment)
+            QualifiedKey::Element.new(type, index || UNKNOWN_INDEX)
+          end
+        end
+
+        module Index
+          LEFT_DELIM = '['
+          RIGHT_DELIM = ']'
+          def self.with_delims(index)
+            "#{LEFT_DELIM}#{index}#{RIGHT_DELIM}"
+          end
+
+          # returns [type, index] where index can be nil
+          def self.parse_segment(key_seqment)
+            type = index = nil
+            split_on_left = key_seqment.split(LEFT_DELIM)
+            if split_on_left.size == 1
+              type = key_seqment
+            else 
+              type = split_on_left.shift
+
+              # find index
+              # being robust if index has index symbols in it by looking for leftmost left deleim and rightmost right delim
+              rest = split_on_left.join(LEFT_DELIM)
+              split_on_right = rest.split(RIGHT_DELIM)
+              if split_on_right.size == 1
+                index = split_on_right.first
+              else
+                split_on_right.pop # get rid of end
+                index = split_on_right.join(RIGHT_DELIM)
+              end
+            end
+            [type, index]
+          end
+          
+        end
+      end
+    end
+  end
+end
+
+

data/lib/dsl/template/parsing/parsing_error/subclasses.rb

@@ -0,0 +1,62 @@
+#
+# 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 Parsing                   
+    class ParsingError
+      class MissingKeyValue < self
+        def initialize(key, opts = {})
+          error_msg = "Missing value for key '#{key}'"
+          super(error_msg, opts)
+        end
+      end
+      
+      class WrongObjectType < self
+        def initialize(obj, correct_ruby_types, opts = {})
+          correct_ruby_types = [correct_ruby_types] unless correct_ruby_types.kind_of?(::Array)
+          error_msg = 
+            if correct_ruby_types.size == 1
+              "The key's value should have type #{correct_ruby_types.first}"
+            else
+              "The key's value should be one of the types (#{correct_ruby_types.join(' ')})"
+            end
+          error_msg << ", but has type #{input_class_string(obj)}"
+          super(error_msg, opts)
+        end
+        
+        private
+        
+        def input_class_string(obj)
+          klass = 
+            if obj.kind_of?(::Hash) 
+              ::Hash 
+            elsif obj.kind_of?(::Array)
+              ::Array
+            elsif obj.kind_of?(::String)
+              ::String
+            else
+              obj.class
+            end
+          # demodularize
+          klass.to_s.split('::').last
+        end
+      end
+    end
+  end
+end; end
+
+

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

@@ -0,0 +1,52 @@
+#
+# 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 Parsing
+      class ParsingError < Error::Usage
+        
+        require_relative('parsing_error/subclasses')
+        
+        # opts can have keys
+        #  :file_obj
+        #  :qualified_key
+        def initialize(error_msg, opts = {})
+          @file_ref      = FileParser.file_ref_in_error(opts[:file_obj])
+          @qualified_key = opts[:qualified_key]
+          # TODO: later enhancment can use @qualified_key to find line numbers in yaml file
+          key_ref = @qualified_key ? " under key '#{@qualified_key}'" : ''
+          super("DTK parsing error#{key_ref}#{@file_ref}:\n  #{error_msg}")
+        end
+        
+        def self.error_class?(args)
+          if args.first.kind_of?(Symbol)
+            begin
+              const_get(args.first.to_s)
+            rescue
+              nil
+            end
+          elsif args.first.kind_of?(self)
+            args.first
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/dsl/template/parsing.rb

@@ -0,0 +1,29 @@
+#
+# 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 Parsing
+      require_relative('parsing/parsing_error')
+      require_relative('parsing/parent_key')
+      require_relative('parsing/class_mixin')
+      require_relative('parsing/mixin')
+
+      ParentInfo = Struct.new(:parent, :key_type)
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+#
+# 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.
+#
+class DTK::DSL::Template
+  class V1
+    class Assembly < self
+      module Constant
+        module Variations
+        end
+
+        extend ClassMixin::Constant
+        Name        = 'name'
+        Description = 'description'
+        Attributes  = 'attributes'
+        Nodes       = 'nodes'
+        Components  = 'components'
+
+        Workflows   = 'workflows'
+        Variations::Workflows = ['workflows', 'workflow']
+
+      end
+
+      ### For parsing
+
+      def self.elements_collection_type
+        :hash
+      end
+
+      def self.parse_elements(input_hash, parent_info)
+        ret = file_parser_output_array
+        input_hash.each do |name, content|
+          ret << parse_element(content.merge('name' => name), parent_info, :index => name)
+        end
+        ret
+      end
+
+      def parse!
+        set  :Name, input_key_value(:Name)
+        set? :Description, input_key_value?(:Description)
+        set? :Attributes, parse_child_elements?(:attribute, :Attributes)
+        set? :Nodes, parse_child_elements?(:node, :Nodes)
+        set? :Components, parse_child_elements?(:component, :Components)
+        set? :Workflows, parse_child_elements?(:workflow, :Workflows)
+    
+        # TODO: This is a catchall that removes ones we so far are parsing and then has catch all
+        input_hash.delete('name')
+        input_hash.delete('description')
+        input_hash.delete('attributes')
+        input_hash.delete('nodes')
+        input_hash.delete('components')
+        input_hash.delete('workflow')
+        input_hash.delete('workflows')
+        merge input_hash
+      end
+
+      ### For generation
+      def generate!
+        # TODO: add attributes
+        set :Description, val(:Description)
+        set :Components, generate_child_elements(:component, val(:Components))
+        set :Nodes, generate_child_elements(:node, val(:Nodes))
+        set :Workflows, generate_child_elements(:workflow, val(:Workflows))
+      end
+
+    end
+  end
+end
+

data/lib/dsl/template/v1/attribute/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 Template::V1
+    class Attribute
+      class SemanticParse < InputOutputCommon::SemanticParse::Hash
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,75 @@
+#
+# 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.
+#
+class DTK::DSL::Template
+  class V1
+    class Attribute < self
+      require_relative('attribute/semantic_parse')
+
+      module Constant
+        module Variations
+        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))
+        end
+      end
+
+      def parse!
+        # using 'input_key_value?' (i.e., with '?') in case null value
+        set :Value, input_key_value?(:Value)
+      end
+
+      ### For generation
+      def self.generate_elements(attributes_content, parent)
+        attributes_content.inject({}) do |h, (attribute_name, attribute)| 
+          attribute.set(:Name, attribute_name)
+          element = generate_element?(attribute, parent)
+          element.nil? ? h : h.merge(element)
+        end
+      end
+
+      def generate!
+        value = val(:Value)
+        unless value.nil?
+          merge(req(:Name) => val(:Value))
+          self
+        end
+      end
+
+      def generate?
+        generate! unless skip_for_generation?
+      end
+
+    end
+  end
+end
+