diecut 0.0.1

data/lib/diecut/template-set.rb

@@ -0,0 +1,108 @@
+require 'tsort'
+require 'diecut/template'
+require 'diecut/mustache'
+require 'diecut/configurable'
+
+module Diecut
+  class TemplateSet
+    include TSort
+
+    def initialize
+      @templates = {}
+      @path_templates = {}
+      @breaking_cycles = {}
+      @partials = {}
+      @context_class = nil
+      @context = nil
+      @renderer = nil
+    end
+    attr_reader :partials, :templates, :path_templates
+
+    def add(path, contents)
+      template = Diecut::Template.new(path, contents)
+      @templates[path] = template
+      path_template = Diecut::Template.new("path for " + path, path)
+      @path_templates[path] = path_template
+      template.partials.each do |name, _|
+        @partials[name] = template
+      end
+    end
+
+    def all_templates
+      @templates.values + @path_templates.values
+    end
+
+    def context_class
+      @context_class ||= Configurable.build_subclass("General context")
+    end
+
+    def context
+      @context ||= context_class.new
+    end
+    attr_writer :context
+
+    def is_partial?(tmpl)
+      @partials.has_key?(tmpl.path)
+    end
+
+    def tsort_each_node(&block)
+      @breaking_cycles.clear
+      @templates.each_value(&block)
+    end
+
+    def tsort_each_child(node)
+      node.partials.each do |name, _|
+        unless @breaking_cycles[name]
+          @breaking_cycles[name] = true
+          yield @templates[name]
+        end
+      end
+    end
+
+    def prepare
+      associate_partials
+      build_context
+    end
+
+    def renderer
+      @renderer ||= Mustache.new.tap do |mustache|
+        mustache.partials_hash = partials
+      end
+    end
+
+    def results
+      context.check_required
+
+      tsort_each do |template|
+        next if is_partial?(template)
+
+        path = @path_templates[template.path]
+        context.copy_settings_to(template.context)
+        context.copy_settings_to(path.context)
+
+        yield path.render(renderer), template.render(renderer)
+      end
+    end
+
+    def associate_partials
+      partials = []
+      tsort_each do |template|
+        partials.each do |partial|
+          template.partial_context(partial)
+        end
+        if is_partial?(template)
+          partials << template
+        end
+      end
+    end
+
+    def build_context
+      tsort_each do |template|
+        context_class.absorb_context(template.context_class)
+      end
+      @path_templates.each_value do |template|
+        context_class.absorb_context(template.context_class)
+      end
+    end
+  end
+end

data/lib/diecut/template.rb

@@ -0,0 +1,58 @@
+require 'diecut/configurable'
+require 'diecut/template-reducer'
+
+module Diecut
+  class Template
+    def initialize(path, template_string)
+      @path = path
+      @template_string = template_string
+      @reduced = nil
+      @context_class = nil
+      @context = nil
+    end
+
+    attr_reader :path, :template_string
+
+    def partial_context(other)
+      reduced.partials.each do |path, nesting|
+        next unless path == other.path
+        add_subcontext(nesting, other.context_class)
+      end
+    end
+
+    def add_subcontext(nesting, other)
+      other.field_names.each do |field|
+        context_class.build_setting(nesting + [field])
+      end
+    end
+
+    def context_class
+      @context_class ||= build_context_class
+    end
+
+    def reduced
+      @reduced ||= TemplateReducer.new(Mustache::Parser.new.compile(template_string))
+    end
+
+    def partials
+      reduced.partials
+    end
+
+    def build_context_class
+      klass = Configurable.build_subclass(path)
+
+      reduced.leaf_fields.each do |field|
+        klass.build_setting(field, reduced.sections.include?(field))
+      end
+      klass
+    end
+
+    def context
+      @context ||= context_class.new
+    end
+
+    def render(renderer)
+      renderer.render(template_string, context.to_hash)
+    end
+  end
+end

data/lib/diecut/ui-applier.rb

@@ -0,0 +1,71 @@
+module Diecut
+  class UIApplier
+    attr_accessor :plugins, :ui, :context
+
+    # setup default values on ui
+    # setup dynamic defaults on context
+    # copy ui settings to context
+    # resolve context config
+    # confirm required
+    def apply
+      check_ui
+      basic_defaults
+      dynamic_defaults
+      copy_to_context
+      resolve_context
+      confirm_required
+    end
+
+    def check_ui
+      ui.check_required
+    end
+
+    def basic_defaults
+      context.setup_defaults
+    end
+
+    def dynamic_defaults
+      plugins.each do |plugin|
+        plugin.context_defaults.each do |default|
+          apply_dynamic_default(default)
+        end
+      end
+    end
+
+    def copy_to_context
+      plugins.each do |plugin|
+        plugin.options.each do |option|
+          copy_option(option)
+        end
+      end
+    end
+
+    def resolve_context
+      plugins.each do |plugin|
+        unless plugin.resolve_block.nil?
+          plugin.apply_resolve(ui, context)
+        end
+      end
+    end
+
+    def confirm_required
+      context.check_required
+    end
+
+    def apply_dynamic_default(default)
+      return if default.simple?
+
+      segment = context.walk_path(default.context_path).last
+
+      segment.value = default.compute_value(context)
+    end
+
+    def copy_option(option)
+      return unless option.has_context_path?
+
+      segment = context.walk_path(option.context_path).last
+
+      segment.value = ui.get_value(option.name.to_sym)
+    end
+  end
+end

data/lib/diecut/ui-config.rb

@@ -0,0 +1,31 @@
+require 'diecut/configurable'
+module Diecut
+  class UIConfig < Configurable
+    class << self
+      def options_hash
+        @options_hash ||= {}
+      end
+
+      def description(name)
+        @options_hash.fetch(name).description
+      end
+
+      def required?(name)
+        field_metadata(name).is?(:required)
+      end
+
+      def default_for(name)
+        field_metadata(name).default_value
+      end
+    end
+
+    def initialize
+      super
+      setup_defaults
+    end
+
+    def get_value(name)
+      self.class.field_metadata(name).value_on(self)
+    end
+  end
+end

data/lib/diecut.rb

@@ -0,0 +1,54 @@
+require 'diecut/mediator'
+require 'diecut/plugin-description'
+require 'diecut/plugin-loader'
+
+module Diecut
+  class << self
+    def plugin_loader
+      @plugin_loader ||= PluginLoader.new
+    end
+
+    def plugin_loader=(loader)
+      @plugin_loader = loader
+    end
+
+    def clear_plugins
+      @plugin_loader = nil
+    end
+
+    def load_plugins(prerelease = false)
+      plugin_loader.load_plugins(prerelease)
+    end
+
+    def plugins
+      plugin_loader.plugins
+    end
+
+    # Used in a `diecut_plugin.rb` file (either in the `lib/` of a gem, or at
+    # the local `~/.config/diecut/diecut_plugin.rb` to register a new plugin.
+    #
+    # @param name [String, Symbol]
+    #   Names the plugin so that it can be toggled  later
+    #
+    # @yieldparam description [PluginDescription]
+    #   The description object to configure the plugin with.
+    def plugin(name, &block)
+      plugin_loader.describe_plugin(name, &block)
+    end
+
+    def kinds
+      plugins.reduce([]) do |list, plugin|
+        list + plugin.kinds
+      end.uniq
+    end
+
+    def mediator(kind)
+      Mediator.new.tap do |med|
+        plugins.each do |plug|
+          next unless plug.has_kind?(kind)
+          med.add_plugin(plug)
+        end
+      end
+    end
+  end
+end

data/spec/cli_spec.rb

@@ -0,0 +1 @@
+require 'diecut/cli'

data/spec/configurable_spec.rb

@@ -0,0 +1,20 @@
+require 'diecut/configurable'
+
+describe Diecut::Configurable do
+  let :subclass do
+    Class.new(described_class){
+      setting :shallow
+      setting :deeply, Class.new(Diecut::Configurable){
+        setting :nested, Class.new(Diecut::Configurable){
+          setting :field
+        }
+      }
+    }.tap do |subclass|
+      subclass.target_name = "for something"
+    end
+  end
+
+  it "inspects nicely" do
+    expect(subclass.inspect).to match(/Configurable.*something.*deeply\.nested\.field/)
+  end
+end

data/spec/linter_spec.rb

@@ -0,0 +1,132 @@
+require 'diecut/mill'
+require 'diecut/linter'
+
+describe Diecut::Mill do
+  let :mill do
+    Diecut::Mill.new("kind").tap do |mill|
+      mill.valise = valise
+    end
+  end
+
+  let :valise do
+    Valise::Set.define do
+      defaults do
+        file "{{testing}}.txt", "I am a {{thing}} for {{testing}}"
+      end
+    end
+  end
+
+  let :plugin do
+    Diecut::PluginDescription.new('dummy', 'dummy.rb').tap do |plugin|
+      plugin.option('testing') do |opt|
+        opt.goes_to('testing')
+      end
+      plugin.option('thing') do |opt|
+        opt.goes_to(['thing'])
+      end
+      plugin.default('thing', 15)
+    end
+  end
+
+  let :option_colision_plugin do
+    Diecut::PluginDescription.new('icky', 'icky.rb').tap do |plugin|
+      plugin.default_off
+      plugin.option('context_colision') do |opt|
+        opt.goes_to('testing')
+      end
+    end
+  end
+
+  let :default_override_plugin do
+    Diecut::PluginDescription.new('stinky', 'stinky.rb').tap do |plugin|
+      plugin.default_off
+      plugin.default('thing', 'fifteen')
+    end
+  end
+
+  let :plugins do
+    [plugin, option_colision_plugin, default_override_plugin]
+  end
+
+  let :loader do
+    instance_double("Diecut::PluginLoader").tap do |loader|
+      allow(loader).to receive(:strict_sequence?).and_return(false)
+      allow(loader).to receive(:plugins).and_return(plugins)
+    end
+  end
+
+  before :each do
+    allow(Diecut).to receive(:plugin_loader).and_return(loader)
+
+    plugins.each do |plugin|
+      mill.mediator.add_plugin(plugin)
+    end
+  end
+
+  subject :linter do
+    Diecut::Linter.new(mill)
+  end
+
+  let :report do
+    linter.report
+  end
+
+  describe "happy set of plugins" do
+    it "should produce a report" do
+      expect(report).to match(/Total QA failing reports: 0/)
+    end
+  end
+
+  describe "with an option collision" do
+    before :each do
+      mill.mediator.activate('icky')
+    end
+
+    it "should produce a report" do
+      expect(report).to match(/Option collisions: FAIL/)
+      expect(report).to match(/Total QA failing reports:/)
+      expect(report).to match(/there's/)
+    end
+  end
+
+  describe "with a missing context field" do
+    before :each do
+      mill.mediator.activate('icky')
+      mill.mediator.deactivate('dummy')
+    end
+
+    it "should produce a report" do
+      expect(report).to match(/Template fields all have settings: WARN/)
+      expect(report).to match(/Output field\s+Source file/)
+      expect(report).to match(/thing\s+{{testing}}.txt/)
+      expect(report).not_to match(/^\s*testing\b/)
+      expect(report).to match(/Total QA failing reports:/)
+    end
+  end
+
+  describe "with intentional override of default" do
+    before :each do
+      mill.mediator.activate("dummy")
+      mill.mediator.activate("stinky")
+      allow(loader).to receive(:strict_sequence?).with(plugin, default_override_plugin).and_return(true)
+    end
+
+    it "should produce a report" do
+      expect(report).to match(/Overridden context defaults: OK/)
+    end
+  end
+
+  describe "with accidental override of default" do
+    before :each do
+      mill.mediator.activate("dummy")
+      mill.mediator.activate("stinky")
+    end
+
+    it "should produce a report" do
+      expect(report).to match(/Overridden context defaults: FAIL/)
+      expect(report).to match(/Output field\s+Default value\s+Source plugin/)
+      expect(report).to match(/thing\s+15\s+dummy/)
+      expect(report).to match(/Total QA failing reports:/)
+    end
+  end
+end

data/spec/mill_spec.rb

@@ -0,0 +1,52 @@
+require 'diecut/mill'
+
+describe Diecut::Mill do
+  subject :mill do
+    Diecut::Mill.new("kind").tap do |mill|
+      mill.valise = valise
+    end
+  end
+
+  let :valise do
+    Valise::Set.define do
+      defaults do
+        file "{{testing}}.txt", "I am a {{thing}} for {{testing}}"
+      end
+    end
+  end
+
+  let :plugin do
+    Diecut::PluginDescription.new('dummy', 'dummy.rb').tap do |plugin|
+      plugin.option('testing') do |opt|
+        opt.goes_to('testing')
+      end
+      plugin.option('thing') do |opt|
+        opt.goes_to(['thing'])
+      end
+    end
+  end
+
+  let :other_plugin do
+    Diecut::PluginDescription.new('icky', 'icky.rb')
+  end
+
+  before :each do
+    mill.mediator.add_plugin(plugin)
+    mill.mediator.add_plugin(other_plugin)
+  end
+
+  it "should render files" do
+    mill.activate_plugins do |name|
+      name == 'dummy'
+    end
+    ui = mill.user_interface
+
+    ui.testing = "checking"
+    ui.thing = "test file"
+
+    mill.churn(ui) do |path, contents|
+      expect(path).to eq "checking.txt"
+      expect(contents).to eq "I am a test file for checking"
+    end
+  end
+end

data/spec/plugin_loader_spec.rb

@@ -0,0 +1,109 @@
+require 'diecut/plugin-loader'
+
+describe Diecut::PluginLoader do
+  let :root_gem do
+    instance_double('Gem::Specification', "root", :name => 'root', :matches_for_glob => ['/root_path/diecut_plugin.rb'],
+                   :dependencies => [])
+  end
+
+  let :simple_dep do
+    instance_double('Gem::Specification', 'simple', :name => 'simple', :matches_for_glob => ['/simple_path/diecut_plugin.rb'],
+                    :dependencies => [instance_double("Gem::Dependency", :name => "root")] )
+  end
+
+  let :side_dep do
+    instance_double('Gem::Specification', 'side', :name => 'side', :matches_for_glob => ['/side_path/diecut_plugin.rb'],
+                    :dependencies => [
+                      instance_double("Gem::Dependency", :name => "root"),
+                      instance_double("Gem::Dependency", :name => "simple"),
+                      instance_double("Gem::Dependency", :name => "cycle")
+                    ])
+  end
+
+  let :cycle_dep do
+    instance_double('Gem::Specification', 'cycle', :name => 'cycle', :matches_for_glob => ['/cycle_path/diecut_plugin.rb'],
+                    :dependencies =>[ instance_double("Gem::Dependency", :name => "side") ])
+  end
+
+  let :gem_specs do
+    [root_gem, simple_dep, side_dep, cycle_dep]
+  end
+
+  let :plugin_defs do
+    {
+      "/root_path/diecut_plugin.rb" => proc{
+        loader.describe_plugin("root"){}
+      },
+      "/simple_path/diecut_plugin.rb" => proc{
+        loader.describe_plugin("simple"){}
+      },
+      "/side_path/diecut_plugin.rb" => proc{
+        loader.describe_plugin("side"){}
+      },
+      "/cycle_path/diecut_plugin.rb" => proc{
+        loader.describe_plugin("cycle"){}
+      },
+      "<DEFAULTS>:diecut_plugin.rb" => proc{
+        loader.describe_plugin("local"){}
+      }
+    }
+  end
+
+  let :valise do
+    Valise::Set.define do
+      defaults do
+        file "diecut_plugin.rb", "I am a thing for testing"
+      end
+    end
+  end
+
+  subject :loader do
+    Diecut::PluginLoader.new.tap do |loader|
+      loader.local_valise = valise
+      current_caller = "no clue"
+      allow(loader).to receive(:caller_locations){ [current_caller] }
+      allow(loader).to receive(:latest_specs).and_return(gem_specs)
+      allow(loader).to receive(:require_plugin) {|path|
+        current_caller = double("Location", :absolute_path => path)
+        plugin_defs.fetch(path).call
+      }
+    end
+  end
+
+  let :root_plugin do
+    loader.plugins.find{|pl| pl.name == 'root' }
+  end
+
+  let :simple_plugin do
+    loader.plugins.find{|pl| pl.name == 'simple' }
+  end
+
+  let :side_plugin do
+    loader.plugins.find{|pl| pl.name == 'side' }
+  end
+
+  let :cycle_plugin do
+    loader.plugins.find{|pl| pl.name == 'cycle' }
+  end
+
+  let :local_plugin do
+    loader.plugins.find{|pl| pl.name == 'local' }
+  end
+
+  before :each do
+    loader.load_plugins
+  end
+
+
+  it "should load some plugins" do
+    expect(loader.plugins.length).to eq(5)
+  end
+
+  it "should trace sequencing" do
+    expect(loader.strict_sequence?(root_plugin, local_plugin)).to eq(true)
+    expect(loader.strict_sequence?(local_plugin, root_plugin)).to eq(false)
+    expect(loader.strict_sequence?(root_plugin, simple_plugin)).to eq(true)
+    expect(loader.strict_sequence?(root_plugin, cycle_plugin)).to eq(true)
+    expect(loader.strict_sequence?(side_plugin, cycle_plugin)).to eq(true)
+  end
+end