devver-germinate 1.0.0

data/lib/germinate/implicit_insertion.rb

@@ -0,0 +1,9 @@
+require File.expand_path("insertion", File.dirname(__FILE__))
+
+class Germinate::ImplicitInsertion < Germinate::Insertion
+  def resolve
+    super
+  rescue IndexError
+    Germinate::NullHunk.new
+  end
+end

data/lib/germinate/insertion.rb

@@ -0,0 +1,15 @@
+require 'fattr'
+
+class Germinate::Insertion
+  attr_reader :library
+  attr_reader :selector
+
+  def initialize(selector, library)
+    @selector = selector
+    @library  = library
+  end
+
+  def resolve
+    library[selector]
+  end
+end

data/lib/germinate/librarian.rb

@@ -0,0 +1,179 @@
+require 'orderedhash'
+require 'fattr'
+require File.expand_path("shared_style_attributes", File.dirname(__FILE__))
+
+# The Librarian is responsible for organizing all the chunks of content derived
+# from reading a source file and making them available for later re-assembly and
+# formatting.
+class Germinate::Librarian
+  include Germinate::SharedStyleAttributes
+
+  attr_reader   :lines
+  attr_reader   :text_lines
+  attr_reader   :code_lines
+  attr_reader   :front_matter_lines
+
+  fattr(:log) { Germinate.logger }
+
+  def initialize
+    @lines              = []
+    @text_lines         = []
+    @code_lines         = []
+    @front_matter_lines = []
+    @sections           = OrderedHash.new do |hash, key| 
+      hash[key] = Germinate::TextHunk.new([], shared_style_attributes)
+    end
+    @samples            = OrderedHash.new do |hash, key| 
+      hash[key] = Germinate::CodeHunk.new([], shared_style_attributes)
+    end
+    @processes = {}
+  end
+
+  def add_front_matter!(line)
+    add_line!(line)
+    @front_matter_lines << line
+  end
+
+  def add_control!(line)
+    add_line!(line)
+  end
+
+  def add_text!(section, line)
+    add_line!(line)
+    @text_lines << line
+    @sections[section] << line
+  end
+
+  def add_code!(sample, line)
+    add_line!(line)
+    @code_lines << line
+    @samples[sample] << line
+  end
+
+  def add_insertion!(section, selector)
+    insertion = Germinate::Insertion.new(selector, self)
+    @sections[section] << insertion
+  end
+
+  def set_code_attributes!(sample, attributes)
+    attributes.each_pair do |key, value| 
+      @samples[sample].send(key, value) unless value.nil?
+    end
+  end
+
+  def add_process!(process_name, command)
+    @processes[process_name] = Germinate::Process.new(process_name, command)
+  end
+
+  def comment_prefix_known?
+    !comment_prefix.nil?
+  end
+
+  def section(section_name)
+    unless has_section?(section_name)
+      raise IndexError, 
+            "No text section named '#{section_name}'.  "\
+            "Known sections: #{@sections.keys.join(', ')}"
+    end
+    Array(@sections[section_name])
+  end
+
+  def has_section?(section_name)
+    @sections.key?(section_name)
+  end
+
+  def sample(sample_name)
+    unless has_sample?(sample_name)
+      raise IndexError,
+            "No code sample named '#{sample_name}'.  "\
+            "Known samples: #{@samples.keys.join(', ')}"
+    end
+    Array(@samples[sample_name])
+  end
+
+  # Fetch a process by name
+  def process(process_name)
+    @processes.fetch(process_name)
+  end
+
+  def process_names
+    @processes.keys
+  end
+
+  def has_sample?(sample_name)
+    @samples.key?(sample_name)
+  end
+
+  def [](selector)
+    selector = case selector
+               when Germinate::Selector then selector
+               else Germinate::Selector.new(selector, "SECTION0")
+               end
+    sample = 
+      case selector.selector_type
+      when :code then sample(selector.key)
+      when :special then 
+        case selector.key
+        when "SOURCE" then Germinate::CodeHunk.new(lines, self)
+        when "CODE"   then Germinate::CodeHunk.new(code_lines, self)
+        when "TEXT"   then Germinate::CodeHunk.new(text_lines, self)
+        else raise "Unknown special section '$#{selector.key}'"
+        end
+      else
+        raise Exception, 
+              "Unknown selector type #{selector.selector_type.inspect}"
+      end
+    
+    sample = execute_pipeline(sample, selector.pipeline)
+
+    start_offset = start_offset(sample, selector)
+    end_offset   = end_offset(sample, selector, start_offset)
+    case selector.delimiter
+    when '..' then sample[start_offset..end_offset]
+    when '...' then sample[start_offset...end_offset]
+    when ','   then sample[start_offset, selector.length]
+    when nil   then sample.dup.replace([sample[start_offset]])
+    else raise "Don't understand delimiter #{selector.delimiter.inspect}"
+    end
+  end
+
+  def section_names
+    @sections.keys
+  end
+
+  def sample_names
+    @samples.keys
+  end
+
+  private
+
+  def add_line!(line)
+    @lines << line
+  end
+
+  def start_offset(hunk, selector)
+    offset = selector.start_offset_for_slice
+    case offset
+    when Integer then offset
+    when Regexp  then hunk.index_matching(offset)
+    else 
+      raise "Don't know how to use #{offset.inspect} as an offset"
+    end
+  end
+
+  def end_offset(hunk, selector, start_offset)
+    offset = selector.end_offset_for_slice
+    case offset
+    when Integer, nil then offset
+    when Regexp then 
+      hunk.index_matching(offset, start_offset)
+    else
+      raise "Don't know how to use #{offset.inspect} as an offset"
+    end
+  end
+
+  def execute_pipeline(hunk, process_names)
+    processes = process_names.map{|n| process(n)}
+    Germinate::Pipeline.new(processes).call(hunk)
+  end
+end

data/lib/germinate/pipeline.rb

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

data/lib/germinate/process.rb

@@ -0,0 +1,67 @@
+require 'tempfile'
+require 'fattr'
+require 'English'
+require 'main'
+
+# A Process represents an external command which can be used to process a Hunk
+# of text.
+class Germinate::Process
+  attr_reader :name
+  attr_reader :command
+
+  fattr(:log) { Germinate.logger }
+
+  def initialize(name, command)
+    @name    = name
+    @command = command
+  end
+
+  def call(input)
+    if pipe?
+      call_command_in_pipe(input)
+    else
+      call_command_on_temp_file(input)
+    end
+  end
+
+  private
+
+  def call_command_in_pipe(input)
+    log_popen(command, 'r+') do |process|
+      input.each do |line|
+        process << line
+      end
+      process.close_write
+      return input.class.new(process.readlines, input)
+    end
+  end
+
+  def call_command_on_temp_file(input)
+    Tempfile.open("germinate_hunk") do |file|
+      input.each do |line|
+        file << line
+      end
+      file.close
+      log_popen(substitute_filename(command, file.path), 'r') do |process|
+        return input.class.new(process.readlines, input)
+      end
+    end
+  end
+
+  def pipe?
+    !command.include?("%f")
+  end
+
+  def substitute_filename(command, filename)
+    command.gsub("%f", "'#{filename}'")
+  end
+
+  def log_popen(command, mode, &block)
+    log.debug "Running command '#{command}'"
+    IO.popen(command, mode, &block)
+    status = $CHILD_STATUS
+    unless status.success?
+      log.warn "Command '#{command}' exited with status #{status}"
+    end
+  end
+end

data/lib/germinate/reader.rb

@@ -0,0 +1,212 @@
+require 'alter_ego'
+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
+
+  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!
+
+    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)
+    @librarian       = librarian
+    @section_count   = 0
+    @current_section = "SECTION0"
+    @line_number     = 1
+  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[2]
+      argument_text  = match_data[3]
+      arguments      = YAML.load("[ #{argument_text} ]")
+
+      if comment_chars && !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) 
+      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,
+      :code_open_bracket  => options.fetch("brackets", []).first,
+      :code_close_bracket => options.fetch("brackets", []).last)
+    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)
+    librarian.add_insertion!(
+      current_section, 
+      Germinate::Selector.new(selector, current_section))
+  end
+
+  def process_control_line!(process_name, command)
+    librarian.add_process!(process_name, command)
+  end
+
+  def sample_name=(name)
+    self.current_section = name
+  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
+    /^\s*(#{comment_prefix})/
+  end
+
+  def unescape(line)
+    line.sub(/\\(:[A-Z0-9_]+:)/, '\1') 
+  end
+end