loom-core 0.0.6 → 0.0.7

data/lib/loom/pattern/expanding_reference.rb

@@ -1,16 +1,98 @@
+require "pry"
+
 module Loom::Pattern
   class ExpandingReference
 
-    attr_reader :slug, :reference_slugs, :source_file, :desc
+    RecursiveExpansionError = Class.new Loom::LoomError
+
+    # TODO: Ensure ExpandingReference and Reference stay in sync. Maybe create
+    # an inheritance hierarchy.
+    attr_reader :slug, :reference_slugs, :source_file, :desc, :pattern
 
-    def initialize(slug, reference_slugs, source_file, description)
+    ##
+    # @param slug [String]: flattened colon separated slug name
+    # @param pattern [Loom::Pattern::Pattern]: a pattern responding to +expanded_slugs+
+    def initialize(slug, pattern, reference_set)
       @slug = slug
-      @reference_slugs = reference_slugs
-      @desc = description
+      @reference_set = reference_set
+      # TODO: Hmm... I tried to abstract the "weave" keyword from the
+      # "ExpandingReference" concept... but it leaked through. Think the
+      # `pattern.kind` based method name over.
+      @reference_slugs = pattern.weave.expanded_slugs
+      @desc = pattern.description
+      @pattern
+    end
+
+    def expand_slugs
+      slug_matchers = @reference_slugs.map do |s|
+        Matcher.get_matcher(s)
+      end
+
+      # O(MN) :(
+      expanded_slugs = @reference_slugs.flat_map do |s|
+        @reference_set.slugs.select { |s| slug_matchers.any? { |m| m.match?(s) } }
+      end.uniq
+      Loom.log.debug3(self) { "Loom::Pattern::ExpandingReference@reference_slugs+: #{@reference_slugs.join(",")}"}
+      Loom.log.debug3(self) { "Loom::Pattern::ExpandingReference+expanded_slugs+: #{expanded_slugs.join(",")}"}
+
+      expanded_refs = expanded_slugs.map { |s| @reference_set[s] }
+      expanded_refs.each do |r|
+        if r.is_a? ExpandingReference
+          Loom.log.error "recursive expansion for pattern[#{r.slug}] in weave[#{@slug}], i.e. only patterns are allowed in weaves"
+          raise RecursiveExpansionError, @slug
+        end
+      end
+
+      Loom.log.info { "expanded slug[#{@slug}] => #{expanded_slugs.join(",")}"}
+      expanded_slugs
     end
 
-    def is_expanding?
-      true
+    private
+    # TODO: This can be made common to some utility directory if one emerges.
+    class Matcher
+
+      def self.get_matcher(slug)
+        matcher_module = [
+          GlobMatcher,
+          EqualityMatcher
+        ].first { |m| m.handles_pattern? slug }
+
+        Class.new(Matcher).include(matcher_module).new(slug)
+      end
+
+      def initialize(loom_pattern_slug)
+        @my_slug = loom_pattern_slug
+      end
+
+      private
+      module GlobMatcher
+        MATCH_P = /(\*)$/
+
+        def self.handles_pattern?(p)
+          p.match? MATCH_P
+        end
+
+        def match?(your_pattern)
+          # TODO: This can be made RE2 compliant later.
+          unless GlobMatcher.handles_pattern?(@my_slug)
+            raise 'WTF? invalid pattern, must end in "*": %s' % @my_slug
+          end
+
+          prefix = @my_slug.to_s.gsub(MATCH_P, "")
+          Loom.log.debug2(self) { "GlobMatcher+match?+ #{@my_slug} #{your_pattern}, prefix: #{prefix}"}
+          your_pattern.to_s.start_with? prefix
+        end
+      end
+
+      module EqualityMatcher
+        def self.handles_pattern?(p)
+          true
+        end
+
+        def match?(your_pattern)
+          @my_slug == your_pattern
+        end
+      end
     end
   end
 end

data/lib/loom/pattern/loader.rb

@@ -1,7 +1,6 @@
 module Loom::Pattern
 
   SiteFileNotFound = Class.new Loom::LoomError
-  RecursiveExpansionError = Class.new Loom::LoomError
 
   class Loader
     class << self
@@ -48,22 +47,7 @@ module Loom::Pattern
     end
 
     def expand_refs(refs)
-      refs.flat_map do |ref|
-        if ref.is_expanding?
-          expanded_refs = ref.reference_slugs.map { |s| get_pattern_ref(s) }
-          expanded_refs.each do |exp_ref|
-            if exp_ref.is_expanding?
-              Loom.log.error "error expanding pattern[#{exp_ref.slug}] in weave[#{ref.slug}], i.e. only patterns are allowed in weaves"
-              raise RecursiveExpansionError, ref.slug
-            end
-          end
-          Loom.log.info(
-            "expanded pattern #{ref.slug} to patterns: #{expanded_refs.map(&:slug).join(",")}")
-          expanded_refs
-        else
-          ref
-        end
-      end
+      refs.flat_map { |r| r.expand_slugs }.map { |s| @reference_set[s] }
     end
   end
 end

data/lib/loom/pattern/pattern.rb

@@ -0,0 +1,52 @@
+module Loom::Pattern
+  # A value object represnting the .loom file pattern declarations. The
+  # difference between a Loom::Pattern::Pattern and Loom::Pattern::Reference is
+  # a pattern has no association to the context it should run in. It is simply a
+  # value object with pointers to its assigned values from the .loom
+  # file. However, a Reference includes it's DefinitionContext, including nested
+  # before/after/with_facts/let hooks.
+  class Pattern
+
+    KINDS = %i[pattern weave report]
+      .reduce({}) { |memo, k| memo.merge k => true }.freeze
+
+    # effectively, a list of `attr_readers` for the Pattern kind. but also used
+    # for validation
+    KIND_KWARGS = {
+      weave: [:expanded_slugs]
+    }.freeze
+
+    attr_reader :name, :description, :kind, :pattern_block
+
+    def initialize(name: nil, description: nil, kind: nil, **kind_kwargs, &block)
+      @name = name
+      @description = description
+      @kind = kind
+      @pattern_block = block
+
+      @valid_kwargs = KIND_KWARGS[kind]
+      kind_kwargs.each do |k, _|
+        raise "unknown kind_kwarg: #{k}" unless @valid_kwargs.include? k
+      end
+      @kind_properties_struct = OpenStruct.new kind_kwargs
+    end
+
+    # Adds methods:
+    # :is_weave?, is_pattern?, :is_reported?
+    # :weave, :patttern, :reported => returns the OpenStruct of KIND_KWARGS.
+    KINDS.keys.each do |k|
+      is_k_name = "is_#{k}?".intern
+      Loom.log.debug3(self) { "defining method Loom::Pattern::Pattern+#{is_k_name}+" }
+      define_method(is_k_name) { @kind == k }
+
+      k_name = k.intern
+      Loom.log.debug1(self) { "defining method Loom::Pattern::Pattern+#{k_name}+" }
+      define_method(k_name) do
+        if @kind != k_name
+          raise "invalid kwarg +#{k_name}+ for Pattern[#{@kind}]"
+        end
+        @kind_properties_struct.dup
+      end
+    end
+  end
+end

data/lib/loom/pattern/reference.rb

@@ -1,22 +1,25 @@
 module Loom::Pattern
+  # See Loom::Pattern::Pattern for the difference between refs and patterns.
   class Reference
 
-    attr_reader :slug, :source_file, :desc
+    attr_reader :slug, :source_file, :desc, :pattern
 
-    def initialize(slug, unbound_method, source_file, definition_ctx, description)
+    def initialize(slug, pattern, source_file, definition_ctx)
       @slug = slug
-      @unbound_method = unbound_method
       @source_file = source_file
       @definition_ctx = definition_ctx
-      @desc = description
+      @desc = pattern.description
+      @pattern = pattern
     end
 
-    def is_expanding?
-      false
+    # Used by Loom::Pattern::Loader to expand weaves. A Pattern::Reference it
+    # just expands to itself.
+    def expand_slugs
+      @slug
     end
 
     def call(shell_api, host_fact_set)
-      run_context = RunContext.new @unbound_method, @definition_ctx
+      run_context = RunContext.new @pattern, @definition_ctx
 
       fact_set = @definition_ctx.fact_set host_fact_set
       Loom.log.debug5(self) {
@@ -30,7 +33,7 @@ module Loom::Pattern
       begin
         run_context.run shell_api, fact_set
       rescue => e
-        error_msg = "error executing '#{slug}' in #{source_file} => #{e} \n%s"
+        error_msg = "error executing '#{slug}' in #{source_file} =>\n\t#{e}\n%s"
         Loom.log.error(error_msg % e.backtrace.join("\n\t"))
         raise
       end
@@ -42,8 +45,8 @@ module Loom::Pattern
     # A small class to bind the unbound_method to and provide context
     # in the case of errors.
     class RunContext
-      def initialize(unbound_method, definition_ctx)
-        @bound_method = unbound_method.bind self
+      def initialize(pattern, definition_ctx)
+        @pattern = pattern
         @definition_ctx = definition_ctx
       end
 
@@ -55,7 +58,7 @@ module Loom::Pattern
           Loom.log.debug1(self) { "before hooks => #{before_hooks}"}
           before_hooks.each do |hook|
             Loom.log.debug2(self) { "executing before hook => #{hook}"}
-            self.instance_exec shell_api, fact_set, &hook.block
+            instance_exec shell_api, fact_set, &hook.block
           end
 
           # This is the entry point into calling patterns.
@@ -64,14 +67,15 @@ module Loom::Pattern
           Loom.log.debug1(self) { "after hooks => #{after_hooks}" }
           after_hooks.each do |hook|
             Loom.log.debug2(self) { "executing after hook => #{hook}"}
-            self.instance_exec shell_api, fact_set, &hook.block
+            instance_exec shell_api, fact_set, &hook.block
           end
         end
       end
 
       private
+
       def apply_pattern(*args)
-        @bound_method.call *args
+        instance_exec(*args, &@pattern.pattern_block)
       end
     end
 

data/lib/loom/pattern/reference_set.rb

@@ -3,10 +3,13 @@
 # into a reference set. There's also a lot of dark magic w/ generating
 # stacktraces to get the correct .loom file line (but I forget if that's done
 # here or in pattern/reference.rb maybe?)
+
+# NB: The use of the word "mod" or "module" in this file probably means a
+# ::Module, not a Loom::Mods::Module
 module Loom::Pattern
 
   DuplicatePatternRef = Class.new Loom::LoomError
-  UnknownPatternMethod = Class.new Loom::LoomError
+  NoReferenceForSlug = Class.new Loom::LoomError
   InvalidPatternNamespace = Class.new Loom::LoomError
 
   ##
@@ -16,7 +19,11 @@ module Loom::Pattern
     class << self
       def load_from_file(path)
         Loom.log.debug1(self) { "loading patterns from file => #{path}" }
-        Builder.create File.read(path), path
+        builder(File.read(path), path).build
+      end
+
+      def builder(file_src, file_path)
+        Builder.create(file_src, file_path)
       end
     end
 
@@ -34,21 +41,20 @@ module Loom::Pattern
 
     def get_pattern_ref(slug)
       ref = @slug_to_ref_map[slug]
-      raise UnknownPatternMethod, slug unless ref
+      raise NoReferenceForSlug, slug unless ref
       ref
     end
     alias_method :[], :get_pattern_ref
 
     def merge!(ref_set)
-      self.add_pattern_refs(ref_set.pattern_refs)
+      add_pattern_refs(ref_set.pattern_refs)
     end
 
     def add_pattern_refs(refs)
-      map = @slug_to_ref_map
       refs.each do |ref|
         Loom.log.debug2(self) { "adding ref to set => #{ref.slug}" }
-        raise DuplicatePatternRef, ref.slug if map[ref.slug]
-        map[ref.slug] = ref
+        raise DuplicatePatternRef, ref.slug if @slug_to_ref_map[ref.slug]
+        @slug_to_ref_map[ref.slug] = ref
       end
     end
 
@@ -57,83 +63,95 @@ module Loom::Pattern
 
       class << self
         def create(ruby_code, source_file)
+          # Creates an anonymous parent module in which to evaluate the .loom
+          # file src. This module acts as a global context for the .loom file.
+          # TODO: How should this be hardened?
           shell_module = Module.new
           shell_module.include Loom::Pattern
           # TODO: I think this is my black magic for capturing stacktrace
           # info... I forget the details. Add documentation.
+          # TODO: This is where I would need to hack into to auto-include
+          # Loom::Pattern in .loom file modules
           shell_module.module_eval ruby_code, source_file, 1
           shell_module.namespace ""
 
-          self.new(shell_module, source_file).build
+          self.new shell_module, source_file
         end
       end
 
       def initialize(shell_module, source_file)
         @shell_module = shell_module
-        @pattern_mod_specs = pattern_mod_specs
         @source_file = source_file
       end
 
       def build
         ref_set = ReferenceSet.new
+
+        dsl_specs = create_dsl_specs
+        pattern_refs = create_pattern_refs dsl_specs, ref_set
+
         ref_set.add_pattern_refs pattern_refs
         ref_set
       end
 
       private
-      def pattern_refs
-        @pattern_mod_specs.map { |mod_spec| refs_for_mod_spec mod_spec }.flatten
+      # TODO: I don't like passing in the ref set build target here.... but
+      # ExpandingReference needs it... Can I do this w/o an instance variable
+      # and w/o plumbing the param through methods?
+      def create_pattern_refs(dsl_specs, builder_target_ref_set)
+        dsl_specs.flat_map do |dsl_spec|
+          create_refs_for_dsl_spec dsl_spec, builder_target_ref_set
+        end
       end
 
-      def refs_for_mod_spec(mod_spec)
-        mod = mod_spec[:module]
-        context = context_for_mod_spec mod_spec
+      def create_refs_for_dsl_spec(dsl_spec, builder_target_ref_set)
+        context = create_defn_context_for_dsl_spec dsl_spec
 
-        mod_spec[:pattern_methods].map do |m|
-          slug = compute_slug mod_spec[:namespace_list], m
+        dsl_spec[:dsl_builder].patterns.map do |pattern|
+          slug = compute_slug dsl_spec[:namespace_list], pattern.name
 
-          if mod.is_weave?(m)
+          case pattern.kind
+          when :weave
             Loom.log.debug2(self) { "adding ExpandingReference for weave: #{slug}" }
-            build_expanding_reference(m, slug, mod)
+            create_expanding_reference(pattern, slug, builder_target_ref_set)
           else
             Loom.log.debug2(self) { "adding Reference for pattern: #{slug}" }
-            build_pattern_reference(m, slug, context, mod)
+            create_pattern_reference(pattern, slug, context)
           end
         end
       end
 
-      def build_expanding_reference(weave_name, slug, mod)
-        desc = mod.pattern_description weave_name
+      def create_expanding_reference(pattern, slug, ref_set)
+        desc = pattern.description
         Loom.log.warn "no descripiton for weave => #{slug}" unless desc
 
-        ExpandingReference.new slug, mod.weave_slugs[weave_name], @source_file, desc
+        ExpandingReference.new slug, pattern, ref_set
       end
 
-      def build_pattern_reference(pattern_name, slug, context, mod)
-        method = mod.pattern_method pattern_name
-        desc = mod.pattern_description pattern_name
+      def create_pattern_reference(pattern, slug, context)
+        desc = pattern.description
         Loom.log.warn "no descripiton for pattern => #{slug}" unless desc
 
-        Reference.new slug, method, @source_file, context, desc
+        Reference.new slug, pattern, @source_file, context
       end
 
-      def context_for_mod_spec(mod_spec)
-        parents = mod_spec[:parent_modules].find_all do |mod|
-          is_pattern_module mod
+      # Creates a DefinitionContext for dsl_module by flattening and mapping
+      # parent ::Modules to a contextualized DefinitionContext.
+      def create_defn_context_for_dsl_spec(dsl_spec)
+        parents = dsl_spec[:parent_modules].find_all do |mod|
+          dsl_module? mod
         end
         parent_context = parents.reduce(nil) do |parent_ctx, parent_mod|
-          DefinitionContext.new parent_mod, parent_ctx
+          DefinitionContext.new parent_mod.dsl_builder, parent_ctx
         end
-
-        mod = mod_spec[:module]
-        DefinitionContext.new mod, parent_context
+        DefinitionContext.new dsl_spec[:dsl_builder], parent_context
       end
 
       def compute_slug(namespace_list, pattern_method_name)
         namespace_list.dup.push(pattern_method_name).join ":"
       end
 
-      def mod_namespace_list(pattern, parent_modules)
+      def create_namespace_list(pattern, parent_modules)
         mods = parent_modules.dup << pattern
         mods.reduce([]) do |memo, mod|
           mod_name = if mod.respond_to?(:namespace) && mod.namespace
@@ -149,32 +167,35 @@ module Loom::Pattern
         end
       end
 
-      def pattern_mod_specs
-        pattern_mods = []
-        traverse_pattern_modules @shell_module do |pattern_mod, parent_modules|
-          Loom.log.debug2(self) { "found pattern module => #{pattern_mod}" }
-          pattern_methods = pattern_mod.pattern_methods
+      def create_dsl_specs
+        dsl_mods = []
+        traverse_dsl_modules @shell_module do |dsl_mod, parent_modules|
+          Loom.log.debug2(self) { "found pattern module => #{dsl_mod}" }
+
+          dsl_builder = dsl_mod.dsl_builder
+          next if dsl_builder.patterns.empty?
 
-          next if pattern_methods.empty?
-          pattern_mods << {
-            :namespace_list => mod_namespace_list(pattern_mod, parent_modules),
-            :pattern_methods => pattern_methods,
-            :module => pattern_mod,
-            :parent_modules => parent_modules.dup
+          dsl_mods << {
+            namespace_list: create_namespace_list(dsl_mod, parent_modules),
+            dsl_builder: dsl_builder,
+            dsl_module: dsl_mod,
+            parent_modules: parent_modules
           }
         end
-        pattern_mods
+        dsl_mods
       end
 
-      def is_pattern_module(mod)
+      def dsl_module?(mod)
         mod.included_modules.include? Loom::Pattern
       end
 
-      def traverse_pattern_modules(mod, pattern_parents=[], visited={}, &block)
+      # Recursive method to walk the tree of dsl_builders representative of the
+      # .loom file pattern modules
+      def traverse_dsl_modules(mod, pattern_parents=[], visited={}, &block)
         return if visited[mod.name] # prevent cycles
         visited[mod.name] = true
 
-        yield mod, pattern_parents.dup if is_pattern_module(mod)
+        yield mod, pattern_parents.dup if dsl_module?(mod)
 
         # Traverse all sub modules, even ones that aren't
         # Loom::Pattern[s], since they might contain more sub modules
@@ -185,7 +206,7 @@ module Loom::Pattern
 
         pattern_parents << mod
         sub_modules.each do |sub_mod|
-          traverse_pattern_modules sub_mod, pattern_parents.dup, visited, &block
+          traverse_dsl_modules sub_mod, pattern_parents.dup, visited, &block
         end
       end
     end