smartgen 0.1.0

data/spec/fixtures/src/with_layout/index.textile

@@ -0,0 +1,10 @@
+h1. Here is some header
+
+And here is a paragraph
+
+* some bullet lists with *style*
+* some bullet lists with _style_
+
+h2. Another header
+
+With some text

data/spec/fixtures/src/with_layout/index_with_specific_metadata.textile

@@ -0,0 +1,10 @@
+h1. Here is some header
+
+And here is a paragraph
+
+* some bullet lists with *style*
+* some bullet lists with _style_
+
+h2. Another header
+
+With some text

data/spec/lib/smartgen/configuration_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe Smartgen::Configuration do
+  matcher :be_an_empty_array do
+    match { |actual| actual.instance_of?(Array) && actual.empty? }
+  end
+  
+  describe "defaults" do
+    it "should initialize src_files to an empty array" do
+      subject.src_files.should be_an_empty_array
+      subject.src_files.should be_empty
+    end
+    
+    it "should initialize output folder to 'tmp'" do
+      subject.output_folder.should == 'tmp'
+    end
+    
+    it "should initialize layout to nil" do
+      subject.layout.should be_nil
+    end
+    
+    it "should initialize assets to an empty array" do
+      subject.assets.should be_an_empty_array
+    end
+    
+    it "should initialize metadata_file to 'metadata.yml'" do
+      subject.metadata_file.should == 'metadata.yml'
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Smartgen::Engine::Base do
+  describe "processing" do
+    it "should just return body" do
+      body = 'body'
+      subject.process(body).should == body
+    end
+    
+    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) # just needs to respond_to?(:process)
+            "<pre_processed>#{body}</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 do run pre processors in the order they were registered" do
+          class AnotherPreProcessor
+            def process(body)
+              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)
+              "<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/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,166 @@
+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
+    
+    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
+  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/markup_file_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe Smartgen::MarkupFile do
+  def path
+    fixture('src/common/index.textile')
+  end
+
+  subject { Smartgen::MarkupFile.new path }
+
+  describe "engine registration" do
+    before do
+      Smartgen::MarkupFile.engines.clear
+    end
+    
+    after do
+      Smartgen::MarkupFile.engines.clear
+    end
+    
+    it "should register textile engine by default" do
+      Smartgen::MarkupFile.engines.one? { |engine| engine.instance_of?(Smartgen::Engine::Textile) }.should be_true, "Textile was not registered as engine"
+    end
+    
+    it "should register markdown engine by default" do
+      Smartgen::MarkupFile.engines.one? { |engine| engine.instance_of?(Smartgen::Engine::Markdown) }.should be_true, "Markdown was not registered as engine"
+    end
+    
+    class MyEngine < Smartgen::Engine::Base
+      protected
+        def parse(body)
+          "some processing"
+        end
+        
+        def extensions
+          ['.something', '.otherext']
+        end
+    end
+    
+    it "should register an engine" do
+      Smartgen::MarkupFile.register(MyEngine)
+      Smartgen::MarkupFile.engines.one? { |engine| engine.instance_of?(MyEngine) }.should be_true, "MyEngine was not registered as engine"
+    end
+    
+    it "should register the engine with high priority" do
+      Smartgen::MarkupFile.register(MyEngine)
+      Smartgen::MarkupFile.engines.first.should be_an_instance_of(MyEngine)
+    end
+  end
+  
+  describe "attributes" do
+    it "should have a file path" do
+      subject.path.should == path
+    end
+
+    it "should have a filename" do
+      subject.filename.should == File.basename(path, File.extname(path))
+    end
+
+    it "should have an extension" do
+      subject.extension.should == File.extname(path)
+    end
+  end
+
+  describe "contents" do
+    it "should returns its raw contents" do
+      subject.raw_contents.should == File.read(path)
+    end
+
+    it "should return its contents" do
+      subject.contents.should == File.read(fixture('expectations/common/index.html'))
+    end
+  end
+
+  context "engines usage" do
+    context "using default engine" do
+      it "should use textile as markup engine when using defaults for files without extension" do
+        def path
+          fixture('src/common/somefile')
+        end
+
+        subject.engine.should be_an_instance_of(Smartgen::Engine::Textile)
+      end
+      
+      it "should use the engine with the highest priority for files without extension" do
+        class MyEngine
+          def process(body)
+            "some processing"
+          end
+          
+          def supported?(extension)
+            ['.something'].include?(extension)
+          end
+        end
+        
+        def path
+          fixture('src/common/somefile')
+        end
+        
+        Smartgen::MarkupFile.register(MyEngine)
+        subject.engine.should be_an_instance_of(MyEngine)
+        Smartgen::MarkupFile.engines.clear
+      end
+    end
+    
+    context "using textile engine" do
+      it "should use textile as markup engine" do
+        subject.engine.should be_an_instance_of(Smartgen::Engine::Textile)
+      end
+    end
+
+    context "using markdown template" do
+      it "should use textile as markup engine for files with .markdown" do
+        def path
+          fixture('src/common/other_index.markdown')
+        end
+
+        subject.engine.should be_an_instance_of(Smartgen::Engine::Markdown)
+      end
+
+      it "should use textile as markup engine for files with .md" do
+        def path
+          fixture('src/common/other_index.md')
+        end
+
+        subject.engine.should be_an_instance_of(Smartgen::Engine::Markdown)
+      end
+    end
+  end
+end