smartgen 0.3.0 → 0.4.0

data/spec/lib/smartgen/markup_file_spec.rb

@@ -1,148 +0,0 @@
-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/another_index.md')
-        end
-
-        subject.engine.should be_an_instance_of(Smartgen::Engine::Markdown)
-      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

@@ -1,64 +0,0 @@
-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 respond to all of its keys" do
-    subject.merge!({:foo => 'foo', 'bar' => 'bar'})
-
-    subject.keys.each do |key|
-      should respond_to(key)
-    end
-  end
-
-  describe "inexistent key" do
-    it "should not respond to" do
-      subject.should_not respond_to("invalid_key")
-    end
-
-    it "should return an empty ObjectHash" do
-      subject.invalid_key.should be_an_instance_of(Smartgen::ObjectHash)
-    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
-  
-  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

@@ -1,32 +0,0 @@
-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, :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, :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, :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

@@ -1,60 +0,0 @@
-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
-      it "should generate files using the configuration" do
-        expected_arguments = [subject.config.src_files, subject.config.output_folder]
-        expected_options = {
-          :layout => subject.config.layout,
-          :assets => subject.config.assets,
-          :metadata_file => subject.config.metadata_file
-        }
-      
-        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
-      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'
-        end
-      end
-      
-      it_should_behave_like "generation with configuration"
-    end
-  end
-end

data/spec/lib/smartgen/watcher_spec.rb

@@ -1,71 +0,0 @@
-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

@@ -1,18 +0,0 @@
-# -*- 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

data/spec/spec_helper.rb

@@ -1,37 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
-require 'rspec'
-require 'smartgen'
-
-RSpec.configure do |config|
-  def fixture(path)
-    File.join(fixtures_dir, path)
-  end
-  
-  def fixtures_dir
-    File.expand_path('fixtures', File.dirname(__FILE__))
-  end
-
-  def sandbox(path)
-    File.join(sandbox_dir, path)
-  end
-  
-  def sandbox_dir
-    File.expand_path('sandbox', File.dirname(__FILE__))
-  end
-  
-  def capture(stream)
-    begin
-      stream = stream.to_s
-      eval "$#{stream} = StringIO.new"
-      yield
-      result = eval("$#{stream}").string
-    ensure
-      eval("$#{stream} = #{stream.upcase}")
-    end
-
-    result
-  end
-  
-  alias silence capture
-end