class Loom::Pattern::DSL::PatternBuilder

Public Class Methods

new() click to toggle source
# File lib/loom/pattern/dsl.rb, line 336
def initialize
  @pattern_map = {}
  @fact_map = {}
  @let_map = {}
  @hooks = []
  @next_description = nil
end

Public Instance Methods

after(&block) click to toggle source
# File lib/loom/pattern/dsl.rb, line 411
def after(&block)
  hook :after, &block
end
before(&block) click to toggle source
# File lib/loom/pattern/dsl.rb, line 407
def before(&block)
  hook :before, &block
end
desc(description)
Alias for: description
description(description) click to toggle source
# File lib/loom/pattern/dsl.rb, line 347
def description(description)
  @next_description = description
end
Also aliased as: desc
facts() click to toggle source
# File lib/loom/pattern/dsl.rb, line 424
def facts
  @fact_map
end
hooks() click to toggle source
# File lib/loom/pattern/dsl.rb, line 420
def hooks
  @hooks
end
let(name, default: nil, &block) click to toggle source
# File lib/loom/pattern/dsl.rb, line 358
def let(name, default: nil, &block)
  raise "malformed let expression: missing block" unless block_given?
  @let_map[name.to_sym] = LetMapEntry.new default, &block
end
let_map() click to toggle source
# File lib/loom/pattern/dsl.rb, line 428
def let_map
  @let_map
end
pattern(name, &block) click to toggle source
# File lib/loom/pattern/dsl.rb, line 363
def pattern(name, &block)
  define_pattern_internal(name, kind: :pattern, &block)
end
patterns() click to toggle source

END DSL Implementation

# File lib/loom/pattern/dsl.rb, line 416
def patterns
  @pattern_map.values
end
report(name, format: :yaml, &block) click to toggle source

@param format default is :yaml

# File lib/loom/pattern/dsl.rb, line 369
def report(name, format: :yaml, &block)
  define_pattern_internal(name, kind: :report) do |loom, facts|
    # TODO: I don't like all of this logic here. It feels like it belongs in
    # a mod.
    result = if block_given?
               Loom.log.debug(self) { "report[#{name}] from block" }
               instance_exec(loom, facts, &block)
             elsif !Loom::Facts.is_empty?(facts[name])
               Loom.log.debug(self) { "report[#{name}] from facts[#{name}]" }
               facts[name]
             elsif respond_to?(name) && !self.send(name).nil?
               Loom.log.debug(self) { "report[#{name}] from let{#{name}}" }
               self.send name
             else
               err_msg = "no facts to report for fact[#{name}:#{name.class}]"
               raise PatternDefinitionError, err_msg
             end
    result = result.stdout if result.is_a? Loom::Shell::CmdResult

    puts case format
         when :yaml then result.to_yaml
         when :json then result.to_json
         when :raw then result
         else
           err_msg = "invalid report format: #{format.inspect}"
           err_msg << "valid options: yaml,json,raw"
           raise PatternDefinitionError, err_msg
         end
  end
end
weave(name, pattern_slugs) click to toggle source
# File lib/loom/pattern/dsl.rb, line 400
def weave(name, pattern_slugs)
  unless @next_description
    @next_description = "Weave runs patterns: %s" % pattern_slugs.join(", ")
  end
  define_pattern_internal(name, kind: :weave, expanded_slugs: pattern_slugs) { true }
end
with_facts(**new_facts) { |fact_map| ... } click to toggle source
# File lib/loom/pattern/dsl.rb, line 352
def with_facts(**new_facts, &block)
  @fact_map.merge! new_facts
  yield_result = yield @fact_map if block_given?
  @fact_map = yield_result if yield_result.is_a? Hash
end

Private Instance Methods

define_pattern_internal(name, kind: :pattern, **kwargs, &loom_file_block) click to toggle source

TODO: Let mods introduce new pattern handlers. A pattern is effectively a named wrapper around a pattern execution block. This would be an advanced usage when before and after blocks aren't scalable. It could also provided additional filtering for pattern selection at weave time.

# File lib/loom/pattern/dsl.rb, line 437
def define_pattern_internal(name, kind: :pattern, **kwargs, &loom_file_block)
  unless block_given?
    raise PatternDefinitionError, "missing block for pattern[#{name}]"
  end
  unless Pattern::KINDS[kind]
    raise "unknown pattern kind: #{kind}"
  end

  desc = @next_description
  unless desc.is_a?(String) || desc.nil?
    raise PatternDefinitionError, "description must be a string: #{desc.class}"
  end
  @next_description = nil
  name = name.intern

  Loom.log.debug(self) { "defined .loom pattern[kind:#{kind}]: #{name}" }
  @pattern_map[name] = Pattern.new(
    name: name, description: desc, kind: kind, **kwargs, &loom_file_block)
end
hook(scope, &block) click to toggle source
# File lib/loom/pattern/dsl.rb, line 457
def hook(scope, &block)
  @hooks << Hook.new(scope, &block)
end