germinate 1.2.0

data/lib/germinate/shared_style_attributes.rb

@@ -0,0 +1,54 @@
+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           => 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({}) { 
+      |attributes, key|
+      
+      attributes[key] = send(key)
+      attributes
+    }
+  end
+
+  def copy_shared_style_attributes_from(other, override=true)
+    case other
+    when Germinate::SharedStyleAttributes
+      copy_attributes!(other.shared_style_attributes)
+    when Hash
+      copy_attributes!(other, override)
+    else
+      raise "Don't know how to copy attributes from #{other.inspect}"
+    end
+  end
+
+  def copy_attributes!(attributes, override=true)
+    attributes.each_pair do |key, value|
+      if !value.nil? && (override || !send(key))
+        self.send(key, value)
+      end
+    end
+  end
+end

data/lib/germinate/shell_process.rb

@@ -0,0 +1,94 @@
+require 'tempfile'
+require 'fattr'
+require 'English'
+require 'main'
+
+# A ShellProcess represents an external command which can be used to process a Hunk
+# of text.
+class Germinate::ShellProcess
+  attr_reader :name
+  attr_reader :command
+  attr_reader :variables
+
+  fattr(:log) { Germinate.logger }
+
+  def initialize(name, command, variables={})
+    @name      = name
+    @command   = command
+    @variables = variables
+  end
+
+  def call(input)
+    if pipe?
+      call_command_in_pipe(input)
+    elsif input.whole_file?
+      call_command_on_source_file(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 call_command_on_source_file(input)
+    log_popen(substitute_filename(command, input.source_path), 'r') do |process|
+      return Germinate::CodeHunk.new(process.readlines, input)
+    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}`"
+    with_environment_variables(@variables) do
+      IO.popen(command, mode, &block)
+    end
+    status = $CHILD_STATUS
+    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

@@ -0,0 +1,119 @@
+# A library of text transforms.  Each public module method returns a callable
+# object which can be used to transform an array of lines.
+module Germinate::TextTransforms
+
+  IDENTITY_TRANSFORM = lambda {|hunk| hunk}
+  def self.join_lines
+    lambda { |hunk|
+      paragraphs = hunk.inject([[]]) { |result, line|
+        case line
+        when /\S/
+          result.last << line.strip
+        when String
+          result << [line]
+          result << []
+        else
+          result << line
+        end
+        result
+      }
+      paragraphs.delete_if{|p| p.empty?}
+      hunk.dup.replace(paragraphs.map {|paragraph|
+        case paragraph
+        when Germinate::Hunk then paragraph
+        else paragraph.join(" ") 
+        end
+      })
+    }
+  end
+
+  def self.strip_blanks
+    lambda { |hunk|
+      result = hunk.dup
+      result.shift while result.first =~ /^\s*$/ && !result.empty?
+      result.pop while result.last =~ /^\s*$/ && !result.empty?
+      result
+    }
+  end
+
+  def self.erase_comments(comment_prefix="")
+    lambda { |hunk|
+      hunk.dup.map! do |line|
+        if comment_prefix && String === line
+          if match_data = /^\s*(#{comment_prefix})+\s*/.match(line)
+            offset = match_data.begin(0)
+            length = match_data[0].length
+            line_copy = line.dup
+            line_copy[offset, length] = (" " * length)
+            line_copy
+          else
+            line
+          end
+        else
+          line
+        end
+      end
+    }
+  end
+
+  def self.uncomment(comment_prefix=nil)
+    lambda { |hunk|
+      comment_prefix ||= hunk.comment_prefix
+      hunk.dup.map! do |line|
+        if comment_prefix && line.respond_to?(:sub)
+          line.sub(/^#{Regexp.escape(comment_prefix.rstrip)}\s*/,"")
+        else
+          line
+        end
+      end
+    }
+  end
+
+  def self.rstrip_lines
+    lambda { |hunk|
+      hunk.dup.map!{|line| String === line ? line.to_s.rstrip : line}
+    }
+  end
+
+  def self.bracket(open_bracket=nil, close_bracket=nil)
+    lambda { |hunk|
+      result = hunk.dup
+      result.clear
+      result << (open_bracket || hunk.code_open_bracket)
+      result.push(*Array(hunk))
+      result << (close_bracket || hunk.code_close_bracket)
+      result.compact!
+      result
+    }
+  end
+
+  def self.pipeline(pipeline=nil)
+    lambda do |hunk|
+      pipeline ||= hunk.pipeline
+      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

@@ -0,0 +1,31 @@
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. .. lib germinate]))
+
+module Germinate
+
+  describe Application do
+    before :each do
+      @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

@@ -0,0 +1,97 @@
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. .. lib germinate]))
+
+module Germinate
+  describe ArticleEditor do
+    before :each do
+      @librarian = Librarian.new
+      @it = ArticleEditor.new(@librarian)
+    end
+
+    context "with an empty library" do
+      it "should yield no hunks" do
+        collect_hunks.should be_empty
+      end
+    end
+
+    context "with a text section and matching code section" do
+      before :each do
+        @librarian.add_text!("SECTION1", "this is the text")
+        @librarian.add_text!("SECTION1", "text line 2")
+        @librarian.add_code!("SECTION1", "this is the code")
+        @librarian.add_code!("SECTION1", "code line 2")
+      end
+
+      it "should yield text and code in order" do
+        collect_hunks.should == [
+          ["this is the text\n", "text line 2\n"],
+          ["this is the code\n", "code line 2\n"]
+        ]
+      end
+
+      it "should yield text section as TextHunk" do
+        collect_hunks[0].should be_a_kind_of(TextHunk)
+      end
+
+      it "should yield code section as CodeHunk" do
+        collect_hunks[1].should be_a_kind_of(CodeHunk)
+      end
+
+      it "should set no comment prefix on hunks" do
+        collect_hunks[0].comment_prefix.should be_nil
+        collect_hunks[1].comment_prefix.should be_nil
+      end
+    end
+
+    context "with a text section and mis-matched code section" do
+      before :each do
+        @librarian.add_text!("SECTION1", "this is the text")
+        @librarian.add_text!("SECTION1", "text line 2")
+        @librarian.add_code!("SECTION2", "this is the code")
+        @librarian.add_code!("SECTION2", "code line 2")
+      end
+
+      it "should yield just the text" do
+        collect_hunks.should == [
+          ["this is the text\n", "text line 2\n"]
+        ]
+      end
+    end
+
+    context "with a known comment prefix" do
+      before :each do
+        @librarian.comment_prefix = ";;"
+        @librarian.add_text!("SECTION1", "this is the text")
+        @librarian.add_code!("SECTION1", "this is the code")
+      end
+
+    end
+
+    context "when iterating through hunks" do
+      before :each do
+        @resolved  = stub("Resolved Section")
+        @section   = stub("Unresolved Section", 
+          :resolve_insertions => @resolved)
+        @librarian = stub("Librarian", 
+          :section_names => ["section1"],
+          :section       => @section,
+          :sample        => @section,
+          :has_sample?   => true)
+        @it = ArticleEditor.new(@librarian)
+      end
+
+      it "should resolve hunks before yielding them" do
+        collect_hunks[0].should equal(@resolved)
+        collect_hunks[1].should equal(@resolved)
+      end
+    end
+
+    def collect_hunks
+      hunks = []
+      @it.each_hunk do |hunk|
+        hunks << hunk
+      end
+      hunks
+    end
+  end
+end