roger 1.3.5 → 1.4.0

data/lib/roger/server.rb

@@ -30,7 +30,7 @@ module Roger
     end
 
     # Sets the options, this is a separate method as we want to override certain
-    # things set in the mockupfile from the commandline
+    # things set in the rogerfile from the commandline
     def set_options(options)
       self.port = options[:port] if options.key?(:port)
       self.handler = options[:handler] if options.key?(:handler)

data/lib/roger/template/helpers/capture.rb

@@ -0,0 +1,53 @@
+module Roger
+  class Template
+    module Helpers
+      # The capture helper
+      module Capture
+        def self.included(base)
+          # Just the writer; the reader is below.
+          base.send(:attr_writer, :_content_for_blocks)
+        end
+
+        # Capture content in blocks in the template for later use in the layout.
+        # Currently only works in ERB templates. Use like this in the template:
+        #
+        # ```
+        #   <% content_for :name %> bla bla <% end %>
+        # ```
+        #
+        # Place it like this in the layout:
+        #
+        # ```
+        #   <%= yield :name %>
+        # ```
+        def content_for(block_name, &block)
+          @_content_for_blocks ||= {}
+          @_content_for_blocks[block_name] = capture(&block)
+        end
+
+        # rubocop:disable Lint/Eval
+        def capture(&block)
+          unless template.template.is_a?(Tilt::ERBTemplate)
+            fail ArgumentError, "content_for works only with ERB Templates"
+          end
+
+          @block_counter ||= 0
+          @block_counter += 1
+          counter = @block_counter
+
+          eval "@_erbout_tmp#{counter} = _erbout", block.binding
+          eval "_erbout = \"\"", block.binding
+          t = Tilt::ERBTemplate.new { "<%= yield %>" }
+          t.render(&block)
+        ensure
+          eval "_erbout = @_erbout_tmp#{counter}", block.binding
+        end
+        # rubocop:enable Lint/Eval
+
+        def _content_for_blocks
+          @_content_for_blocks || {}
+        end
+      end
+    end
+  end
+end

data/lib/roger/template/helpers/partial.rb

@@ -0,0 +1,37 @@
+module Roger
+  class Template
+    module Helpers
+      # The partial helper
+      module Partial
+        # rubocop:disable Lint/Eval
+        def partial(name, options = {}, &block)
+          template_path = template.find_template(name, :partials_path)
+          if template_path
+            out = render_partial(template_path, options, &block)
+            if block_given?
+              eval "_erbout.concat(#{out.dump})", block.binding
+            else
+              out
+            end
+          else
+            fail ArgumentError, "No such partial #{name}, referenced from #{template.source_path}"
+          end
+        end
+        # rubocop:enable Lint/Eval
+
+        protected
+
+        # Capture a block and render the partial
+        def render_partial(template_path, options, &block)
+          partial_template = Tilt.new(template_path.to_s)
+          if block_given?
+            block_content = capture(&block)
+          else
+            block_content = ""
+          end
+          partial_template.render(self, options[:locals] || {}) { block_content }
+        end
+      end
+    end
+  end
+end

data/lib/roger/template/template_context.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + "/helpers/capture"
+require File.dirname(__FILE__) + "/helpers/partial"
+
+module Roger
+  class Template
+    # The context that is passed to all templates
+    class TemplateContext
+      include Helpers::Capture
+      include Helpers::Partial
+
+      def initialize(template, env = {})
+        @_template = template
+        @_env = env
+      end
+
+      # The current Roger::Template in use
+      def template
+        @_template
+      end
+
+      # Access to the front-matter of the document (if any)
+      def document
+        @_data ||= OpenStruct.new(template.data)
+      end
+
+      # The current environment variables.
+      def env
+        @_env
+      end
+    end
+  end
+end

data/lib/roger/template.rb

@@ -3,6 +3,8 @@ require "mime/types"
 require "yaml"
 require "ostruct"
 
+require File.dirname(__FILE__) + "/template/template_context"
+
 # We're enforcing Encoding to UTF-8
 Encoding.default_external = "UTF-8"
 
@@ -26,6 +28,17 @@ module Roger
         fail "Unknown file #{path}" unless File.exist?(path)
         new(File.read(path), options.update(source_path: path))
       end
+
+      # Register a helper module that should be included in
+      # every template context.
+      def helper(mod)
+        @helpers ||= []
+        @helpers << mod
+      end
+
+      def helpers
+        @helpers || []
+      end
     end
 
     # @option options [String,Pathname] :source_path The path to
@@ -43,7 +56,7 @@ module Roger
     end
 
     def render(env = {})
-      context = TemplateContext.new(self, env)
+      context = prepare_context(env)
 
       if @layout_template
         content_for_layout = template.render(context, {}) # yields
@@ -111,6 +124,17 @@ module Roger
 
     protected
 
+    def prepare_context(env)
+      context = TemplateContext.new(self, env)
+
+      # Extend context with all helpers
+      self.class.helpers.each do |mod|
+        context.extend(mod)
+      end
+
+      context
+    end
+
     def initialize_layout
       return unless data[:layout]
       layout_template_path = find_template(data[:layout], :layouts_path)
@@ -160,94 +184,4 @@ module Roger
       [{}, source]
     end
   end
-
-  # The context that is passed to all templates
-  class TemplateContext
-    attr_accessor :_content_for_blocks
-
-    def initialize(template, env = {})
-      @_content_for_blocks = {}
-      @_template = template
-      @_env = env
-
-      # Block counter to make sure erbtemp binding is always unique
-      @block_counter = 0
-    end
-
-    # The current Roger::Template in use
-    def template
-      @_template
-    end
-
-    # Access to the front-matter of the document (if any)
-    def document
-      @_data ||= OpenStruct.new(template.data)
-    end
-
-    # The current environment variables.
-    def env
-      @_env
-    end
-
-    # Capture content in blocks in the template for later use in the layout.
-    # Currently only works in ERB templates. Use like this in the template:
-    #
-    # ```
-    #   <% content_for :name %> bla bla <% end %>
-    # ```
-    #
-    # Place it like this in the layout:
-    #
-    # ```
-    #   <%= yield :name %>
-    # ```
-    def content_for(block_name, &block)
-      @_content_for_blocks[block_name] = capture(&block)
-    end
-
-    # rubocop:disable Lint/Eval
-    def capture(&block)
-      unless template.template.is_a?(Tilt::ERBTemplate)
-        fail ArgumentError, "content_for works only with ERB Templates"
-      end
-
-      @block_counter += 1
-      counter = @block_counter
-
-      eval "@_erbout_tmp#{counter} = _erbout", block.binding
-      eval "_erbout = \"\"", block.binding
-      t = Tilt::ERBTemplate.new { "<%= yield %>" }
-      t.render(&block)
-    ensure
-      eval "_erbout = @_erbout_tmp#{counter}", block.binding
-    end
-
-    def partial(name, options = {}, &block)
-      template_path = template.find_template(name, :partials_path)
-      if template_path
-        out = render_partial(template_path, options, &block)
-        if block_given?
-          eval "_erbout.concat(#{out.dump})", block.binding
-        else
-          out
-        end
-      else
-        fail ArgumentError, "No such partial #{name}, referenced from #{template.source_path}"
-      end
-    end
-    # rubocop:enable Lint/Eval
-
-    protected
-
-    # Capture a block and render the partial
-    def render_partial(template_path, options, &block)
-      partial_template = Tilt.new(template_path.to_s)
-      if block_given?
-        block_content = capture(&block)
-      else
-        block_content = ""
-      end
-      partial_template.render(self, options[:locals] || {}) { block_content }
-    end
-  end
 end

data/lib/roger/test.rb

@@ -33,7 +33,7 @@ module Roger
     class << self
       include Roger::Helpers::GetCallable
 
-      # Register a test method to Roger::Test so it can be used in the Mockupfile
+      # Register a test method to Roger::Test so it can be used in the Rogerfile
 
       def register(name, test, cli = nil)
         if map.key?(name)

data/lib/roger/version.rb

@@ -1,4 +1,4 @@
 # Roger main namespace
 module Roger
-  VERSION = "1.3.5"
+  VERSION = "1.4.0"
 end

data/test/helpers/cli.rb

@@ -26,17 +26,17 @@ module Roger
       [out, err]
     end
 
-    def run_command_with_mockupfile(args, &_block)
+    def run_command_with_rogerfile(args, &_block)
       project = Project.new(
         @base_path || File.dirname(__FILE__) + "/../../project",
-        mockupfile_path: false
+        rogerfile_path: false
       )
 
-      mockupfile = Roger::Mockupfile.new(project)
+      rogerfile = Roger::Rogerfile.new(project)
 
-      yield(mockupfile) if block_given?
+      yield(rogerfile) if block_given?
 
-      project.mockupfile = mockupfile
+      project.rogerfile = rogerfile
 
       Cli::Base.project = project
 

data/test/unit/cli/cli_serve_test.rb

@@ -67,12 +67,12 @@ module Roger
     end
   end
 
-  # These tests ar for the roger serve command with a mockupfile config
-  class CliServeWithMockupfileTest < ::Test::Unit::TestCase
+  # These tests ar for the roger serve command with a rogerfile config
+  class CliServeWithRogerfileTest < ::Test::Unit::TestCase
     include TestCli
 
-    def test_serve_with_port_in_mockupfile
-      out, _err = run_command_with_mockupfile(%w(serve)) do |m|
+    def test_serve_with_port_in_rogerfile
+      out, _err = run_command_with_rogerfile(%w(serve)) do |m|
         m.serve do |s|
           s.port = 9001
         end
@@ -83,8 +83,8 @@ module Roger
       assert_includes out, "Puma"
     end
 
-    def test_serve_with_host_in_mockupfile
-      out, _err = run_command_with_mockupfile(%w(serve)) do |m|
+    def test_serve_with_host_in_rogerfile
+      out, _err = run_command_with_rogerfile(%w(serve)) do |m|
         m.serve do |s|
           s.host = "127.0.0.1"
         end
@@ -95,8 +95,8 @@ module Roger
       assert_includes out, "Puma"
     end
 
-    def test_serve_with_handler_in_mockupfile
-      out, _err = run_command_with_mockupfile(%w(serve)) do |m|
+    def test_serve_with_handler_in_rogerfile
+      out, _err = run_command_with_rogerfile(%w(serve)) do |m|
         m.serve do |s|
           s.handler = "webrick"
         end
@@ -107,8 +107,8 @@ module Roger
       assert_includes out, "WEBrick"
     end
 
-    def test_serve_with_custom_port_should_override_mockupfile
-      out, _err = run_command_with_mockupfile(%w(serve --port=9002)) do |m|
+    def test_serve_with_custom_port_should_override_rogerfile
+      out, _err = run_command_with_rogerfile(%w(serve --port=9002)) do |m|
         m.serve do |s|
           s.port = 9001
         end
@@ -119,8 +119,8 @@ module Roger
       assert_includes out, "Puma"
     end
 
-    def test_serve_with_custom_host_should_override_mockupfile
-      out, _err = run_command_with_mockupfile(%w(serve --host=localhost)) do |m|
+    def test_serve_with_custom_host_should_override_rogerfile
+      out, _err = run_command_with_rogerfile(%w(serve --host=localhost)) do |m|
         m.serve do |s|
           s.host = "127.0.0.1"
         end
@@ -131,8 +131,8 @@ module Roger
       assert_includes out, "Puma"
     end
 
-    def test_serve_with_custom_handler_should_override_mockupfile
-      out, _err = run_command_with_mockupfile(%w(serve --handler=webrick)) do |m|
+    def test_serve_with_custom_handler_should_override_rogerfile
+      out, _err = run_command_with_rogerfile(%w(serve --handler=webrick)) do |m|
         m.serve do |s|
           s.handler = "puma"
         end

data/test/unit/cli/cli_test_test.rb

@@ -17,11 +17,11 @@ module Roger
     end
 
     def run_test_command(args, &block)
-      run_command_with_mockupfile(args) do |mockupfile|
+      run_command_with_rogerfile(args) do |rogerfile|
         if block_given?
-          mockupfile.test(&block)
+          rogerfile.test(&block)
         else
-          mockupfile.test do |t|
+          rogerfile.test do |t|
             t.use :succeed
             t.use :noop
           end
@@ -68,7 +68,7 @@ module Roger
       # A somewhat a-typical test,
       # just to make it work
       cli = ::Roger::Cli::Base.new [], %w(--verbose)
-      cli.class.project.mockupfile.test do |t|
+      cli.class.project.rogerfile.test do |t|
         t.use :noop
       end
 

data/test/unit/generators_test.rb

@@ -7,7 +7,7 @@ module CustomGens
     # Simple Mock generator
     class MockedGenerator < Roger::Generators::Base
       desc "@mocked description"
-      argument :path, type: :string, required: false, desc: "Path to generate mockup into"
+      argument :path, type: :string, required: false, desc: "Path to generate project into"
       argument :another_arg, type: :string, required: false, desc: "Mocked or what?!"
 
       def test

data/test/unit/mockupfile_test.rb

@@ -0,0 +1,38 @@
+# Generators register themself on the CLI module
+require "test_helper"
+require "roger/testing/mock_project"
+
+class RogerfileLoadedError < StandardError
+end
+
+module Roger
+  # Test Roger Release
+  class ReleaseTest < ::Test::Unit::TestCase
+    def setup
+      @project = Testing::MockProject.new
+    end
+
+    def teardown
+      @project.destroy
+    end
+
+    def test_load_rogerfile
+      @project.construct.file "Rogerfile", "raise RogerfileLoadedError"
+
+      rogerfile = Roger::Rogerfile.new(@project)
+
+      assert_raise(RogerfileLoadedError) do
+        rogerfile.load
+      end
+    end
+
+    def test_loaded_rogerfile
+      @project.construct.file "Rogerfile", ""
+
+      rogerfile = Roger::Rogerfile.new(@project)
+      rogerfile.load
+
+      assert rogerfile.loaded?
+    end
+  end
+end

data/test/unit/rack/roger_test.rb

@@ -6,7 +6,7 @@ module Roger
     # Test Roger Rack
     class ServerTest < ::Test::Unit::TestCase
       def setup
-        @project = Project.new(File.dirname(__FILE__) + "/../../project", mockupfile_path: false)
+        @project = Project.new(File.dirname(__FILE__) + "/../../project", rogerfile_path: false)
         @app = ::Roger::Rack::Roger.new(@project)
       end
 

data/test/unit/release/finalizers/dir_test.rb

@@ -0,0 +1,43 @@
+require "test_helper"
+require "roger/testing/mock_release"
+
+module Roger
+  # Test for Roger DirFinalizer
+  class DirFinalizerTest < ::Test::Unit::TestCase
+    def setup
+      @release = Testing::MockRelease.new
+
+      # Create a file to release in the build dir
+      @release.project.construct.file "build/index.html"
+
+      # Set fixed version
+      @release.scm.version = "1.0.0"
+    end
+
+    def teardown
+      @release.destroy
+      @release = nil
+    end
+
+    def test_basic_functionality
+      finalizer = Roger::Release::Finalizers::Dir.new
+
+      finalizer.call(@release)
+
+      assert File.exist?(@release.target_path + "html-1.0.0"), @release.target_path.inspect
+      assert File.directory?(@release.target_path + "html-1.0.0"), @release.target_path.inspect
+    end
+
+    def test_cleanup_existing_dir
+      dir = @release.project.construct.directory("releases/html-1.0.0")
+
+      finalizer = Roger::Release::Finalizers::Dir.new
+
+      original_ctime = File.ctime(dir)
+
+      finalizer.call(@release)
+
+      assert_not_same original_ctime, File.ctime(dir)
+    end
+  end
+end

data/test/unit/release/finalizers/git_branch_test.rb

@@ -1,9 +1,12 @@
 require "test_helper"
 require "roger/testing/mock_release"
+require "shellwords"
 
 module Roger
   # Test for Roger GitBranchFinalizer
   class GitBranchTest < ::Test::Unit::TestCase
+    include TestConstruct::Helpers
+
     def setup
       @release = Testing::MockRelease.new
 
@@ -36,5 +39,28 @@ module Roger
 
       FileUtils.rm_rf(output_dir)
     end
+
+    def test_find_remote
+      finalizer = Roger::Release::Finalizers::GitBranch.new
+      remote_repo = setup_construct(chdir: false)
+
+      `git init`
+
+      Dir.chdir(remote_repo.to_s) do
+        `git init --bare`
+      end
+
+      `git remote add origin #{Shellwords.escape(remote_repo.to_s)}`
+
+      assert_nothing_raised do
+        finalizer.call(
+          @release,
+          push: false,
+          cleanup: false
+        )
+      end
+    ensure
+      teardown_construct(remote_repo)
+    end
   end
 end

data/test/unit/release/injector_test.rb

@@ -0,0 +1,66 @@
+require "test_helper"
+require "roger/testing/mock_release"
+
+module Roger
+  # Test Roger Injector
+  class InjectorTest < ::Test::Unit::TestCase
+    def setup
+      @release = Testing::MockRelease.new
+
+      # Create a file to release in the build dir
+      @release.project.construct.directory "build" do |dir|
+        @target_file = dir.file("out", "aVARb")
+        @source_file = dir.file("in", "IN")
+        @source_md_file = dir.file("md", "*a*")
+      end
+    end
+
+    def teardown
+      @release.destroy
+    end
+
+    def test_string_injection
+      injector = Roger::Release::Injector.new(
+        { "VAR" => "1" },
+        into: ["out"]
+      )
+
+      injector.call(@release)
+
+      assert_equal "a1b", File.read(@target_file.to_s)
+    end
+
+    def test_regex_injection
+      injector = Roger::Release::Injector.new(
+        { /V.R/ => "1" },
+        into: ["out"]
+      )
+
+      injector.call(@release)
+
+      assert_equal "a1b", File.read(@target_file.to_s)
+    end
+
+    def test_file_injection
+      injector = Roger::Release::Injector.new(
+        { "VAR" => { file: @source_file.to_s } },
+        into: ["out"]
+      )
+
+      injector.call(@release)
+
+      assert_equal "aINb", File.read(@target_file.to_s)
+    end
+
+    def test_template_injection
+      injector = Roger::Release::Injector.new(
+        { "VAR" => { file: @source_md_file.to_s, processor: "md" } },
+        into: ["out"]
+      )
+
+      injector.call(@release)
+
+      assert_equal "a<p><em>a</em></p>\nb", File.read(@target_file.to_s)
+    end
+  end
+end

data/test/unit/release/processors/url_relativizer_test.rb

@@ -2,7 +2,7 @@ require "test_helper"
 require "roger/testing/mock_release"
 
 module Roger
-  # Test Roger Mockup
+  # Test UrlRelativizer
   class UrlRelativizerTest < ::Test::Unit::TestCase
     def setup
       @release = Testing::MockRelease.new

data/test/unit/release/scm/base_test.rb

@@ -0,0 +1,23 @@
+require "test_helper"
+require "mocha/test_unit"
+
+module Roger
+  # Test for Roger Base scm
+  class BaseScmTest < ::Test::Unit::TestCase
+    def setup
+      @scm = Roger::Release::Scm::Base.new
+    end
+
+    def test_implements_scm_interfase
+      assert @scm.respond_to?(:version)
+      assert @scm.respond_to?(:date)
+      assert @scm.respond_to?(:previous)
+    end
+
+    def test_only_abstract_methods
+      assert_raise(RuntimeError) { @scm.version }
+      assert_raise(RuntimeError) { @scm.date }
+      assert_raise(RuntimeError) { @scm.previous }
+    end
+  end
+end