devver-germinate 1.1.0 → 1.2.0

data/spec/germinate/pipeline_spec.rb

@@ -21,4 +21,14 @@ module Germinate
       @it.call(@input).should == @output3
     end
   end
+
+  describe Pipeline, "given no processes" do
+    before :each do
+      @it = Pipeline.new([])
+     end
+    
+    it "should pass input through unchanged" do
+      @it.call(["foo", "bar"]).should == ["foo", "bar"]
+    end
+  end
 end

data/spec/germinate/process_spec.rb

@@ -2,21 +2,46 @@ require File.expand_path(
     File.join(File.dirname(__FILE__), %w[.. .. lib germinate]))
 
 module Germinate
-  describe Process do
+  describe ShellProcess do
     before :each do
       @input   = Germinate::Hunk.new(
         ["line 1\n", "line 2\n"], 
         :comment_prefix => "//")
       @output  = ["1 enil\n", "2 enil\n"]
       @command = stub("Command", :readlines => @output).as_null_object
+      @tempfile = stub("Temp File", :path => "TEMP_PATH").as_null_object
+      @status   = stub("Child Status", :success => true)
       IO.stub!(:popen).and_yield(@command)
+      Tempfile.stub!(:open).and_yield(@tempfile)
+    end
+
+    context "given a command and some variables" do
+      before :each do
+        @it = Germinate::ShellProcess.new(
+          "myproc", "mycommand", { "FOO" => 123, "BAR" => 456 })
+        ENV["FOO"] = "xxx"
+      end
+
+      it "should set the variables in the environment before execution" do
+        IO.should_receive(:popen) do
+          ENV["FOO"].should == "123"
+          ENV["BAR"].should == "456"
+        end
+        @it.call(@input)
+      end
+
+      it "should reset the environment after execution" do
+        @it.call(@input)
+        ENV["FOO"].should == "xxx"
+        ENV["BAR"].should be_nil
+      end
     end
 
     context "given a command 'mycommand'" do
       before :each do
-        @it = Germinate::Process.new("myproc", "mycommand")
+        @it = Germinate::ShellProcess.new("myproc", "mycommand")
       end
-      
+
       context "when called on a hunk of text" do
         it "should pipe the input through the command" do
           @command.should_receive(:<<).with("line 1\n").ordered
@@ -33,16 +58,16 @@ module Germinate
           output = @it.call(@input)
           output.comment_prefix.should == "//"
         end
+
       end
     end
 
     context "given a command 'mycommand %f' and called on some text" do
       before :each do
-        @it = Germinate::Process.new("myproc", "mycommand %f")
+        @it = Germinate::ShellProcess.new("myproc", "mycommand %f")
       end
 
       it "should create a temporary file and pass the name to the command" do
-        @tempfile = stub("Temp File", :path => "TEMP_PATH")
         Tempfile.should_receive(:open).with("germinate_hunk").and_yield(@tempfile)
         @tempfile.should_receive(:<<).with("line 1\n").ordered
         @tempfile.should_receive(:<<).with("line 2\n").ordered
@@ -66,7 +91,7 @@ module Germinate
         @input = Germinate::FileHunk.new(
           ["line 1\n", "line 2\n"],
           {:source_path => "SOURCE_PATH"})
-        @it = Germinate::Process.new("myproc", "mycommand %f")
+        @it = Germinate::ShellProcess.new("myproc", "mycommand %f")
       end
 
       it "should pass the source file path to the command" do

data/spec/germinate/publisher_spec.rb

@@ -0,0 +1,130 @@
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. .. lib germinate]))
+
+module Germinate
+  describe Publisher do
+    before :each do
+      @name      = "my_pub"
+      @hunk      = stub("Input Hunk")
+      @output    = stub("Pipeline Output")
+      @pipeline  = stub("Pipeline", :call => @output)
+      @librarian = stub("Librarian", 
+        :make_pipeline => @pipeline,
+        :[]            => @hunk ).as_null_object
+      @options   = {:a => 'b'}
+    end
+
+    context "when a new publisher type 'foo' is defined" do
+      before :each do
+        @it = Germinate::Publisher
+        @subclass = Class.new(Publisher) do
+          identifier "foo"
+        end
+      end
+
+      it "should be able to make 'foo' publishers" do
+        @publisher = stub("Publisher")
+        @subclass.should_receive(:new).with(@name, @librarian, @options).
+          and_return(@publisher)
+        
+        @it.make(@name, "foo", @librarian, @options)
+      end
+
+    end
+
+    context "when an anonymous publisher subclass is defined" do
+      before :each do
+        @it = Germinate::Publisher
+        @subclass = Class.new(Publisher) do
+          self.identifier = nil
+        end
+      end
+
+      it "should not make the publisher available as an instantiable type" do
+        @librarian = stub("Librarian")
+        @options   = {:a => 'b'}
+        @publisher = stub("Publisher")
+
+        lambda do 
+          @it.make("mypub", nil, @librarian, @options)
+        end.should raise_error(IndexError)
+      end
+
+    end
+
+    context "given name, librarian, and options" do
+      before :each do
+        @name = "frank"
+        @librarian = stub("Librarian").as_null_object
+        @options   = {:foo => "bar"}
+        @it = Publisher.new(@name, @librarian, @options)
+      end
+
+      it "should know its name" do
+        @it.name.should == @name
+      end
+
+      it "should know its librarian" do
+        @it.librarian.should == @librarian
+      end
+
+      it "should know its options" do
+        @it.options.should == @options
+      end
+    end
+
+    context "given a pipeline option" do
+      before :each do
+        @name = "frank"
+        @librarian = stub("Librarian").as_null_object
+        @options   = {:pipeline => "foo|bar"}
+      end
+
+      it "should have a pipeline" do
+        @it = Publisher.new(@name, @librarian, @options)
+        @it.pipeline.should_not be_nil
+      end
+
+      it "should use the librarian to construct a pipeline" do
+        @librarian.should_receive(:make_pipeline).with("foo|bar")
+        @it = Publisher.new(@name, @librarian, @options)
+      end
+    end
+
+    context "with no selector specified" do
+      before :each do
+        @it = Publisher.new(@name, @librarian, @options)
+      end
+
+      it "should select $TEXT|_transform" do
+        @it.selector.should == "$TEXT|_transform"
+      end
+
+    end
+
+    context "with a custom selector specified" do
+      before :each do
+        @it = Publisher.new(@name, @librarian, { :selector => "@sec1|myproc" })
+      end
+
+      it "should have the specified selector" do
+        @it.selector.should == "@sec1|myproc"
+      end
+
+      it "should use the selector to get a hunk to process" do
+        @librarian.should_receive(:[]).
+          with("@sec1|myproc", anything)
+        @it.input
+      end
+
+      it "should pass the selected hunk through the pipeline to get input" do
+        @pipeline.should_receive(:call).with(@hunk)
+        @it.input
+      end
+
+      it "should use pipeline output as input to publisher process" do
+        @it.input.should == @output
+      end
+    end
+  end
+end

data/spec/germinate/reader_spec.rb

@@ -45,8 +45,8 @@ module Germinate
     CONTROL_LINES = [
       # Line                  Comment  Args
       [":TEXT:\n",            nil,     []],
-      ["# :CUT: \n",          "#",     []],
-      ["  ; :TEXT: foo\n",    ";",     ["foo"]],
+      ["# :CUT: \n",          "# ",    []],
+      ["  ; :TEXT: foo\n",    "  ; ",  ["foo"]],
       ["//:SAMPLE:\n",        "//",    []],
       ["$>:END: ",            "$>",    []],
       [":SAMPLE: bar, { a: 1, b: 2 }", nil, ["bar", {"a"=>1, "b"=>2}]],
@@ -225,6 +225,19 @@ module Germinate
       end
     end
 
+    context "given a :SAMPLE: after a TEXT section with the same name" do
+      before :each do
+        @it << ":TEXT: foobar\n"
+        @it << "This is the text\n"
+      end
+
+      it "should add an implicit insertion to the TEXT section" do
+        @librarian.should_receive(:add_insertion!).with("foobar", "@foobar", {})
+        @it << ":SAMPLE: foobar\n"
+      end
+
+    end
+
     context "given a :SAMPLE: keyword with custom brackets" do
       before :each do
         @line = ':SAMPLE: foobar, { brackets: ["<<", ">>"] }'
@@ -314,6 +327,25 @@ module Germinate
 
     end
 
+    context "given an insertion with the special disable_transforms attr" do
+      before :each do
+        @it << ":TEXT: mysection"
+        @line = ":INSERT: foo, { disable_transforms: true } "
+      end
+      
+      it "should disable all transforms in the options" do
+        @librarian.should_receive(:add_insertion!) do 
+          |section, selector, options|
+          
+          TextTransforms.singleton_methods.each do |transform|
+            options[transform.to_sym].should be_false
+          end
+        end
+        @it << @line
+      end
+
+    end
+
     context "given a process directive" do
       before :each do
         @line = ' # :PROCESS: sortail, "sort | tail"'
@@ -325,5 +357,29 @@ module Germinate
       end
     end
 
+    context  "given a publisher directive" do
+      before :each do
+        @line = ' # :PUBLISHER: source, shell, { command: "cat %f" }'
+      end
+
+      it "should add the publisher to the librarian" do
+        @librarian.should_receive(:add_publisher!).
+          with("source", "shell", { :command => "cat %f" })
+        @it << @line
+      end
+    end
+
+    context "given a set directive" do
+      before :each do
+        @line = ' # :SET: name, value'
+      end
+
+      it "should set a variable on the librarian" do
+        @librarian.should_receive(:set_variable!).
+          with(@line, 1, "name", "value")
+        @it << @line
+      end
+    end
+
   end
 end 

data/spec/germinate/selector_spec.rb

@@ -3,6 +3,11 @@ require File.expand_path(
 
 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
@@ -31,21 +36,36 @@ module Germinate
       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,   []       ,false],
-      [ "@A:1",        :code,    "A",       nil,   1,    1,  nil,   []       ,false],
-      [ "",            :code,    "DEFAULT", '..',  1,    -1, nil,   []       ,false],
-      [ nil,           :code,    "DEFAULT", '..',  1,    -1, nil,   []       ,false],
-      [ ":2..4",       :code,    "DEFAULT", '..',  2,    4,  nil,   []       ,false],
-      [ ":2...4",      :code,    "DEFAULT", '...', 2,    4,  nil,   []       ,false],
-      [ "@B:2,5",      :code,    "B",       ',',   2,    nil,5,     []       ,false],
-      [ "@B:/z/,6",    :code,    "B",       ',',   /z/,  nil,6,     []       ,false],
-      [ "@_:/z/../x/", :code,    "_",       '..',  /z/,  /x/,nil,   []       ,false],
-      [ "@B:2,4|fnord",:code,    "B",       ',',   2,    nil,4,     ["fnord"],false],
-      [ "$FOO",        :special, "FOO",     '..',  1,    -1, nil,   []       ,false],
-      [ "@A|foo|bar",  :code,    "A",       '..',  1,    -1, nil,   ["foo", "bar"],false],
-      [ "@B|fnord:2,4",:code,    "B",       ',',   2,    nil,4,     ["fnord"],true],
+      # 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| 

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