devver-germinate 1.1.0 → 1.2.0

data/lib/germinate/hunk.rb

@@ -16,6 +16,10 @@ class Germinate::Hunk < ::Array
     copy_shared_style_attributes_from(template)
   end
 
+  def to_s
+    "#{self.class.name}[#{origin}](#{self.size} lines)"
+  end
+
   # return a copy with leading and trailing whitespace lines removed
   def strip
     Germinate::TextTransforms.strip_blanks.call(self)
@@ -121,6 +125,16 @@ end
 
 # Represents a hunk of article text
 class Germinate::TextHunk < Germinate::Hunk
+  def initialize(contents = [], template = {})
+    self.join_lines        = true
+    self.strip_blanks      = true
+    self.rstrip_lines      = true
+    self.uncomment         = true
+    self.expand_insertions = true
+    self.flatten_nested    = true
+    super
+  end
+
   def format_with(formatter)
     super(formatter) do |formatter|
       formatter.format_text!(self, comment_prefix)
@@ -130,6 +144,12 @@ end
 
 # Represents a hunk of source code
 class Germinate::CodeHunk < Germinate::Hunk
+  def initialize(contents = [], template = {})
+    self.strip_blanks = true
+    self.bracket      = true
+    super
+  end
+
   def code_open_bracket=(new_value)
     super
   end

data/lib/germinate/insertion.rb

@@ -1,21 +1,29 @@
 require 'fattr'
+require 'ick'
 require File.expand_path("shared_style_attributes", File.dirname(__FILE__))
 
 class Germinate::Insertion
   include Germinate::SharedStyleAttributes
+  Ick::Returning.belongs_to(self)
 
   attr_reader :library
   attr_reader :selector
 
+  fattr(:log) { Germinate.logger }
+
   def initialize(selector, library, template={})
     copy_shared_style_attributes_from(template)
     @selector = selector
     @library  = library
   end
 
+  def to_s
+    "Insertion[#{selector}]"
+  end
+
   def resolve
-    returning(library[selector]) do |hunk|
-      hunk.copy_shared_style_attributes_from(self, false)
+    returning(library[selector, self, self]) do |hunk|
+      log.debug "Resolved #{self} to #{hunk}"
     end
   end
 end

data/lib/germinate/librarian.rb

@@ -1,5 +1,6 @@
 require 'orderedhash'
 require 'fattr'
+require 'ick'
 require File.expand_path("shared_style_attributes", File.dirname(__FILE__))
 
 # The Librarian is responsible for organizing all the chunks of content derived
@@ -7,7 +8,40 @@ require File.expand_path("shared_style_attributes", File.dirname(__FILE__))
 # formatting.
 class Germinate::Librarian
   include Germinate::SharedStyleAttributes
+  Ick::Returning.belongs_to(self)
 
+  class VariableStore < OrderedHash
+    def initialize(librarian)
+      super()
+      @librarian = librarian
+    end
+
+    def []=(key, value)
+      if key?(key)
+        variable = fetch(key)
+        variable.replace(value.to_s)
+        variable.update_source_line!(@librarian.comment_prefix)
+      else
+        variable = 
+          case value
+          when Germinate::Variable
+            value
+          else
+            line_number = @librarian.lines.length + 1
+            line        = ""
+            Germinate::Variable.new(
+              key, value, line, @librarian.source_path, line_number)
+          end
+        variable.update_source_line!(@librarian.comment_prefix)
+        store(key, variable)
+        @librarian.log.debug "Appending #{variable.line.inspect} to lines"
+        @librarian.lines << variable.line
+      end
+      @librarian.updated = true
+    end
+
+  end
+    
   attr_reader   :lines
   attr_reader   :text_lines
   attr_reader   :code_lines
@@ -16,6 +50,9 @@ class Germinate::Librarian
   fattr         :source_path => nil
 
   fattr(:log) { Germinate.logger }
+  fattr(:variables) { VariableStore.new(self) }
+  fattr(:updated) { false }
+  fattr(:source_file) { Germinate::SourceFile.new(source_path) }
 
   def initialize
     @lines              = []
@@ -28,7 +65,8 @@ class Germinate::Librarian
     @samples            = OrderedHash.new do |hash, key| 
       hash[key] = Germinate::CodeHunk.new([], shared_style_attributes)
     end
-    @processes = {}
+    @processes = {'_transform' => Germinate::TransformProcess.new}
+    @publishers = OrderedHash.new
   end
 
   def add_front_matter!(line)
@@ -55,6 +93,7 @@ class Germinate::Librarian
   def add_insertion!(section, selector, attributes)
     insertion = Germinate::Insertion.new(selector, self, attributes)
     @sections[section] << insertion
+    @text_lines << insertion
   end
 
   def set_code_attributes!(sample, attributes)
@@ -64,7 +103,20 @@ class Germinate::Librarian
   end
 
   def add_process!(process_name, command)
-    @processes[process_name] = Germinate::Process.new(process_name, command)
+    @processes[process_name] = 
+      Germinate::ShellProcess.new(process_name, command, variables)
+  end
+
+  def add_publisher!(name, identifier, options)
+    @publishers[name] = Germinate::Publisher.make(name, identifier, self, options)
+  end
+
+  def store_changes!
+    source_file.write!(lines)
+  end
+
+  def set_variable!(line, line_number, name, value)
+    variables.store(name,Germinate::Variable.new(name, value, line, source_path, line_number))
   end
 
   def comment_prefix_known?
@@ -96,52 +148,70 @@ class Germinate::Librarian
   # Fetch a process by name
   def process(process_name)
     @processes.fetch(process_name)
+  rescue IndexError => error
+    raise error.exception("Unknown process #{process_name.inspect}")
   end
 
   def process_names
     @processes.keys
   end
 
+  def publisher_names
+    @publishers.keys
+  end
+
+  # fetch a publisher by name
+  def publisher(publisher_name)
+    @publishers.fetch(publisher_name)
+  rescue IndexError => error
+    raise error.exception("Unknown publisher #{publisher_name.inspect}")
+  end
+
   def has_sample?(sample_name)
     @samples.key?(sample_name)
   end
 
-  def [](selector)
+  # TODO Too big, refactor.
+  def [](selector, origin="<Unknown>", template={})
+    log.debug "Selecting #{selector}, from #{origin}"
     selector = case selector
                when Germinate::Selector then selector
-               else Germinate::Selector.new(selector, "SECTION0")
+               else Germinate::Selector.new(selector, "SECTION0", origin)
                end
     sample = 
       case selector.selector_type
-      when :code then sample(selector.key)
+      when :code then 
+        sample(selector.key)
       when :special then 
         case selector.key
         when "SOURCE" 
-          if selector.whole?
-            Germinate::FileHunk.new(lines, self)
-          else
-            Germinate::CodeHunk.new(lines, self)
-          end
+          source_hunk = 
+            if selector.whole?
+              Germinate::FileHunk.new(lines, self)
+            else
+              Germinate::CodeHunk.new(lines, self)
+            end
+          source_hunk.disable_all_transforms!
+          source_hunk
         when "CODE"   then Germinate::CodeHunk.new(code_lines, self)
-        when "TEXT"   then Germinate::CodeHunk.new(text_lines, self)
+        when "TEXT"   then Germinate::TextHunk.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
+    sample.copy_shared_style_attributes_from(template)
+    sample.origin.source_path ||= source_path
+    sample.origin.selector    ||= selector
+
+    sample = if selector.excerpt_output?
+               excerpt(execute_pipeline(sample, selector.pipeline), selector)
+             else
+               execute_pipeline(excerpt(sample, selector), selector.pipeline)
+             end
+    sample
   end
 
   def section_names
@@ -152,9 +222,38 @@ class Germinate::Librarian
     @samples.keys
   end
 
+  # Given a list of process names or a '|'-delimited string, return a Pipeline
+  # object representing a super-process of all the named processes chained
+  # together.
+  def make_pipeline(process_names_or_string)
+    names = 
+      if process_names_or_string.kind_of?(String)
+        process_names_or_string.split("|")
+      else
+        process_names_or_string
+      end
+    processes = names.map{|n| process(n)}
+    Germinate::Pipeline.new(processes)
+  end
+
   private
 
+  def excerpt(sample, selector)
+    # TODO make excerpting just another TextTransform
+    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 add_line!(line)
+    line.chomp!
+    line << "\n"
     @lines << line
   end
 
@@ -163,9 +262,9 @@ class Germinate::Librarian
     case offset
     when Integer then offset
     when Regexp  then 
-      returning(hunk.index_matching(offset)) do |offset|
-        if offset.nil?
-          raise "Cannot find line matching #{offset.inspect}"
+      returning(hunk.index_matching(offset)) do |index|
+        if index.nil?
+          raise "Cannot find line matching #{offset.inspect} in #{selector}"
         end
       end
     else 
@@ -178,9 +277,9 @@ class Germinate::Librarian
     case offset
     when Integer, nil then offset
     when Regexp then 
-      returning(hunk.index_matching(offset, start_offset)) do |offset|
-        if offset.nil?
-          raise "Cannot find line matching #{offset.inspect}"
+      returning(hunk.index_matching(offset, start_offset)) do |index|
+        if index.nil?
+          raise "Cannot find line matching #{offset.inspect} in #{selector}"
         end
       end
     else
@@ -188,8 +287,7 @@ class Germinate::Librarian
     end
   end
 
-  def execute_pipeline(hunk, process_names)
-    processes = process_names.map{|n| process(n)}
-    Germinate::Pipeline.new(processes).call(hunk)
+  def execute_pipeline(hunk, names)
+    make_pipeline(names).call(hunk)
   end
 end

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

@@ -1,4 +1,6 @@
 class Germinate::Pipeline
+  attr_reader :processes
+
   def initialize(processes)
     @processes = processes
   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

@@ -1,4 +1,5 @@
 require 'alter_ego'
+require 'ick'
 require 'forwardable'
 require 'fattr'
 
@@ -9,8 +10,9 @@ require 'fattr'
 class Germinate::Reader
   include AlterEgo
   extend Forwardable
+  Ick::Returning.belongs_to(self)
 
-  CONTROL_PATTERN  = /^\s*([^\s\\]+)?\s*:([A-Z0-9_]+):\s*(.*)?\s*$/
+  CONTROL_PATTERN  = /^(\s*([^\s\\]+)?\s*):([A-Z0-9_]+):\s*(.*)?\s*$/
 
   attr_reader :librarian
   attr_reader :current_section
@@ -40,6 +42,12 @@ class Germinate::Reader
   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!
@@ -61,7 +69,7 @@ class Germinate::Reader
     @librarian       = librarian
     @section_count   = 0
     @current_section = "SECTION0"
-    @line_number     = 1
+    @line_number     = 0
     @source_path     = source_path ? Pathname(source_path) : nil
     librarian.source_path = @source_path
   end
@@ -109,11 +117,11 @@ class Germinate::Reader
   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]
+      keyword        = match_data[3]
+      argument_text  = match_data[4]
       arguments      = YAML.load("[ #{argument_text} ]")
 
-      if comment_chars && !comment_prefix_known?
+      if comment_chars && !comment_chars.empty? && !comment_prefix_known?
         self.comment_prefix = comment_chars
       end
       case keyword
@@ -123,9 +131,11 @@ class Germinate::Reader
       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 "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}"
+        log.warn "Ignoring unknown directive #{keyword} at line #{@line_number}"
       end
       librarian.add_control!(line)
       true
@@ -175,10 +185,22 @@ class Germinate::Reader
     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
@@ -205,7 +227,7 @@ class Germinate::Reader
   end
 
   def comment_pattern
-    /^\s*(#{comment_prefix})/
+    /^#{Regexp.escape(comment_prefix.rstrip)}/
   end
 
   def unescape(line)
@@ -218,6 +240,27 @@ class Germinate::Reader
         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