diecut 0.0.1

data/lib/diecut/mustache.rb

@@ -0,0 +1,20 @@
+require 'mustache'
+module Diecut
+  class Mustache < ::Mustache
+    attr_accessor :partials_hash
+
+    def partial(name)
+      partials_hash.fetch(name).template_string
+    end
+
+    def raise_on_context_miss?
+      true
+    end
+
+    # Diecut's templates aren't HTML files - if they need escaping it should
+    # happen in the source file
+    def escapeHTML(str)
+      str
+    end
+  end
+end

data/lib/diecut/plugin-description/context-default.rb

@@ -0,0 +1,13 @@
+module Diecut
+  class PluginDescription
+    class ContextDefault < Struct.new(:context_path, :value, :block)
+      def simple?
+        value != NO_VALUE
+      end
+
+      def compute_value(context)
+        block.call(context)
+      end
+    end
+  end
+end

data/lib/diecut/plugin-description/option.rb

@@ -0,0 +1,63 @@
+module Diecut
+  class PluginDescription
+    class Option
+      def initialize(name)
+        @name = name
+        @default_value = NO_VALUE
+      end
+      attr_reader :name, :description, :context_path, :default_value
+
+      def has_default?
+        default_value != NO_VALUE
+      end
+
+      def has_context_path?
+        !context_path.nil?
+      end
+
+      # A description for the option in the user interface.
+      # @param desc [String]
+      #   The description itself
+      def description(desc = NO_VALUE)
+        if desc == NO_VALUE
+          return @description
+        else
+          @description = desc
+        end
+      end
+
+      # Defines the templating context path this value should be copied to.
+      # @param context_path [Array,String]
+      #   The path into the context to set from this option's value.
+      #
+      # @example Three equivalent calls
+      #   option.goes_to("deeply.nested.field")
+      #   option.goes_to(%w{deeply nested field})
+      #   option.goes_to("deeply", "nested", "field")
+      def goes_to(*context_path)
+        if context_path.length == 1
+          context_path =
+            case context_path.first
+            when Array
+              context_path.first
+            when /.+\..+/ # has an embedded .
+              context_path.first.split('.')
+            else
+              context_path
+            end
+        end
+
+        @context_path = context_path
+      end
+
+      # Gives the option a default value (and therefore makes it optional for
+      # the user to provide)
+      #
+      # @param value
+      #   The default value
+      def default(value)
+        @default_value = value
+      end
+    end
+  end
+end

data/lib/diecut/plugin-description.rb

@@ -0,0 +1,147 @@
+require 'diecut/errors'
+require 'diecut/caller-locations-polyfill'
+require 'diecut/plugin-description/context-default'
+require 'diecut/plugin-description/option'
+
+module Diecut
+  class PluginDescription
+    include CallerLocationsPolyfill
+    NO_VALUE = Object.new.freeze
+
+    KindStem = Struct.new(:kind, :stem, :template_dir)
+
+    def initialize(name, source_path)
+      @name = name
+      @source_path = source_path
+      @default_activated = true
+      @context_defaults = []
+      @options = []
+      @resolve_block = nil
+      @kind_stems = {}
+    end
+    attr_reader :default_activated, :name, :source_path, :context_defaults,
+      :options, :resolve_block
+
+    def kinds
+      @kind_stems.keys
+    end
+
+    def stem_for(kind)
+      @kind_stems.fetch(kind)
+    end
+
+    def has_kind?(kind)
+      @kind_stems.key?(kind)
+    end
+
+    def default_active?
+      @default_activated
+    end
+
+    def apply_resolve(ui, context)
+      @resolve_block.call(ui, context)
+    end
+
+    # Attaches this plugin to a particular kind of diecut generator. Can be
+    # called multiple times in order to reuse the plugin.
+    #
+    # @param kind [String, Symbol]
+    #   The kind of generator to register the plugin to
+    # @param templates [String]
+    #   The directory of templates that the plugin adds to the generation
+    #   process. Relative paths are resolved from the directory the plugin is
+    #   being defined in. If omitted (or nil) defaults to "templates"
+    # @param stem [Array(String), String]
+    #   A prefix for the templates directory when it's used for this kind of
+    #   generator. By default, this will be [kind], which is what you'll
+    #   probably want in a gem plugin. For local plugins, you probably want to
+    #   have directories per kind, and set this to []
+    #
+    # For instance, you might set up a plugin for Rails that also works in Xing
+    # projects that use Rails for a backend
+    #
+    # @example Install for Rails and Xing
+    #   plugin.for_kind(:rails)
+    #   plugin.for_kind(:xing, nil, "xing/backend")
+    #
+    #
+    def for_kind(kind, templates = nil, stem = nil)
+      stem ||= [kind]
+      templates ||= "templates"
+      templates = File.expand_path(templates, File.dirname(caller_locations(1..1).first.absolute_path))
+      @kind_stems[kind] = KindStem.new(kind, stem, templates)
+    end
+
+    # Force this plugin to be enabled to be used. Good for optional features.
+    def default_off
+      @default_activated = false
+    end
+
+    # Make this plugin part of the generation process by default. The is the
+    # default behavior anyway, provided for consistency.
+    def default_on
+      @default_activated = true
+    end
+
+    # Set a default value for a field in the templating context.
+    #
+    # @param context_path [String, Array]
+    #   Either an array of strings or a dotted string (e.g.
+    #   "deeply.nested.value") that describes a path into the templating
+    #   context to give a default value to.
+    #
+    # @param value
+    #   A simple default value, which will be used verbatim (n.b. it will be
+    #   cloned if appropriate, so you can use [] for an array).
+    #
+    # @yieldreturn
+    #   A computed default value. The block will be called when the context is
+    #   set up. You cannot use both a simple value and a computed value.
+    #
+    # @example
+    #   plugin.default("built_at"){ Time.now }
+    #   plugin.default("author", "Judson")
+    def default(context_path, value = NO_VALUE, &block)
+      context_path =
+        case context_path
+        when Array
+          context_path
+        when /.+\..+/ # has an embedded .
+          context_path.split('.')
+        else
+          [context_path]
+        end
+      if value != NO_VALUE and not block.nil?
+        raise InvalidPlugin, "Default on #{name.inspect} both has a simple default value (#{value}) and a dynamic block value, which isn't allowed."
+      end
+      @context_defaults << ContextDefault.new(context_path, value, block)
+    end
+
+    # Define an option to provide to the user interface.
+    # @param name [String,Symbol]
+    #   The name for the option, as it'll be provided to the user.
+    # @yieldparam option [Option]
+    #   The option description object
+    def option(name)
+      name = name.to_sym
+      option = Option.new(name)
+      yield option
+      @options << option
+      return option
+    end
+
+    # The resolve block provides the loophole to allow complete configuration
+    # of the rendering context. The last thing that happens before files are
+    # generated is that all the plugin resolves are run, so that e.g. values
+    # can be calculated from other values. It's very difficult to analyze
+    # resolve blocks, however: use them as sparingly as possible.
+    #
+    # @yeildparam ui [UIContext]
+    #   the values supplied by the user to satisfy options
+    # @yeildparam context [Configurable]
+    #   the configured rendering context
+    def resolve(&block)
+      @resolve_block = block
+    end
+  end
+end

data/lib/diecut/plugin-loader.rb

@@ -0,0 +1,189 @@
+require 'tsort'
+require 'rubygems/specification'
+require 'diecut/plugin-description'
+
+module Diecut
+  class PluginLoader
+    include TSort
+
+    NO_VALUE = Object.new.freeze
+
+    class GemPlugin < Struct.new(:gem, :path)
+      def gem?
+        gem != NO_VALUE
+      end
+    end
+
+    def initialize
+      @sources = {}
+      @local_sources = []
+      @by_gem_name = Hash.new{|h,k| h[k] = []}
+      @plugins = []
+    end
+    attr_reader :plugins
+    attr_accessor :local_valise
+
+    def local_valise
+      @local_valise ||= Valise::Set.define do
+        ro '.diecut'
+        ro '~/.config/diecut'
+        ro '/usr/share/diecut'
+        ro '/etc/diecut'
+      end
+    end
+
+    # :nocov:
+    def latest_specs(prerelease)
+      Gem::Specification.latest_specs(prerelease)
+    end
+
+    def require_plugin(path)
+      require path
+    end
+    # :nocov:
+
+    PLUGIN_FILENAME = 'diecut_plugin.rb'
+    def discover(prerelease)
+      latest_specs(prerelease).map do |spec|
+        spec.matches_for_glob(PLUGIN_FILENAME).map do |match|
+          from_gem(spec, match)
+        end
+      end
+      local_valise.get(PLUGIN_FILENAME).present.map(&:full_path).each do |path|
+        from_local(path)
+      end
+    end
+
+    def from_gem(spec, path)
+      plugin = GemPlugin.new(spec, path)
+
+      @sources[path] = plugin
+      spec.dependencies.map(&:name).each do |depname|
+        @by_gem_name[depname] << plugin
+      end
+    end
+
+    def from_local(path)
+      source = GemPlugin.new(NO_VALUE, path)
+      @sources[path] = source
+      @local_sources << source
+    end
+
+    def tsort_each_node(&block)
+      @sources.each_value(&block)
+    end
+
+    def tsort_each_child(node)
+      if node.gem?
+        @by_gem_name[node.gem.name].each do |depplugin|
+          yield depplugin
+        end
+        @local_sources.each do |local|
+          yield local
+        end
+      else
+        @local_sources.drop_while do |src|
+          src != node
+        end.drop(1).each do |node|
+          yield(node)
+        end
+      end
+    end
+
+    def component_sort
+      unless block_given?
+        return enum_for(:component_sort)
+      end
+      child_idxs = {}
+      strongly_connected_components.each_with_index do |component, idx|
+        component.sort_by{|node| child_idxs.fetch(node, -1) }.each do |comp|
+          yield(comp)
+        end
+
+        component.each do |comp|
+          tsort_each_child(comp) do |child|
+            child_idxs[child] = idx
+          end
+        end
+      end
+    end
+
+    def each_path
+      component_sort.reverse_each do |source|
+        yield source.path
+      end
+    end
+
+    # Can a chain of "is after" arrows be walked from 'from' to 'to'.
+    # The rules are:
+    # A plugin defined by a gem that depends on another gem "is after" the
+    # plugin defined in the latter gem.
+    # A plugin defined in a local config file is after "more general" local
+    # files (project config is after personal is after system).
+    # All local plugins are after all gem plugins
+    #
+    # The rationale for these rules is that decisions made later in time have
+    # more information and that decisions made closer to the problem know the
+    # problem domain better.
+    #
+    def strict_sequence?(to, from)
+      from_source = @sources[from.source_path]
+      to_source = @sources[to.source_path]
+
+      case [from_source.gem?, to_source.gem?]
+      when [true, true]
+        dep_path?(to_source, from_source)
+      when [true, false]
+        false
+      when [false, true]
+        true
+      when [false, false]
+        @local_sources.index_of(from.source_path) <= @local_sources.index_of(to.source_path)
+      end
+    end
+
+    def dep_path?(from_gem, to_gem)
+      # potential to optimize this: build a map of reachablility and test
+      # against that.
+      closed = {}
+      open = [from_gem]
+      until open.empty?
+        current = open.shift
+        return true if current == to_gem
+        closed[current] = true
+        open += @by_gem_name[current.gem.name].select{|gem| !closed.has_key?(gem)}
+      end
+      return false
+    end
+
+    def load_plugins(prerelease = false)
+      discover(prerelease)
+      each_path do |path|
+        require_plugin(path)
+      end
+    end
+
+    def choose_source(locations)
+      locations.each do |loc|
+        path = loc.absolute_path
+        if @sources.has_key?(path)
+          return path
+        end
+      end
+      raise "Couldn't find source of plugin..."
+    end
+
+    def add_plugin_desc(desc)
+      plugins << desc
+    end
+
+    def describe_plugin(name)
+      source_path = choose_source(caller_locations)
+      desc = PluginDescription.new(name, source_path)
+      yield(desc)
+      add_plugin_desc(desc)
+      return desc
+    end
+
+  end
+end

data/lib/diecut/report.rb

@@ -0,0 +1,136 @@
+require 'paint'
+require 'diecut/mustache'
+
+module Diecut
+  #Adopted gratefully from Xavier Shay's Cane
+  class ReportFormatter
+    def initialize(reports)
+      @reports = reports
+    end
+    attr_reader :reports
+
+    def rejection_fields
+      %i(file_and_line label value)
+    end
+
+    def template
+      (<<-EOT).gsub(/^      /, '')
+      {{#reports}}{{#status_color}}{{name}}: {{status}} {{#length}} {{length}}{{/length}}
+      {{/status_color}}
+      {{#summary}}{{summary}}
+      {{/summary}}{{^empty  }}{{#headers}}{{it}}    {{/headers}}
+      {{/empty  }}{{#rejects}} {{#reject }}{{it}}    {{/reject}}
+      {{/rejects}}{{#advice}}
+      {{advice}}
+      {{/advice}}
+      {{/reports}}
+      {{#status_color}}Total QA report items: {{total_items}}
+      Total QA failing reports: {{total_fails}}
+      {{/status_color}}
+      EOT
+    end
+
+    def to_s(widths=nil)
+      renderer = Mustache.new
+
+      # require 'pp'; puts "\n#{__FILE__}:#{__LINE__} => {context(renderer).pretty_inspect}"
+      renderer.render(template, context(renderer))
+    end
+
+    def passed?
+      fail_count == 0
+    end
+
+    def fail_count
+      reports.inject(0){|sum, report| sum + (report.passed ? 0 : 1)}
+    end
+
+    def context(renderer)
+      bad_color = proc{|text,render| Paint[renderer.render(text), :red]}
+      good_color =  proc{|text,render| Paint[renderer.render(text), :green]}
+      warn_color = proc{|text,render| Paint[renderer.render(text), :yellow]}
+
+      context = {
+        reports: reports.map(&:context),
+        passed: passed?,
+        total_items: reports.inject(0){|sum, report| sum + report.length},
+        total_fails: fail_count,
+        status_color: passed? ? good_color : bad_color
+      }
+      context[:reports].each do |report|
+        report[:status_color] =
+          case report[:status]
+          when /ok/i
+            good_color
+          when /fail/i
+            bad_color
+          else
+            warn_color
+          end
+      end
+      context
+    end
+  end
+
+  class Report
+    def initialize(name, column_headers)
+      @name = name
+      @column_headers = column_headers
+      @rejects = []
+      @status = "OK"
+      @passed = true
+      @summary = ""
+      @summary_counts = true
+    end
+    attr_reader :name, :column_headers, :rejects
+    attr_accessor :summary, :passed, :summary_count, :advice, :status
+
+    def add(*args)
+      @rejects << args
+    end
+
+    def fail(summary)
+      @passed = false
+      @status = "FAIL"
+      @summary = summary
+    end
+
+    def length
+      @rejects.length
+    end
+    alias count length
+
+    def empty?
+      @rejects.empty?
+    end
+
+    def column_widths
+      column_headers.map.with_index do |header, idx|
+        (@rejects.map{|reject| reject[idx]} + [header]).map{|field|
+          field.to_s.length
+        }.max
+      end
+    end
+
+    def sized(array, widths)
+      array.take(widths.length).zip(widths).map{|item, width| { it: item.to_s.ljust(width)}}
+    end
+
+    def context
+      widths = column_widths
+      {
+        empty: empty?,
+        passing: passed,
+        status: status,
+        name: name,
+        length: summary_count,
+        summary: summary,
+        advice: advice,
+        headers: sized(column_headers, widths),
+        rejects: rejects.map do |reject|
+          {reject: sized(reject, widths)}
+        end
+      }
+    end
+  end
+end

data/lib/diecut/template-reducer.rb

@@ -0,0 +1,88 @@
+module Diecut
+  class TemplateReducer
+    def initialize(tokens)
+      @tokens = tokens
+    end
+
+    def fields
+      process([], [@tokens]) if @fields.nil?
+      @fields.keys
+    end
+
+    def sections
+      process([], [@tokens]) if @sections.nil?
+      @sections.keys
+    end
+
+    def partials
+      process([], [@tokens]) if @partials.nil?
+      @partials.keys
+    end
+
+    def unknown
+      process([], [@tokens]) if @unknown.nil?
+      @unknown
+    end
+
+    def leaf_fields
+      leaves_and_nodes if @leaf_fields.nil?
+      return @leaf_fields
+    end
+
+    def node_fields
+      leaves_and_nodes if @node_fields.nil?
+      return @node_fields
+    end
+
+    def leaves_and_nodes
+      @node_fields, @leaf_fields = fields.partition.with_index do |field, idx|
+        fields.drop(idx + 1).any? do |other|
+          field.zip(other).all? {|l,r|
+            l==r}
+        end
+      end
+    end
+
+    # XXX Used as a section and as a field is different from used as a field
+    # and as parent of a field. Tricky tricky
+    def validate
+      not_sections = node_fields.find_all {|node| !sections.include?(node)}
+      unless not_sections.empty?
+        warn "These fields are referenced directly, and as the parent of another field:\n" +
+          not_sections.map{|sec| sec.join(".")}.join("\n")
+      end
+    end
+
+    def process(prefix, tokens)
+      @fields ||= {}
+      @partials ||= {}
+      @unknown ||= []
+      @sections ||= {}
+
+      tokens.each do |token|
+        case token[0]
+        when :multi
+          process(prefix, token[1..-1])
+        when :static
+        when :mustache
+          case token[1]
+          when :etag, :utag
+            process(prefix, [token[2]])
+          when :section, :inverted_section
+            @sections[prefix + token[2][2]] = true
+            process(prefix, [token[2]])
+            process(prefix + token[2][2], [token[4]])
+          when :partial
+            @partials[[token[2], prefix]] = true
+          when :fetch
+            @fields[prefix + token[2]] = true
+          else
+            @unknown << token
+          end
+        else
+          @unknown << token
+        end
+      end
+    end
+  end
+end