germinate 1.2.0

data/lib/germinate/origin.rb

@@ -0,0 +1,5 @@
+Germinate::Origin = Struct.new(:source_path, :line_number, :selector) do
+  def to_s
+    "#{source_path}:#{line_number}:#{selector}"
+  end
+end

data/lib/germinate/pipeline.rb

@@ -0,0 +1,13 @@
+class Germinate::Pipeline
+  attr_reader :processes
+
+  def initialize(processes)
+    @processes = processes
+  end
+
+  def call(input)
+    @processes.inject(input) { |output, process|
+      process.call(output)
+    }
+  end
+end

data/lib/germinate/publisher.rb

@@ -0,0 +1,57 @@
+require 'fattr'
+require File.expand_path("publisher", File.dirname(__FILE__))
+
+class Germinate::Publisher
+  Fattr :identifier
+  Fattr :registered_publishers => {}
+
+  fattr :name
+  fattr :librarian
+  fattr :options
+
+  fattr(:pipeline) 
+  fattr(:log) { Germinate.logger }
+  fattr(:selector) 
+
+  @registered_publishers = {}
+
+  def self.make(name, identifier, librarian, options)
+    @registered_publishers.fetch(identifier).new(name, librarian, options)
+  rescue IndexError => error
+    raise error.exception("Unknown publisher type #{identifier.inspect}")
+  end
+
+  def self.register_publisher_type(identifier, klass)
+    @registered_publishers[identifier] = klass
+  end
+
+  def self.identifier(*args)
+    if args.empty?
+      @identifier
+    else
+      id = args.first
+      self.identifier = id
+      Germinate::Publisher.register_publisher_type(id, self)
+    end
+  end
+
+  def initialize(name, librarian, options={})
+    self.name      = name
+    self.librarian = librarian
+    self.options   = options
+    self.pipeline  = librarian.make_pipeline(options.delete(:pipeline){""})
+    self.selector  = options.delete(:selector) {
+      options.delete(:select){"$TEXT|_transform"}
+    }
+
+    # All options should have been removed by this point
+    options.keys.each do |key|
+      log.warn "Unknown publisher option '#{key}'"
+    end
+  end
+
+  def input
+    source = librarian[selector, "publish #{name} command"]
+    pipeline.call(source)
+  end
+end

data/lib/germinate/reader.rb

@@ -0,0 +1,266 @@
+require 'alter_ego'
+require 'ick'
+require 'forwardable'
+require 'fattr'
+
+# The Reader is responsible for reading a source file, breaking it down into
+# into its constituent chunks of text, code, etc., assigning names to them, and
+# filing them away in a Librarian.  It is also responsible for interpreting any
+# special control lines found in the input document.
+class Germinate::Reader
+  include AlterEgo
+  extend Forwardable
+  Ick::Returning.belongs_to(self)
+
+  CONTROL_PATTERN  = /^(\s*([^\s\\]+)?\s*):([A-Z0-9_]+):\s*(.*)?\s*$/
+
+  attr_reader :librarian
+  attr_reader :current_section
+  attr_reader :section_count
+  fattr(:log) { Germinate.logger }
+  
+  def_delegators :librarian, 
+                 :comment_prefix, 
+                 :comment_prefix=, 
+                 :comment_prefix_known?
+  
+  state :initial, :default => true do
+    handle :add_line!, :first_line!
+
+    transition :to => :text, :on => :text!
+    transition :to => :code, :on => :code!
+    transition :to => :front_matter, :on => :front_matter!
+  end
+
+  state :front_matter do
+    handle :add_line!, :add_front_matter!
+
+    transition :to => :text, :on => :text!
+    transition :to => :code, :on => :code!
+  end
+
+  state :code do
+    handle :add_line!, :add_code!
+
+    on_enter do
+      if librarian.section_names.include?(sample_name)
+        librarian.add_insertion!(sample_name, "@#{sample_name}", {})
+      end
+    end
+
+    transition :to => :text, :on => :text!
+    transition :to => :code, :on => :code!
+    transition :to => :finished, :on => :finish!
+  end
+  
+  state :text do
+    handle :add_line!, :add_text!
+
+    transition :to => :text, :on => :text!
+    transition :to => :code, :on => :code!
+    transition :to => :finished, :on => :finish!
+  end
+
+  state :finished do
+
+  end
+
+  def initialize(librarian, source_path=nil)
+    @librarian       = librarian
+    @section_count   = 0
+    @current_section = "SECTION0"
+    @line_number     = 0
+    @source_path     = source_path ? Pathname(source_path) : nil
+    librarian.source_path = @source_path
+  end
+
+  # Read a line
+  def <<(line)
+    @line_number += 1
+    unless handle_control_line!(line)
+      add_line!(unescape(line))
+    end
+  end
+
+  def increment_section_count!
+    self.section_count = section_count.succ
+    self.current_section = automatic_section_name
+  end
+
+  private
+
+  attr_writer :current_section
+  attr_writer :section_count
+
+  def first_line!(line)
+    front_matter!
+    add_front_matter!(line)
+  end
+
+  def add_front_matter!(line)
+    librarian.add_front_matter!(line)
+  end
+
+  def add_text!(line)
+    if uncommented?(line) && non_blank?(line)
+      code!
+      add_code!(line)
+    else
+      librarian.add_text!(current_section, line)
+    end
+  end
+
+  def add_code!(line)
+    librarian.add_code!(current_section, line)
+  end
+
+  def handle_control_line!(line)
+    if match_data = CONTROL_PATTERN.match(line)
+      comment_chars  = match_data[1]
+      keyword        = match_data[3]
+      argument_text  = match_data[4]
+      arguments      = YAML.load("[ #{argument_text} ]")
+
+      if comment_chars && !comment_chars.empty? && !comment_prefix_known?
+        self.comment_prefix = comment_chars
+      end
+      case keyword
+      when "TEXT"   then text_control_line!(*arguments)
+      when "SAMPLE" then sample_control_line!(*arguments)
+      when "CUT"    then cut_control_line!(*arguments)
+      when "END"    then end_control_line!(*arguments)
+      when "INSERT" then insert_control_line!(*arguments)
+      when "BRACKET_CODE" then bracket_code_control_line!(*arguments)
+      when "PROCESS" then process_control_line!(*arguments)
+      when "PUBLISHER" then publisher_control_line!(*arguments)
+      when "SET"    then set_control_line!(line, *arguments)
+      else 
+        log.warn "Ignoring unknown directive #{keyword} at line #{@line_number}"
+      end
+      librarian.add_control!(line)
+      true
+    else
+      false
+    end
+  end
+  
+  def text_control_line!(section_name=nil)
+    increment_section_count!
+    self.current_section = section_name || automatic_section_name
+    text!
+  end
+
+  def cut_control_line!
+    increment_section_count!
+    code!
+  end
+
+  def end_control_line!
+    increment_section_count!
+    code!
+  end
+
+  def sample_control_line!(sample_name=current_section, options={})
+    increment_section_count!
+    self.sample_name = sample_name || automatic_section_name
+    librarian.set_code_attributes!(
+      sample_name,
+      options_to_style_attributes(options))
+    code!
+  end
+
+  def bracket_code_control_line!(open_bracket=nil, close_bracket=nil)
+    librarian.code_open_bracket = open_bracket
+    librarian.code_close_bracket = close_bracket
+  end
+
+  def insert_control_line!(selector=nil, options={})
+    librarian.add_insertion!(
+      current_section, 
+      Germinate::Selector.new(selector, current_section),
+      options_to_style_attributes(options))
+  end
+
+  def process_control_line!(process_name, command)
+    librarian.add_process!(process_name, command)
+  end
+
+  def publisher_control_line!(name, type, options={})
+    librarian.add_publisher!(name, type, symbolize_keys(options))
+  end
+
+  def set_control_line!(line, name, value)
+    librarian.set_variable!(line, @line_number, name, value)
+  end
+
+  def sample_name=(name)
+    self.current_section = name
+  end
+
+  def sample_name
+    self.current_section
+  end
+
+  def automatic_section_name
+    "SECTION#{section_count}"
+  end
+
+  def parse_section_name(text)
+    name = YAML.load(text)
+    if name && !name.empty?
+      name.to_s
+    else
+      nil
+    end
+  end
+  
+  def non_blank?(line)
+    /^\s*$/ !~ line
+  end
+
+  def uncommented?(line)
+    if comment_prefix_known?
+      comment_pattern !~ line
+    else
+      false
+    end
+  end
+
+  def comment_pattern
+    /^#{Regexp.escape(comment_prefix.rstrip)}/
+  end
+
+  def unescape(line)
+    line.sub(/\\(:[A-Z0-9_]+:)/, '\1') 
+  end
+
+  def options_to_style_attributes(options)
+    returning({}) do |attributes|
+      if options.key?("brackets")
+        attributes[:code_open_bracket] = options.fetch("brackets").first
+        attributes[:code_close_bracket] = options.fetch("brackets").last
+      end
+      if options["disable_transforms"]
+        Germinate::TextTransforms.singleton_methods.each do |transform|
+          attributes[transform.to_sym] = false
+        end
+      end
+      attributes
+    end
+  end
+
+  def symbolize_keys(hash)
+    hash.inject({}){|result, (key, value)|
+      new_key = case key
+                when String then key.to_sym
+                else key
+                end
+      new_value = case value
+                  when Hash then symbolize_keys(value)
+                  else value
+                  end
+      result[new_key] = new_value
+      result
+    }
+  end
+end

data/lib/germinate/selector.rb

@@ -0,0 +1,136 @@
+class Germinate::Selector
+  attr_reader :string
+  attr_reader :selector_type
+  attr_reader :key
+  attr_reader :start_offset
+  attr_reader :end_offset
+  attr_reader :length
+  attr_reader :delimiter
+  attr_reader :pipeline
+  attr_reader :default_key
+  attr_reader :origin
+
+  PATTERN = /^([@$])?(\w+)?(:([^\|]+))?(\|([\w|]+))?$/
+  EXCERPT_OUTPUT_PATTERN = /^([@$])?(\w+)?(\|([\w|]+))?(:([^\|]+))?$/
+  EXCERPT_PATTERN = %r{((-?\d+)|(/[^/]*/))(((\.\.\.?)|(,))((-?\d+)|(/[^/]*/)))?}
+
+  def initialize(string, default_key=:unspecified, origin="<Unknown>")
+    @string      = string
+    @default_key = default_key
+    @origin      = origin
+    match_data = case string
+                 when "", nil then {}
+                 else 
+                   if data = PATTERN.match(string) 
+                     @excerpt_output = false
+                   elsif data = EXCERPT_OUTPUT_PATTERN.match(string)
+                     @excerpt_output = true
+                   else
+                     raise "Could not parse selector '#{string}'"
+                   end
+                   data
+                 end
+
+    subscript_index = @excerpt_output ? 6 : 3
+    pipeline_index  = @excerpt_output ? 4 : 6
+
+    @selector_type = 
+      case match_data[1]
+      when "$" then :special
+      when "@" then :code
+      when nil then default_key == :unspecified ? :special : :code
+      else raise "Unknown selector type '#{match_data[1]}'"
+      end
+    @key = match_data[2] || (default_key == :unspecified ? "SOURCE" : default_key)
+    if match_data[subscript_index]
+      @slice = true
+      parse_excerpt(match_data[subscript_index])
+    else
+      @slice        = false
+      @delimiter    = '..'
+      @start_offset = 1
+      @end_offset   = -1
+      @length       = nil
+    end
+    @pipeline = String(match_data[pipeline_index]).
+      split("|").unshift('_transform').uniq
+  end
+
+  def start_offset_for_slice
+    offset_for_slice(start_offset)
+  end
+
+  def end_offset_for_slice
+    offset_for_slice(end_offset)
+  end
+
+  # Should excerpting be done on the output of the process?
+  def excerpt_output?
+    @excerpt_output
+  end
+
+  # Is it just a subset of the source hunk? (opposite of @whole?)
+  def slice?
+    @slice && !@excerpt_output
+  end
+
+  # Is it the entire hunk? (opposite of #slice?)
+  def whole?
+    !slice?
+  end
+
+  def to_s
+    string + "(#{origin})"
+  end
+
+  def ==(other)
+    string == other
+  end
+
+  private
+
+  def parse_excerpt(excerpt)
+    match_data = EXCERPT_PATTERN.match(excerpt)
+    integer_start_offset = match_data[2]
+    regexp_start_offset  = match_data[3]
+    @delimiter           = match_data[5]
+    integer_end_offset   = match_data[9]
+    regexp_end_offset    = match_data[10]
+
+    if integer_start_offset
+      @start_offset = integer_start_offset.to_i
+    elsif regexp_start_offset
+      @start_offset = Regexp.new(regexp_start_offset[1..-2])
+    else
+      raise "Could not parse start offset '#{match_data[1]}'"
+    end
+
+    case @delimiter
+    when '..', '...'
+      if integer_end_offset
+        @end_offset = integer_end_offset.to_i
+      elsif regexp_end_offset
+        @end_offset = Regexp.new(regexp_end_offset[1..-2])
+      end
+    when nil
+      @end_offset = @start_offset
+    when ','
+      @length = integer_end_offset.to_i
+    else raise "Should not get here"
+    end
+
+  end
+
+  def integer_offsets?
+    Integer === @start_offset && Integer === @end_offset
+  end
+
+  def offset_for_slice(offset)
+    return offset if offset.nil? || offset.kind_of?(Regexp)
+    if offset < 1
+      offset
+    else
+      offset - 1
+    end
+  end
+end