smartgen 0.4.0 → 0.5.0

data/spec/lib/smartgen/markup_file_spec.rb

@@ -0,0 +1,168 @@
+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
+
+    context "when filename ends with .html" do
+      def path
+        fixture('src/erb/index.html.erb')
+      end
+
+      it "should not have .html in filename" do
+        subject.filename.should == File.basename(path, ".html#{File.extname(path)}")
+      end
+    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, metadata={})
+            "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 engine" do
+      it "should use markdown 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 markdown as markup engine for files with .md" do
+        def path
+          fixture('src/common/another_index.md')
+        end
+
+        subject.engine.should be_an_instance_of(Smartgen::Engine::Markdown)
+      end
+    end
+
+    context "using erb engine" do
+      it "should use markdown as markup engine for files with .md" do
+        def path
+          fixture('src/erb/index.html.erb')
+        end
+
+        subject.engine.should be_an_instance_of(Smartgen::Engine::ERB)
+      end
+    end
+  end
+
+  describe "indexer" do
+    subject { Smartgen::MarkupFile.new path, :indexer => true }
+
+    it "should be accessible when using indexer" do
+      subject.indexer.should be_an_instance_of(Smartgen::Indexer)
+    end
+
+    it "should use indexer" do
+      mock_indexer = mock(Smartgen::Indexer, :result => 'result')
+      Smartgen::Indexer.should_receive(:new).and_return(mock_indexer)
+      subject
+    end
+
+    it "should return indexer result as contents" do
+      mock_indexer = mock(Smartgen::Indexer, :result => 'result')
+      Smartgen::Indexer.should_receive(:new).and_return(mock_indexer)
+      subject.contents.should == 'result'
+    end
+  end
+end

data/spec/lib/smartgen/object_hash_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Smartgen::ObjectHash do
+  it { should be_a_kind_of(HashWithIndifferentAccess) }
+
+  it "should be duped as an Smartgen::ObjectHash" do
+    subject.dup.should be_an_instance_of(Smartgen::ObjectHash)
+  end
+
+  it "should differentiate itself when its inspected" do
+    subject.inspect.should == "ObjectHash({})"
+  end
+
+  it "should respond to all of its keys" do
+    subject.merge!({:foo => 'foo', 'bar' => 'bar'})
+
+    subject.keys.each do |key|
+      should respond_to(key)
+    end
+  end
+
+  it "should respond to all of its keys with setter methods" do
+    subject.merge!({:foo => 'foo', 'bar' => 'bar'})
+
+    subject.keys.map { |k| "#{k}=" }.each do |key|
+      should respond_to(key)
+    end
+  end
+
+  describe "inexistent key" do
+    it "should not respond to" do
+      capture(:stderr) { subject.should_not respond_to("invalid_key") }
+    end
+
+    it "should return an empty ObjectHash" do
+      capture(:stderr) { subject.invalid_key.should be_an_instance_of(Smartgen::ObjectHash) }
+    end
+
+    it "should print a warn" do
+      capture(:stderr) { subject.invalid_key }.should == "warning: key invalid_key not found on #{subject.inspect}\n"
+    end
+  end
+
+  it "should respond to ancestor methods" do
+    ancestor = Smartgen::ObjectHash.ancestors.first
+    ancestor.instance_methods.each do |method|
+      should respond_to(method)
+    end
+  end
+
+  it "should fetch key when calling method with the same name directly" do
+    subject.merge!({:foo => 'foo'})
+    subject.foo.should == 'foo'
+  end
+
+  it "should set a new key when any setter method is called" do
+    subject.foo = 'foo'
+    subject.foo.should == 'foo'
+  end
+
+  it "should update an existing key when setter method is called" do
+    subject.merge!({:foo => 'foo'})
+    subject.foo = 'bar'
+    subject.foo.should == 'bar'
+  end
+
+  describe "nested hashes" do
+    subject { Smartgen::ObjectHash.new({:nested_hash => {:some_key => 'value'}})}
+
+    it "should accept calling nested methods" do
+      subject.nested_hash.some_key.should == 'value'
+    end
+  end
+
+  describe "nested array with hashes" do
+    subject { Smartgen::ObjectHash.new({:array => [{:some_key => 'value'}]})}
+
+    it "should accept calling nested methods" do
+      subject.array.first.some_key.should == 'value'
+    end
+  end
+
+  describe Hash do
+    subject { Hash.new }
+
+    it "should return an object hash" do
+      subject.with_object_hash.should be_an_instance_of(Smartgen::ObjectHash)
+    end
+  end
+end
+

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

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Smartgen::Renderer::ERB do
+  def contents
+    "<p>Some HTML content</p>"
+  end
+  
+  def markup_file
+    @markup_file ||= mock(Smartgen::MarkupFile, :contents => contents)
+  end
+  
+  it "should render the given layout with markup_file variable" do
+    layout = "<html><body><%= markup_file.contents %></body></html>"
+    
+    subject.render(layout, markup_file).should == "<html><body>#{contents}</body></html>"
+  end
+  
+  it "should render the given layout with metadata variable" do
+    layout = "<html><body><%= markup_file.contents %><div><%= metadata[:some_key] %></div></body></html>"
+    subject.render(layout, markup_file, Smartgen::ObjectHash.new(:some_key => 'some_value')).should == "<html><body>#{contents}<div>some_value</div></body></html>"
+  end
+  
+  it "should render the given layout with metadata variable, using methods instead of accessing keys" do
+    layout = "<html><body><%= markup_file.contents %><div><%= metadata.some_key %></div></body></html>"
+    subject.render(layout, markup_file, Smartgen::ObjectHash.new(:some_key => 'some_value')).should == "<html><body>#{contents}<div>some_value</div></body></html>"
+  end
+
+  it "should render the given layout with metadata variable, using nested methods instead of accessing keys" do
+    layout = "<html><body><%= markup_file.contents %><div><%= metadata.nested_hash.some_key %></div></body></html>"
+    subject.render(layout, markup_file, Smartgen::ObjectHash.new(:nested_hash => {:some_key => 'some_value'})).should == "<html><body>#{contents}<div>some_value</div></body></html>"
+  end
+end

data/spec/lib/smartgen/resource_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Smartgen::Resource do
+  describe "configuration" do
+    it "should yield a configuration when configuring" do
+      subject.configure do |config|
+        config.should be_an_instance_of(Smartgen::Configuration)
+      end
+    end
+
+    it "should use the same configuration on later accesses" do
+      configuration = nil
+      subject.configure { |config| configuration = config }
+
+      subject.configure do |config|
+        config.should be_equal(configuration)
+      end
+    end
+  end
+
+  describe "generating" do
+    shared_examples_for "generation with configuration" do
+      let :expected_arguments do
+        [subject.config.src_files, subject.config.output_folder]
+      end
+
+      it "should generate files using the configuration" do
+        mock_generator = mock(Smartgen::Generator)
+        Smartgen::Generator.
+                  should_receive(:new).
+                  with(expected_arguments, expected_options).
+                  and_return(mock_generator)
+
+        mock_generator.should_receive(:invoke_all)
+        subject.generate!
+      end
+    end
+
+    context "with default options" do
+      let :expected_options do
+        Smartgen::ObjectHash.new
+      end
+
+      it_should_behave_like "generation with configuration"
+    end
+
+    context "with customized options" do
+      before do
+        subject.configure do |c|
+          c.src_files = ['help/**/*', 'ChangeLog', 'doc_src/**/*']
+          c.output_folder = 'public/docs'
+          c.layout = 'doc_src/layout.html.erb'
+          c.assets = ['doc_src/javascript/*.js', 'doc_src/stylesheets/*.css', 'doc_src/images/*.*']
+          c.metadata_file = 'doc_src/metadata.yml'
+          c.some_other_option = true
+          c.and_another_one = 'some-value'
+        end
+      end
+
+      let :expected_options do
+        Smartgen::ObjectHash.new({
+          :layout => subject.config.layout,
+          :assets => subject.config.assets,
+          :metadata_file => subject.config.metadata_file,
+          :some_other_option => subject.config.some_other_option,
+          :and_another_one => subject.config.and_another_one
+        })
+      end
+
+      it_should_behave_like "generation with configuration"
+    end
+  end
+end

data/spec/lib/smartgen/watcher_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Smartgen::Watcher do
+  it "should create a resource and yield its configuration" do
+    expected_config = nil
+    Smartgen::Watcher.new(:my_resource) { |config| expected_config = config }
+    expected_config.should == Smartgen[:my_resource].config
+  end
+  
+  context "when it will start watching" do
+    def src_files
+      ['doc/**/*']
+    end
+    
+    def directory_watcher
+      return @directory_watcher if @directory_watcher
+      
+      @directory_watcher = mock(DirectoryWatcher, :add_observer => 'observer', :interval= => '2')
+      @directory_watcher.stub!(:start).and_return(@directory_watcher)
+      @directory_watcher.stub!(:join).and_return(@directory_watcher)
+      @directory_watcher
+    end
+    
+    before do
+      DirectoryWatcher.stub!(:new).and_return(directory_watcher)
+    end
+    
+    subject do
+      Smartgen::Watcher.new(:my_resource) do |config|
+        config.src_files = src_files
+        config.output_folder = 'public/docs'
+      end
+    end
+    
+    it "should create a directory watcher, pre loading src_files" do
+      DirectoryWatcher.should_receive(:new).with('.', :glob => src_files).and_return(directory_watcher)
+      capture(:stdout) { subject.start }
+    end
+    
+    it "should add itself as an observer, with :generate method as the callback" do
+      directory_watcher.should_receive(:add_observer).with(subject, :generate)
+      capture(:stdout) { subject.start }
+    end
+    
+    it "should start watching" do
+      directory_watcher.should_receive(:start)
+      directory_watcher.should_receive(:join)
+      capture(:stdout) { subject.start }
+    end
+    
+    it "should set interval to 2 seconds" do
+      directory_watcher.should_receive(:interval=).with(2)
+      capture(:stdout) { subject.start }
+    end
+
+    context "when generating" do
+      it "should generate files" do
+        Smartgen[:my_resource].should_receive(:generate!)
+        capture(:stdout) { subject.generate }
+      end
+    end
+    
+    context "when user hits ctrl+c" do
+      it "should exit gracefully" do
+        directory_watcher.should_receive(:stop)
+        Kernel.should_receive(:trap).with('INT').and_yield
+        capture(:stdout) { subject.start }
+      end
+    end
+  end
+end

data/spec/lib/smartgen_spec.rb

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+require 'spec_helper'
+
+describe Smartgen do
+  describe "resources" do
+    it "should create a resource the first time it is accessed" do
+      Smartgen[:foo].should be_an_instance_of(Smartgen::Resource)
+    end
+    
+    it "should use the same resource when it is accessed in the future" do
+      Smartgen[:foo].should be_equal(Smartgen[:foo])
+    end
+    
+    it "should create different resource for each given name" do
+      Smartgen[:foo].should_not be_equal(Smartgen[:bar])
+    end
+  end
+end