smartgen 0.4.0 → 0.5.0

data/spec/lib/smartgen/configuration_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Smartgen::Configuration do
+  it { subject.should be_kind_of(Smartgen::ObjectHash) }
+end

data/spec/lib/smartgen/engines/base_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Smartgen::Engine::Base do
+  describe "processing" do
+    describe "pre processing" do
+      before do
+        Smartgen::Engine::Base.pre_processors = []
+      end
+
+      context "without pre processors" do
+        it "should just return body" do
+          body = 'body'
+          subject.process(body).should == body
+        end
+      end
+
+      context "with pre processors" do
+        class PreProcessor
+          def process(body, metadata=Smartgen::ObjectHash.new) # just needs to respond_to?(:process)
+            "<pre_processed>#{body}#{metadata[:name]}</pre_processed>"
+          end
+        end
+
+        it "should pre process body" do
+          Smartgen::Engine::Base.register(PreProcessor.new)
+
+          body = 'body'
+          subject.process(body).should == "<pre_processed>#{body}</pre_processed>"
+        end
+
+        it "should pre process body with metadata" do
+          Smartgen::Engine::Base.register(PreProcessor.new)
+
+          body = 'body'
+          subject.process(body, Smartgen::ObjectHash.new({:name => " John"})).should == "<pre_processed>body John</pre_processed>"
+        end
+
+        it "should do run pre processors in the order they were registered" do
+          class AnotherPreProcessor
+            def process(body, metadata={})
+              body.gsub(/pre_processed/, 'another')
+            end
+          end
+
+          Smartgen::Engine::Base.register(PreProcessor.new)
+          Smartgen::Engine::Base.register(AnotherPreProcessor.new)
+
+          body = 'body'
+          subject.process(body).should == "<another>#{body}</another>"
+        end
+
+        context "of a subclass" do
+          class OtherPreProcessor
+            def process(body, metadata={})
+              "<another>#{body}</another>"
+            end
+          end
+
+          class MyCustomEngine < Smartgen::Engine::Base
+          end
+
+          it "should pre process body with different processor of ancestor" do
+            Smartgen::Engine::Base.register(PreProcessor.new)
+            MyCustomEngine.register(OtherPreProcessor.new)
+
+            body = 'body'
+            MyCustomEngine.new.process(body).should == "<another>#{body}</another>"
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/smartgen/engines/erb_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Smartgen::Engine::ERB do
+  let :body do
+    "2 + 2 = <%= 2 * 2 %>"
+  end
+  
+  let :contents do
+    "2 + 2 = 4"
+  end
+  
+  it "should process body using ERB" do
+    subject.process(body).should == contents
+  end
+  
+  it "should support .erb extension" do
+    should be_supported('.erb')
+  end
+  
+  context "with metadata" do
+    let :body do
+      "Some metadata: <%= metadata.name %>"
+    end
+    
+    let :contents do
+      "Some metadata: #{metadata.name}"
+    end
+    
+    let :metadata do
+      Smartgen::ObjectHash.new :name => 'Vicente'
+    end
+    
+    it "should process body using ERB" do
+      subject.process(body, metadata).should == contents
+    end
+  end
+end

data/spec/lib/smartgen/engines/markdown_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Smartgen::Engine::Markdown do
+  def body
+    "# Some Header\n\nSome paragraph"
+  end
+  
+  def contents
+    "<h1>Some Header</h1>\n\n<p>Some paragraph</p>"
+  end
+  
+  it "should process body using BlueCloth" do
+    subject.process(body).should == contents
+  end
+  
+  it "should support .md extension" do
+    should be_supported('.md')
+  end
+  
+  it "should support .markdown extension" do
+    should be_supported('.markdown')
+  end
+end

data/spec/lib/smartgen/engines/textile_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Smartgen::Engine::Textile do
+  def body
+    "h1. Some Header\n\nSome paragraph"
+  end
+  
+  def contents
+    "<h1>Some Header</h1>\n<p>Some paragraph</p>"
+  end
+  
+  it "should process body using RedCloth" do
+    subject.process(body).should == contents
+  end
+  
+  it "should support .textile extension" do
+    should be_supported('.textile')
+  end
+end

data/spec/lib/smartgen/generator_spec.rb

@@ -0,0 +1,272 @@
+require 'spec_helper'
+require 'fileutils'
+
+describe Smartgen::Generator do
+  def src_files
+    [fixture('src/common/**/*')]
+  end
+  
+  def output_folder
+    sandbox('doc')
+  end
+  
+  def output_folder_file(path)
+    File.join(output_folder, path)
+  end
+  
+  def actual_src_files
+    Dir[*src_files].select { |f| ['.textile', '.markdown', '.md'].include?(File.extname(f)) }
+  end
+  
+  def actual_src_filenames
+    actual_src_files.map { |f| [File.basename(f, File.extname(f)), File.extname(f)] }
+  end
+  
+  def read_output(filename)
+    File.read(output_folder_file(filename))
+  end
+  
+  def read_fixture(filename)
+    File.read(fixture(filename))
+  end
+  
+  def arguments
+    [src_files, output_folder]
+  end
+  
+  def options
+    {}
+  end
+  
+  subject { Smartgen::Generator.new arguments, options, { :verbose => false } }
+  
+  before do
+    FileUtils.rm_rf output_folder
+  end
+  
+  describe "generation" do
+    it "should create the output folder" do
+      capture(:stdout) { subject.invoke_all }
+      File.should be_directory(output_folder)
+    end
+    
+    it "should create HTML files for each markup template in src_files" do
+      capture(:stdout) { subject.invoke_all }
+      
+      actual_src_filenames.each do |src_filename, src_ext|
+        File.should be_file(output_folder_file("#{src_filename}.html"))
+      end
+    end
+    
+    it "should convert markup files into HTML files when generating" do
+      capture(:stdout) { subject.invoke_all }
+      actual_src_filenames.each do |src_filename, src_ext|
+        read_output("#{src_filename}.html").should == read_fixture("expectations/common/#{src_filename}.html")
+      end
+    end
+    
+    it "should always force generation of each file, even if it exists" do
+      FileUtils.mkdir_p(output_folder)
+      File.open(output_folder_file("index.html"), 'w') { |f| f.write('old contents') }
+      capture(:stdout) { subject.invoke_all }
+      read_output("index.html").should == read_fixture("expectations/common/index.html")
+    end
+    
+    context "with nil layout" do
+      def options
+        { :layout => nil }
+      end
+    
+      it "should not use layout" do
+        capture(:stdout) { subject.invoke_all }
+        actual_src_filenames.each do |src_filename, src_ext|
+          read_output("#{src_filename}.html").should == read_fixture("expectations/common/#{src_filename}.html")
+        end
+      end
+    end
+    
+    describe "inexistent file" do
+      def src_files
+        [fixture('src/common/inexistent_file.textile')]
+      end
+
+      it "should not generate html" do
+        capture(:stdout) { subject.invoke_all }
+        File.should_not be_file(output_folder_file("inexistent_file.html"))
+      end
+    end
+
+    describe "with ERB files" do
+      def src_files
+        [fixture('src/erb/index.html.erb')]
+      end
+
+      it "should generate index file" do
+        capture(:stdout) { subject.invoke_all }
+        read_output("index.html").should == read_fixture("expectations/erb/index.html")
+      end
+
+      describe "with layout" do
+        def src_files
+          [fixture('src/erb/with_layout/index.html.erb')]
+        end
+
+        def options
+          { :layout => fixture('src/layout.html.erb') }
+        end
+
+        it "should use the layout when generating" do
+          capture(:stdout) { subject.invoke_all }
+          read_output("index.html").should == read_fixture("expectations/erb/with_layout/index.html")
+        end
+
+        context "inside the src_files pattern" do
+          def src_files
+            [fixture('src/erb/with_layout/**/*')]
+          end
+
+          def options
+            { :layout => fixture('src/erb/with_layout/layout.html.erb') }
+          end
+
+          it "should use the layout when generating" do
+            capture(:stdout) { subject.invoke_all }
+            read_output("index.html").should == read_fixture("expectations/erb/with_layout/index.html")
+          end
+
+          it "should not attempt to render layout using ERB engine" do
+            capture(:stdout) { subject.invoke_all }
+            read_output("index.html").should == read_fixture("expectations/erb/with_layout/index.html")
+          end
+        end
+      end
+    end
+
+    describe "with layout" do
+      def src_files
+        [fixture('src/with_layout/index.textile')]
+      end
+      
+      def options
+        { :layout => fixture('src/layout.html.erb') }
+      end
+      
+      it "should use the layout when generating" do
+        capture(:stdout) { subject.invoke_all }
+        read_output("index.html").should == read_fixture("expectations/with_layout/index.html")
+      end
+      
+      describe "and metadata" do
+        def options
+          { :layout => fixture('src/layout_with_metadata.html.erb'), :metadata_file => fixture('src/metadata.yml') }
+        end
+        
+        it "should load metadata from file and expose it when rendering files" do
+          capture(:stdout) { subject.invoke_all }
+          read_output("index.html").should == read_fixture("expectations/with_layout/index_with_metadata.html")
+        end
+        
+        describe "using conventions" do
+          def src_files
+            [fixture('src/with_layout/index_with_specific_metadata.textile')]
+          end
+
+          def options
+            { :layout => fixture('src/layout_with_specific_metadata.html.erb'), :metadata_file => fixture('src/metadata.yml') }
+          end
+          
+          it "should expose metadata for current page data for each file in metadata.current_page" do
+            capture(:stdout) { subject.invoke_all }
+            read_output("index_with_specific_metadata.html").should == read_fixture("expectations/with_layout/index_with_specific_metadata.html")
+          end
+        end
+      end
+    end
+    
+    describe "assets" do
+      def assets
+        [fixture("src/assets/images"), fixture("src/assets/javascripts"), fixture("src/assets/stylesheets")]
+      end
+      
+      def options
+        { :assets => assets }
+      end
+      
+      it "should copy directories to output folder" do
+        capture(:stdout) { subject.invoke_all }
+
+        File.should be_directory(output_folder_file('images'))
+        File.should be_directory(output_folder_file('javascripts'))
+      end
+      
+      it "should copy the contents of the given directories to output folder" do
+        capture(:stdout) { subject.invoke_all }
+
+        File.should be_file(output_folder_file('images/image.gif'))
+        File.should be_file(output_folder_file('javascripts/somelib.js'))
+        File.should be_file(output_folder_file('stylesheets/style.css'))
+      end
+
+      it "should force copy of the contents of the given directories to output folder" do
+        FileUtils.mkdir_p(output_folder_file('javascripts'))
+        File.open(output_folder_file('javascripts/somelib.js'), 'w') { |f| f.write('//some code') }
+
+        capture(:stdout) { subject.invoke_all }
+        read_output('javascripts/somelib.js').should == read_fixture('src/assets/javascripts/somelib.js')
+      end
+    end
+    
+    describe "with indexer" do
+      def src_files
+        [fixture('src/indexer/index_with_indexer.textile')]
+      end
+      
+      def options
+        { :use_indexer => true }
+      end
+      
+      it "should add IDs to each <h> tag" do
+        capture(:stdout) { subject.invoke_all }
+
+        actual_src_filenames.each do |src_filename, src_ext|
+          read_output("#{src_filename}.html").should == read_fixture("expectations/indexer/#{src_filename}.html")
+        end
+      end
+      
+      context "and numbered_index" do
+        def src_files
+          [fixture('src/indexer/index_with_indexer_and_numbered_index.textile')]
+        end
+        
+        def options
+          { :use_indexer => true, :numbered_index => true }
+        end
+
+        it "should add numbered indexes on each <h> tag" do
+          capture(:stdout) { subject.invoke_all }
+          
+          actual_src_filenames.each do |src_filename, src_ext|
+            read_output("#{src_filename}.html").should == read_fixture("expectations/indexer/#{src_filename}.html")
+          end
+        end
+      end
+    end
+  end
+  
+  describe "renderer registration" do
+    it "should register ERB renderer by default" do
+      Smartgen::Generator.renderer.should be_an_instance_of(Smartgen::Renderer::ERB)
+    end
+    
+    it "should allow the registration of a custom renderer" do
+      class MyRenderer
+        def render(layout, markup_file)
+          "do some rendering stuff"
+        end
+      end
+      
+      Smartgen::Generator.renderer = MyRenderer.new
+      Smartgen::Generator.renderer.render('some_layout', mock(Smartgen::MarkupFile)).should == "do some rendering stuff"
+    end
+  end
+end

data/spec/lib/smartgen/indexer_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe Smartgen::Indexer do
+  matcher :have_tag do |tag, attributes|
+    match do |actual|
+      tags = Nokogiri::HTML(actual).css(tag.to_s)
+      tags.present? && tags.any? do |tag|
+        attributes.all? do |attribute, value|
+          tag.has_attribute?(attribute.to_s) && tag[attribute.to_s] == value
+        end
+      end
+    end
+  end
+  
+  matcher :have_tag_with_contents do |tag, content|
+    match do |actual|
+      tags = Nokogiri::HTML(actual).css(tag.to_s)
+      tags.present? && tags.any? do |tag|
+        tag.content == content
+      end
+    end
+  end
+  
+  def html
+    "<h1>Some header</h1>"
+  end
+  
+  subject { Smartgen::Indexer.new html }
+
+  describe "addition of IDs" do
+    def html
+      return <<-HTML
+<html>
+<body>
+  <h1>A h1 header</h1>
+  <h2>A h2 header</h2>
+  <h3>A h3 header</h3>
+  <h4>A h4 header</h4>
+  <h5>A h5 header</h5>
+  <h6>A h6 header</h6>
+</body>
+</html>
+  HTML
+    end
+  
+    1.upto(6).each do |header_level|
+      it "should add IDs for each <h#{header_level}> tag in the result" do
+        subject.result.should have_tag("h#{header_level}", :id => "a-h#{header_level}-header")
+      end
+    end
+  end
+  
+  describe "index" do
+    def html
+      return <<-HTML
+<html>
+<body>
+  <h1>A h1 header</h1>
+  <h2>A h2 header</h2>
+  <h3>A h3 header</h3>
+  <h3>Some other h3 header</h3>
+  <h2>Another h2 header</h2>
+  <h5>A h5 header</h5>
+  <h2>Yet Another h2 header</h2>
+  <h3>Yet Another h3 header</h3>
+  <h1>Other h1 header</h1>
+</body>
+</html>
+  HTML
+    end
+    
+    it "should return an index with headers data hierarquically distributed" do
+      expected_index = [
+        { :text => 'A h1 header', :id => 'a-h1-header', :level => 1, :children => [
+          { :text => 'A h2 header', :id => 'a-h2-header', :level => 2, :children => [
+            { :text => 'A h3 header', :id => 'a-h3-header', :level => 3, :children => [] },
+            { :text => 'Some other h3 header', :id => 'some-other-h3-header', :level => 3, :children => [] }
+          ] },
+          { :text => 'Another h2 header', :id => 'another-h2-header', :level => 2, :children => [
+            { :text => 'A h5 header', :id => 'a-h5-header', :level => 5, :children => [] }
+          ] },
+          { :text => 'Yet Another h2 header', :id => 'yet-another-h2-header', :level => 2, :children => [
+            { :text => 'Yet Another h3 header', :id => 'yet-another-h3-header', :level => 3, :children => [] }
+          ] },
+        ]},
+        { :text => 'Other h1 header', :id => 'other-h1-header', :level => 1, :children => [] }
+      ]
+
+      subject.index.should == expected_index
+    end
+    
+    context "when numbered_index options is given" do
+      subject { Smartgen::Indexer.new html, :numbered_index => true }
+      
+      it "should add the numbered index to header contents" do
+        subject.result.should have_tag_with_contents("h1", "1 A h1 header")
+        subject.result.should have_tag_with_contents("h2", "1.1 A h2 header")
+        subject.result.should have_tag_with_contents("h3", "1.1.2 Some other h3 header")
+      end
+      
+      it "should return an index with headers data hierarquically distributed with numbered index" do
+        expected_index = [
+          { :text => 'A h1 header', :id => 'a-h1-header', :level => 1, :numbered_index => '1', :children => [
+            { :text => 'A h2 header', :id => 'a-h2-header', :level => 2, :numbered_index => '1.1', :children => [
+              { :text => 'A h3 header', :id => 'a-h3-header', :level => 3, :numbered_index => '1.1.1', :children => [] },
+              { :text => 'Some other h3 header', :id => 'some-other-h3-header', :level => 3, :numbered_index => '1.1.2', :children => [] }
+            ] },
+            { :text => 'Another h2 header', :id => 'another-h2-header', :level => 2, :numbered_index => '1.2', :children => [
+              { :text => 'A h5 header', :id => 'a-h5-header', :level => 5, :numbered_index => '1.2.1', :children => [] }
+            ] },
+            { :text => 'Yet Another h2 header', :id => 'yet-another-h2-header', :level => 2, :numbered_index => '1.3', :children => [
+              { :text => 'Yet Another h3 header', :id => 'yet-another-h3-header', :level => 3, :numbered_index => '1.3.1', :children => [] }
+            ] },
+          ]},
+          { :text => 'Other h1 header', :id => 'other-h1-header', :level => 1, :numbered_index => '2', :children => [] }
+        ]
+
+        subject.index.should == expected_index
+      end
+    end
+  end
+end