roger 1.6.4 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 92478f7482bcbb5fa9dfe14d0a96d092a46e5d78
-  data.tar.gz: b6f75c7d2deb4c7d3d5afb2fd5c5ea3bd2e9c22d
+  metadata.gz: 254dec98111150e5adbe9e84f7aa1f46c66f5531
+  data.tar.gz: a5dc918ad5089d30ca4e05cc33d2cd9c5add57eb
 SHA512:
-  metadata.gz: 2a7ca884f0897b455af8b81c1eff91fe0066ac71b3d3f89bd302b533fdf2b7dc7ba1ba8f69a1472727327fc9434b328f11ad92b6fb98d7ef8a0d7f836469ad43
-  data.tar.gz: 560301778c4892fbbeb5040a7c1e00162f1012af0395202e4f0c92c52c2401bb7e920f9df40e9bdda9b9af4c212bebd4fd02c0339256fbf1c94000b57a08bb1c
+  metadata.gz: 40834adf5d70b5935c8a783b962a34c59e4a74103db5f39bb13cc3805b28924535acf16abb1cc56c4c1c4998247894eeeb01825907ffac61ac432150aabb2369
+  data.tar.gz: 39fbb668e16cfa3d6c082325a167c6e6ab357feea2276ceca8fb5cae40f799998f5a7c1b1b4a3fe4f95dfe5a0514fcd904dbf2bdc2401d860d248f1d406b3c88

data/.travis.yml

@@ -1,12 +1,12 @@
 language: ruby
 rvm:
-  - 2.0.0
-  - 2.1.1
-  - 2.2.2
   - 2.3.0
+  - 2.3.3
 before_script:
   - git config --global user.email "travis-ci@digitpaint.nl"
   - git config --global user.name "Travis-CI"
+after_success:
+  - bundle exec codeclimate-test-reporter
 matrix:
   fast_finish: true
 env:

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## Version 1.7.0
+* Finalizers and processors now use the same stack. This means you can run processors after certain finalizers
+* Finalizers and processors now have exactly the same API
+* Roger automatically detects free ports now. This can be disabled by passing `auto_port = false` to the server options ( or passing `--server:auto_port=false` on the commandline)
+* Add support for using partials with directly passing locals. Instead of doing `partial "x", locals: {a: 1}` you can now do `partial "x", a: 1`. The old method still works and allows for setting other template options.
+* Allow setting of a default layout by setting `roger.project.options[:renderer][:layout] = "the_default_layout_name"` in your `Rogerfile`. Or via commandline `--renderer:layout='bla'` if you must.
+* Bug fixes:
+    - Release will take the set `project.html_path` instead of hardcoded path
+    - Fix issues with newer Thor versions
+    - Add more code higiene
+    - Don't fail if there is no Gemfile. This fixes the `roger generate new` command.
+
 ## Version 1.6.4
 * Fix bug with block partials in layouts by correctly determine the current Tilt template we're rendering.
 

data/Gemfile

@@ -3,6 +3,7 @@ source "https://rubygems.org"
 gemspec name: "roger"
 
 gem "rake"
-gem "pry"
-# Only coverage support in CI, CODECLIMATE TOKEN is part of travis.yml
-gem "codeclimate-test-reporter", group: :test, require: nil if ENV["CODECLIMATE_REPO_TOKEN"]
+
+group :test do
+  gem "codeclimate-test-reporter", "~> 1.0.0"
+end

data/Rakefile

@@ -13,4 +13,5 @@ Rake::TestTask.new do |t|
   t.libs << "test/unit"
   t.test_files = FileList["test/unit/**/*_test.rb"]
   t.verbose = false
+  t.warning = false
 end

data/doc/cli.md

@@ -52,4 +52,15 @@ All commands accept these options.
 Options:
   -v, [--verbose]  # Set's verbose output
   -h, [--help]  # Help
-```
+```
+
+## Custom options
+
+All processors/middleware/etc. can use custom options. Roger will parse any leftover option that starts with `--` and sets it in the `project.options` hash. It even supports setting nested keys by using `:` as a separator. This means that `--release:rsync:disable=true` will become: `{release: { rsync: { disable: true}}}` in the options hash.
+
+### Parsing
+The commandline parser will work with flags in the following formats:
+
+* `--key` will just set the flag to `true`
+* `--key=value` and `--key value` will set the key `:key` to `"value"`
+* `--key=true` and `--key=false` will convert to boolean `true` and `false`

data/doc/templating.md

@@ -72,6 +72,15 @@ Template
 Layout (after)
 ```
 
+### Default layout
+It is possible to define a global default layout in the Rogerfile. 
+
+```
+roger.project.options[:renderer][:layout] = "my_default_layout"
+```
+
+The layout can of course be overwritten in the frontmatter. Setting an empty layout will disable the default layout.
+
 ### Advanced layouts
 
 #### Using `content_for`

data/lib/roger/cli/serve.rb

@@ -5,7 +5,7 @@ module Roger
 
     class_options port: :string, # Defaults to 9000
                   host: :string, # Defaults to 0.0.0.0
-                  handler: :string # The handler to use (defaults to mongrel)
+                  handler: :string # The handler to use
 
     def serve
       server_options = {}
@@ -18,15 +18,19 @@ module Roger
       @project.server.set_options(server_options[:server])
     end
 
-    def show_banner
+    def start
       server  = @project.server
-      puts "Running Roger with #{server.handler.inspect} on #{server.host}:#{server.port}"
-      puts project_banner(@project)
-    end
 
-    # Hack so we can override it in tests.
-    def start
-      @project.server.run!
+      @project.server.run! do |server_instance|
+        puts "Running Roger with #{server.used_handler.inspect}"
+        puts "  Host: #{server.host}"
+        puts "  Port: #{server.used_port}"
+        puts
+        puts project_banner(@project)
+
+        # Hack so we can override it in tests.
+        yield server_instance if block_given?
+      end
     end
   end
 end

data/lib/roger/cli.rb

@@ -1,7 +1,13 @@
 require "rubygems"
 
-# Require bundler gems if available
-Bundler.require(:default) if Object.const_defined?(:Bundler)
+# Require bundler gems if Bundler and Gemfile is available
+if Object.const_defined?(:Bundler)
+  begin
+    Bundler.require(:default)
+  rescue Bundler::GemfileNotFound # rubocop:disable all
+    # No Gemfile found, not using local bundler
+  end
+end
 
 require "thor"
 require "thor/group"
@@ -96,14 +102,81 @@ module Roger
 
     protected
 
-    # TODO: handle options
     def initialize_project
-      if (Pathname.new(options[:path]) + "../partials").exist?
+      # Most unfortunately we have to hack around the
+      # class_options not being set in the help command
+      # since thor v0.19.4
+      path = options[:path] || "."
+
+      if (Pathname.new(path) + "../partials").exist?
         puts "[ERROR]: Don't use the \"html\" path, use the project base path instead"
         exit(1)
       end
 
-      Project.new(options[:path], { shell: shell }.update(options))
+      project_options = { shell: shell }
+      project_options.update(parse_generic_options(args)[0])
+      project_options.update(options)
+
+      Project.new(path, project_options)
+    end
+
+    # Very simplified method to parse CLI options
+    # only works with options starting with --
+    # Will also make nested options by using ":" so
+    # --a:b:c=yes will become {a: {b: {c: "yes"}}}
+    def parse_generic_options(args)
+      a = args.dup
+      arguments = []
+      options = {}
+
+      until a.empty?
+        arg = a.shift
+        case arg
+        when /\A--.+=/
+          _, option, value = arg.match(/\A--(.+)=(.+)\Z/).to_a
+          update_options(option, value, options)
+        when /\A--.+/
+          if a[0].nil? || a[0].to_s.start_with?("--")
+            # Current option is a boolean
+            update_options(arg, true, options)
+          else
+            # Take value from next
+            update_options(arg, a.shift, options)
+          end
+        else
+          arguments << arg
+        end
+      end
+
+      [options, arguments]
+    end
+
+    # Will update the passed options array by splitting
+    # the composite_key by ":" and applying the keys nested
+    def update_options(composite_key, value, options)
+      nesting = options
+      keys = composite_key.sub(/\A--/, "").split(":")
+      keys.each_with_index do |key, i|
+        key = key.to_sym
+        if i < keys.length - 1
+          nesting[key] ||= {}
+          nesting = nesting[key]
+        else
+          nesting[key] = parse_possible_boolean(value)
+        end
+      end
+      options
+    end
+
+    def parse_possible_boolean(value)
+      case value
+      when "true"
+        true
+      when "false"
+        false
+      else
+        value
+      end
     end
   end
 end

data/lib/roger/helpers/registration.rb

@@ -0,0 +1,33 @@
+module Roger
+  module Helpers
+    # Helper module to handle registration
+    module Registration
+      # Register a class with a name. The method can have the following signatures:
+      #
+      # def register(processor)
+      #
+      # and for legacy reasons:
+      #
+      # def register(name, processor)
+      #
+      # in the first case the processor must have a name class method.
+      def register(name, processor = nil)
+        if name.is_a?(Class)
+          processor = name
+          name = processor.name
+        end
+
+        type = to_s.split("::").last
+
+        fail ArgumentError, "#{type} 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
+
+      def map
+        @_map ||= {}
+      end
+    end
+  end
+end

data/lib/roger/project.rb

@@ -29,6 +29,7 @@ module Roger
         partial_path: @path + "partials",
         layouts_path: @path + "layouts",
         rogerfile_path: @path + "Rogerfile",
+        renderer: {},
         server: {},
         release: {},
         test: {}
@@ -38,7 +39,7 @@ module Roger
       options.each { |k, v| @options[k.is_a?(String) ? k.to_sym : k] = v }
 
       initialize_accessors
-      intialize_rogerfile_path
+      initialize_rogerfile_path
       initialize_roger
     end
 
@@ -47,18 +48,15 @@ module Roger
     end
 
     def server(options = {})
-      options = {}.update(@options[:server]).update(options)
-      @server ||= Server.new(self, options)
+      @server ||= Server.new(self, merge_options(options, :server))
     end
 
     def release(options = {})
-      options = {}.update(@options[:release]).update(options)
-      @release ||= Release.new(self, options)
+      @release ||= Release.new(self, merge_options(options, :release))
     end
 
     def test(options = {})
-      options = {}.update(@options[:test]).update(options)
-      @test ||= Test.new(self, options)
+      @test ||= Test.new(self, merge_options(options, :test))
     end
 
     def html_path=(p)
@@ -77,7 +75,15 @@ module Roger
 
     protected
 
-    def intialize_rogerfile_path
+    # Creates new options and merges:
+    # - @options[:key]
+    # - passed options
+    #
+    def merge_options(options, key)
+      {}.update(@options[key]).update(options)
+    end
+
+    def initialize_rogerfile_path
       # We stop immediately if rogerfile is not a Pathname
       unless @options[:rogerfile_path].is_a? Pathname
         self.rogerfile_path = @options[:rogerfile_path]

data/lib/roger/rack/roger.rb

@@ -44,7 +44,7 @@ module Roger
         ::Rack::Response.new do |res|
           res.headers["Content-Type"] = mime if mime
           res.status = 200
-          res.write renderer.render(template_path)
+          res.write renderer.render(template_path, @project.options[:renderer] || {})
         end
       end
     end

data/lib/roger/release/finalizers/dir.rb

@@ -6,17 +6,20 @@ module Roger::Release::Finalizers
   # The directory name will have the format PREFIX-VERSION
   #
   class Dir < Base
+    self.name = :dir
+
     # @option options :prefix Prefix to put before the version (default = "html")
-    def call(release, call_options = {})
-      options = {
+    def default_options
+      {
         prefix: "html",
         target_path: release.target_path
-      }.update(@options)
-      options.update(call_options) if call_options
+      }
+    end
 
-      name = [options[:prefix], release.scm.version].join("-")
+    def perform
+      name = [@options[:prefix], @release.scm.version].join("-")
 
-      target_dir = Pathname.new(options[:target_path])
+      target_dir = Pathname.new(@options[:target_path])
       FileUtils.mkdir_p(target_dir) unless target_dir.exist?
 
       target_path = target_dir + name
@@ -33,4 +36,4 @@ module Roger::Release::Finalizers
   end
 end
 
-Roger::Release::Finalizers.register(:dir, Roger::Release::Finalizers::Dir)
+Roger::Release::Finalizers.register(Roger::Release::Finalizers::Dir)

data/lib/roger/release/finalizers/git_branch.rb

@@ -3,6 +3,8 @@ require "tmpdir"
 module Roger::Release::Finalizers
   # Finalizes the release into a specific branch of a repository and pushes it
   class GitBranch < Roger::Release::Finalizers::Base
+    self.name = :git_branch
+
     # @param Hash options The options
     #
     # @option options String :remote The remote repository (default is the
@@ -11,8 +13,8 @@ module Roger::Release::Finalizers
     # @option options Boolean :cleanup Cleanup temp dir afterwards (default is
     #   true)
     # @option options Boolean :push Push to remote (default is true)
-    def initialize
-      @options = {
+    def default_options
+      {
         remote: nil,
         branch: "gh-pages",
         cleanup: true,
@@ -20,8 +22,7 @@ module Roger::Release::Finalizers
       }
     end
 
-    def call(release, options = {})
-      @options = @options.dup.update(options)
+    def perform
       remote = find_git_remote(release.project.path)
       branch = @options[:branch]
 
@@ -37,9 +38,9 @@ module Roger::Release::Finalizers
         create_empty_branch(clone_dir, remote, branch)
       end
 
-      release.log(self, "Working git magic in #{clone_dir}")
+      @release.log(self, "Working git magic in #{clone_dir}")
 
-      commit_and_push_release(clone_dir, release, branch, @options)
+      commit_and_push_release(clone_dir, branch)
 
       if @options[:cleanup]
         FileUtils.rm_rf(tmp_dir)
@@ -50,19 +51,19 @@ module Roger::Release::Finalizers
 
     protected
 
-    def commit_and_push_release(clone_dir, release, branch, options)
+    def commit_and_push_release(clone_dir, branch)
       ::Dir.chdir(clone_dir) do
         # 3. Copy changes
         FileUtils.rm_rf("*")
-        FileUtils.cp_r release.build_path.to_s + "/.", clone_dir.to_s
+        FileUtils.cp_r @release.build_path.to_s + "/.", clone_dir.to_s
 
         commands = [
           %w(git add .), # 4. Add all files
-          %w(git commit -a -m) << "Release #{release.scm.version}" # 5. Commit
+          %w(git commit -a -m) << "Release #{@release.scm.version}" # 5. Commit
         ]
 
         # 6. Git push if in options
-        commands << (%w(git push origin) << branch) if options[:push]
+        commands << (%w(git push origin) << branch) if @options[:push]
 
         commands.each do |command|
           `#{Shellwords.join(command)}`
@@ -111,25 +112,13 @@ module Roger::Release::Finalizers
       `#{command}`
     end
 
-    # Find the git dir
-    # TODO: this is just a copy from release/scm/git.rb
-    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
-
     def find_git_remote(path)
-      remote =
-        @options[:remote] ||
-        `git --git-dir=#{Shellwords.escape(find_git_dir(path).to_s)} config --get remote.origin.url`
+      if @options[:remote]
+        remote = @options[:remote]
+      else
+        git_dir = Roger::Release::Scm::Git.find_git_dir(path)
+        remote = `git --git-dir=#{Shellwords.escape(git_dir.to_s)} config --get remote.origin.url`
+      end
 
       remote.strip!
 
@@ -140,7 +129,4 @@ module Roger::Release::Finalizers
   end
 end
 
-Roger::Release::Finalizers.register(
-  :git_branch,
-  Roger::Release::Finalizers::GitBranch
-)
+Roger::Release::Finalizers.register(Roger::Release::Finalizers::GitBranch)

data/lib/roger/release/finalizers/rsync.rb

@@ -7,6 +7,8 @@ module Roger::Release::Finalizers
   # @see RsyncFinalizer#initialize for options
   #
   class Rsync < Base
+    self.name = :rsync
+
     # @param Hash options The options
     #
     # @option options String :rsync The Rsync command to run (default is "rsync")
@@ -14,34 +16,32 @@ module Roger::Release::Finalizers
     # @option options String :host The remote host to upload to
     # @option options String :username The remote username to upload to
     # @option options Boolean :ask Prompt the user before uploading (default is true)
-    def initialize(options = {})
-      @options = {
+    def default_options
+      {
         rsync: "rsync",
         remote_path: "",
         host: nil,
         username: nil,
         ask: true
-      }.update(options)
+      }
     end
 
-    def call(release, options = {})
-      options = @options.dup.update(options)
-
+    def perform
       # Validate options
-      validate_options!(release, options)
+      validate_options!
 
-      return unless prompt_for_upload(options)
+      return unless prompt_for_upload
 
-      check_rsync_command(options[:rsync])
+      check_rsync_command(@options[:rsync])
 
-      local_path = release.build_path.to_s
-      remote_path = options[:remote_path]
+      local_path = @release.build_path.to_s
+      remote_path = @options[:remote_path]
 
       local_path += "/" unless local_path =~ %r{/\Z}
       remote_path += "/" unless remote_path =~ %r{/\Z}
 
-      release.log(self, "Starting upload of #{(release.build_path + '*')} to #{options[:host]}")
-      rsync(options[:rsync], local_path, remote_path, options)
+      release.log(self, "Starting upload of #{(@release.build_path + '*')} to #{@options[:host]}")
+      rsync(@options[:rsync], local_path, remote_path)
     end
 
     protected
@@ -52,10 +52,10 @@ module Roger::Release::Finalizers
       raise "Could not find rsync in #{command.inspect}"
     end
 
-    def rsync(command, local_path, remote_path, options = {})
+    def rsync(command, local_path, remote_path)
       target_path = remote_path
-      target_path = "#{options[:host]}:#{target_path}" if options[:host]
-      target_path = "#{options[:username]}@#{target_path}" if options[:username]
+      target_path = "#{@options[:host]}:#{target_path}" if @options[:host]
+      target_path = "#{@options[:username]}@#{target_path}" if @options[:username]
 
       command = [
         options[:rsync],
@@ -71,17 +71,17 @@ module Roger::Release::Finalizers
       fail "Rsync failed.\noutput:\n #{output}" unless $CHILD_STATUS.success?
     end
 
-    def prompt_for_upload(options)
+    def prompt_for_upload
       !options[:ask] ||
-        (prompt("Do you wish to upload to #{options[:host]}? [y/N]: ")) =~ /\Ay(es)?\Z/
+        prompt("Do you wish to upload to #{@options[:host]}? [y/N]: ") =~ /\Ay(es)?\Z/
     end
 
-    def validate_options!(release, options)
+    def validate_options!
       must_have_keys = [:remote_path]
-      return if (options.keys & must_have_keys).size == must_have_keys.size
+      return if (@options.keys & must_have_keys).size == must_have_keys.size
 
-      release.log(self, "Missing options: #{(must_have_keys - options.keys).inspect}")
-      fail "Missing keys: #{(must_have_keys - options.keys).inspect}"
+      release.log(self, "Missing options: #{(must_have_keys - @options.keys).inspect}")
+      fail "Missing keys: #{(must_have_keys - @options.keys).inspect}"
     end
 
     def prompt(question = "Do you wish to continue?")
@@ -90,4 +90,5 @@ module Roger::Release::Finalizers
     end
   end
 end
-Roger::Release::Finalizers.register(:rsync, Roger::Release::Finalizers::Rsync)
+
+Roger::Release::Finalizers.register(Roger::Release::Finalizers::Rsync)

data/lib/roger/release/finalizers/zip.rb

@@ -1,34 +1,34 @@
 module Roger::Release::Finalizers
   # The zip finalizer
-  # The zip finalizer will
   class Zip < Base
-    attr_reader :release
+    self.name = :zip
 
     # @option options [String] :prefix Prefix to put before the version (default = "html")
     # @option options [String] :zip The zip command
     # @option options [String, Pathname] :target_path (release.target_path) The path to zip to
-    def call(release, call_options = {})
-      options = {
+
+    def default_options
+      {
         zip: "zip",
         prefix: "html",
         target_path: release.target_path
-      }.update(@options)
-
-      options.update(call_options) if call_options
+      }
+    end
 
-      target_path = ensure_target_path(options[:target_path])
+    def perform
+      target_path = ensure_target_path(@options[:target_path])
 
-      name = [options[:prefix], release.scm.version].join("-") + ".zip"
+      name = [options[:prefix], @release.scm.version].join("-") + ".zip"
       zip_path = target_path + name
 
-      release.log(self, "Finalizing release to #{zip_path}")
+      @release.log(self, "Finalizing release to #{zip_path}")
 
-      cleanup_existing_zip(release, zip_path)
+      cleanup_existing_zip(zip_path)
 
-      check_zip_command(options[:zip])
+      check_zip_command(@options[:zip])
 
-      ::Dir.chdir(release.build_path) do
-        `#{options[:zip]} -r -9 "#{zip_path}" ./*`
+      ::Dir.chdir(@release.build_path) do
+        `#{@options[:zip]} -r -9 "#{zip_path}" ./*`
       end
     end
 
@@ -40,7 +40,7 @@ module Roger::Release::Finalizers
       target_path
     end
 
-    def cleanup_existing_zip(release, path)
+    def cleanup_existing_zip(path)
       return unless File.exist?(path)
 
       release.log(self, "Removing existing target #{path}")
@@ -54,4 +54,4 @@ module Roger::Release::Finalizers
     end
   end
 end
-Roger::Release::Finalizers.register(:zip, Roger::Release::Finalizers::Zip)
+Roger::Release::Finalizers.register(Roger::Release::Finalizers::Zip)

data/lib/roger/release/finalizers.rb

@@ -1,26 +1,10 @@
 # The Finalizers will finalize the release. Finalizers can be used to
 # copy the release, zip the release or upload the release
 module Roger::Release::Finalizers
-  # Abstract base finalizer
-  class Base
-    def initialize(options = {})
-      @options = {}
-      @options.update(options) if options
-    end
+  extend Roger::Helpers::Registration
 
-    def call(_release, _options = {})
-      fail ArgumentError, "Implement in subclass"
-    end
-  end
-
-  def self.register(name, finalizer)
-    fail ArgumentError, "Finalizer name '#{name.inspect}' already in use" if map.key?(name)
-    fail ArgumentError, "Name must be a symbol" unless name.is_a?(Symbol)
-    map[name] = finalizer
-  end
-
-  def self.map
-    @_map ||= {}
+  # Abstract base finalizer; This is practically the same as a processor
+  class Base < Roger::Release::Processors::Base
   end
 end