devver-germinate 1.0.0

data/lib/germinate/selector.rb

@@ -0,0 +1,95 @@
+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
+
+  PATTERN = /([@$])?(\w+)?(:([^\s\|]+))?(\|([\w|]+))?/
+  EXCERPT_PATTERN = %r{((-?\d+)|(/[^/]*/))(((\.\.\.?)|(,))((-?\d+)|(/[^/]*/)))?}
+
+  def initialize(string, default_key)
+    @string      = string
+    @default_key = default_key
+    match_data = case string
+                 when "", nil then {}
+                 else PATTERN.match(string)
+                 end
+
+    @selector_type = 
+      case match_data[1]
+      when "$" then :special
+      when "@", nil then :code
+      else raise "Unknown selector type '#{match_data[1]}'"
+      end
+    @key = match_data[2] || default_key
+    if match_data[3]
+      parse_excerpt(match_data[3])
+    else
+      @delimiter    = '..'
+      @start_offset = 1
+      @end_offset   = -1
+      @length       = nil
+    end
+    @pipeline = String(match_data[6]).split("|")
+  end
+
+  def start_offset_for_slice
+    offset_for_slice(start_offset)
+  end
+
+  def end_offset_for_slice
+    offset_for_slice(end_offset)
+  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

data/lib/germinate/shared_style_attributes.rb

@@ -0,0 +1,23 @@
+require 'fattr'
+
+module Germinate::SharedStyleAttributes
+  fattr :comment_prefix
+  fattr :code_open_bracket  => nil
+  fattr :code_close_bracket => nil
+  fattr :pipeline           => []
+
+  def shared_style_attributes
+    Germinate::SharedStyleAttributes.fattrs.inject({}) { 
+      |attributes, key|
+      
+      attributes[key] = send(key)
+      attributes
+    }
+  end
+
+  def copy_shared_style_attrubutes_from(other)
+    other.shared_style_attributes.each_pair do |key, value|
+      self.send(key, value) unless other.send(key).nil?
+    end
+  end
+end

data/lib/germinate/text_transforms.rb

@@ -0,0 +1,90 @@
+# 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
+        else
+          result << [line]
+          result << []
+        end
+        result
+      }
+      paragraphs.delete_if{|p| p.empty?}
+      hunk.dup.replace(paragraphs.map {|paragraph|
+        paragraph.join(" ")
+      })
+    }
+  end
+
+  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
+    }
+  end
+
+  def self.erase_comments(comment_prefix="")
+    lambda { |hunk|
+      hunk.dup.map! do |line|
+        if comment_prefix
+          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="")
+    lambda { |hunk|
+      hunk.dup.map! do |line|
+        if comment_prefix
+          line.sub(/^#{comment_prefix}/,"")
+        else
+          line
+        end
+      end
+    }
+  end
+
+  def self.rstrip_lines
+    lambda { |hunk|
+      hunk.dup.map!{|line| line.to_s.rstrip}
+    }
+  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
+end

data/spec/germinate/application_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. .. lib germinate]))
+
+module Germinate
+
+  describe Application do
+    before :each do
+      @it = Application.new
+    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", "text line 2"],
+          ["this is the code", "code line 2"]
+        ]
+      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", "text line 2"]
+        ]
+      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

data/spec/germinate/article_formatter_spec.rb

@@ -0,0 +1,153 @@
+require 'stringio'
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. .. lib germinate]))
+
+module Germinate
+  describe ArticleFormatter do
+    before :each do 
+      @output = StringIO.new
+      @hunk1  = stub("Hunk1")
+      @hunk2  = stub("Hunk2")
+      @it = ArticleFormatter.new(@output)
+    end
+
+    def output
+      @output.rewind
+      @output.string
+    end
+
+    context "given some hunks to format" do
+      before :each do
+        @hunks = [@hunk1, @hunk2]
+      end
+
+      it "should visit each hunk in turn" do
+        @hunk1.should_receive(:format_with).with(@it).ordered
+        @hunk2.should_receive(:format_with).with(@it).ordered
+        @hunks.each do |hunk|
+          @it.format!(hunk)
+        end
+      end
+    end
+
+    
+    context "given some text lines to format but no comment prefix" do
+      before :each do
+        @it.join_lines = false
+        @it.format_text!(Hunk.new([" # foo", "bar\n\n"]))
+      end
+
+      it "should just normalise newlines" do
+        output.should == " # foo\nbar\n"
+      end
+    end
+
+    context "given some text lines to format and a comment prefix" do
+      before :each do
+        @it.comment_prefix = "# "
+        @it.uncomment      = true
+        @it.join_lines     = false
+        @it.format_text!(Hunk.new(["#  foo", "bar\n\n"]), "# ")
+      end
+
+      it "should erase comments" do
+        output.should == " foo\nbar\n"
+      end
+    end
+
+    context "given leading and trailing blank lines around text" do
+      before :each do
+        @it.format_text!(Hunk.new(["", "foo", " \n "]), "#")
+      end
+
+      it "should erase comments" do
+        output.should == "foo\n"
+      end
+    end
+
+    context "given uncommenting is enabled and a comment prefix is set" do
+      it "should supply the comment prefix to the uncomment transform" do
+        @hunk          = stub("Hunk").as_null_object
+        @hunk.stub!(:strip).and_return(@hunk)
+        @prefix        = "//"
+        @transform     = stub("Transform", :call => @transformed)
+        TextTransforms.stub!(:uncomment).and_return(@transform)
+
+        TextTransforms.should_receive(:uncomment).with(@prefix).
+          and_return(lambda{|h| h})
+
+        @it.comment_prefix = @prefix
+        @it.uncomment      = true
+        @it.format_text!(@hunk)
+      end
+    end
+
+    CODE_TRANSFORMS = %w[rstrip_lines strip_blanks]
+    TEXT_TRANSFORMS  = %w[join_lines strip_blanks uncomment rstrip_lines]
+    TEXT_TRANSFORMS.each do |transform_name|
+      context "when only #{transform_name} is enabled" do
+        before :each do
+          (TEXT_TRANSFORMS - [transform_name]).each do |disabled_transform|
+            @it.send("#{disabled_transform}=", false)
+            TextTransforms.stub!(disabled_transform) do
+              fail "Transform #{disabled_transform} should not be enabled"
+            end
+          end
+          @it.send("#{transform_name}=", true)
+          
+          @transformed   = stub("Transformed Hunk").as_null_object
+          @hunk          = stub("Hunk").as_null_object
+          @hunk.stub!(:strip).and_return(@hunk)
+          @transform     = stub("Transform", :call => @transformed)
+          TextTransforms.stub!(transform_name).and_return(@transform)
+
+        end
+
+        it "should perform transform on text hunks" do
+          @transform.should_receive(:call).with(@hunk)
+          @it.format_text!(@hunk)
+        end
+
+        it "should return the result of the transform" do
+          @it.format_text!(@hunk).should == @transformed
+        end
+
+        unless CODE_TRANSFORMS.include?(transform_name)
+          it "should not perform transform on code hunks" do
+            @transform.should_not_receive(:call).with(@hunk)
+            @it.format_code!(@hunk)
+          end
+        end
+      end
+    end
+
+    context "given some code lines to format" do
+      before :each do
+        @it.format_code!(Hunk.new([" \n ", " # foo", "bar\n\n", ""]))
+      end
+
+      it "should normalise newlines and strip blanks" do
+        output.should == " # foo\nbar\n"
+      end
+    end
+
+    context "given a code hunk with brackets specified" do
+      before :each do
+        @hunk = Hunk.new(["line 1"], 
+          :code_open_bracket => "<<<",
+          :code_close_bracket => ">>>")
+      end
+
+      it "should wrap the code in brackets" do
+        @transform = stub("Bracketer")
+        TextTransforms.should_receive(:bracket).
+          with().and_return(@transform)
+        @transform.should_receive(:call).with(["line 1"]).and_return([])
+        @it.format_code!(@hunk)
+      end
+    end
+
+  end
+
+end