dtk-dsl 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e6850c2038d1af4481513a9d06fdf9391d589241
-  data.tar.gz: 8ff25444f0f40e76ebcdab8672ead6a2d71e06b8
+  metadata.gz: 80e593bfb3fdafca2ec5659cb23d027021b12646
+  data.tar.gz: 719da019d2d90879ae54fb0cd5862644eef253fc
 SHA512:
-  metadata.gz: aa6414e6bc8f983c86f4416ce750c4d2754311e48bd6beabe22eab121e013a8326b1d487237f4c1baed66f46a00487a2c2a20aed3b7ad9e982a8336628c15b77
-  data.tar.gz: c843fe596c4c9d9ecd5f53d06eb5c612c374b736d1af3ddf2d76094a83c3821dcb68e439580ef22d8cfd8a34ab38d7db465e81f3b21a6d9e7c678d1fa804af5a
+  metadata.gz: 5180a6a6ff23dff2c813d535b04885164bef6d45e397843c06cab7f5907cea83681846f62fae3025b4800074f2b5968d1e864f5e804261cdaa5013d37be14013
+  data.tar.gz: af53ec0c65ce2625bcc8bd2548e7c3e8a66e1748697565952eb9755d99cb4f24aba8cd0a5e42f7d6d6d90537064f2461ccddbe262dc893819dae12da02881eee

data/lib/dsl/aux.rb

@@ -0,0 +1,31 @@
+#
+# 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
+    module Aux
+      def self.snake_to_camel_case(string)
+        ::DTK::Common::Aux.snake_to_camel_case(string)
+      end
+
+      def self.camel_case_to_snake(string)
+        string.gsub(/(.)([A-Z])/,'\1_\2').downcase
+      end
+
+    end
+  end
+end

data/lib/dsl/directory_parser.rb

@@ -19,14 +19,10 @@
 module DTK::DSL
   # Abstract class; application that uses this library must provide a concrete class that inherits from this
   class DirectoryParser
-    require_relative('directory_parser/path_info')
-    # file_types - a single or array of FileObj objects
-    # opts can have keys
-    #   :file_path - string
-    #   :dir_path - string
-    # Returns  FileObj that matches a file_typeo bject that matches a file_type in file_types
+    # file_types - a single or array of FileType
+    # Returns a FileObj that matches a file_type object that matches a file_type in file_types
     #   or returns nil if no match found
-    def self.matching_file_obj?(file_types, opts = {})
+    def self.matching_file_obj?(_file_types, *_args)
       raise Error::NoMethodForConcreteClass.new(self.class)
     end
   end

data/lib/dsl/dsl_version.rb

@@ -19,6 +19,7 @@
 module DTK::DSL
   # This refers to semnatic dsl version
   class DSLVersion < ::String
+    #versions in DSL_VERIONS are ordered so that most recent versions are last
     DSL_VERSIONS = ['1.0.0']
 
     def self.legal?(str)

data/lib/dsl/file_generator/content_input/mixin.rb

@@ -34,10 +34,7 @@ module DTK::DSL
       end
         
       def add_tags!(new_tags)
-        Tags.raise_error_if_invalid(new_tags)
-        new_tags = [new_tags] unless new_tags.kind_of?(::Array)
-        @tags += new_tags
-        @tags.uniq!
+        Tag.add_tags!(@tags, new_tags)
         self
       end
 
@@ -46,7 +43,7 @@ module DTK::DSL
       end
       
       def matches_tag_type?(tag_type)
-        !! @tags.find { |tag| Tags.matches_tag_type?(tag_type, tag) }
+        !! @tags.find { |tag| Tag.matches_tag_type?(tag_type, tag) }
       end
 
       def add_tags_to_obj?(obj, new_tags) 

data/lib/dsl/file_generator/content_input/tag/assignment.rb

@@ -0,0 +1,32 @@
+#
+# 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 FileGenerator::ContentInput
+    class Tag
+      class Assignment < self
+        attr_reader :value
+        def initialize(tag_name, tag_value)
+          super(tag_name)
+          @value = tag_value
+        end
+
+      end
+    end
+  end
+end
+

data/lib/dsl/file_generator/content_input/tag/simple.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 FileGenerator::ContentInput
+    class Tag
+      class Simple < self
+      end
+    end
+  end
+end
+

data/lib/dsl/file_generator/content_input/{tags.rb → tag.rb}

@@ -17,7 +17,57 @@
 #
 module DTK::DSL
   class FileGenerator::ContentInput
-    module Tags
+    class Tag
+      require_relative('tag/simple')
+      require_relative('tag/assignment')
+
+      attr_reader :name
+      def initialize(tag_name)
+        @name = tag_name
+      end
+      private :initialize
+
+      def self.create(tag_input)
+        tag = 
+          if tag_input.kind_of?(::String) or tag_input.kind_of?(::Symbol)
+            Simple.new(tag_input.to_sym)
+          elsif tag_input.kind_of?(::Hash) and tag_input.size == 1
+            tag_name  = tag_input.keys.first
+            if tag_name.kind_of?(::String) or tag_name.kind_of?(::Symbol)
+              tag_value = tag_input.values.first
+              Assignment.new(tag_name.to_sym, tag_value)
+            end
+          end
+        raise Error, "Invalid form for a tag: #{tag_input.inspect}"  unless tag
+        raise Error, "Invalid tag name '#{tag.name}'" unless  tag.valid_tag_name?
+        tag
+      end
+      private_class_method :create
+
+      def self.add_tags!(tags, new_tags_input)
+        new_tags_input.each do |new_tag_input|
+          new_tag = create(new_tag_input)
+          new_tag_name = new_tag.name
+          unless match = tags.find { |tag| tag.name == new_tag_name }
+            tags << new_tag
+          else
+            raise_error_if_conflicting_tags(match, new_tag)
+          end
+        end
+        tags
+      end
+
+      def self.matches_tag_type?(tag_type, tag)
+        tag_type_split = split(tag_type)
+        tag_split = split(tag.name)
+        if tag_split.size >= tag_type_split.size
+          tag_type_split.each_with_index do |tag_type_part, i|
+            return nil unless tag_type_part == tag_split[i]
+          end
+          true
+        end
+      end
+
       #####
       # In this module a 'tag_type' subsumes a tag and consitutes an element in BASE_LEVEL_TAGS or one its prefixes
       #
@@ -27,35 +77,23 @@ module DTK::DSL
          :desired__derived__default, 
          :desired__derived__propagated, 
          :actual,
-         :hidden
+         :hidden,
+         :dsl_location
         ]
       
-      def self.matches_tag_type?(tag_type, tag)
-        tag_type_split = split(tag_type)
-        tag_split = split(tag)
-        if tag_split.size >= tag_type_split.size
-          tag_type_split.each_with_index do |tag_type_part, i|
-            return nil unless tag_type_part == tag_split[i]
-          end
-          true
-        end
+      def valid_tag_name?
+        self.class.valid_tag_types.include?(name)
       end
       
-      def self.valid?(tag_type)
-        valid_tag_types.include?(tag_type)
-      end
+      private
       
-      def self.raise_error_if_invalid(tag_types)
-        tag_types = [tag_types] unless tag_types.kind_of?(::Array)
-        bad_tag_types = tag_types.select { |tag| !valid?(tag)}
-        unless bad_tag_types.empty?
-          err_msg = bad_tag_types.size == 1 ? "Invalid tag '#{bad_tag_types.first}'" : "Invalid tag_types: #{bad_tag_types.join(', ')}"
-          raise Error, err_msg
+      def raise_error_if_conflicting_tags(existing_tag, new_tag)
+        if (existing_tag.class != new_tag.class) or
+            (existing_tag.kind_of?(Assignment) and existing_tag.value != new_tag.value)
+          raise Error, "The tags (#{existing_tag.inspect}) and (#{new_tag.inspect}) are conflicting"
         end
       end
-      
-      private
-      
+
       def self.valid_tag_types
         @valid_tag_tag_types ||= compute_valid_tag_types
       end

data/lib/dsl/file_generator/content_input.rb

@@ -18,7 +18,7 @@
 module DTK::DSL
   class FileGenerator
     class ContentInput < InputOutputCommon::Canonical
-      require_relative('content_input/tags')
+      require_relative('content_input/tag')
       require_relative('content_input/mixin')
       # mixin must go before the files below
       require_relative('content_input/hash')

data/lib/dsl/file_generator.rb

@@ -34,6 +34,13 @@ module DTK::DSL
       template_class = Template.template_class(parse_template_type, dsl_version)
       template_class.create_for_generation(content_input, opts).generate_yaml_text
     end
+
+    # opts can have keys
+    #   :filter
+    def self.generate_yaml_file_path__content_array(parse_template_type, top_file_path, content_input, dsl_version, opts = {})
+      template_class = Template.template_class(parse_template_type, dsl_version)
+      template_class.create_for_generation(content_input, opts).generate_yaml_file_path__content_array(top_file_path)
+    end
   end
 end
 

data/lib/dsl/file_parser.rb

@@ -57,6 +57,7 @@ module DTK::DSL
 
     DSL_VERSION_KEY = 'dsl_version'
     def self.dsl_version__raise_error_if_illegal(input_hash, file_obj)
+      raise Error::Usage, "Ill-formed DSL#{file_ref_in_error(file_obj)}" unless input_hash.kind_of?(::Hash)
       if dsl_version = input_hash[DSL_VERSION_KEY]
         unless DSLVersion.legal?(dsl_version)
           raise Error::Usage, "Illegal DSL version '#{dsl_version}'#{file_ref_in_error(file_obj)}"

data/lib/dsl/file_type/match.rb

@@ -0,0 +1,68 @@
+#
+# 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 FileType
+    class Match
+      def initialize(file_type)
+        @file_type = file_type
+      end
+      private :initialize
+
+      # opts can have keys:
+      #  :exact (Booelan) - meaning regexp completely matches file_path; otherwise it means jsut match the end
+      def self.matches?(file_type, file_path, opts = {})
+        new(file_type).matches?(file_path, opts = {})
+      end
+      
+      def matches?(file_path, opts = {})
+        file_path = remove_multiple_slashes(file_path)
+        if opts[:exact]
+          file_path =~ regexp_exact
+        else
+          # extra check to see if regexp is just for file part or has '/' seperators
+          # if just for file then we can have more restrictive match
+          if regexp.source =~ Regexp.new('/')
+            file_path =~ regexp_match_end
+          else
+            file_path.split('/').last =~ regexp_exact
+          end
+        end
+      end
+      
+      private
+
+      def remove_multiple_slashes(string)
+        string.split('/').reject { |el| el.empty?}.join('/')
+      end
+
+      def regexp
+        @regexp ||=  @file_type.regexp
+      end
+
+      def regexp_exact
+        @regexp_exact ||= Regexp.new("^#{regexp.source}$")
+      end
+
+      def regexp_match_end
+        @regexp_match_end ||= Regexp.new("#{regexp.source}$")
+      end
+
+    end
+  end
+end

data/lib/dsl/file_type/matching_files.rb

@@ -0,0 +1,57 @@
+#
+# 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 FileType
+    class MatchingFiles
+      attr_reader :file_type_instance, :file_paths
+      def initialize(file_type_instance)
+        @file_type_instance  = file_type_instance
+        @file_paths          = []
+      end
+      private :initialize
+
+      def add_file_path!(file_path)
+        @file_paths << file_path
+        self
+      end
+
+      # Returns array of MatchingFiles
+      def self.matching_files_array(file_type_classes, file_paths)
+        ndx_ret = {}
+        file_type_classes = [file_type_classes] unless file_type_classes.kind_of?(Array)
+        file_type_classes.each do |file_type_class|
+          file_paths.each do |file_path|
+            if file_type_instance = file_type_class.file_type_instance_if_match?(file_path)
+              file_type_instance_index = file_type_instance.index
+              if matching_index = ndx_ret.keys.find { |index| index == file_type_instance_index }
+                ndx_ret[matching_index].add_file_path!(file_path)
+              else
+                ndx_ret[file_type_instance_index] = new(file_type_instance).add_file_path!(file_path)
+              end
+            end
+          end
+        end
+        ndx_ret.values
+      end
+
+    end
+  end
+end
+
+

data/lib/dsl/file_type/subclasses.rb

@@ -0,0 +1,71 @@
+#
+# 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 FileType
+    class CommonModule < self
+      def self.top_level_type
+        :common_module
+      end
+
+      class DSLFile < self
+        class Top < self
+        end
+      end
+    end
+
+    class ServiceInstance < self
+      def self.top_level_type
+        :service_instance
+      end
+
+      class DSLFile < self
+        class Top < self
+        end
+      end
+
+      class NestedModule < self
+        attr_reader :module_name
+        # params can have keys:
+        #  :module_name (required)
+        def initialize(params = {})
+          unless @module_name = params[:module_name]
+            raise Error, "Unexpected that opts[:module_name] is nil"
+          end
+        end
+
+        def index
+          "#{super}--#{@module_name}"
+        end
+
+        def canonical_path
+          self.class.canonical_path_lambda.call(:module_name => @module_name)
+        end
+
+        def base_dir
+          matching_type_def(:base_dir_lambda).call(:module_name => @module_name)
+        end
+
+        class DSLFile < self
+          class Top < self
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dsl/file_type.rb

@@ -17,62 +17,131 @@
 #
 
 module DTK::DSL
-  # This has specific file type meta info
   class FileType
-    Types = 
-      [
-       {
-         :type           => :common_module,
-         :regexp         => "/dtk\.module\.(yml|yaml)/",
-         :canonical_path => 'dtk.module.yaml', 
-         :backup_path    => 'dtk.module.bak.yaml', 
-         :print_name     => 'module DSL file'
-       },
-       {
-         :type           => :service_instance,
-         :regexp         => "/dtk\.service\.(yml|yaml)/",
-         :canonical_path => 'dtk.service.yaml', 
-         :backup_path    => 'dtk.service.bak.yaml', 
-         :print_name     => 'service DSL file'
-       }
-      ]
-      # regexps purposely do not have ^ or $ so calling function can insert these depending on context
-
-    Types.each do |type_info|
-      # convert to camel case
-      class_name = type_info[:type].to_s.gsub(/(?<=_|^)(\w)/){$1.upcase}.gsub(/(?:_)(\w)/,'\1')
-      class_eval("
-         class #{class_name} < self
-           def self.type
-             :#{type_info[:type]}
-           end
-           def self.print_name
-             '#{type_info[:print_name]}'
-           end
-           def self.canonical_path
-             '#{type_info[:canonical_path]}'
-           end
-           def self.backup_path
-             '#{type_info[:backup_path]}'
-           end
-
-           private
-
-           def self.regexp
-             #{type_info[:regexp]}
-           end
-        end")
-    end
-
-    def self.create_path_info
-      DirectoryParser::PathInfo.new(regexp)
-    end
-    
+    require_relative('file_type/subclasses')
+    require_relative('file_type/match')
+    require_relative('file_type/matching_files')
+
     # opts can have keys:
     #  :exact - Booelan (default: false) - meaning regexp completely matches file_path
     def self.matches?(file_path, opts = {})
-      DirectoryParser::PathInfo.matches?(file_path, regexp, opts)
+      Match.matches?(self, file_path, opts)
+    end
+    def matches?(file_path, opts = {})
+      Match.matches?(self, file_path, opts)
+    end
+
+    # Returns array of MatchingFiles or nil
+    def self.matching_files_array?(file_type_classes, file_paths)
+      MatchingFiles.matching_files_array?(file_type_classes, file_paths)
+    end
+
+    SERVICE_INSTANCE_NESTED_MODULE_DIR = 'modules'
+    TYPES = {
+      CommonModule::DSLFile::Top => {
+        :regexp                => Regexp.new("dtk\.module\.(yml|yaml)"),
+        :canonical_path_lambda => lambda { |_params| 'dtk.module.yaml' }, 
+        :print_name            => 'module DSL file'
+      },
+      ServiceInstance::DSLFile::Top => {
+        :regexp                => Regexp.new("dtk\.service\.(yml|yaml)"),
+        :canonical_path_lambda => lambda { |_params| 'dtk.service.yaml' }, 
+        :print_name            => 'service DSL file'
+      },
+      ServiceInstance::NestedModule => {
+        :instance_match_lambda => lambda { |path| path =~ Regexp.new("^#{SERVICE_INSTANCE_NESTED_MODULE_DIR}/([^/]+)/.+$") && { :module_name => $1 } },    
+        :base_dir_lambda       => lambda { |params| "#{SERVICE_INSTANCE_NESTED_MODULE_DIR}/#{params[:module_name]}" },
+        :print_name            => 'nested module file'
+      },
+      ServiceInstance::NestedModule::DSLFile::Top => {
+        :regexp                => Regexp.new("#{SERVICE_INSTANCE_NESTED_MODULE_DIR}/[^/]+/dtk\.nested_module\.(yml|yaml)"),
+        :canonical_path_lambda => lambda { |params| "#{SERVICE_INSTANCE_NESTED_MODULE_DIR}/#{params[:module_name]}/dtk.nested_module.yaml" },
+        :print_name            => 'nested module DSL file'
+      }
+    }
+    # regexps, except for one in :instance_match_lambda, purposely do not have ^ or $ so calling function can insert these depending on context
+
+    def self.print_name
+      matching_type_def(:print_name)
+    end
+
+    def self.regexp
+      matching_type_def(:regexp)
+    end
+
+    def self.canonical_path
+      canonical_path_lambda.call({})
+    end
+    # This can be over-written
+    def canonical_path
+      self.class.canonical_path
+    end
+
+    def self.backup_path
+      backup_path_from_canonical_path(canonical_path)
+    end
+    def backup_path
+      self.class.backup_path_from_canonical_path(canonical_path)
+    end
+
+    def self.base_dir
+      nil
     end
+    # This can be over-written
+    def base_dir
+      self.class.base_dir
+    end
+
+
+    # If match it retuns a hash with params that can be used to create a File Type instance
+    def self.file_type_instance_if_match?(file_path)
+      # just want to match 'this' and dont want to match parent so not using matching_type_def
+      if instance_match_lambda = TYPES[self][:instance_match_lambda]
+        if hash_params_for_new = instance_match_lambda.call(file_path)
+          new(hash_params_for_new)
+        end
+      end
+    end
+
+    def self.type_level_type
+      raise Error::NoMethodForConcreteClass.new(self)
+    end
+
+    # This can be over-written
+    def index
+      self.class.to_s
+    end
+
+    private
+
+    BASE_CLASS = FileType 
+    # The method matching_type_def starts at tpe and looks to see if or recursive parents have definition
+    def self.matching_type_def(key, klass = nil, orig_klass = nil)
+      klass      ||= self
+      orig_klass ||= self
+      fail Error, "Type '#{orig_klass}' is not in TYPES" if klass == BASE_CLASS 
+      if type_def_hash = TYPES[klass] 
+        type_def_hash[key]
+      else
+        matching_type_def(key, klass.superclass, orig_klass)
+      end
+    end
+    def matching_type_def(key)
+      self.class.matching_type_def(key)
+    end
+
+    def self.canonical_path_lambda
+      matching_type_def(:canonical_path_lambda)
+    end
+
+    FILE_PREFIX = 'bak'
+    def self.backup_path_from_canonical_path(canonical_path)
+      split_path = canonical_path.split('/')
+      file_path = split_path.pop
+      backup_file_path = "#{FILE_PREFIX}.#{file_path}"
+      split_path.empty? ? backup_file_path : "#{split_path.join('/')}/#{backup_file_path}"      
+    end
+
   end
 end