roger 1.6.4 → 1.7.0

data/lib/roger/release/processors/mockup.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + "/../../renderer"
 module Roger::Release::Processors
   # The Mockup processor that will process all templates
   class Mockup < Base
-    attr_accessor :project
+    self.name = :mockup
 
     MIME_TYPES_TO_EXTENSION = {
       "text/html" => "html",
@@ -15,31 +15,31 @@ module Roger::Release::Processors
       "application/json" => "json"
     }
 
-    def initialize(options = {})
-      @options = {
+    def default_options
+      {
         env: {},
         match: ["**/*.{html,md,html.erb}"],
         skip: [/\Astylesheets/, /\Ajavascripts/]
       }
-
-      @options.update(options) if options
     end
 
-    def call(release, options = {})
-      self.project = release.project
+    def project
+      release.project
+    end
 
-      options = update_call_options(options)
+    def perform
+      @options[:env].update("roger.project" => project, "MOCKUP_PROJECT" => project)
 
-      log_call(release, options)
+      log_call
 
-      release.get_files(options[:match], options[:skip]).each do |file_path|
+      release.get_files(@options[:match], @options[:skip]).each do |file_path|
         release.log(self, "    Extract: #{file_path}", true)
 
         # Avoid rendering partials which can also be included
         # in the roger.base_path
         next if File.basename(file_path).start_with? "_"
 
-        self.run_on_file!(file_path, options[:env])
+        run_on_file!(file_path, @options[:env])
       end
     end
 
@@ -62,7 +62,7 @@ module Roger::Release::Processors
         partials_path: project.partial_path,
         layouts_path: project.layouts_path
       )
-      renderer.render(file_path)
+      renderer.render(file_path, project.options[:renderer] || {})
     end
 
     # Determines the output path for a mockup path with a certain template
@@ -92,25 +92,14 @@ module Roger::Release::Processors
 
     protected
 
-    def update_call_options(options)
-      updated_options = {}
-      updated_options.update(@options)
-
-      updated_options.update(options) if options
-
-      updated_options[:env].update("roger.project" => project, "MOCKUP_PROJECT" => project)
-
-      updated_options
-    end
-
-    def log_call(release, options)
+    def log_call
       release.log(self, "Processing mockup files")
 
-      release.log(self, "  Matching: #{options[:match].inspect}", true)
-      release.log(self, "  Skiping : #{options[:skip].inspect}", true)
-      release.log(self, "  Env     : #{options[:env].inspect}", true)
+      release.log(self, "  Matching: #{@options[:match].inspect}", true)
+      release.log(self, "  Skiping : #{@options[:skip].inspect}", true)
+      release.log(self, "  Env     : #{@options[:env].inspect}", true)
       release.log(self, "  Files   :", true)
     end
   end
 end
-Roger::Release::Processors.register(:mockup, Roger::Release::Processors::Mockup)
+Roger::Release::Processors.register(Roger::Release::Processors::Mockup)

data/lib/roger/release/processors/url_relativizer.rb

@@ -6,20 +6,18 @@ module Roger::Release::Processors
   # The relativizer can be used to rewrite absolute paths in attributes to relative paths
   # during release.
   class UrlRelativizer < Base
-    def initialize(options = {})
-      @options = {
+    self.name = :url_relativizer
+
+    def default_options
+      {
         url_attributes: %w(src href action),
         match: ["**/*.html"],
         skip: []
       }
-
-      @options.update(options) if options
     end
 
-    def call(release, options = {})
-      options = {}.update(@options).update(options)
-
-      log_call(release, options)
+    def perform
+      log_call
 
       @resolver = Roger::Resolver.new(release.build_path)
 
@@ -32,10 +30,10 @@ module Roger::Release::Processors
 
     protected
 
-    def log_call(release, options)
-      log_message = "Relativizing all URLS in #{options[:match].inspect}"
-      log_message << "files in attributes #{options[:url_attributes].inspect},"
-      log_message << "skipping #{options[:skip].any? ? options[:skip].inspect : 'none' }"
+    def log_call
+      log_message = "Relativizing all URLS in #{@options[:match].inspect}"
+      log_message << "files in attributes #{@options[:url_attributes].inspect},"
+      log_message << "skipping #{@options[:skip].any? ? @options[:skip].inspect : 'none'}"
       release.log(self, log_message)
     end
 
@@ -73,4 +71,4 @@ module Roger::Release::Processors
   end
 end
 
-Roger::Release::Processors.register(:url_relativizer, Roger::Release::Processors::UrlRelativizer)
+Roger::Release::Processors.register(Roger::Release::Processors::UrlRelativizer)

data/lib/roger/release/processors.rb

@@ -1,30 +1,58 @@
-module Roger
-  class Release
-    # The Processors namespace
-    module Processors
-      # Abstract Processor class
-      class Base
-        def initialize(options = {})
-          @options = {}
-          @options.update(options) if options
-        end
-
-        def call(_release, _options = {})
-          fail ArgumentError, "Implement in subclass"
-        end
-      end
+# Processors can perform any action on a release
+module Roger::Release::Processors
+  extend Roger::Helpers::Registration
 
-      def self.register(name, processor)
-        fail ArgumentError, "Processor name '#{name.inspect}' already in use" if map.key?(name)
-        fail ArgumentError, "Name must be a symbol" unless name.is_a?(Symbol)
-        map[name] = processor
-      end
+  # Abstract Processor class
+  class Base
+    attr_reader :options, :release
+
+    class << self
+      attr_writer :name
 
-      def self.map
-        @_map ||= {}
+      # Name of this processor
+      def name
+        @name || fail(ArgumentError, "Implement in subclass")
       end
     end
+
+    # Default options for this processor
+    def default_options
+      {}
+    end
+
+    # Name of this processor.
+    # - Can be set by setting the :name config in the release block
+    # - Can be overwritten in implementation if needed
+    def name
+      options && options[:name] || self.class.name
+    end
+
+    def call(release, options = {})
+      @release = release
+      @options = {}.update(default_options)
+      @options.update(options) if options
+      @options.update(my_project_options)
+
+      # Stop immideatly if we've been disabled
+      return if @options[:disable]
+
+      perform
+    end
+
+    protected
+
+    # The options passed through the project. This can contain
+    # command line options
+    def my_project_options
+      project_options = release.project.options
+      project_options[:release] && project_options[:release][name] || {}
+    end
+
+    def perform
+      fail ArgumentError, "Implement in subclass"
+    end
   end
 end
+
 require File.dirname(__FILE__) + "/processors/mockup"
 require File.dirname(__FILE__) + "/processors/url_relativizer"

data/lib/roger/release/scm/git.rb

@@ -6,6 +6,20 @@ module Roger
     module Scm
       # The GIT SCM implementation for Roger release
       class Git < Base
+        # Find the .git dir in path and all it's parents
+        def self.find_git_dir(path)
+          path = Pathname.new(path).realpath
+          while path.parent != path && !(path + ".git").directory?
+            path = path.parent
+          end
+
+          path += ".git"
+
+          fail "Could not find suitable .git dir in #{path}" unless path.directory?
+
+          path
+        end
+
         # @option config [String] :ref Ref to use for current tag
         # @option config [String, Pathname] :path Path to working dir
         def initialize(config = {})
@@ -51,7 +65,7 @@ module Roger
         end
 
         def git_dir
-          @git_dir ||= find_git_dir(@config[:path])
+          @git_dir ||= self.class.find_git_dir(@config[:path])
         end
 
         # Safely escaped git dir
@@ -96,20 +110,6 @@ module Roger
         rescue RuntimeError
           nil
         end
-
-        # Find the git dir
-        def find_git_dir(path)
-          path = Pathname.new(path).realpath
-          while path.parent != path && !(path + ".git").directory?
-            path = path.parent
-          end
-
-          path += ".git"
-
-          fail "Could not find suitable .git dir in #{path}" unless path.directory?
-
-          path
-        end
       end
     end
   end

data/lib/roger/release.rb

@@ -1,6 +1,7 @@
 require File.dirname(__FILE__) + "/helpers/get_callable"
 require File.dirname(__FILE__) + "/helpers/get_files"
 require File.dirname(__FILE__) + "/helpers/logging"
+require File.dirname(__FILE__) + "/helpers/registration"
 
 require "shellwords"
 
@@ -12,18 +13,10 @@ module Roger
 
     attr_reader :config, :project
 
-    attr_reader :finalizers, :stack
+    attr_reader :stack
 
     class << self
      include Roger::Helpers::GetCallable
-
-     def default_stack
-       []
-     end
-
-     def default_finalizers
-       [[get_callable(:dir, Roger::Release::Finalizers.map), {}]]
-     end
     end
 
     # @option config [:git, :fixed] :scm The SCM to use (default = :git)
@@ -39,7 +32,7 @@ module Roger
       real_project_path = project.path.realpath
       defaults = {
         scm: :git,
-        source_path: real_project_path + "html",
+        source_path: project.html_path.realpath,
         target_path: real_project_path + "releases",
         build_path: real_project_path + "build",
         cp: ["cp", "-RL"],
@@ -51,7 +44,6 @@ module Roger
 
       @project = project
       @stack = []
-      @finalizers = []
     end
 
     # Accessor for target_path
@@ -121,7 +113,7 @@ module Roger
     # @examples
     #   release.finalize :zip
     def finalize(finalizer, options = {})
-      @finalizers << [self.class.get_callable(finalizer, Roger::Release::Finalizers.map), options]
+      @stack << [self.class.get_callable(finalizer, Roger::Release::Finalizers.map), options]
     end
 
     # Files to clean up in the build directory just before finalization happens
@@ -180,9 +172,6 @@ module Roger
       # Run stack
       run_stack!
 
-      # Run finalizers
-      run_finalizers!
-
       # Cleanup
       cleanup! if config[:cleanup_build]
     ensure
@@ -262,16 +251,17 @@ module Roger
     def validate_stack!
       return if config[:blank]
 
-      mockup_options = {}
-      relativizer_options = {}
-
       unless find_in_stack(Roger::Release::Processors::Mockup)
-        @stack.unshift([Roger::Release::Processors::Mockup.new, mockup_options])
+        @stack.unshift([Roger::Release::Processors::Mockup.new, {}])
       end
 
-      # rubocop:disable Style/GuardClause
       unless find_in_stack(Roger::Release::Processors::UrlRelativizer)
-        @stack.push([Roger::Release::Processors::UrlRelativizer.new, relativizer_options])
+        @stack.push([Roger::Release::Processors::UrlRelativizer.new, {}])
+      end
+
+      # rubocop:disable Style/GuardClause
+      unless find_in_stack(Roger::Release::Finalizers::Dir)
+        @stack.push([Roger::Release::Finalizers::Dir.new, {}])
       end
     end
 
@@ -295,8 +285,6 @@ module Roger
     end
 
     def run_stack!
-      @stack = self.class.default_stack.dup if @stack.empty?
-
       # call all objects in @stack
       @stack.each do |task|
         if task.is_a?(Array)
@@ -307,19 +295,6 @@ module Roger
       end
     end
 
-    # Will run all finalizers, if no finalizers are set it will take the
-    # default finalizers.
-    #
-    # If config[:blank] is true, it will not use the default finalizers
-    def run_finalizers!
-      @finalizers = self.class.default_finalizers.dup if @finalizers.empty? && !config[:blank]
-
-      # call all objects in @finalizes
-      @finalizers.each do |finalizer|
-        finalizer[0].call(self, finalizer[1])
-      end
-    end
-
     def cleanup!
       log(self, "Cleaning up build path #{build_path}")
       rm_rf(build_path)
@@ -330,5 +305,5 @@ end
 require File.dirname(__FILE__) + "/release/scm"
 require File.dirname(__FILE__) + "/release/injector"
 require File.dirname(__FILE__) + "/release/cleaner"
-require File.dirname(__FILE__) + "/release/finalizers"
 require File.dirname(__FILE__) + "/release/processors"
+require File.dirname(__FILE__) + "/release/finalizers"

data/lib/roger/renderer.rb

@@ -111,8 +111,9 @@ module Roger
     #
     # If you just want to render an arbitrary file, use #render_file instead
     #
-    # @option options [Hash] :locals
-    # @option options [String] :source
+    # @option options [Hash] :locals Locals to use during rendering
+    # @option options [String] :source The source for the template
+    # @option options [String, nil] :layout The default layout to use
     def render(path, options = {}, &block)
       template, layout = template_and_layout_for_render(path, options)
 
@@ -196,16 +197,23 @@ module Roger
       template_type = current_template ? :partial : :template
       template = template(path, options[:source], template_type)
 
-      # Only attempt to load layout for toplevel
-      if !current_template && template.data[:layout]
-        layout = template(template.data[:layout], nil, :layout)
-      else
-        layout = BlankTemplate.new
-      end
+      layout = layout_for_template(template, options)
 
       [template, layout]
     end
 
+    # Gets the layout for a specific template
+    def layout_for_template(template, options)
+      layout_name = template.data.key?(:layout) ? template.data[:layout] : options[:layout]
+
+      # Only attempt to load layout when:
+      # - Template is the toplevel template
+      # - A layout_name is available
+      return BlankTemplate.new if current_template || !layout_name
+
+      template(layout_name, nil, :layout)
+    end
+
     # Will check the template nesting if we haven't already
     # rendered this path before. If it has we'll throw an argumenteerror
     def prevent_recursion!(template)

data/lib/roger/server.rb

@@ -7,12 +7,26 @@ require "webrick/https"
 
 module Roger
   # The Roger webserver. Initializes a rack server.
+  #
+  # @option options :port [Integer] The specified port you'd want to use
+  # @option options :auto_port [Boolean] Wether or not you want Roger
+  #   to find a suitable port if the specified port is in use.
+  # @option options :handler [String] The preferred handler to use
   class Server
     attr_reader :server_options
 
+    # @attr_reader [Roger::Project] project The project used in this server
     attr_reader :project
 
-    attr_accessor :port, :handler, :host
+    # @attr_reader [nil, Integer] used_port The actual port used to start
+    #   the webserver. Only set if the server is running.
+    attr_reader :used_port
+
+    # @attr_reader [nil, Class] used_handler The actual used handler.
+    #   Only set if the server is running.
+    attr_reader :used_handler
+
+    attr_accessor :port, :handler, :host, :auto_port
 
     def initialize(project, options = {})
       @project = project
@@ -25,6 +39,10 @@ module Roger
       self.port = 9000
       self.handler = nil
       self.host = "0.0.0.0"
+      self.auto_port = true
+
+      @used_port = nil
+      @used_handler = nil
 
       set_options(options)
     end
@@ -32,9 +50,10 @@ module Roger
     # Sets the options, this is a separate method as we want to override certain
     # things set in the rogerfile from the commandline
     def set_options(options)
-      self.port = options[:port] if options.key?(:port)
+      self.port = options[:port].to_i if options.key?(:port)
       self.handler = options[:handler] if options.key?(:handler)
       self.host = options[:host] if options.key?(:host)
+      self.auto_port = options[:auto_port] if options.key?(:auto_port)
     end
 
     # Use the specified Rack middleware
@@ -53,18 +72,38 @@ module Roger
 
     def run!
       project.mode = :server
-      handler.run application, server_options do |server|
+
+      options = server_options_for_handler
+      @used_port = options[:Port]
+      @used_handler = handler
+
+      handler.run application, options do |server|
         trap(:INT) do
           ## Use thins' hard #stop! if available, otherwise just #stop
           server.respond_to?(:stop!) ? server.stop! : server.stop
           puts "Roger, out!"
         end
+
+        yield server if block_given?
       end
     ensure
       project.mode = nil
+      @used_port = nil
+      @used_handler = nil
     end
     alias_method :run, :run!
 
+    def server_options_for_handler
+      # Search for available port
+      options = server_options.dup
+      if auto_port && !port_free?(options[:Host], options[:Port])
+        options[:Port] = free_port_for_host_above(options[:Host], options[:Port])
+      end
+
+      # Return the options
+      options
+    end
+
     def port=(p)
       @port = server_options[:Port] = p
     end
@@ -83,6 +122,23 @@ module Roger
 
     protected
 
+    # Get the first free port for host above port
+    # Will only ever test 100 ports.
+    def free_port_for_host_above(host, port)
+      test_port = port
+      test_port += 1 until port_free?(host, test_port) || port + 100 <= test_port
+      test_port
+    end
+
+    # See if a certain port is free on a certain host
+    def port_free?(host, port)
+      Addrinfo.tcp(host, port).listen.close
+
+      true
+    rescue SocketError, Errno::EADDRINUSE
+      false
+    end
+
     # Build the final application that get's run by the Rack Handler
     def application
       return @app if @app

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

@@ -3,7 +3,12 @@ module Roger
     module Helpers
       # The partial helper
       module Partial
-        def partial(name, options = {}, &block)
+        def partial(name, locals = {}, &block)
+          if locals[:locals]
+            options = locals
+          else
+            options = { locals: locals }
+          end
           if block_given?
             partial_with_block(name, options, &block)
           else

data/lib/roger/version.rb

@@ -1,4 +1,4 @@
 # Roger main namespace
 module Roger
-  VERSION = "1.6.4"
+  VERSION = "1.7.0"
 end

data/roger.gemspec

@@ -41,6 +41,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency("test-unit", "~> 3.0.0")
   s.add_development_dependency("mocha", "~> 1.1.0")
   s.add_development_dependency("simplecov", "~> 0.10.0")
-  s.add_development_dependency("puma", "~> 2.10.0")
+  s.add_development_dependency("puma", "~> 3.6.0")
   s.add_development_dependency("rubocop", "~> 0.31.0")
 end

data/test/helpers/generators.rb

@@ -0,0 +1,25 @@
+# Generator scope
+module Generators
+  # Simple Mock generator
+  class MockedGenerator < Roger::Generators::Base
+    desc "@mocked description"
+    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
+      # Somewhat ugly way of checking
+      fail NotImplementedError
+    end
+  end
+
+  Roger::Generators.register :mocked, MockedGenerator
+
+  # Simple Mocku generator that has a project
+  class MockedWithProjectGenerator < Roger::Generators::Base
+    desc "Returns a project"
+    def test
+      # Somewhat ugly way of checking
+      fail StandardError if @project
+    end
+  end
+end

data/test/project/layouts/bracket.html.erb

@@ -0,0 +1 @@
+[<%= yield %>]

data/test/project/partials/test/locals.html.erb

@@ -0,0 +1 @@
+<%= locals[:variable] %>

data/test/project/partials/test/max_depth.html.erb

@@ -1,5 +1,5 @@
 <% if depth < max_depth %>
-  <%= partial 'test/max_depth', locals: { depth: locals[:depth] + 1, max_depth: locals[:max_depth] } %>
+  <%= partial 'test/max_depth', { depth: locals[:depth] + 1, max_depth: locals[:max_depth] } %>
 <% else %>
   Stop! Hammertime!
 <% end %>

data/test/project/partials/test/parent_template.html.erb

@@ -0,0 +1 @@
+<%= renderer.parent_template.source_path %>