diecut 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0db4143a62b998da4c0a37dca8bd1c10dfdc083e
+  data.tar.gz: 3df81689d7dd8c921dfba82edaed9aeaa5a60773
+SHA512:
+  metadata.gz: 8c8ad0152418a96ffde7d7a262d24868ff18c1604bed78699c618726d80806792eb5c344f1946af855ec9f7bf0599be0100878c7d3deecd2ffdf7718d86466d2
+  data.tar.gz: 524f260e59f3ee1375f432f9880d79e4aa9976ed127fb35a0767b7a40768943fc97ae741ceecf9c66c5567b946f9385dd85335fdac060e2aba57ff7af6e6cbbb

data/bin/diecut

@@ -0,0 +1,10 @@
+$: << 'lib'
+
+require 'diecut'
+require 'diecut/cli'
+
+Diecut.load_plugins
+Diecut.kinds.each do |kind|
+  Diecut::CommandLine.add_kind(kind)
+end
+Diecut::CommandLine.start

data/gem_test_suite.rb

@@ -0,0 +1,17 @@
+puts Dir::pwd
+require 'test/unit'
+begin
+  require 'spec'
+rescue LoadError
+  false
+end
+
+class RSpecTest < Test::Unit::TestCase
+  def test_that_rspec_is_available
+    assert_nothing_raised("\n\n *  RSpec isn't available - please run: gem install rspec  *\n\n"){ ::Spec }
+  end
+
+  def test_that_specs_pass
+    assert(system(*%w{spec -f e -p **/*.rb spec}),"\n\n *  Specs failed  *\n\n")
+  end
+end

data/lib/diecut/caller-locations-polyfill.rb

@@ -0,0 +1,18 @@
+module Diecut
+  module CallerLocationsPolyfill
+    unless Kernel.instance_method(:caller_locations)
+      # :nocov:
+      FakeLocation = Struct.new(:absolute_path, :lineno, :label)
+      LINE_RE = %r[(?<absolute_path>[^:]):(?<lineno>\d+):(?:in `(?<label>[^'])')?]
+      # covers exactly the use cases we need
+      def caller_locations(range, length=nil)
+        caller[range.begin+1..range.end+1].map do |line|
+          if m = LINE_RE.match(line)
+            FakeLocation.new(m.named_captures.values_at("absolute_path", "lineno", "label"))
+          end
+        end
+      end
+      # :nocov:
+    end
+  end
+end

data/lib/diecut/cli.rb

@@ -0,0 +1,77 @@
+require 'thor'
+require 'diecut'
+require 'diecut/mill'
+
+module Diecut
+  class KindCli < Thor
+    include Thor::Actions
+
+    desc "generate TARGET", "Generate code"
+    def generate(target_dir)
+      self.destination_root = target_dir
+
+      mill = Mill.new(self.class.kind)
+      mill.activate_plugins {|name| options["with-#{name}"] }
+
+      ui = mill.user_interface
+      options.delete_if{|_, value| value.nil?}
+      ui.from_hash(options)
+
+      mill.churn(ui) do |path, contents|
+        create_file(path, contents)
+      end
+    end
+
+    method_option :all_on => false
+    desc "lint", "Check well-formed-ness of code generators"
+    def lint
+      require 'diecut/linter'
+      mill = Mill.new(self.class.kind)
+      if options["all_on"]
+        mill.activate_plugins{ true }
+      else
+        mill.activate_plugins {|name| options["with-#{name}"] }
+      end
+
+      puts Linter.new(mill).report
+    end
+  end
+
+  class CommandLine < Thor
+    def self.build_kind_subcommand(plugin_kind)
+      mediator = Diecut.mediator(plugin_kind)
+      example_ui = mediator.build_example_ui
+
+      klass = Class.new(KindCli) do
+        class << self
+          def kind(value = nil)
+            if @kind.nil?
+              @kind = value
+            end
+            @kind
+          end
+        end
+
+        mediator.plugins.each do |plugin|
+          class_option "with-#{plugin.name}", :default => plugin.default_active?
+        end
+
+        example_ui.field_names.each do |field|
+          method_option(field, {:for => :generate, :desc => example_ui.description(field) || field,
+            :required => example_ui.required?(field), :default => example_ui.default_for(field)})
+        end
+      end
+
+      klass.kind(plugin_kind)
+
+      klass
+    end
+
+    def self.add_kind(kind)
+      desc "#{kind}", "Commands related to templating for #{kind}"
+      kind_class = build_kind_subcommand(kind)
+      const_set(kind.sub(/\A./){|match| match.upcase }, kind_class)
+      subcommand kind, kind_class
+    end
+  end
+end

data/lib/diecut/configurable.rb

@@ -0,0 +1,142 @@
+require 'calibrate'
+module Diecut
+  class Configurable
+    include Calibrate::Configurable
+    module ClassMethods
+      attr_accessor :target_name
+
+      def build_subclass(name)
+        Class.new(self).tap{|cc| cc.target_name = name }
+      end
+
+      def classname
+        name || superclass.name
+      end
+
+      def deep_field_names
+        field_names.map do |name|
+          field_value = field_metadata(name).default_value
+          if field_value==self
+            return ["LOOPED"]
+          end
+          if field_value.is_a?(Class) and field_value < Diecut::Configurable
+            field_value.deep_field_names.map do |subname|
+              "#{name}.#{subname}"
+            end
+          else
+            name
+          end
+        end.flatten
+      end
+
+      def inspect
+        return "#<#{classname}:#{target_name}:(#{deep_field_names.join(",")})>"
+      end
+
+      def absorb_context(from)
+        from.field_names.each do |name|
+          from_metadata = from.field_metadata(name)
+          from_value = from_metadata.default_value
+          into_metadata = field_metadata(name)
+
+          if into_metadata.nil?
+            if from_value.is_a?(Class) and from_value < Calibrate::Configurable
+              nested = build_subclass("#{target_name}.#{name}")
+              setting(name, nested)
+              nested.absorb_context(from_value)
+            else
+              if from_metadata.is?(:required)
+                setting(name)
+              else
+                setting(name, from_value)
+              end
+            end
+            next
+          end
+          into_value = into_metadata.default_value
+          if into_value.is_a?(Class) and into_value < Calibrate::Configurable
+            if from_value.is_a?(Class) and from_value < Calibrate::Configurable
+              into_value.absorb_context(from_value)
+            else
+              raise "Field clash: #{name.inspect} is already a complex value, but a simple value in the absorbed configurable"
+            end
+          else
+            unless from_value.is_a?(Class) and from_value < Calibrate::Configurable
+              # Noop - maybe should compare the default values? - should always
+              # be nil right now...
+            else
+              raise "Field clash: #{name.inspect} is already a simple value, but a complex value on the absorbed configurable"
+            end
+          end
+        end
+      end
+
+      def walk_path(field_path)
+        first, *rest = *field_path
+
+        segment = PathSegment.new(self, first.to_sym)
+        if rest.empty?
+          [segment]
+        else
+          [segment] + segment.nested.walk_path(rest)
+        end
+      end
+
+      def build_setting(field, is_section = false)
+        nested = walk_path(field).last.klass
+
+        if is_section
+          nested.setting(field.last, build_subclass("#{target_name}.#{field.last}"))
+        else
+          nested.setting(field.last)
+        end
+      end
+    end
+    extend ClassMethods
+
+    def walk_path(field_path)
+      first, *rest = *field_path
+
+      segment = InstanceSegment.new(self, first.to_sym)
+      if rest.empty?
+        [segment]
+      else
+        [segment] + segment.value.walk_path(rest)
+      end
+
+    end
+
+    class InstanceSegment < ::Struct.new(:instance, :name)
+      def metadata
+        @metadata ||= instance.class.field_metadata(name)
+      end
+
+      def value
+        metadata.value_on(instance)
+      end
+
+      def value=(value)
+        instance.__send__(metadata.writer_method, value)
+      end
+    end
+
+    class PathSegment < ::Struct.new(:klass, :name)
+      def metadata
+        @metadata ||= klass.field_metadata(name)
+      end
+
+      def nested
+        @nested ||=
+          begin
+            if metadata.nil?
+              nested = Configurable.build_subclass("#{klass.target_name}.#{name}")
+              klass.setting(name, nested)
+              nested
+            else
+              metadata.default_value
+            end
+          end
+      end
+    end
+  end
+end

data/lib/diecut/context-handler.rb

@@ -0,0 +1,77 @@
+require 'diecut/errors'
+module Diecut
+  class ContextHandler
+    attr_accessor :context_class, :ui_class, :plugins
+
+    def apply_simple_defaults
+      plugins.each do |plugin|
+        plugin.context_defaults.each do |default|
+          next unless default.simple?
+          begin
+            apply_simple_default(default)
+          rescue Error
+            raise Error, "Plugin #{plugin.name.inspect} failed"
+          end
+        end
+      end
+    end
+
+    def apply_to_ui
+      plugins.each do |plugin|
+        plugin.options.each do |option|
+          apply_option_to_ui(option)
+        end
+      end
+    end
+
+    def backfill_options_to_context
+      plugins.each do |plugin|
+        plugin.options.each do |option|
+          backfill_to_context(option)
+        end
+      end
+    end
+
+    def backfill_to_context(option)
+      return unless option.has_context_path?
+
+      segment = context_class.walk_path(option.context_path).last
+      if option.has_default?
+        segment.klass.setting(segment.name, option.default_value)
+      else
+        segment.klass.setting(segment.name)
+      end
+    end
+
+    def apply_simple_default(default)
+      target = context_class.walk_path(default.context_path).last
+      if target.metadata.nil?
+        raise UnusedDefault, "No template uses a value at #{default.context_path.inspect}"
+      else
+        target.metadata.default_value = default.value
+        target.metadata.is(:defaulting)
+      end
+    end
+
+    def apply_option_to_ui(option)
+      ui_class.options_hash[option.name] = option
+
+      if option.has_context_path?
+        context_metadata = context_class.walk_path(option.context_path).last.metadata
+        if option.has_default?
+          ui_class.setting(option.name, option.default_value)
+        elsif context_metadata.is?(:defaulting)
+          ui_class.setting(option.name, context_metadata.default_value)
+        else
+          ui_class.setting(option.name)
+        end
+      else
+        if option.has_default?
+          ui_class.setting(option.name, option.default_value)
+        else
+          ui_class.setting(option.name)
+        end
+      end
+    end
+  end
+end

data/lib/diecut/errors.rb

@@ -0,0 +1,14 @@
+module Diecut
+  class Error < RuntimeError;
+    def message
+      if cause.nil?
+        super
+      else
+        super + " because: #{cause.message}"
+      end
+    end
+  end
+  class UnusedDefault < Error; end
+  class OverriddenDefault < Error; end
+  class InvalidConfig < Error; end
+end

data/lib/diecut/linter.rb

@@ -0,0 +1,177 @@
+require 'diecut/report'
+
+module Diecut
+  class Linter
+    def initialize(mill)
+      @mill = mill
+    end
+    attr_reader :mill
+
+    def report
+      @ui = mill.user_interface
+
+      formatter = ReportFormatter.new([
+        option_collision_report,
+        orphaned_fields,
+        overridden_context_defaults
+      ])
+
+      formatter.to_s
+    end
+
+    # Needed:
+    # Overridden option defaults (without plugin dep)
+    # Option with default, context with default (w/o PD)
+
+    def unindent(text)
+      indent = text.scan(/(^[ \t]*)\S/).map{|cap| cap.first}.max_by(&:length)
+      text.gsub(%r{^#{indent}},'')
+    end
+
+    def each_plugin
+      mill.mediator.activated_plugins.each do |plugin|
+        yield plugin
+      end
+    end
+
+    def each_default
+      each_plugin do |plugin|
+        plugin.context_defaults.each do |default|
+          yield default, plugin
+        end
+      end
+    end
+
+    def each_option
+      each_plugin do |plugin|
+        plugin.options.each do |option|
+          yield option, plugin
+        end
+      end
+    end
+
+    def overridden_context_defaults
+      Report.new("Overridden context defaults", ["Output field", "Default value", "Source plugin"]).tap do |report|
+        default_values = Hash.new{|h,k| h[k]=[]}
+        each_default do |default, plugin|
+          next unless default.simple?
+
+          default_values[default.context_path] << [default, plugin]
+        end
+
+        default_values.each do |key, set|
+          default_values[key] = set.find_all do |plugin|
+            !set.any?{|child|
+              next if child == plugin
+              Diecut.plugin_loader.strict_sequence?(plugin[1], child[1])
+            }
+          end
+        end
+
+        default_values.each_value do |set|
+          if set.length > 1
+            set.each do |default, plugin|
+
+              report.add(default.context_path.join("."), default.value, plugin.name)
+            end
+          end
+        end
+
+        unless report.empty?
+          report.fail("Multiple plugins assign different values to be rendered")
+          report.advice = unindent(<<-EOA)
+          This is a problem because each plugin may be assuming it's default
+          value, and since there's no guarantee in which order the plugins are
+          loaded, the actual default value is difficult to predict. In general,
+          this kind of override behavior can be difficult to reason about.
+
+          Either the collision is accidental, in which case the default value
+          should be removed from one plugin or the other. If the override is
+          intentional, then the overriding plugin's gem should depend on the
+          overridden one's - since you are overriding the value intentionally,
+          it makes sense to ensure that the value is there to override. Diecut
+          will load plugins such that the dependant plugins are loaded later,
+          which solves the predictability problem.
+          EOA
+        end
+      end
+    end
+
+    def option_collision_report
+      Report.new("Option collisions", ["Output target", "Option name", "Source plugin"]).tap do |report|
+        option_targets = Hash.new{|h,k| h[k]=[]}
+        each_option do |option, plugin|
+          next unless option.has_context_path?
+          option_targets[option.context_path] << [plugin, option]
+        end
+        option_targets.each_value do |set|
+          if set.length > 1
+            set.each do |plugin, option|
+              report.add(option.context_path.join("."), option.name, plugin.name)
+            end
+          end
+        end
+
+        unless report.empty?
+          report.fail("Multiple options assign the same values to be rendered")
+          report.advice = unindent(<<-EOA)
+          This is problem because two options in the user interface both change
+          rendered values. If a user supplies both with different values, the
+          output isn't predictable (either one might take effect).
+
+          Most likely, this is a simple error: remove options from each group
+          that targets the same rendered value until only one remains. It may
+          also be that one option has a typo - that there's a rendering target
+          that's omitted.
+          EOA
+        end
+      end
+    end
+
+    def orphaned_fields
+      Report.new("Template fields all have settings", ["Output field", "Source file"]).tap do |report|
+        context_class = mill.context_class
+
+        required_fields = {}
+
+        context_class.field_names.each do |field_name|
+          if context_class.field_metadata(field_name).is?(:required)
+            required_fields[field_name.to_s] = []
+          end
+        end
+
+        mill.templates.all_templates.each do |template|
+          template.reduced.leaf_fields.each do |field|
+            field = field.join(".")
+            if required_fields.has_key?(field)
+              required_fields[field] << template.path
+            end
+          end
+        end
+
+        each_option do |option, plugin|
+          next unless option.has_context_path?
+          field = option.context_path.join(".")
+          required_fields.delete(field)
+        end
+
+        required_fields.each do |name, targets|
+          targets.each do |target|
+            report.add(name, target)
+          end
+        end
+
+        unless report.empty?
+          report.status = "WARN"
+          report.advice = unindent(<<-EOA)
+          These fields might not receive a value during generation, which will
+          raise an error at use time.
+
+          It's possible these fields are set in a resolve block in one of the
+          plugins - Diecut can't check for that yet.
+          EOA
+        end
+      end
+    end
+  end
+end

data/lib/diecut/mediator.rb

@@ -0,0 +1,79 @@
+require 'diecut/errors'
+require 'diecut/ui-config'
+require 'diecut/ui-applier'
+require 'diecut/context-handler'
+
+module Diecut
+  class Mediator
+    def initialize
+      @plugins = []
+      @activated = {}
+    end
+    attr_reader :plugins
+
+    def add_plugin(plug)
+      @activated[plug.name] = plug.default_activated
+      @plugins << plug
+    end
+
+    def activated?(plug_name)
+      @activated[plug_name]
+    end
+
+    def activate(plug_name)
+      @activated[plug_name] = true
+    end
+
+    def deactivate(plug_name)
+      @activated[plug_name] = false
+    end
+
+    def activated_plugins
+      @plugins.find_all do |plugin|
+        @activated[plugin.name]
+      end
+    end
+
+    # Set up context default settings
+    # set up ui settings from context
+    #
+    # < User gets involved >
+    #
+    def build_example_ui
+      ui_class = Class.new(UIConfig)
+
+      handler = ContextHandler.new
+      handler.context_class = Class.new(Configurable)
+      handler.ui_class = ui_class
+      handler.plugins = @plugins
+
+      handler.backfill_options_to_context
+      handler.apply_to_ui
+
+      handler.ui_class
+    end
+
+    def build_ui_class(context_class)
+      ui_class = Class.new(UIConfig)
+
+      handler = ContextHandler.new
+      handler.context_class = context_class
+      handler.ui_class = ui_class
+      handler.plugins = activated_plugins
+
+      handler.apply_simple_defaults
+      handler.apply_to_ui
+
+      handler.ui_class
+    end
+
+    def apply_user_input(ui, context_class)
+      applier = UIApplier.new
+      applier.plugins = activated_plugins
+      applier.ui = ui
+      applier.context = context_class.new
+      applier.apply
+
+    end
+  end
+end

data/lib/diecut/mill.rb

@@ -0,0 +1,68 @@
+require 'valise'
+require 'diecut'
+require 'diecut/template-set'
+
+module Diecut
+  class Mill
+    def initialize(kind)
+      @kind = kind
+    end
+    attr_reader :kind
+    attr_writer :valise, :mediator, :templates
+
+    def mediator
+      @mediator ||= Diecut.mediator(kind)
+    end
+
+    def templates
+      @templates ||= TemplateSet.new
+    end
+
+    def activate_plugins
+      mediator.plugins.map(&:name).each do |name|
+        if yield(name)
+          mediator.activate(name)
+        else
+          mediator.deactivate(name)
+        end
+      end
+    end
+
+    def valise
+      @valise ||= mediator.activated_plugins.map do |plugin|
+        stem = plugin.stem_for(kind)
+        Valise::Set.define do
+          ro stem.template_dir
+        end.stemmed(stem.stem)
+      end.reduce{|left, right| left + right}.sub_set(kind)
+    end
+
+    def load_files
+      valise.filter('**', %i[extended dotmatch]).files do |file|
+        templates.add(file.rel_path.to_s, file.contents)
+      end
+    end
+
+    def context_class
+      templates.context_class
+    end
+
+    def ui_class
+      mediator.build_ui_class(context_class)
+    end
+
+    def user_interface
+      load_files
+      templates.prepare
+
+      ui_class.new
+    end
+
+    def churn(ui)
+      templates.context = mediator.apply_user_input(ui, templates.context_class)
+      templates.results do |path, contents|
+        yield(path, contents)
+      end
+    end
+  end
+end