germinate 1.2.0

data/spec/germinate/pipeline_spec.rb

@@ -0,0 +1,34 @@
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. .. lib germinate]))
+
+module Germinate
+  describe Pipeline, "given a set of processes" do
+    before :each do 
+      @intput   = stub("Input")
+      @output1  = stub("Output 1")
+      @output2  = stub("Output 2")
+      @output3  = stub("Output 3")
+      @process1 = stub("Process 1", :call => @output1)
+      @process2 = stub("Process 2", :call => @output2)
+      @process3 = stub("Process 3", :call => @output3)
+      @it = Germinate::Pipeline.new([@process1, @process2, @process3])
+    end
+
+    it "should compose the processes into a pipeline" do
+      @process1.should_receive(:call).with(@input).and_return(@output1)
+      @process2.should_receive(:call).with(@output1).and_return(@output2)
+      @process3.should_receive(:call).with(@output2).and_return(@output3)
+      @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

@@ -0,0 +1,105 @@
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. .. lib germinate]))
+
+module Germinate
+  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::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
+          @command.should_receive(:<<).with("line 2\n").ordered
+          @command.should_receive(:close_write).ordered
+          @command.should_receive(:readlines).ordered.
+            and_return(["a\n", "b\n"])
+          IO.should_receive(:popen).with("mycommand", "r+").and_yield(@command)
+          output = @it.call(@input)
+          output.should == ["a\n", "b\n"]
+        end
+        
+        it "should preserve hunk attributes" do
+          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::ShellProcess.new("myproc", "mycommand %f")
+      end
+
+      it "should create a temporary file and pass the name to the command" do
+        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
+        @tempfile.should_receive(:close).ordered
+        IO.should_receive(:popen).
+          with("mycommand 'TEMP_PATH'", "r").
+          and_yield(@command)
+        
+        @it.call(@input).should == @output
+      end
+
+      it "should preserve hunk attributes" do
+        output = @it.call(@input)
+        output.comment_prefix.should == "//"
+      end
+
+    end
+
+    context "given a command 'mycommand %f' and called on a file hunk" do
+      before :each do
+        @input = Germinate::FileHunk.new(
+          ["line 1\n", "line 2\n"],
+          {:source_path => "SOURCE_PATH"})
+        @it = Germinate::ShellProcess.new("myproc", "mycommand %f")
+      end
+
+      it "should pass the source file path to the command" do
+        @path = stub("Source File Path")
+        IO.should_receive(:popen).with("mycommand 'SOURCE_PATH'", "r").
+          and_yield(@command)
+        @it.call(@input).should == @output
+      end
+    end
+  end
+end

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

@@ -0,0 +1,385 @@
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. .. lib germinate]))
+
+module Germinate
+  describe Reader do
+    before :each do
+      @librarian = stub("Librarian", :comment_prefix_known? => false).
+        as_null_object
+      @it        = Reader.new(@librarian, "SOURCE_PATH")
+    end
+
+    it "should start in the :initial state" do
+      @it.state.should == :initial
+    end
+
+    it "should start out with a section count of 0" do
+      @it.section_count.should == 0
+    end
+
+    it "should start out with current section SECTION0" do
+      @it.current_section.should == "SECTION0"
+    end
+
+    it "should set the librarian's source path" do
+      @librarian.should_receive(:source_path=).with(Pathname("SOURCE_PATH"))
+      @it = Reader.new(@librarian, "SOURCE_PATH")
+    end
+
+    context "when section count is incremented" do
+
+      before :each do
+        @it.increment_section_count!
+      end
+
+      it "should increment section count by one" do
+        @it.section_count.should == 1
+      end
+
+      it "should update current section" do
+        @it.current_section.should == "SECTION1"
+      end
+
+    end
+
+    CONTROL_LINES = [
+      # Line                  Comment  Args
+      [":TEXT:\n",            nil,     []],
+      ["# :CUT: \n",          "# ",    []],
+      ["  ; :TEXT: foo\n",    "  ; ",  ["foo"]],
+      ["//:SAMPLE:\n",        "//",    []],
+      ["$>:END: ",            "$>",    []],
+      [":SAMPLE: bar, { a: 1, b: 2 }", nil, ["bar", {"a"=>1, "b"=>2}]],
+      [':BRACKET_CODE:',      nil,     []],
+      [':INSERT: @sel',       nil,     ["@sel"]],
+      [':PROCESS: foo, bar',  nil,     ["foo", "bar"]],
+    ]
+
+    CONTROL_LINES.each do |(line, comment, args)|
+      context "when given the line #{line}" do
+        if comment
+          it "should set the comment character to '#{comment}'" do
+            @librarian.should_receive(:comment_prefix=).with(comment)
+            @it << line
+          end
+        else
+          it "should not set a comment prefix" do
+            @librarian.should_not_receive(:comment_prefix=)
+            @it << line
+          end
+        end
+
+        it "should store the line as a control line" do
+          @librarian.should_receive(:add_control!).with(line)
+          @it << line
+        end
+      end
+    end
+
+    context "given a BRACKET_CODE control line" do
+      before :each do 
+        @line = ':BRACKET_CODE: "<<<", ">>>"'
+      end
+
+      it "should store the brackets" do
+        @librarian.should_receive(:code_open_bracket=).with("<<<")
+        @librarian.should_receive(:code_close_bracket=).with(">>>")
+        @it << @line
+      end
+
+    end
+
+    context "before the first line of text" do
+      it "should treat non-keyword lines as front matter" do
+        @librarian.should_receive(:add_front_matter!, "TEST")
+        @it << "TEST"
+      end
+    end
+
+    context "after an initial line of text" do
+      before :each do
+        @it << "\n"
+      end
+
+      it "should be in the :front_matter state" do
+        @it.state.should == :front_matter
+      end
+
+      it "should record non-keyword lines as more front matter" do
+        @librarian.should_receive(:add_front_matter!, "TEST")
+        @it << "TEST"
+      end
+    end
+
+    context "after the :TEXT: keyword" do
+      before :each do
+        @it << ":TEXT:\n"
+      end
+
+      it "should be in the :text state" do
+        @it.state.should == :text
+      end
+
+      it "should place following text lines into a section" do
+        @librarian.should_receive(:add_text!).with("SECTION1", "blah blah blah")
+        @it << "blah blah blah"
+      end
+
+      context "given an escaped directive" do
+        it "should add the directive line as text" do
+          @librarian.should_receive(:add_text!).with("SECTION1", ":TEXT: abc")
+          @it << "\\:TEXT: abc"
+        end
+      end
+    end
+
+    context "after two anonymous :TEXT: sections" do
+      before :each do
+        @it << ":TEXT:\n"
+        @it << ":TEXT:\n"
+      end
+
+      it "should be in SECTION2" do
+        @it.current_section.should == "SECTION2"
+      end
+    end
+
+    context "after a named :TEXT: keyword" do
+      before :each do
+        @it << ":TEXT: foo\n"
+      end
+
+      it "should be in the :text state" do
+        @it.state.should == :text
+      end
+
+      it "should place following text lines into the named section" do
+        @librarian.should_receive(:add_text!).with("foo", "yadda yadda")
+        @it << "yadda yadda"
+      end
+
+      it "should name following code lines after the section" do
+        @librarian.should_receive(:add_code!).with("foo", "this is code")
+        @it << "yadda yadda\n"
+        @it << ":SAMPLE:\n"
+        @it << "this is code"
+      end
+    end
+
+    context "after text is ended by a :CUT:" do
+      before :each do
+        @it << ":TEXT:\n"
+        @it << ":CUT:\n"
+      end
+
+      it "should be in the :code state" do
+        @it.state.should == :code
+      end
+
+      it "should add following lines to a code sample" do
+        @librarian.should_receive(:add_code!).with("SECTION2", "this is code")
+        @it << "this is code"
+      end
+    end
+
+    context "after a :TEXT: keyword prefixed with '#'" do
+      before :each do
+        @it << "# :TEXT:\n"
+      end
+
+      it "should be in the :text state" do
+        @it.state.should == :text
+      end
+
+    end
+
+    context "after a :TEXT: keyword prefixed with ';'" do
+      before :each do
+        @it << " ; :TEXT:\n"
+      end
+
+      it "should be in the :text state" do
+        @it.state.should == :text
+      end
+
+    end
+
+    context "given a :SAMPLE: keyword with a name" do
+      before :each do
+        @it << ":SAMPLE: foobar"
+      end
+
+      it "should file following code lines under the given name" do
+        @librarian.should_receive(:add_code!).with("foobar", "line 1")
+        @librarian.should_receive(:add_code!).with("foobar", "line 2")
+
+        @it << "line 1"
+        @it << "line 2"
+      end
+
+      context "given an escaped directive" do
+        it "should add the directive line as code" do
+          @librarian.should_receive(:add_code!).with("foobar", " # :TEXT: abc")
+          @it << " # \\:TEXT: abc"
+        end
+      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: ["<<", ">>"] }'
+      end
+
+      it "should assign custom bracket attributes to the sample" do
+        @librarian.should_receive(:set_code_attributes!).
+          with("foobar", 
+          { 
+            :code_open_bracket  => "<<", 
+            :code_close_bracket => ">>" 
+          })
+
+        @it << @line
+      end
+    end
+
+    context "in text section with comment set" do
+      before :each do
+        @librarian.stub!(:comment_prefix_known?).and_return(true)
+        @librarian.stub!(:comment_prefix).and_return("#")
+        @it << "# :TEXT:\n"
+        @section = @it.current_section
+      end
+      
+      it "should treat a commented line as more of the same section" do
+        @librarian.should_receive(:add_text!).
+          with(@section, "# commented text\n")
+        @it << "# commented text\n"
+      end
+
+      it "should treat a commented blank line as more of the same section" do
+        @librarian.should_receive(:add_text!).
+          with(@section, "# \n")
+        @it << "# \n"
+      end
+
+      it "should treat an uncommented blank line as more of the same section" do
+        @librarian.should_receive(:add_text!).
+          with(@section, " \n")
+        @it << " \n"
+      end
+
+      it "should treat an uncommented line as the start of code" do
+        @librarian.should_receive(:add_code!).
+          with(@section, "uncommented text\n")
+        @it << "uncommented text\n"
+      end
+    end
+
+    context "given an insertion with an explicit selector" do
+      before :each do
+        @it << ":TEXT: mysection"
+        @line = ":INSERT: foo"
+      end
+      
+      it "should add an insertion to the current section" do
+        @librarian.should_receive(:add_insertion!).
+          with("mysection", anything, anything)
+        @it << @line
+      end
+
+      it "should pass a selector object to the librarian" do
+        @librarian.should_receive(:add_insertion!) do |section, selector, options|
+          selector.should be_a_kind_of(Selector)
+          selector.string.should == "foo"
+          selector.default_key.should == "mysection"
+        end
+        @it << @line
+      end
+    end
+
+    context "given an insertion with custom attributes" do
+      before :each do
+        @it << ":TEXT: mysection"
+        @line = ":INSERT: foo, { brackets: ['<<', '>>'] } "
+      end
+      
+      it "should pass the attributes on to the library" do
+        @librarian.should_receive(:add_insertion!).
+          with(anything, anything, {
+            :code_open_bracket => "<<", 
+            :code_close_bracket => ">>" 
+          })
+        @it << @line
+      end
+
+    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"'
+      end
+
+      it "should add the process to the library" do
+        @librarian.should_receive(:add_process!).with("sortail", "sort | tail")
+        @it << @line
+      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