roger 1.1.3 → 1.2.1

data/lib/roger/mockupfile.rb

@@ -1,11 +1,9 @@
 module Roger
   # Loader for mockupfile
   class Mockupfile
-
     # This is the context for the mockupfile evaluation. It should be empty except for the
     # #mockup method.
     class Context
-
       def initialize(mockupfile)
         @_mockupfile = mockupfile
       end
@@ -17,7 +15,6 @@ module Roger
       def binding
         ::Kernel.binding
       end
-
     end
 
     # @attr :path [Pathname] The path of the Mockupfile for this project
@@ -30,12 +27,12 @@ module Roger
 
     # Actually load the mockupfile
     def load
-      if File.exist?(@path) && !self.loaded?
-        @source = File.read(@path)
-        context = Context.new(self)
-        eval @source, context.binding, @path.to_s, 1
-        @loaded = true
-      end
+      return unless File.exist?(@path) && !self.loaded?
+
+      @source = File.read(@path)
+      context = Context.new(self)
+      eval @source, context.binding, @path.to_s, 1 # rubocop:disable Lint/Eval
+      @loaded = true
     end
 
     # Wether or not the Mockupfile has been loaded
@@ -44,30 +41,23 @@ module Roger
     end
 
     def release(options = {})
-      release = self.project.release(options)
-      if block_given?
-        yield(release)
-      end
+      release = project.release(options)
+      yield(release) if block_given?
       release
     end
 
     def serve(options = {})
-      server = self.project.server(options)
-      if block_given?
-        yield(server)
-      end
+      server = project.server(options)
+      yield(server) if block_given?
       server
     end
 
-    alias :server :serve
+    alias_method :server, :serve
 
     def test(options = {})
-      test = self.project.test(options)
-      if block_given?
-        yield(test)
-      end
+      test = project.test(options)
+      yield(test) if block_given?
       test
     end
-
   end
 end

data/lib/roger/project.rb

@@ -7,48 +7,38 @@ require File.dirname(__FILE__) + "/mockupfile"
 module Roger
   # Loader for mockupfile and project dependencies
   class Project
-
     # @attr :path [Pathname] The project path
     # @attr :html_path [Pathname] The path of the HTML mockup
     # @attr :partial_path [Pathname] The path for the partials for this mockup
     # @attr :mockupfile [Mockupfile] The Mockupfile for this project
     # @attr :mockupfile_path [Pathname] The path to the Mockupfile
-    # @attr :mode [nil, :test, :server, :release] The mode we're currently in. If nil, we aren't doing anything.
-    attr_accessor :path, :html_path, :partial_path, :layouts_path, :mockupfile, :mockupfile_path, :mode
+    # @attr :mode [nil, :test, :server, :release] The mode we're currently in.
+    #   If nil, we aren't doing anything.
+    attr_accessor :path, :html_path, :partial_path, :layouts_path,
+                  :mockupfile, :mockupfile_path, :mode
 
     attr_accessor :shell
 
     attr_accessor :options
 
-    def initialize(path, options={})
+    def initialize(path, options = {})
       @path = Pathname.new(path)
 
       @options = {
-        :html_path => @path + "html",
-        :partial_path => @path + "partials",
-        :layouts_path => @path + "layouts",
-        :mockupfile_path => @path + "Mockupfile",
-        :server => {},
-        :release => {},
-        :test => {}
+        html_path: @path + "html",
+        partial_path: @path + "partials",
+        layouts_path: @path + "layouts",
+        mockupfile_path: @path + "Mockupfile",
+        server: {},
+        release: {},
+        test: {}
       }
 
       # Clumsy string to symbol key conversion
-      options.each{|k,v| @options[k.is_a?(String) ? k.to_sym : k] = v }
-
-      self.html_path = @options[:html_path]
-      self.partial_path = @options[:partials_path] || @options[:partial_path] || self.html_path + "../partials/"
-      self.layouts_path = @options[:layouts_path]
-      self.mockupfile_path = @options[:mockupfile_path]
-      self.shell = @options[:shell]
-
-      if self.mockupfile_path
-        @mockupfile = Mockupfile.new(self, self.mockupfile_path)
-        @mockupfile.load
-      else
-        @mockupfile = Mockupfile.new(self)
-      end
+      options.each { |k, v| @options[k.is_a?(String) ? k.to_sym : k] = v }
 
+      initialize_accessors
+      initialize_mockup
     end
 
     def shell
@@ -71,26 +61,44 @@ module Roger
     end
 
     def html_path=(p)
-      @html_path = self.realpath_or_path(p)
+      @html_path = realpath_or_path(p)
     end
 
     def partial_path=(p)
-      @partial_path = self.single_or_multiple_paths(p)
+      @partial_path = single_or_multiple_paths(p)
     end
-    alias :partials_path :partial_path
-    alias :partials_path= :partial_path=
+    alias_method :partials_path, :partial_path
+    alias_method :partials_path=, :partial_path=
 
     def layouts_path=(p)
-      @layouts_path = self.single_or_multiple_paths(p)
+      @layouts_path = single_or_multiple_paths(p)
     end
 
     protected
 
+    def initialize_accessors
+      self.html_path = @options[:html_path]
+      self.partial_path =
+        @options[:partials_path] || @options[:partial_path] || html_path + "../partials/"
+      self.layouts_path = @options[:layouts_path]
+      self.mockupfile_path = @options[:mockupfile_path]
+      self.shell = @options[:shell]
+    end
+
+    def initialize_mockup
+      if mockupfile_path
+        @mockupfile = Mockupfile.new(self, mockupfile_path)
+        @mockupfile.load
+      else
+        @mockupfile = Mockupfile.new(self)
+      end
+    end
+
     def single_or_multiple_paths(p)
-      if p.kind_of?(Array)
-        p.map{|tp| self.realpath_or_path(tp) }
+      if p.is_a?(Array)
+        p.map { |tp| realpath_or_path(tp) }
       else
-        self.realpath_or_path(p)
+        realpath_or_path(p)
       end
     end
 
@@ -102,6 +110,5 @@ module Roger
         path
       end
     end
-
   end
 end

data/lib/roger/rack/roger.rb

@@ -1,52 +1,51 @@
-require 'rack/request'
-require 'rack/response'
-require 'rack/file'
+require "rack/request"
+require "rack/response"
+require "rack/file"
 
-require File.dirname(__FILE__) + '/../resolver'
+require File.dirname(__FILE__) + "/../resolver"
 
 module Roger
   module Rack
-    
+    # Roger middleware that processe roger templates
     class Roger
-      
       attr_reader :project
-      
+
       def initialize(project)
         @project = project
         @docroot = project.html_path
-        
+
         @resolver = Resolver.new(@docroot)
         @file_server = ::Rack::File.new(@docroot)
       end
 
       def call(env)
         url = env["PATH_INFO"]
-        env["MOCKUP_PROJECT"] = project
-        
+        env["MOCKUP_PROJECT"] = env["roger.project"] || @project
+
         if template_path = @resolver.url_to_path(url)
           env["rack.errors"].puts "Rendering template #{template_path.inspect} (#{url.inspect})"
-          # begin
-            templ = ::Roger::Template.open(template_path, :partials_path => @project.partials_path, :layouts_path => @project.layouts_path)
-            mime = ::Rack::Mime.mime_type(File.extname(template_path), 'text/html')
-            resp = ::Rack::Response.new do |res|
-              res.headers["Content-Type"] = mime if mime
-              res.status = 200
-              res.write templ.render(env)
-            end
-            resp.finish
-          # rescue StandardError => e
-          #   env["rack.errors"].puts "#{e.message}\n #{e.backtrace.join("\n")}\n\n"
-          #   resp = ::Rack::Response.new do |res|
-          #     res.status = 500
-          #     res.write "An error occurred"
-          #   end
-          #   resp.finish
-          # end
+          build_response(template_path, env).finish
         else
           env["rack.errors"].puts "Invoking file handler for #{url.inspect}"
           @file_server.call(env)
         end
-      end    
+      end
+
+      protected
+
+      def build_response(template_path, env)
+        templ = ::Roger::Template.open(
+          template_path,
+          partials_path: @project.partials_path,
+          layouts_path: @project.layouts_path
+        )
+        mime = ::Rack::Mime.mime_type(File.extname(template_path), "text/html")
+        ::Rack::Response.new do |res|
+          res.headers["Content-Type"] = mime if mime
+          res.status = 200
+          res.write templ.render(env)
+        end
+      end
     end
   end
-end
+end

data/lib/roger/rack/sleep.rb

@@ -1,12 +1,12 @@
 module Roger
   module Rack
-    # Listens to the "sleep" parameter and sleeps the amount of seconds specified by the parameter. There is however a maximum of 5 seconds.
+    # Listens to the "sleep" parameter and sleeps the amount of seconds specified by the parameter.
+    # There is however a maximum of 5 seconds.
     class Sleep
-  
       def initialize(app)
         @app = app
       end
-  
+
       def call(env)
         r = ::Rack::Request.new(env)
         if r.params["sleep"]
@@ -15,7 +15,6 @@ module Roger
         end
         @app.call(env)
       end
-  
     end
   end
-end
+end

data/lib/roger/release.rb

@@ -5,6 +5,7 @@ require File.dirname(__FILE__) + "/helpers/logging"
 require "shellwords"
 
 module Roger
+  # The release runner
   class Release
     include Roger::Helpers::Logging
 
@@ -15,32 +16,34 @@ module Roger
     class << self
      include Roger::Helpers::GetCallable
 
-      def default_stack
-        []
-      end
-
-      def default_finalizers
-        [[self.get_callable(:dir, Roger::Release::Finalizers.map), {}]]
-      end
+     def default_stack
+       []
+     end
 
+     def default_finalizers
+       [[get_callable(:dir, Roger::Release::Finalizers.map), {}]]
+     end
     end
 
     # @option config [Symbol] :scm The SCM to use (default = :git)
     # @option config [String, Pathname] :target_path The path/directory to put the release into
     # @option config [String, Pathname]:build_path Temporary path used to build the release
-    # @option config [Boolean] :cleanup_build Wether or not to remove the build_path after we're done (default = true)
-    # @option config [Array,String, nil] :cp CP command to use; Array will be escaped with Shellwords. Pass nil to get native Ruby CP. (default = ["cp", "-RL"])
-    # @option config [Boolean] :blank Keeps the release clean, don't automatically add any processors or finalizers (default = false)
+    # @option config [Boolean] :cleanup_build Wether or not to remove the build_path after we're
+    #   done (default = true)
+    # @option config [Array,String, nil] :cp CP command to use; Array will be escaped with
+    #   Shellwords. Pass nil to get native Ruby CP. (default = ["cp", "-RL"])
+    # @option config [Boolean] :blank Keeps the release clean, don't automatically add any
+    #   processors or finalizers (default = false)
     def initialize(project, config = {})
       real_project_path = project.path.realpath
       defaults = {
-        :scm => :git,
-        :source_path  => real_project_path + "html",
-        :target_path => real_project_path + "releases",
-        :build_path => real_project_path + "build",
-        :cp => ["cp", "-RL"],
-        :blank => false,
-        :cleanup_build => true
+        scm: :git,
+        source_path: real_project_path + "html",
+        target_path: real_project_path + "releases",
+        build_path: real_project_path + "build",
+        cp: ["cp", "-RL"],
+        blank: false,
+        cleanup_build: true
       }
 
       @config = {}.update(defaults).update(config)
@@ -55,7 +58,7 @@ module Roger
     #
     # @return Pathname the target_path
     def target_path
-      Pathname.new(self.config[:target_path])
+      Pathname.new(config[:target_path])
     end
 
     # Accessor for build_path
@@ -63,7 +66,7 @@ module Roger
     #
     # @return Pathname the build_path
     def build_path
-      Pathname.new(self.config[:build_path])
+      Pathname.new(config[:build_path])
     end
 
     # Accessor for source_path
@@ -71,26 +74,28 @@ module Roger
     #
     # @return Pathanem the source_path
     def source_path
-      Pathname.new(self.config[:source_path])
+      Pathname.new(config[:source_path])
     end
 
     # Get the current SCM object
     def scm(force = false)
       return @_scm if @_scm && !force
 
-      case self.config[:scm]
+      case config[:scm]
       when :git
-        @_scm = Release::Scm::Git.new(:path => self.source_path)
+        @_scm = Release::Scm::Git.new(path: source_path)
       else
-        raise "Unknown SCM #{options[:scm].inspect}"
+        fail "Unknown SCM #{options[:scm].inspect}"
       end
     end
 
     # Inject variables into files with an optional filter
     #
     # @examples
-    #   release.inject({"VERSION" => release.version, "DATE" => release.date}, :into => %w{_doc/toc.html})
-    #   release.inject({"CHANGELOG" => {:file => "", :filter => BlueCloth}}, :into => %w{_doc/changelog.html})
+    #   release.inject({"VERSION" => release.version, "DATE" => release.date},
+    #     :into => %w{_doc/toc.html})
+    #   release.inject({"CHANGELOG" => {:file => "", :filter => BlueCloth}},
+    #     :into => %w{_doc/changelog.html})
     def inject(variables, options)
       @stack << Injector.new(variables, options)
     end
@@ -137,29 +142,21 @@ module Roger
     # =======================
     #
     #
-    # @option options [:css,:js,:html,false] :comment Wether or not to comment the output and in what style. (default=js)
-    def banner(options = {}, &block)
+    # @option options [:css,:js,:html,false] :comment Wether or not to comment the output and in
+    #   what style. (default=js)
+    def banner(options = {}, &_block)
       options = {
-        :comment => :js
+        comment: :js
       }.update(options)
 
       if block_given?
         @_banner = yield.to_s
       elsif !@_banner
-        banner = []
-        banner << "Version : #{self.scm.version}"
-        banner << "Date  : #{self.scm.date.strftime("%Y-%m-%d")}"
-
-        size = banner.inject(0){|mem,b| b.size > mem ? b.size : mem }
-        banner.map!{|b| "= #{b.ljust(size)} =" }
-        div = "=" * banner.first.size
-        banner.unshift(div)
-        banner << div
-        @_banner = banner.join("\n")
+        @_banner = default_banner.join("\n")
       end
 
       if options[:comment]
-        self.comment(@_banner, :style => options[:comment])
+        comment(@_banner, style: options[:comment])
       else
         @_banner
       end
@@ -172,7 +169,8 @@ module Roger
     #
     # @deprecated Don't use the extractor anymore, use release.use(:mockup, options) processor
     def extract(options = {})
-      self.warn(self, "Don't use the extractor anymore, use release.use(:mockup, options) and release.use(:url_relativizer, options) processors")
+      warn(self, "Don't use the extractor anymore, use release.use(:mockup, options)
+        and release.use(:url_relativizer, options) processors")
       @extractor_options = options
     end
 
@@ -195,18 +193,17 @@ module Roger
       run_finalizers!
 
       # Cleanup
-      cleanup! if self.config[:cleanup_build]
+      cleanup! if config[:cleanup_build]
     ensure
       project.mode = nil
     end
 
-
     # @param [Array] globs an array of file path globs that will be globbed against the build_path
     # @param [Array] excludes an array of regexps that will be excluded from the result
     def get_files(globs, excludes = [])
-      files = globs.map{|g| Dir.glob(self.build_path + g) }.flatten
+      files = globs.map { |g| Dir.glob(build_path + g) }.flatten
       if excludes.any?
-        files.reject{|c| excludes.detect{|e| e.match(c) } }
+        files.reject { |c| excludes.detect { |e| e.match(c) } }
       else
         files
       end
@@ -214,6 +211,23 @@ module Roger
 
     protected
 
+    def default_banner
+      banner = [
+        "Version : #{scm.version}",
+        "Date  : #{scm.date.strftime('%Y-%m-%d')}"
+      ]
+
+      # Find longest line
+      size = banner.map(&:size).max
+
+      # Pad all lines
+      banner.map! { |b| "= #{b.ljust(size)} =" }
+
+      div = "=" * banner.first.size
+      banner.unshift(div)
+      banner << div
+    end
+
     # ==============
     # = The runway =
     # ==============
@@ -221,14 +235,14 @@ module Roger
     # Checks if build path exists (and cleans it up)
     # Checks if target path exists (if not, creates it)
     def validate_paths!
-      if self.build_path.exist?
-        log self, "Cleaning up previous build \"#{self.build_path}\""
-        rm_rf(self.build_path)
+      if build_path.exist?
+        log self, "Cleaning up previous build \"#{build_path}\""
+        rm_rf(build_path)
       end
 
-      if !self.target_path.exist?
-        log self, "Creating target path \"#{self.target_path}\""
-        mkdir self.target_path
+      unless target_path.exist? # rubocop:disable Style/GuardClause
+        log self, "Creating target path \"#{target_path}\""
+        mkdir target_path
       end
     end
 
@@ -240,39 +254,48 @@ module Roger
 
       mockup_options = {}
       relativizer_options = {}
-      run_relativizer = true
+
       if @extractor_options
-        mockup_options = {:env => @extractor_options[:env]}
-        relativizer_options = {:url_attributes => @extractor_options[:url_attributes]}
-        run_relativizer = @extractor_options[:url_relativize]
+        mockup_options = { env: @extractor_options[:env] }
+        relativizer_options = { url_attributes: @extractor_options[:url_attributes] }
       end
 
-      unless @stack.find{|(processor, options)| processor.class == Roger::Release::Processors::Mockup }
+      unless find_in_stack(Roger::Release::Processors::Mockup)
         @stack.unshift([Roger::Release::Processors::Mockup.new, mockup_options])
       end
 
-      unless @stack.find{|(processor, options)| processor.class == Roger::Release::Processors::UrlRelativizer }
+      # rubocop:disable Style/GuardClause
+      unless find_in_stack(Roger::Release::Processors::UrlRelativizer)
         @stack.push([Roger::Release::Processors::UrlRelativizer.new, relativizer_options])
       end
     end
 
+    # Find a processor in the stack
+    def find_in_stack(klass)
+      @stack.find { |(processor, _options)| processor.class == klass }
+    end
+
     def copy_source_path_to_build_path!
-      mkdir(self.build_path)
+      mkdir(build_path)
 
-      if self.config[:cp]
-        command = [self.config[:cp]].flatten
-        system(Shellwords.join(command + ["#{self.source_path}/", self.build_path.to_s]))
+      if config[:cp]
+        copy_source_path_to_build_path_using_system
       else
-        cp_r(self.source_path.children, self.build_path)
+        cp_r(source_path.children, build_path)
       end
     end
 
+    def copy_source_path_to_build_path_using_system
+      command = [config[:cp]].flatten
+      system(Shellwords.join(command + ["#{source_path}/", build_path.to_s]))
+    end
+
     def run_stack!
       @stack = self.class.default_stack.dup if @stack.empty?
 
       # call all objects in @stack
       @stack.each do |task|
-        if (task.kind_of?(Array))
+        if task.is_a?(Array)
           task[0].call(self, task[1])
         else
           task.call(self)
@@ -291,35 +314,35 @@ module Roger
       @finalizers.each do |finalizer|
         finalizer[0].call(self, finalizer[1])
       end
-
     end
 
     def cleanup!
-      log(self, "Cleaning up build path #{self.build_path}")
-      rm_rf(self.build_path)
+      log(self, "Cleaning up build path #{build_path}")
+      rm_rf(build_path)
     end
 
     # @param [String] string The string to comment
     #
-    # @option options [:html, :css, :js] :style The comment style to use (default=:js, which is the same as :css)
+    # @option options [:html, :css, :js] :style The comment style to use
+    #   (default=:js, which is the same as :css)
     # @option options [Boolean] :per_line Comment per line or make one block? (default=true)
     def comment(string, options = {})
       options = {
-        :style => :css,
-        :per_line => true
+        style: :css,
+        per_line: true
       }.update(options)
 
       commenters = {
-        :html => Proc.new{|s| "<!-- #{s} -->" },
-        :css => Proc.new{|s| "/*! #{s} */" },
-        :js => Proc.new{|s| "/*! #{s} */" }
+        html: proc { |s| "<!-- #{s} -->" },
+        css: proc { |s| "/*! #{s} */" },
+        js: proc { |s| "/*! #{s} */" }
       }
 
       commenter = commenters[options[:style]] || commenters[:js]
 
       if options[:per_line]
         string = string.split(/\r?\n/)
-        string.map{|s| commenter.call(s) }.join("\n")
+        string.map { |s| commenter.call(s) }.join("\n")
       else
         commenter.call(s)
       end