roger 1.1.3 → 1.2.1

data/test/unit/release/processors_test.rb

@@ -1,47 +1,47 @@
 require "./lib/roger/release.rb"
 require "test/unit"
 
+# Test Roger processors
 class ProcessorsTest < ::Test::Unit::TestCase
   def setup
     Roger::Release::Processors.map.clear
   end
 
   def test_register_processor
-    processor = lambda{|e| raise "ProcessorName" }
+    processor = ->(_e) { fail "ProcessorName" }
     assert Roger::Release::Processors.register(:name, processor)
-    assert_equal Roger::Release::Processors.map, {:name => processor}
+    assert_equal Roger::Release::Processors.map, name: processor
   end
 
   def test_register_processor_with_symbol_only_name
-    processor = lambda{|e| raise "ProcessorName" }
+    processor = ->(_e) { fail "ProcessorName" }
 
-    assert_raise(ArgumentError){
-      Roger::Release::Processors.register("name", processor) 
-    }
+    assert_raise(ArgumentError) do
+      Roger::Release::Processors.register("name", processor)
+    end
 
-    assert_raise(ArgumentError){
-      Roger::Release::Processors.register("name", processor) 
-    }
+    assert_raise(ArgumentError) do
+      Roger::Release::Processors.register("name", processor)
+    end
   end
 
   def test_register_processor_with_same_name
-    processor = lambda{|e| raise "ProcessorName" }
+    processor = ->(_e) { fail "ProcessorName" }
     Roger::Release::Processors.register(:name, processor)
 
-    assert_raise(ArgumentError){
-      Roger::Release::Processors.register(:name, processor) 
-    }
+    assert_raise(ArgumentError) do
+      Roger::Release::Processors.register(:name, processor)
+    end
   end
 
   def test_register_processor_with_same_contents
-    processor = lambda{|e| raise "ProcessorName" }
+    processor = ->(_e) { fail "ProcessorName" }
     Roger::Release::Processors.register(:name, processor)
 
-    assert_nothing_raised{
-      Roger::Release::Processors.register(:name2, processor) 
-    }
+    assert_nothing_raised do
+      Roger::Release::Processors.register(:name2, processor)
+    end
 
-    assert_equal Roger::Release::Processors.map, {:name => processor, :name2 => processor}
+    assert_equal Roger::Release::Processors.map, name: processor, name2: processor
   end
-
 end

data/test/unit/release_test.rb

@@ -3,20 +3,19 @@ require "./lib/roger/release.rb"
 require "test/unit"
 
 module Roger
+  # Test Roger Release
   class ReleaseTest < ::Test::Unit::TestCase
-
     def setup
-      @project = Project.new(File.dirname(__FILE__) + "/../project", :mockupfile_path => false)
+      @project = Project.new(File.dirname(__FILE__) + "/../project", mockupfile_path: false)
       @mockupfile = Roger::Mockupfile.new(@project)
     end
 
-
     def test_run_should_set_project_mode
       assert_equal @project.mode, nil
 
       # Running a blank release
-      @mockupfile.release(:blank => true) do |r|
-        r.use Proc.new{|release|
+      @mockupfile.release(blank: true) do |r|
+        r.use proc{|release|
           assert_equal release.project.mode, :release
         }
       end
@@ -26,7 +25,7 @@ module Roger
     end
 
     def test_blank_release_should_have_no_processors_and_finalizers
-      @mockupfile.release(:blank => true)
+      @mockupfile.release(blank: true)
       @project.release.run!
 
       assert @project.release.stack.empty?
@@ -34,31 +33,33 @@ module Roger
     end
 
     def test_get_callable
-      p = lambda{}
+      p = -> {}
       assert_equal Release.get_callable(p, {}), p
-      assert_raise(ArgumentError){ Release.get_callable(nil, {})}
+      assert_raise(ArgumentError) { Release.get_callable(nil, {}) }
     end
 
     def test_get_callable_with_map
-      p = lambda{}
+      p = -> {}
       map = {
-        :lambda => p,
+        lambda: p
       }
 
       assert_equal Release.get_callable(:lambda, map), p
-      assert_raise(ArgumentError){ Release.get_callable(:huh, map)}
+      assert_raise(ArgumentError) { Release.get_callable(:huh, map) }
     end
 
+    # A Release class that is valid
     class Works
       def call; end
     end
+
+    # A Release class that is invalid
     class Breaks
     end
 
     def test_get_callable_with_class
       assert Release.get_callable(Works, {}).instance_of?(Works)
-      assert_raise(ArgumentError){ Release.get_callable(Breaks, {}) }
+      assert_raise(ArgumentError) { Release.get_callable(Breaks, {}) }
     end
-
   end
-end
+end

data/test/unit/resolver_test.rb

@@ -3,6 +3,7 @@ require "./lib/roger/resolver.rb"
 require "test/unit"
 
 module Roger
+  # Test Roger resolver
   class ResolverTest < ::Test::Unit::TestCase
     def setup
       @base = Pathname.new(File.dirname(__FILE__) + "/../project/html")
@@ -27,19 +28,22 @@ module Roger
 
     def test_find_template_with_template_extension
       assert_equal @resolver.find_template("formats/markdown"), @base + "formats/markdown.md"
-    end  
+    end
 
     def test_find_template_with_double_extensions
       assert_equal @resolver.find_template("formats/erb"), @base + "formats/erb.html.erb"
       assert_equal @resolver.find_template("formats/erb.html"), @base + "formats/erb.html.erb"
 
       assert_equal @resolver.find_template("formats/json.json"), @base + "formats/json.json.erb"
-    end    
+    end
 
     def test_find_template_with_preferred_extension
-      assert_equal @resolver.find_template("formats/json", :preferred_extension => "json"), @base + "formats/json.json.erb"
+      assert_equal(
+        @resolver.find_template("formats/json", preferred_extension: "json"),
+        @base + "formats/json.json.erb"
+      )
     end
-    
+
     def test_find_template_exact_match
       # TODO
     end
@@ -49,15 +53,24 @@ module Roger
     end
 
     def test_path_to_url_relative_to_relative_path
-      assert_equal @resolver.path_to_url(@base + "formats/erb.html.erb", "../front_matter/erb.html.erb"), "../formats/erb.html.erb"
+      assert_equal(
+        @resolver.path_to_url(@base + "formats/erb.html.erb", "../front_matter/erb.html.erb"),
+        "../formats/erb.html.erb"
+      )
     end
 
     def test_path_to_url_relative_to_absolute_path
-      assert_equal @resolver.path_to_url(@base + "formats/erb.html.erb", @base.realpath + "front_matter/erb.html.erb"), "../formats/erb.html.erb"
+      assert_equal(
+        @resolver.path_to_url(
+          @base + "formats/erb.html.erb",
+          @base.realpath + "front_matter/erb.html.erb"
+        ),
+        "../formats/erb.html.erb"
+      )
     end
-
   end
 
+  # Test resolver with multiple load paths
   class ResolverMultipleTest < ::Test::Unit::TestCase
     def setup
       @base = Pathname.new(File.dirname(__FILE__) + "/../project")
@@ -82,11 +95,5 @@ module Roger
 
       assert_equal @resolver.find_template("formats/erb"), @base + "partials/formats/erb.html.erb"
     end
-
-
-
-
-
   end
-
-end
+end

data/test/unit/server_test.rb

@@ -0,0 +1,31 @@
+require "test/unit"
+require File.dirname(__FILE__) + "../../../lib/roger/rack/roger"
+
+module Roger
+  # Test Roger Server test
+  class ServerTest < ::Test::Unit::TestCase
+    def setup
+      @project = Project.new(File.dirname(__FILE__) + "/../../project", mockupfile_path: false)
+      @server = Server.new(@project)
+    end
+
+    # Test to see if env["roger.project"] is set
+    def test_env_roger_project_is_set
+      test = Class.new do
+        def initialize(_app)
+        end
+
+        def call(env)
+          [200, {}, [env["roger.project"].object_id.to_s]]
+        end
+      end
+
+      @server.use test
+
+      request = ::Rack::MockRequest.new(@server.send(:application))
+
+      # This is a bit of a clunky comparison but it suffices for now
+      assert_equal @project.object_id.to_s, request.get("/").body
+    end
+  end
+end

data/test/unit/template_test.rb

@@ -4,18 +4,19 @@ require "./lib/roger/template.rb"
 require "test/unit"
 
 module Roger
+  # Roger template tests
   class TemplateTest < ::Test::Unit::TestCase
     def setup
       @base = Pathname.new(File.dirname(__FILE__) + "/../project")
       @config = {
-        :partials_path => @base + "partials",
-        :layouts_path => @base + "layouts"
+        partials_path: @base + "partials",
+        layouts_path: @base + "layouts",
+        source_path: @base + "html/test.html.erb"
       }
       @template_path = @base + "html"
     end
 
     def test_encoding
-
     end
 
     # Extension
@@ -30,8 +31,11 @@ module Roger
       }
 
       mime_types.each do |ext, ext_out|
-        assert_equal ext_out, Template.new("", @config.update(:source_path => @base + "html/file.#{ext}")).source_extension
-      end      
+        assert_equal(
+          ext_out,
+          Template.new("", @config.update(source_path: @base + "html/file.#{ext}")).source_extension
+        )
+      end
     end
 
     def test_target_extension
@@ -44,11 +48,13 @@ module Roger
       }
 
       mime_types.each do |ext, ext_out|
-        assert_equal ext_out, Template.new("", @config.update(:source_path => @base + "html/file.#{ext}")).target_extension
-      end      
+        assert_equal(
+          ext_out,
+          Template.new("", @config.update(source_path: @base + "html/file.#{ext}")).target_extension
+        )
+      end
     end
 
-
     # Mime type
     def test_target_mime_type
       mime_types = {
@@ -59,16 +65,19 @@ module Roger
       }
 
       mime_types.each do |ext, mime|
-        assert_equal mime, Template.new("", @config.update(:source_path => @base + "html/file.#{ext}")).target_mime_type
+        assert_equal(
+          mime,
+          Template.new("", @config.update(source_path: @base + "html/file.#{ext}")).target_mime_type
+        )
       end
     end
 
     # Front-matter
 
     def test_front_matter_partial_access
-      template = Template.new("---\ntest: yay!\n---\n<%= partial 'test/front_matter' %>", @config.update(:source_path => @base + "html/test.html.erb"))
+      template = Template.new("---\ntest: yay!\n---\n<%= partial 'test/front_matter' %>", @config)
       assert_equal template.render, "yay!"
-    end    
+    end
 
     # Partials
 
@@ -76,39 +85,46 @@ module Roger
     end
 
     def test_partial
-      template = Template.new("<%= partial 'test/simple' %>", @config.update(:source_path => @base + "html/test.html.erb"))
+      template = Template.new("<%= partial 'test/simple' %>", @config)
       assert_equal template.render, "ERB"
 
-      template = Template.new("<%= partial 'test/simple.html' %>", @config.update(:source_path => @base + "html/test.erb"))
+      template = Template.new(
+        "<%= partial 'test/simple.html' %>",
+        @config.update(source_path: @base + "html/test.erb")
+      )
       assert_equal template.render, "ERB"
     end
 
     def test_partial_with_double_template_extensions
-      template = Template.new("<%= partial 'test/json.json' %>", @config.update(:source_path => @base + "html/test.erb"))
+      template = Template.new(
+        "<%= partial 'test/json.json' %>",
+        @config.update(source_path: @base + "html/test.erb")
+      )
       assert_equal template.render, "{ key: value }"
     end
 
     def test_partial_with_preferred_extension
-      template = Template.new("<%= partial 'test/json' %>", @config.update(:source_path => @base + "html/test.html.erb"))
-      assert_raise(ArgumentError) {
+      template = Template.new("<%= partial 'test/json' %>", @config)
+      assert_raise(ArgumentError) do
         template.render
-      }
-
-      template = Template.new("<%= partial 'test/json' %>", @config.update(:source_path => @base + "html/test.json.erb"))
+      end
+      template = Template.new(
+        "<%= partial 'test/json' %>",
+        @config.update(source_path: @base + "html/test.json.erb")
+      )
       assert_equal template.render, "{ key: value }"
-
     end
 
     def test_partial_with_block
-      template = Template.new("<% partial 'test/yield' do %>CONTENT<% end %>", @config.update(:source_path => @base + "html/test.html.erb"))
+      template = Template.new("<% partial 'test/yield' do %>CONTENT<% end %>", @config)
       assert_equal template.render, "B-CONTENT-A"
 
-      template = Template.new("<% partial 'test/yield' do %><%= 'CONTENT' %><% end %>", @config.update(:source_path => @base + "html/test.html.erb"))
+      template = Template.new("<% partial 'test/yield' do %><%= 'CONTENT' %><% end %>", @config)
       assert_equal template.render, "B-CONTENT-A"
     end
 
     def test_partial_with_block_without_yield
-      template = Template.new("<% partial 'test/simple' do %>CONTENT<% end %>", @config.update(:source_path => @base + "html/test.html.erb"))
+      template = Template.new("<% partial 'test/simple' do %>CONTENT<% end %>", @config)
       assert_equal template.render, "ERB"
     end
 
@@ -117,37 +133,43 @@ module Roger
     def test_content_for_not_returning_in_template
       content_for_block = 'B<% content_for :one do %><%= "one" %><% end %>A'
 
-      template = Template.new(content_for_block, @config.update(:source_path => @base + "html/test.erb"))
+      template = Template.new(
+        content_for_block,
+        @config.update(source_path: @base + "html/test.erb")
+      )
       assert_equal template.render, "BA"
     end
 
     def test_content_for_yield_in_layout
-      content_for_block = "---\nlayout: \"yield\"\n---\nB<% content_for :one do %><%= \"one\" %><% end %>A"
+      content_for_block = "---\nlayout: \"yield\"\n---\n"
+      content_for_block << "B<% content_for :one do %><%= \"one\" %><% end %>A"
 
-      template = Template.new(content_for_block, @config.update(:source_path => @base + "html/test.html.erb"))
-      assert_equal template.render, "BAone"      
+      template = Template.new(content_for_block, @config)
+      assert_equal template.render, "BAone"
     end
 
     def test_content_for_yield_in_layout_without_content_for
       content_for_block = "---\nlayout: \"yield\"\n---\nBA"
 
-      template = Template.new(content_for_block, @config.update(:source_path => @base + "html/test.html.erb"))
+      template = Template.new(content_for_block, @config)
       assert_equal template.render, "BA"
-    end    
+    end
 
     def test_content_for_yield_with_partial_with_block
-      template = Template.new("---\nlayout: \"yield\"\n---\nB<% content_for :one do %><% partial 'test/yield' do %>CONTENT<% end %><% end %>A", @config.update(:source_path => @base + "html/test.html.erb"))
+      template_string = "---\nlayout: \"yield\"\n---\nB"
+      template_string << "<% content_for :one do %>"
+      template_string << "<% partial 'test/yield' do %>CONTENT<% end %>"
+      template_string << "<% end %>A"
+
+      template = Template.new(template_string, @config)
       assert_equal template.render, "BAB-CONTENT-A"
     end
 
     # Environment
 
     def test_template_env
-      template = Template.new("<%= env[:test] %>", @config.update(:source_path => @base + "html/test.html.erb"))
-      assert_equal template.render(:test => "test"), "test"
+      template = Template.new("<%= env[:test] %>", @config)
+      assert_equal template.render(test: "test"), "test"
     end
-
-
-
   end
-end
+end

data/test/unit/test_test.rb

@@ -4,13 +4,14 @@ require "mocha/test_unit"
 require "./lib/roger/test.rb"
 
 module Roger
+  # Testing the Roger Test fucntionality
   class TestTest < ::Test::Unit::TestCase
     def setup
       @files = ["html/javascripts/site.js",
                 "html/vendor/underscore/underscore.js"]
       @globs = stub(map: @files)
 
-      @project = Project.new(File.dirname(__FILE__) + "/../project", :mockupfile_path => false)
+      @project = Project.new(File.dirname(__FILE__) + "/../project", mockupfile_path: false)
       @mockupfile = Roger::Mockupfile.new(@project)
     end
 
@@ -18,7 +19,7 @@ module Roger
       assert_equal @project.mode, nil
 
       @mockupfile.test do |t|
-        t.use Proc.new{|test|
+        t.use proc{|test|
           assert_equal test.project.mode, :test
         }
       end