germinate 1.2.0

data/spec/germinate/selector_spec.rb

@@ -0,0 +1,121 @@
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. .. lib germinate]))
+
+module Germinate
+  describe Selector do
+    
+    it "should be comparable to a string" do
+      Selector.new("@A:1..5").should be == "@A:1..5"
+      Selector.new("@A:1..5").should_not be == "@A:1..6"
+    end
+
+    context "given a subscript" do
+      before :each do
+        @it = Germinate::Selector.new("@A:1", "DEFAULT")
+      end
+
+      specify { @it.should be_slice }
+      specify { @it.should_not be_whole }
+    end
+
+    context "given no subscript" do
+      before :each do
+        @it = Germinate::Selector.new("@A", "DEFAULT")
+      end
+
+      specify { @it.should_not be_slice }
+      specify { @it.should be_whole }
+    end
+
+    context "given a post-pipeline subscript" do
+      before :each do
+        @it = Germinate::Selector.new("@A|foo:1", "DEFAULT")
+      end
+
+      specify { @it.should_not be_slice }
+      specify { @it.should be_whole }
+    end
+
+    context "given no type sigil or key" do
+      before :each do
+        @it = Selector.new(":2..5")
+      end
+
+      it "should have type code" do
+        @it.selector_type.should == :special
+      end
+
+      it "should have key SOURCE" do
+        @it.key.should == "SOURCE"
+      end
+    end
+
+    EXAMPLE_SELECTORS = [
+      # selector       type      key        delim  start end length pipeline             excerpt_output?
+      [ "@A",          :code,    "A",       '..',  1,    -1, nil,   %w[_transform]       ,false],
+      [ "@A:1",        :code,    "A",       nil,   1,    1,  nil,   %w[_transform]       ,false],
+      [ "",            :code,    "DEFAULT", '..',  1,    -1, nil,   %w[_transform]       ,false],
+      [ nil,           :code,    "DEFAULT", '..',  1,    -1, nil,   %w[_transform]       ,false],
+      [ ":2..4",       :code,    "DEFAULT", '..',  2,    4,  nil,   %w[_transform]       ,false],
+      [ ":2...4",      :code,    "DEFAULT", '...', 2,    4,  nil,   %w[_transform]       ,false],
+      [ "@B:2,5",      :code,    "B",       ',',   2,    nil,5,     %w[_transform]       ,false],
+      [ "@B:/z/,6",    :code,    "B",       ',',   /z/,  nil,6,     %w[_transform]       ,false],
+      [ "@_:/z/../x/", :code,    "_",       '..',  /z/,  /x/,nil,   %w[_transform]       ,false],
+      [ "@B:2,4|fnord",:code,    "B",       ',',   2,    nil,4,     %w[_transform fnord] ,false],
+      [ "$FOO",        :special, "FOO",     '..',  1,    -1, nil,   %w[_transform]       ,false],
+      [ "@A|foo|bar",  :code,    "A",       '..',  1,    -1, nil,   %w[_transform foo bar],false],
+      [ "@B|fnord:2,4",:code,    "B",       ',',   2,    nil,4,     %w[_transform fnord],true],
+      [ "@B|_transform",:code,   "B",       '..',  1,   -1,  nil,   %w[_transform],       false]
+    ]
+
+    EXAMPLE_SELECTORS.each do |selector_attributes| 
+      selector_string = selector_attributes[0]
+      type            = selector_attributes[1]
+      key             = selector_attributes[2]
+      delimiter       = selector_attributes[3]
+      start           = selector_attributes[4]
+      end_offset      = selector_attributes[5]
+      length          = selector_attributes[6]
+      pipeline        = selector_attributes[7]
+      excerpt_output  = selector_attributes[8]
+
+      context "given selector '#{selector_attributes[0]}'" do
+        before :each do
+          @it = Germinate::Selector.new(selector_string, "DEFAULT")
+        end
+
+        it "should have string #{selector_string}" do
+          @it.string.should == selector_string
+        end
+
+        it "should have type #{type.inspect}" do
+          @it.selector_type.should == type 
+        end
+        it "should have key #{key.inspect}" do
+          @it.key.should == key 
+        end
+        it "should start at #{start.inspect}" do
+          @it.start_offset.should == start 
+        end
+        it "should end at #{end_offset.inspect}" do 
+          @it.end_offset.should == end_offset
+        end
+        it "should have length #{length.inspect}" do
+          @it.length.should == length 
+        end
+        it "should have pipeline #{pipeline.inspect}" do
+          @it.pipeline.should == pipeline 
+        end
+        it "should have delimiter #{delimiter.inspect}" do
+          @it.delimiter.should == delimiter
+        end
+        
+        if excerpt_output
+          specify { @it.should be_excerpt_output }
+        else
+          specify { @it.should_not be_excerpt_output }
+        end
+      end
+    end
+  end
+end

data/spec/germinate/shell_publisher_spec.rb

@@ -0,0 +1,61 @@
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. .. lib germinate]))
+
+module Germinate
+  describe ShellPublisher do
+    before :each do
+      @name = "frank"
+      @pipeline_output = ["* line 1\n", "* line 2\n"]
+      @pipeline  = stub("Pipeline", :call => @pipeline_output)
+      @variables = stub("Variables")
+      @librarian = stub("Librarian", 
+        :make_pipeline => @pipeline,
+        :variables     => @variables)
+      @command   = "cat %f"
+      @options   = {:command => @command}
+      @it = ShellPublisher.new(@name, @librarian, @options)
+    end
+
+    it "should have identifier 'shell'" do
+      ShellPublisher.identifier.should == "shell"
+    end
+
+    context "on publish" do
+      before :each do
+        @result  = ["line 1\n", "line 2\n"]
+        @output  = StringIO.new
+        @process = stub("ShellProcess", :call => @result).as_null_object
+        @source  = stub("Source").as_null_object
+        @librarian.stub!(:[]).and_return(@source)
+        ShellProcess.stub!(:new).and_return(@process)
+      end
+      
+      it "should create a new process" do
+        ShellProcess.should_receive(:new).with(@name, @command, @variables)
+        @it.publish!(@output)
+      end
+
+      it "should execute the created process" do
+        @process.should_receive(:call).with(anything).and_return(@result)
+        @it.publish!(@output)
+      end
+
+      it "should pass the pipeline output to the created process" do
+        @process.should_receive(:call).with(@pipeline_output).and_return(@result)
+        @it.publish!(@output)
+      end
+
+      it "should ask the librarian for the source file" do
+        @librarian.should_receive(:[]).with("$TEXT|_transform", anything)
+        @it.publish!(@output)
+      end
+
+      it "should write process output to given output stream" do
+        @it.publish!(@output)
+        @output.rewind
+        @output.read.should == "line 1\nline 2\n"
+      end
+
+    end
+  end
+end

data/spec/germinate/source_file_spec.rb

@@ -0,0 +1,99 @@
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. .. lib germinate]))
+
+module Germinate
+  describe SourceFile do
+    before :each do
+      @it = SourceFile.new("DIR/SOURCE_PATH.EXT")
+      @file = stub("File", :flock => 0)
+      @lines = ["Line 1\n", "Line 2\n"]
+      File.stub!(:new).and_return(@file)
+      FileUtils.stub!(:cp)
+    end
+
+    it "should have a source path" do
+      @it.path.to_s.should == "DIR/SOURCE_PATH.EXT"
+    end
+
+    it "should append .germ.back for the backup path" do
+      @it.backup_path.to_s.should == "DIR/SOURCE_PATH.EXT.germ.bak"
+    end
+
+    context "when writing" do
+      before :each do
+        @open_file = stub("Open File", :write => nil)
+        @path = stub("Source Path", :read => "...")
+        @path.stub!(:open).and_yield(@open_file)
+        @backup_path = stub("BACKUP_PATH", :read => "...")
+        @it.backup_path = @backup_path
+        @it.path = @path
+      end
+
+      it "should lock and unlock the source path" do
+        File.should_receive(:new).with(@it.path).and_return(@file)
+        @file.should_receive(:flock).with(File::LOCK_EX).ordered.and_return(0)
+        @file.should_receive(:flock).with(File::LOCK_UN).ordered
+        @it.write!(@lines)
+      end
+
+      it "should raise error if locking fails" do
+        @file.should_receive(:flock).with(File::LOCK_EX).ordered.and_return(1)
+        @file.should_receive(:flock).with(File::LOCK_UN).ordered
+
+        lambda do
+          @it.write!(@lines)
+        end.should raise_error(RuntimeError)
+      end
+
+      it "should make a backup copy after locking the file" do
+        @file.should_receive(:flock).with(File::LOCK_EX).ordered.and_return(0)
+        FileUtils.should_receive(:cp).with(@it.path, @backup_path).ordered
+        @it.write!(@lines)
+      end
+
+      it "should make no backup if locking fails" do
+        @file.should_receive(:flock).with(File::LOCK_EX).ordered.and_return(1)
+        FileUtils.should_not_receive(:cp)
+        @it.write!(@lines) rescue nil
+      end
+
+      it "should unlock the file if backup fails" do
+        FileUtils.should_receive(:cp).and_raise("Some Error")
+        @file.should_receive(:flock).with(File::LOCK_UN)
+        @it.write!(@lines) rescue nil
+      end
+
+      it "should raise error if source file and backup are not equal" do
+        @path.should_receive(:read).and_return("...")
+        @backup_path.should_receive(:read).and_return("....")
+        lambda do @it.write!(@lines) end.should raise_error(RuntimeError)
+      end
+      
+      it "should not open the source file if comparison fails" do
+        @path.should_receive(:read).and_return("...")
+        @backup_path.should_receive(:read).and_return("....")
+        @path.should_not_receive(:open)
+        lambda do @it.write!(@lines) end.should raise_error(RuntimeError)
+      end
+
+      it "should open the source file for overwriting after backing up" do
+        FileUtils.should_receive(:cp).ordered
+        @path.should_receive(:open).with('w+').ordered
+        @it.write!(@lines)
+      end
+
+      it "should write lines to the source file" do
+        @open_file.should_receive(:write).with("Line 1\n").ordered
+        @open_file.should_receive(:write).with("Line 2\n").ordered
+        @it.write!(@lines)
+      end
+
+      it "should restore backup if write fails" do
+        @open_file.should_receive(:write).and_raise("Some Failure")
+        FileUtils.should_receive(:cp).with(@backup_path, @path)
+        lambda do @it.write!(@lines) end.should raise_error(RuntimeError)
+      end
+
+    end
+  end
+end

data/spec/germinate/text_hunk_spec.rb

@@ -0,0 +1,98 @@
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. .. lib germinate]))
+
+module Germinate
+  describe TextHunk do
+    before :each do
+      @it = TextHunk.new(["line 1", "line 2"])
+    end
+
+    it "should enable insertion expansion" do
+      @it.should be_expand_insertions
+    end
+
+    it "should enable line joining" do
+      @it.should 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 enable uncommenting" do
+      @it.should be_uncomment
+    end
+
+    it "should enable stripping right-side whitespace" do
+      @it.should be_rstrip_lines
+    end
+
+    it "should disable bracketing" do
+      @it.should_not be_bracket
+    end
+      
+    it "should enable pipeline processing" do
+      @it.should be_pipeline
+    end
+
+    it "should enable insertion resolution" do
+      @it.should be_expand_insertions
+    end
+
+    it "should enable flattening nested hunks" do
+      @it.should be_flatten_nested
+    end
+
+
+    context "when visited by a formatter" do
+      before :each do
+        @comment_prefix = ">>"
+        contents = [
+          "foo",
+          "bar"
+        ]
+        @it = TextHunk.new(contents, 
+          :comment_prefix => @comment_prefix)
+        @formatter = stub("Formatter")
+      end
+
+      it "should call #format_text! on self" do
+        @formatter.should_receive(:format_text!).with(@it, anything)
+        @it.format_with(@formatter)
+      end
+
+      it "should provide the comment prefix to the formatter" do
+        @formatter.should_receive(:format_text!).with(anything, @comment_prefix)
+        @it.format_with(@formatter)
+      end
+
+    end
+
+    describe "with a nested hunk" do
+      before :each do
+        @comment_prefix = ">>"
+        @formatter = stub("Formatter")
+        @nested_hunk = stub("Nested Hunk", :empty? => false)
+        contents = [
+          "foo",
+          "bar",
+          @nested_hunk,
+          "baz"
+        ]
+        @it = TextHunk.new(contents, 
+          :comment_prefix => @comment_prefix)
+      end
+
+      it "should pass formatter on to nested hunks" do
+        @formatter.should_receive(:format_text!).with(["foo", "bar"], ">>").ordered
+        @nested_hunk.should_receive(:format_with).with(@formatter).ordered
+        @formatter.should_receive(:format_text!).with(["baz"], ">>").ordered
+        @it.format_with(@formatter)
+      end
+    end
+  end
+end

data/spec/germinate/text_transforms_spec.rb

@@ -0,0 +1,242 @@
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. .. lib germinate]))
+
+module Germinate
+  describe TextTransforms do
+
+    Germinate::TextTransforms.methods(false).each do |transform|
+      describe "'#{transform}'" do
+        before :each do
+          @transform = Germinate::TextTransforms.send(transform)
+        end
+
+        it "should preserve hunk attributes from input to output" do
+          @pipeline = lambda {|h| h}
+          @input = Hunk.new([], :comment_prefix => "foo", :pipeline => @pipeline)
+          @output = @transform.call(@input)
+          @output.comment_prefix.should == @input.comment_prefix
+        end
+
+        unless transform == "flatten_nested"
+          context "given a lumpy hunk" do
+            before :each do
+              @nested_hunk = Hunk.new(["line 3", "line 4"])
+              @lumpy = Hunk.new([
+                  "line 1",
+                  @nested_hunk,
+                  "line 2"
+                ],
+                :comment_prefix => "foo")
+              @output = @transform.call(@lumpy)
+            end
+            
+            it "should pass nested hunks through untouched" do
+              @output[1].should == @nested_hunk
+            end
+          end
+        end
+      end
+    end
+
+    describe "join_lines" do
+      before :each do
+        @it = TextTransforms.join_lines
+      end
+
+      context "given some line-broken paragraphs" do 
+        before :each do 
+          @input = [
+            "p1l1\n",
+            "p1l2\n",
+            "\n",
+            "p2l1",
+            "p2l2"
+          ]
+        end
+
+        it "should collapse the paragraphs into single lines" do
+          @it.call(@input).should == [
+            "p1l1 p1l2",
+            "\n",
+            "p2l1 p2l2"
+          ]
+        end
+      end
+    end
+
+    describe "uncomment" do
+      context "with no comment prefix" do
+        before :each do
+          @it = TextTransforms.uncomment(nil)
+        end
+
+        it "should do nothing" do
+          @it.call(Hunk.new(["# foo", " bar"])).should == ["# foo", " bar"]
+        end
+      end
+
+      context "with a comment prefix of '# '" do
+        before :each do
+          @it = TextTransforms.uncomment('# ')
+        end
+
+        it "should strip matching comment prefixes" do
+          @it.call(["# foo", " bar"]).should == ["foo", " bar"]
+        end
+      end
+
+      context "given no explicit prefix" do
+        before :each do
+          @hunk = Hunk.new([" # foo", " bar"], :comment_prefix => " # ")
+          @it = TextTransforms.uncomment
+        end
+
+        it "should fall back on hunk's comment prefix" do
+          @it.call(@hunk).should == ["foo", " bar"]
+        end
+      end
+
+    end
+
+    describe "strip_blanks" do
+      context "given some leading and trailing blank lines" do
+        before :each do
+          @hunk = Hunk.new(
+            [
+              "  \n ", "\t\t\t", "the good stuff", 
+              "  \n", "more good stuff\n", "\n"
+            ])
+          @it = TextTransforms.strip_blanks
+        end
+
+        it "should strip the blak lines" do
+          @it.call(@hunk).should == ["the good stuff", "  \n", "more good stuff\n"]
+        end
+      end
+
+      context "given a nested hunk at the end" do
+        before :each do
+          @hunk = Hunk.new(
+            [
+              "not blank", 
+              "the good stuff", 
+              Hunk.new(["line 1"])
+            ])
+          @it = TextTransforms.strip_blanks
+        end
+
+        it "should not strip the hunk" do
+          @it.call(@hunk).should == 
+            ["not blank", "the good stuff", Hunk.new(["line 1"])]
+        end
+      end
+
+    end
+
+    describe "rstrip_lines" do
+      before :each do
+        @it = TextTransforms.rstrip_lines
+      end
+
+      it "should strip whitespace from the ends of lines" do
+        @it.call(["foo\n", "\n", "", "\tbar\t \n "]).should == ["foo", "", "", "\tbar"]
+      end
+    end
+
+    describe "bracket" do
+      
+      context "given explicit brackets" do
+        before :each do
+          @it = TextTransforms.bracket("[", "]")
+        end
+
+        it "should bracket lines with the given brackets" do
+          @it.call(["line 1", "line 2"]).should == ["[", "line 1", "line 2", "]"]
+        end
+      end
+
+      context "given no arguments" do
+        before :each do
+          @hunk = Hunk.new(
+            ["line 1", "line 2"],
+            :code_open_bracket => "{{{", 
+            :code_close_bracket => "}}}")
+          @it = TextTransforms.bracket
+        end
+
+        it "should use brackets specified on hunk" do
+          @it.call(@hunk).should == ["{{{", "line 1", "line 2", "}}}"]
+        end
+      end
+
+      context "given no no brackets" do
+        before :each do
+          @hunk = Hunk.new(
+            ["line 1", "line 2"])
+          @it = TextTransforms.bracket
+        end
+
+        it "should leave the hunk unchanged" do
+          @it.call(@hunk).should == ["line 1", "line 2"]
+        end
+      end
+    end
+
+    describe "pipeline" do
+      before :each do
+        @output   = stub("Output")
+        @pipeline = stub("Pipeline", :call => @output)
+        @hunk     = stub("Hunk")
+      end
+
+      context "called on a hunk and a pipeline" do
+        before :each do
+          @it = TextTransforms.pipeline(@pipeline)
+        end
+
+        it "should invoke the pipeline on the hunk" do
+          @pipeline.should_receive(:call).with(@hunk).and_return(@output)
+          @it.call(@hunk).should == @output
+        end
+      end
+    end
+
+    describe "expand_insertions" do
+      before :each do
+        @output   = stub("Output")
+        @hunk     = stub("Hunk")
+      end
+
+      context "called on a hunk" do
+        before :each do
+          @it = TextTransforms.expand_insertions
+        end
+
+        it "should invoke expand_insertions on the hunk" do
+          @hunk.should_receive(:resolve_insertions).and_return(@output)
+          @it.call(@hunk).should == @output
+        end
+      end
+    end
+
+    describe "flatten" do
+      context "given a lumpy hunk" do
+        before :each do
+          @nested_hunk = Hunk.new(["line 3", "line 4"])
+          @lumpy = Hunk.new([
+              "line 1",
+              @nested_hunk,
+              "line 2"
+            ],
+            :comment_prefix => "foo")
+          @output = TextTransforms.flatten_nested.call(@lumpy)
+        end
+        
+        it "should flatten the hunk into a single level" do
+          @output.should == ["line 1", "line 3", "line 4", "line 2"]
+        end
+      end
+
+    end
+  end
+end