devver-germinate 1.1.0 → 1.2.0

data/lib/germinate/selector.rb

@@ -8,14 +8,16 @@ class Germinate::Selector
   attr_reader :delimiter
   attr_reader :pipeline
   attr_reader :default_key
+  attr_reader :origin
 
-  PATTERN = /^([@$])?(\w+)?(:([^\s\|]+))?(\|([\w|]+))?$/
-  EXCERPT_OUTPUT_PATTERN = /^([@$])?(\w+)?(\|([\w|]+))?(:([^\s\|]+))?$/
+  PATTERN = /^([@$])?(\w+)?(:([^\|]+))?(\|([\w|]+))?$/
+  EXCERPT_OUTPUT_PATTERN = /^([@$])?(\w+)?(\|([\w|]+))?(:([^\|]+))?$/
   EXCERPT_PATTERN = %r{((-?\d+)|(/[^/]*/))(((\.\.\.?)|(,))((-?\d+)|(/[^/]*/)))?}
 
-  def initialize(string, default_key)
+  def initialize(string, default_key=:unspecified, origin="<Unknown>")
     @string      = string
     @default_key = default_key
+    @origin      = origin
     match_data = case string
                  when "", nil then {}
                  else 
@@ -35,10 +37,11 @@ class Germinate::Selector
     @selector_type = 
       case match_data[1]
       when "$" then :special
-      when "@", nil then :code
+      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
+    @key = match_data[2] || (default_key == :unspecified ? "SOURCE" : default_key)
     if match_data[subscript_index]
       @slice = true
       parse_excerpt(match_data[subscript_index])
@@ -49,7 +52,8 @@ class Germinate::Selector
       @end_offset   = -1
       @length       = nil
     end
-    @pipeline = String(match_data[pipeline_index]).split("|")
+    @pipeline = String(match_data[pipeline_index]).
+      split("|").unshift('_transform').uniq
   end
 
   def start_offset_for_slice
@@ -75,6 +79,14 @@ class Germinate::Selector
     !slice?
   end
 
+  def to_s
+    string + "(#{origin})"
+  end
+
+  def ==(other)
+    string == other
+  end
+
   private
 
   def parse_excerpt(excerpt)

data/lib/germinate/shared_style_attributes.rb

@@ -1,11 +1,28 @@
+require File.expand_path("text_transforms", File.dirname(__FILE__))
+require File.expand_path("pipeline", File.dirname(__FILE__))
+require File.expand_path("origin", File.dirname(__FILE__))
 require 'fattr'
 
 module Germinate::SharedStyleAttributes
   fattr :comment_prefix
   fattr :code_open_bracket  => nil
   fattr :code_close_bracket => nil
-  fattr :pipeline           => []
+  fattr :pipeline           => Germinate::Pipeline.new([])
   fattr :source_path        => nil
+  fattr :origin             => Germinate::Origin.new
+
+
+  TEXT_TRANSFORMS = Germinate::TextTransforms.singleton_methods
+
+  (TEXT_TRANSFORMS - ['pipeline']).each do |transform|
+    fattr(transform, false)
+  end
+
+  def disable_all_transforms!
+    TEXT_TRANSFORMS.each do |transform|
+      self.send("#{transform}=", false)
+    end
+  end
 
   def shared_style_attributes
     Germinate::SharedStyleAttributes.fattrs.inject({}) { 

data/lib/germinate/{process.rb → shell_process.rb}

@@ -3,17 +3,19 @@ require 'fattr'
 require 'English'
 require 'main'
 
-# A Process represents an external command which can be used to process a Hunk
+# A ShellProcess represents an external command which can be used to process a Hunk
 # of text.
-class Germinate::Process
+class Germinate::ShellProcess
   attr_reader :name
   attr_reader :command
+  attr_reader :variables
 
   fattr(:log) { Germinate.logger }
 
-  def initialize(name, command)
-    @name    = name
-    @command = command
+  def initialize(name, command, variables={})
+    @name      = name
+    @command   = command
+    @variables = variables
   end
 
   def call(input)
@@ -65,11 +67,28 @@ class Germinate::Process
   end
 
   def log_popen(command, mode, &block)
-    log.debug "Running command '#{command}'"
-    IO.popen(command, mode, &block)
+    log.debug "Running command `#{command}`"
+    with_environment_variables(@variables) do
+      IO.popen(command, mode, &block)
+    end
     status = $CHILD_STATUS
-    unless status.success?
+    unless status.nil? ||status.success? 
       log.warn "Command '#{command}' exited with status #{status}"
     end
   end
+
+  def with_environment_variables(variables)
+    old_values = variables.inject({}) do |original, (name, variable)| 
+      original[name.to_s] = ENV[name.to_s]
+      ENV[name.to_s] = variable.to_s
+      original
+    end
+    yield
+  ensure
+    (old_values || {}).each_pair do |name, value|
+      if value.nil? then ENV.delete(name)
+      else ENV[name] = value
+      end
+    end
+  end
 end

data/lib/germinate/shell_publisher.rb

@@ -0,0 +1,19 @@
+class Germinate::ShellPublisher < Germinate::Publisher
+  identifier 'shell'
+
+  def initialize(name, librarian, options)
+    @command = options.delete(:command) do
+      raise ArgumentError, 
+            "A 'command' option must be supplied for publisher type 'shell'"
+    end
+    super
+  end
+
+  def publish!(output, extra_options={})
+    process = Germinate::ShellProcess.new(name, @command, librarian.variables)
+    processed = process.call(input)
+    processed.each do |line|
+      output.print(line)
+    end
+  end
+end

data/lib/germinate/simple_publisher.rb

@@ -0,0 +1,7 @@
+class Germinate::SimplePublisher < Germinate::Publisher
+  def publish!(output, extra_options={})
+    input.each do |line|
+      output.puts(line)
+    end
+  end
+end

data/lib/germinate/source_file.rb

@@ -0,0 +1,41 @@
+require 'pathname'
+require 'fattr'
+require 'fileutils'
+
+# SourcePath represents an article source file on disk.
+class Germinate::SourceFile
+  fattr :path
+  fattr(:backup_path) { Pathname(path.to_s + ".germ.bak") }
+  fattr(:log) { Germinate.logger }
+
+  def initialize(path)
+    @path = Pathname(path)
+  end
+
+  def write!(lines)
+    log.debug "Writing #{lines.size} lines to #{path}"
+    file = File.new(path)
+    flock_result = file.flock(File::LOCK_EX)
+    if flock_result != 0
+      raise "Unable to lock file #{path}"
+    end
+    FileUtils.cp(path, backup_path)
+    unless path.read == backup_path.read
+      raise "Error backup up #{path} to #{backup_path}"
+    end
+    begin
+      path.open('w+') do |output|
+        lines.each do |line|
+          output.write(line)
+        end
+      end
+    rescue Exception => error
+      FileUtils.cp(backup_path, path)
+      raise
+    end
+    log.info "Changes saved to #{path}."
+    log.info "Previous state saved as #{backup_path}."
+  ensure
+    file.flock(File::LOCK_UN)
+  end
+end

data/lib/germinate/text_transforms.rb

@@ -9,15 +9,20 @@ module Germinate::TextTransforms
         case line
         when /\S/
           result.last << line.strip
-        else
+        when String
           result << [line]
           result << []
+        else
+          result << line
         end
         result
       }
       paragraphs.delete_if{|p| p.empty?}
       hunk.dup.replace(paragraphs.map {|paragraph|
-        paragraph.join(" ")
+        case paragraph
+        when Germinate::Hunk then paragraph
+        else paragraph.join(" ") 
+        end
       })
     }
   end
@@ -25,8 +30,8 @@ module Germinate::TextTransforms
   def self.strip_blanks
     lambda { |hunk|
       result = hunk.dup
-      result.shift until result.first =~ /\S/ || result.empty?
-      result.pop until result.last =~ /\S/ || result.empty?
+      result.shift while result.first =~ /^\s*$/ && !result.empty?
+      result.pop while result.last =~ /^\s*$/ && !result.empty?
       result
     }
   end
@@ -34,7 +39,7 @@ module Germinate::TextTransforms
   def self.erase_comments(comment_prefix="")
     lambda { |hunk|
       hunk.dup.map! do |line|
-        if comment_prefix
+        if comment_prefix && String === line
           if match_data = /^\s*(#{comment_prefix})+\s*/.match(line)
             offset = match_data.begin(0)
             length = match_data[0].length
@@ -51,11 +56,12 @@ module Germinate::TextTransforms
     }
   end
 
-  def self.uncomment(comment_prefix="")
+  def self.uncomment(comment_prefix=nil)
     lambda { |hunk|
+      comment_prefix ||= hunk.comment_prefix
       hunk.dup.map! do |line|
-        if comment_prefix
-          line.sub(/^#{comment_prefix}/,"")
+        if comment_prefix && line.respond_to?(:sub)
+          line.sub(/^#{Regexp.escape(comment_prefix.rstrip)}\s*/,"")
         else
           line
         end
@@ -65,7 +71,7 @@ module Germinate::TextTransforms
 
   def self.rstrip_lines
     lambda { |hunk|
-      hunk.dup.map!{|line| line.to_s.rstrip}
+      hunk.dup.map!{|line| String === line ? line.to_s.rstrip : line}
     }
   end
 
@@ -87,4 +93,27 @@ module Germinate::TextTransforms
       pipeline.call(hunk)
     end
   end
+
+  def self.expand_insertions
+    lambda do |hunk|
+      hunk.resolve_insertions
+    end
+  end
+
+  def self.flatten_nested
+    lambda do |hunk|
+      result = hunk.flatten
+      result.copy_shared_style_attributes_from(hunk)
+      result
+    end
+  end
+
+  eigenclss = class << self; self; end
+
+  eigenclss.instance_eval do
+    private
+    def log
+      @log ||= Germinate.logger
+    end
+  end
 end

data/lib/germinate/transform_process.rb

@@ -0,0 +1,25 @@
+require 'fattr'
+require File.expand_path("shared_style_attributes", File.dirname(__FILE__))
+
+class Germinate::TransformProcess
+  fattr(:log) { Germinate.logger }
+  
+  # We can't just use TextTransforms.singleton_methods because order is important
+  def ordered_transforms
+    %w[expand_insertions strip_blanks erase_comments
+       uncomment         join_lines   rstrip_lines   
+       pipeline          bracket      flatten_nested]
+  end
+
+  def call(hunk)
+    ordered_transforms.inject(hunk) { |input, transform|
+      if hunk.send("#{transform}?")
+        log.debug "Performing text transform #{transform} on #{hunk}"
+        Germinate::TextTransforms.send(transform).call(input) 
+      else
+        log.debug "Skipping text transform #{transform} on #{hunk} lines"
+        input
+      end
+    }
+  end
+end

data/lib/germinate/variable.rb

@@ -0,0 +1,23 @@
+class Germinate::Variable < String
+  attr_reader   :name
+  attr_reader   :origin
+  attr_reader   :line
+
+  def initialize(name, value, line, source_path, line_number)
+    super(value.to_s)
+    @name = name
+    @line = line
+    @origin = Germinate::Origin.new(source_path, line_number)
+  end
+
+  def update_source_line!(comment_prefix)
+    line.replace(make_control_line(comment_prefix))
+  end
+
+  private
+  
+  def make_control_line(comment_prefix)
+    "#{comment_prefix}:SET: '#{name}', '#{self}'\n"
+  end
+
+end

data/sample.rb

@@ -0,0 +1,14 @@
+# :BRACKET_CODE: "<pre>", "</pre>"
+
+# :SAMPLE: sample1
+code sample 1
+
+# :SAMPLE: sample2
+code sample 2
+
+# :TEXT:
+# Here is example 2:
+# :INSERT: @sample2
+#
+# And here is example 1:
+# :INSERT: @sample1

data/spec/germinate/application_spec.rb

@@ -5,10 +5,27 @@ module Germinate
 
   describe Application do
     before :each do
-      @it = Application.new
+      @it = Application.new(nil, nil)
     end
 
+    context "loading plugins" do
+      before :each do 
+        @files = ['a', 'b']
+        Gem.stub!(:find_files).and_return(@files)
+        Kernel.stub!(:load)
+      end
 
+      it "should look for files called germinate_plugin_v0_init.rb" do
+        Gem.should_receive(:find_files).with('germinate_plugin_v0_init')
+        @it.load_plugins!
+      end
+
+      it "should load the found files" do
+        Kernel.should_receive(:load).with('a')
+        Kernel.should_receive(:load).with('b')
+        @it.load_plugins!
+      end
+    end
   end
 
 end

data/spec/germinate/article_editor_spec.rb

@@ -24,8 +24,8 @@ module Germinate
 
       it "should yield text and code in order" do
         collect_hunks.should == [
-          ["this is the text", "text line 2"],
-          ["this is the code", "code line 2"]
+          ["this is the text\n", "text line 2\n"],
+          ["this is the code\n", "code line 2\n"]
         ]
       end
 
@@ -53,7 +53,7 @@ module Germinate
 
       it "should yield just the text" do
         collect_hunks.should == [
-          ["this is the text", "text line 2"]
+          ["this is the text\n", "text line 2\n"]
         ]
       end
     end

data/spec/germinate/code_hunk_spec.rb

@@ -7,6 +7,34 @@ module Germinate
       @it = CodeHunk.new(["foo", "bar"])
     end
 
+    it "should disable line joining" do
+      @it.should_not be_join_lines
+    end
+
+    it "should enable blank stripping" do
+      @it.should be_strip_blanks
+    end
+
+    it "should disable comment erasure" do
+      @it.should_not be_erase_comments
+    end
+
+    it "should disable uncommenting" do
+      @it.should_not be_uncomment
+    end
+
+    it "should disable stripping right-side whitespace" do
+      @it.should_not be_rstrip_lines
+    end
+
+    it "should enable bracketing" do
+      @it.should be_bracket
+    end
+      
+    it "should enable pipeline processing" do
+      @it.should be_pipeline
+    end
+
     context "when visited by a formatter" do
       before :each do
         @formatter = stub("Formatter")