roger 1.1.3 → 1.2.1

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

@@ -1,44 +1,47 @@
 module Roger::Release::Finalizers
-  
+  # The zip finalizer
+  # The zip finalizer will
   class Zip < Base
-    
     attr_reader :release
-    
+
     # @option options :prefix Prefix to put before the version (default = "html")
     # @option options :zip The zip command
     def call(release, options = {})
-      if options
-        options = @options.dup.update(options)
-      else
-        options = @options
-      end
-      
       options = {
-        :zip => "zip",
-        :prefix => "html"
-      }.update(options)
+        zip: "zip",
+        prefix: "html"
+      }.update(@options)
+
+      options.update(options) if options
 
       name = [options[:prefix], release.scm.version].join("-") + ".zip"
-      release.log(self, "Finalizing release to #{release.target_path + name}")
-      
-      if File.exist?(release.target_path + name)
-        release.log(self, "Removing existing target #{release.target_path + name}")
-        FileUtils.rm_rf(release.target_path + name)
-      end
-      
-      begin
-        `#{options[:zip]} -v`
-      rescue Errno::ENOENT
-        raise RuntimeError, "Could not find zip in #{options[:zip].inspect}"
-      end
+      zip_path = release.target_path + name
+
+      release.log(self, "Finalizing release to #{zip_path}")
+
+      cleanup_existing_zip(zip_path)
+
+      check_zip_command(options[:zip])
 
       ::Dir.chdir(release.build_path) do
-        `#{options[:zip]} -r -9 "#{release.target_path + name}" ./*`
+        `#{options[:zip]} -r -9 "#{zip_path}" ./*`
       end
     end
-    
- 
+
+    protected
+
+    def cleanup_existing_zip(path)
+      return unless File.exist?(path)
+
+      release.log(self, "Removing existing target #{path}")
+      FileUtils.rm_rf(path)
+    end
+
+    def check_zip_command(command)
+      `#{command} -v`
+    rescue Errno::ENOENT
+      raise "Could not find zip in #{command.inspect}"
+    end
   end
 end
-
-Roger::Release::Finalizers.register(:zip, Roger::Release::Finalizers::Zip)
+Roger::Release::Finalizers.register(:zip, Roger::Release::Finalizers::Zip)

data/lib/roger/release/injector.rb

@@ -1,49 +1,53 @@
-require 'tilt'
+require "tilt"
 module Roger
-  
+  # The Injector can inject variables and files into other files based on regexps.
+  #
   # Inject VERSION / DATE (i.e. in TOC)
   # r.inject({"VERSION" => release.version, "DATE" => release.date}, :into => %w{_doc/toc.html})
-  
+  #
   # Inject CHANGELOG
-  # r.inject({"CHANGELOG" => {:file => "", :filter => BlueCloth}}, :into => %w{_doc/changelog.html})  
-  
+  # r.inject({"CHANGELOG" => {file: "", filter: BlueCloth}}, :into => %w{_doc/changelog.html})
   class Release::Injector
-    
     # @example Simple variable injection (replaces [VARIABLE] into all .css files)
     #     {"[VARIABLE]" => "replacement"}, :into => %w{**/*.css}
     #
     # @example Regex variable injection (replaces all matches into test.js files)
-    #     {/\/\*\s*\[BANNER\]\s*\*\// => "replacement"}, :into => %w{javacripts/test.js}    
+    #     {/\/\*\s*\[BANNER\]\s*\*\// => "replacement"}, :into => %w{javacripts/test.js}
     #
-    # @example Simple variable injection with filtering (replaces [VARIABLE] with :content run through the markdown processor into all .html files)
-    #     {"[VARIABLE]" => {:content => "# header one", :processor => "md"}, :into => %w{**/*.html}
-    #    
-    # @example Full file injection (replaces all matches of [CHANGELOG] with the contents of "CHANGELOG.md" into _doc/changelog.html)
+    # @example Simple variable injection with filtering (replaces [VARIABLE] with :content
+    #   run through the markdown processor into all .html files)
     #
-    #     {"CHANGELOG" => {:file => "CHANGELOG.md"}}, :into => %w{_doc/changelog.html}
+    #     {"[VARIABLE]" => {content: "# header one", processor: "md"}, :into => %w{**/*.html}
     #
-    # @example Full file injection with filtering (replaces all matches of [CHANGELOG] with the contents of "CHANGELOG" which ran through Markdown compresser into _doc/changelog.html)
+    # @example Full file injection (replaces all matches of [CHANGELOG] with the contents
+    #   of "CHANGELOG.md" into _doc/changelog.html)
     #
-    #     {"CHANGELOG" => {:file => "CHANGELOG", :processor => "md"}}, :into => %w{_doc/changelog.html}
+    #     {"CHANGELOG" => {file: "CHANGELOG.md"}}, :into => %w{_doc/changelog.html}
     #
-    # Processors are based on Tilt (https://github.com/rtomayko/tilt). 
+    # @example Full file injection with filtering (replaces all matches of [CHANGELOG]
+    #   with the contents of "CHANGELOG" which ran through Markdown compresser
+    #   into _doc/changelog.html)
+    #
+    #     {"CHANGELOG" => {file: "CHANGELOG", processor: "md"}}, :into => %w{_doc/changelog.html}
+    #
+    # Processors are based on Tilt (https://github.com/rtomayko/tilt).
     # Currently supported/tested processors are:
     #
     # * 'md' for Markdown (bluecloth)
     #
     # Injection files are relative to the :source_path
-    # 
+    #
     # @param [Hash] variables Variables to inject. See example for more info
     # @option options [Array] :into An array of file globs relative to the build_path
-    def initialize(variables, options)      
+    def initialize(variables, options)
       @variables = variables
       @options = options
     end
-    
+
     def call(release, options = {})
       @options.update(options)
       files = release.get_files(@options[:into])
-      
+
       files.each do |f|
         c = File.read(f)
         injected_vars = []
@@ -52,12 +56,13 @@ module Roger
             injected_vars << variable
           end
         end
-        release.log(self, "Injected variables #{injected_vars.inspect} into #{f}") if injected_vars.size > 0
-        File.open(f,"w") { |fh| fh.write c }
+        if injected_vars.size > 0
+          release.log(self, "Injected variables #{injected_vars.inspect} into #{f}")
+        end
+        File.open(f, "w") { |fh| fh.write c }
       end
-      
     end
-    
+
     def get_content(injection, release)
       case injection
       when String
@@ -68,32 +73,33 @@ module Roger
         if injection.respond_to?(:to_s)
           injection.to_s
         else
-          raise ArgumentError, "Woah, what's this? #{injection.inspect}"
+          fail ArgumentError, "Woah, what's this? #{injection.inspect}"
         end
       end
     end
-    
+
     def get_complex_injection(injection, release)
-      
-      if injection[:file]
-        content = File.read(release.source_path + injection[:file])
-      else
-        content = injection[:content]
-      end
-      
-      raise ArgumentError, "No :content or :file specified" if !content
+      content = injection_content(injection, release)
+
+      fail ArgumentError, "No :content or :file specified" unless content
 
       if injection[:processor]
         if tmpl = Tilt[injection[:processor]]
-          (tmpl.new{ content }).render
+          (tmpl.new { content }).render
         else
-          raise ArgumentError, "Unknown processor #{injection[:processor]}"
+          fail ArgumentError, "Unknown processor #{injection[:processor]}"
         end
       else
         content
       end
-      
     end
-    
+
+    def injection_content(injection, release)
+      if injection[:file]
+        File.read(release.source_path + injection[:file])
+      else
+        injection[:content]
+      end
+    end
   end
 end

data/lib/roger/release/processors.rb

@@ -1,28 +1,30 @@
-module Roger::Release::Processors
-  class Base
-    
-    def initialize(options = {})
-      @options = {}
-      @options.update(options) if options
-    end
-  
-    
-    def call(release, options = {})
-      raise ArgumentError, "Implement in subclass"
-    end
-  end
+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 self.register(name, processor)
-    raise ArgumentError, "Another processor has already claimed the name #{name.inspect}" if self.map.has_key?(name)
-    raise ArgumentError, "Name must be a symbol" unless name.kind_of?(Symbol)
-    self.map[name] = processor
-  end
+        def call(_release, _options = {})
+          fail ArgumentError, "Implement in subclass"
+        end
+      end
 
-  def self.map
-    @_map ||= {}
-  end
+      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
 
+      def self.map
+        @_map ||= {}
+      end
+    end
+  end
 end
-
 require File.dirname(__FILE__) + "/processors/mockup"
 require File.dirname(__FILE__) + "/processors/url_relativizer"

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

@@ -1,95 +1,123 @@
 module Roger::Release::Processors
+  # The Mockup processor that will process all templates
   class Mockup < Base
-    
     attr_accessor :project
-    
-    def initialize(options={})
+
+    MIME_TYPES_TO_EXTENSION = {
+      "text/html" => "html",
+      "text/css"  => "css",
+      "application/javascript" => "js",
+      "text/xml" => "xml",
+      "application/xml" => "xml",
+      "text/csv" => "csv",
+      "application/json" => "json"
+    }
+
+    def initialize(options = {})
       @options = {
-        :env => {},
-        :match => ["**/*.{html,md,html.erb}"],
-        :skip => [/\Astylesheets/, /\Ajavascripts/]
+        env: {},
+        match: ["**/*.{html,md,html.erb}"],
+        skip: [/\Astylesheets/, /\Ajavascripts/]
       }
-      
-      @options.update(options) if options            
+
+      @options.update(options) if options
     end
 
-    def call(release, options={})
+    def call(release, options = {})
       self.project = release.project
-      
-      options = {}.update(@options).update(options)
-      
-      options[:env].update("MOCKUP_PROJECT" => project)
-      
-      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, "  Files   :", true)
-      
+
+      options = update_call_options(options)
+
+      log_call(options)
+
       release.get_files(options[:match], options[:skip]).each do |file_path|
         release.log(self, "    Extract: #{file_path}", true)
         self.run_on_file!(file_path, options[:env])
       end
     end
-    
-    
+
     def run_on_file!(file_path, env = {})
-      template = Roger::Template.open(file_path, :partials_path => self.project.partial_path, :layouts_path => self.project.layouts_path)
-      
+      template = Roger::Template.open(
+        file_path,
+        partials_path: project.partial_path,
+        layouts_path: project.layouts_path
+      )
+
       # Clean up source file
       FileUtils.rm(file_path)
-      
+
       # Write out new file
-      File.open(self.target_path(file_path, template),"w"){|f| f.write(template.render(env.dup)) }
+      File.open(target_path(file_path, template).to_s, "w") do |f|
+        f.write(template.render(env.dup))
+      end
     end
-    
+
     # Runs the extractor on a single file and return processed source.
     def extract_source_from_file(file_path, env = {})
-      Roger::Template.open(file_path, :partials_path => self.project.partial_path, :layouts_path => self.project.layouts_path).render(env.dup)
-    end    
-    
-    protected
-    
+      Roger::Template.open(
+        file_path,
+        partials_path: project.partial_path,
+        layouts_path: project.layouts_path
+      ).render(env.dup)
+    end
+
+    # Determines the output path for a mockup path with a certain template
+    #
+    # @return [Pathname]
     def target_path(path, template)
-      # 1. If we have a double extension we rip of the template it's own extension and be done with it
-      parts = File.basename(path.to_s).split(".")
-      dir = Pathname.new(File.dirname(path.to_s))
-      
-      # 2. Try to figure out the extension based on the template's mime-type
-      mime_types = {
-        "text/html" => "html",
-        "text/css"  => "css",
-        "application/javascript" => "js",
-        "text/xml" => "xml",
-        "application/xml" => "xml",
-        "text/csv" => "csv",
-        "application/json" => "json"
-      }
-      extension = mime_types[template.template.class.default_mime_type]
-      
+      parts, dir = split_path(path)
+
       # Always return .html directly as it will cause too much trouble otherwise
-      if parts.last == "html"
-        return path
-      end
-      
-      if parts.size > 2
-        # Strip extension
-        dir + parts[0..-2].join(".")
+      return Pathname.new(path) if parts.last == "html"
+
+      # Strip last extension if we have a double extension
+      return dir + parts[0..-2].join(".") if parts.size > 2
+
+      dir + extension_based_on_mime_type(parts, template.template.class.default_mime_type)
+    end
+
+    protected
+
+    def update_call_options(options)
+      {}.update(@options).update(options)
+      options[:env].update("roger.project" => project, "MOCKUP_PROJECT" => project)
+      options
+    end
+
+    def log_call(options)
+      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, "  Files   :", true)
+    end
+
+    # Split the path into two parts:
+    # 1. Filename, in an array, split by .
+    # 2. Pathname of directory
+    def split_path(path)
+      [
+        File.basename(path.to_s).split("."),
+        Pathname.new(File.dirname(path.to_s))
+      ]
+    end
+
+    def extension_based_on_mime_type(parts, mime_type)
+      # 2. Try to figure out the extension based on the template's mime-type
+      extension = MIME_TYPES_TO_EXTENSION[mime_type]
+
+      # No matching extension, let's return path
+      return parts.join(".") if extension.nil?
+
+      if parts.size > 1
+        # Strip extension and replace with extension
+        (parts[0..-2] << extension).join(".")
       else
-        return path if extension.nil?
-        
-        if parts.size > 1
-          # Strip extension and replace with extension
-          dir + (parts[0..-2] << extension).join(".")
-        else
-          # Let's just add the extension
-          dir + (parts << extension).join(".")
-        end
+        # Let's just add the extension
+        (parts << extension).join(".")
       end
-    end    
-    
+    end
   end
 end
-
-Roger::Release::Processors.register(:mockup, Roger::Release::Processors::Mockup)
+Roger::Release::Processors.register(:mockup, Roger::Release::Processors::Mockup)