roger 1.1.3 → 1.2.1

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

@@ -1,47 +1,74 @@
-require File.dirname(__FILE__) + '../../../resolver'
+require File.dirname(__FILE__) + "../../../resolver"
 
 module Roger::Release::Processors
+  # URL relativizer processor
+  # The relativizer can be used to rewrite absolute paths in attributes to relative paths
+  # during release.
   class UrlRelativizer < Base
-    
-    def initialize(options={})
+    def initialize(options = {})
       @options = {
-        :url_attributes => %w{src href action},
-        :match => ["**/*.html"],
-        :skip => []
+        url_attributes: %w(src href action),
+        match: ["**/*.html"],
+        skip: []
       }
-      
-      @options.update(options) if options            
+
+      @options.update(options) if options
     end
 
-    def call(release, options={})
+    def call(release, options = {})
       options = {}.update(@options).update(options)
-      
-      release.log(self, "Relativizing all URLS in #{options[:match].inspect} files in attributes #{options[:url_attributes].inspect}, skipping #{options[:skip].any? ? options[:skip].inspect : "none" }")
-      
+
+      log_call(options)
+
       @resolver = Roger::Resolver.new(release.build_path)
-     release.get_files(options[:match], options[:skip]).each do |file_path|
+
+      relativize_attributes_in_files(
+        options[:url_attributes],
+        release.get_files(options[:match], options[:skip])
+      )
+    end
+
+    protected
+
+    def log_call(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' }"
+      release.log(self, log_message)
+    end
+
+    def relativize_attributes_in_files(attributes, files)
+      files.each do |file_path|
         release.debug(self, "Relativizing URLS in #{file_path}") do
-          orig_source = File.read(file_path)
-          File.open(file_path,"w") do |f| 
-            doc = Hpricot(orig_source)
-            options[:url_attributes].each do |attribute|
-              (doc/"*[@#{attribute}]").each do |tag|
-                converted_url = @resolver.url_to_relative_url(tag[attribute], file_path)
-                release.debug(self, "Converting '#{tag[attribute]}' to '#{converted_url}'")
-                case converted_url
-                when String
-                  tag[attribute] = converted_url
-                when nil
-                  release.log(self, "Could not resolve link #{tag[attribute]} in #{file_path}")
-                end
-              end
-            end
-            f.write(doc.to_original_html) 
+          relativize_attributes_in_file(attributes, file_path)
+        end
+      end
+    end
+
+    def relativize_attributes_in_file(attributes, file_path)
+      orig_source = File.read(file_path)
+      File.open(file_path, "w") do |f|
+        f.write(relativize_attributes_in_source(attributes, orig_source, file_path))
+      end
+    end
+
+    def relativize_attributes_in_source(attributes, source, file_path)
+      doc = Hpricot(source)
+      attributes.each do |attribute|
+        (doc / "*[@#{attribute}]").each do |tag|
+          converted_url = @resolver.url_to_relative_url(tag[attribute], file_path)
+          release.debug(self, "Converting '#{tag[attribute]}' to '#{converted_url}'")
+          case converted_url
+          when String
+            tag[attribute] = converted_url
+          when nil
+            release.log(self, "Could not resolve link #{tag[attribute]} in #{file_path}")
           end
         end
       end
+      doc.to_original_html
     end
   end
 end
 
-Roger::Release::Processors.register(:url_relativizer, Roger::Release::Processors::UrlRelativizer)
+Roger::Release::Processors.register(:url_relativizer, Roger::Release::Processors::UrlRelativizer)

data/lib/roger/release/scm.rb

@@ -1,31 +1,34 @@
-module Roger::Release::Scm
-  class Base
-    
-    attr_reader :config
-    
-    def initialize(config={})
-      @config = config
-    end
-    
-    # Returns the release version string from the SCM
-    #
-    # @return String The current version string
-    def version
-      raise "Implement in subclass"
-    end
-    
-    # Returns the release version date from the SCM
-    def date
-      raise "Implement in subclass"      
-    end
-    
-    # Returns a Release::Scm object with the previous version's data
-    #
-    # @return Roger::Release::Scm The previous version
-    def previous
-      raise "Implement in subclass"      
+module Roger
+  class Release
+    module Scm
+      # Abstract SCM base class
+      class Base
+        attr_reader :config
+
+        def initialize(config = {})
+          @config = config
+        end
+
+        # Returns the release version string from the SCM
+        #
+        # @return String The current version string
+        def version
+          fail "Implement in subclass"
+        end
+
+        # Returns the release version date from the SCM
+        def date
+          fail "Implement in subclass"
+        end
+
+        # Returns a Release::Scm object with the previous version's data
+        #
+        # @return Roger::Release::Scm The previous version
+        def previous
+          fail "Implement in subclass"
+        end
+      end
     end
-    
   end
 end
 

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

@@ -1,106 +1,115 @@
-require 'pathname'
-
-module Roger::Release::Scm
-  class Git < Base
-    
-    # @option config [String] :ref Ref to use for current tag
-    # @option config [String, Pathname] :path Path to working dir
-    def initialize(config={})
-      super(config)
-      @config[:ref] ||= "HEAD"
-    end
-        
-    # Version is either:
-    # - the tagged version number (first "v" will be stripped) or
-    # - the return value of "git describe --tags HEAD"
-    # - the short SHA1 if there hasn't been a previous tag
-    def version
-      get_scm_data if @_version.nil?
-      @_version
-    end
-    
-    # Date will be Time.now if it can't be determined from GIT repository
-    def date
-      get_scm_data if @_date.nil?
-      @_date
-    end
-  
-    def previous
-      self.class.new(@config.dup.update(:ref => get_previous_tag_name))
-    end
-    
-    protected
-    
-    def get_previous_tag_name
-      # Get list of SHA1 that have a ref
-      begin
-        sha1s = `git --git-dir=#{safe_git_dir} log --pretty='%H' --simplify-by-decoration`.split("\n")
-        tags = []
-        while tags.size < 2 && sha1s.any?
-          sha1 = sha1s.shift
-          tag = `git --git-dir=#{safe_git_dir} describe --tags --exact-match #{sha1} 2>/dev/null`.strip
-          tags << tag if !tag.empty?
+require "pathname"
+
+module Roger
+  class Release
+    module Scm
+      # The GIT SCM implementation for Roger release
+      class Git < Base
+        # @option config [String] :ref Ref to use for current tag
+        # @option config [String, Pathname] :path Path to working dir
+        def initialize(config = {})
+          super(config)
+          @config[:ref] ||= "HEAD"
         end
-        tags.last
-      rescue
-        raise "Could not get previous tag"
-      end      
-    end
-    
-    def git_dir
-      @git_dir ||= find_git_dir(@config[:path])
-    end
 
-    # Safely escaped git dir
-    def safe_git_dir
-      Shellwords.escape(self.git_dir.to_s)
-    end
+        # Version is either:
+        # - the tagged version number (first "v" will be stripped) or
+        # - the return value of "git describe --tags HEAD"
+        # - the short SHA1 if there hasn't been a previous tag
+        def version
+          get_scm_data if @_version.nil?
+          @_version
+        end
+
+        # Date will be Time.now if it can't be determined from GIT repository
+        def date
+          get_scm_data if @_date.nil?
+          @_date
+        end
+
+        def previous
+          self.class.new(@config.dup.update(ref: get_previous_tag_name))
+        end
+
+        protected
+
+        def get_previous_tag_name
+          # Get list of SHA1 that have a ref
+          sha1s = `git --git-dir=#{safe_git_dir} log --pretty='%H' --simplify-by-decoration`
+          sha1s = sha1s.split("\n")
+          tags = []
+          while tags.size < 2 && sha1s.any?
+            sha1 = sha1s.shift
+            tag = `git --git-dir=#{safe_git_dir} describe --tags --exact-match #{sha1} 2>/dev/null`
+            tag = tag.strip
+            tags << tag unless tag.empty?
+          end
+          tags.last
+        rescue
+          raise "Could not get previous tag"
+        end
+
+        def git_dir
+          @git_dir ||= find_git_dir(@config[:path])
+        end
+
+        # Safely escaped git dir
+        def safe_git_dir
+          Shellwords.escape(git_dir.to_s)
+        end
+
+        # Preload version control data.
+        def get_scm_data(ref = @config[:ref])
+          @_version = scm_version(ref) || ""
+          @_date = scm_date(ref) || Time.now
+        end
+
+        # Some hackery to determine if ref is on a tagged version or not
+        # @return [String, nil] Will return version number if available, nil otherwise
+        def scm_version(ref)
+          return nil unless File.exist?(git_dir)
+
+          version = `git --git-dir=#{safe_git_dir} describe --tags #{ref} 2>&1`
 
-    # Some hackery to determine if we're on a tagged version or not
-    def get_scm_data(ref = @config[:ref])
-      @_version = ""
-      @_date = Time.now
-      begin
-        if File.exist?(git_dir)
-          @_version = `git --git-dir=#{safe_git_dir} describe --tags #{ref} 2>&1`
-          
-          if $?.to_i > 0
-            # HEAD is not a tagged verison, get the short SHA1 instead            
-            @_version = `git --git-dir=#{safe_git_dir} show #{ref} --format=format:"%h" -s 2>&1` 
+          if $CHILD_STATUS.to_i > 0
+            # HEAD is not a tagged version, get the short SHA1 instead
+            version = `git --git-dir=#{safe_git_dir} show #{ref} --format=format:"%h" -s 2>&1`
           else
             # HEAD is a tagged version, if version is prefixed with "v" it will be stripped off
-            @_version.gsub!(/^v/,"")
+            version.gsub!(/^v/, "")
           end
-          @_version.strip!
-    
+
+          version.strip!
+        rescue RuntimeError
+          nil
+        end
+
+        # Get date of ref from git
+        # @return [Time, nil] Returns time if available and parseable, nil otherwise
+        def scm_date(ref)
+          return nil unless File.exist?(git_dir)
+
           # Get the date in epoch time
           date = `git --git-dir=#{safe_git_dir} show #{ref} --format=format:"%ct" -s 2>&1`
-          if date =~ /\d+/
-            @_date = Time.at(date.to_i)
-          else
-            @_date = Time.now
-          end
-    
+          Time.at(date.to_i) if date =~ /\d+/
+        rescue RuntimeError
+          nil
         end
-      rescue RuntimeError => e
-      end
 
-    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 = path + ".git"
-      
-      raise "Could not find suitable .git dir in #{path}" if !path.directory?
+        # 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
+          path += ".git"
+
+          fail "Could not find suitable .git dir in #{path}" unless path.directory?
+
+          path
+        end
+      end
     end
-    
   end
 end
-

data/lib/roger/resolver.rb

@@ -1,92 +1,72 @@
 module Roger
+  # The resolver is here to resolve urls to paths and sometimes vice-versa
   class Resolver
-
     attr_reader :load_paths
-    
+
     def initialize(paths)
-      raise ArgumentError, "Resolver base path can't be nil" if paths.nil?
+      fail ArgumentError, "Resolver base path can't be nil" if paths.nil?
 
       # Convert to paths
-      @load_paths = [paths].flatten.map{|p| Pathname.new(p) }
+      @load_paths = [paths].flatten.map { |p| Pathname.new(p) }
     end
-    
+
     # @param [String] url The url to resolve to a path
     # @param [Hash] options Options
     #
-    # @option options [true,false] :exact_match Wether or not to match exact paths, this is mainly used in the path_to_url method to match .js, .css, etc files.
-    # @option options [String] :preferred_extension The part to chop off and re-add to search for more complex double-extensions. (Makes it possible to have context aware partials)
+    # @option options [true,false] :exact_match Wether or not to match exact paths,
+    #   this is mainly used in the path_to_url method to match .js, .css, etc files.
+    # @option options [String] :preferred_extension The part to chop off
+    #   and re-add to search for more complex double-extensions. (Makes it possible to have context
+    #   aware partials)
     def find_template(url, options = {})
-      orig_path, qs, anch = strip_query_string_and_anchor(url.to_s)
-
       options = {
-        :exact_match => false,
-        :preferred_extension => "html"  
+        exact_match: false,
+        preferred_extension: "html"
       }.update(options)
 
-      paths = self.load_paths.map{|base| File.join(base, orig_path) }
-  
-      paths.find do |path|
-        if options[:exact_match] && File.exist?(path)
-          return Pathname.new(path)
-        end      
-        
-        # It's a directory, add "/index"
-        if File.directory?(path)
-          path = File.join(path, "index")
-        end
-        
-        # 2. If it's preferred_extension, we strip of the extension
-        if path =~ /\.#{options[:preferred_extension]}\Z/
-          path.sub!(/\.#{options[:preferred_extension]}\Z/, "")
-        end
-        
-        extensions = Tilt.default_mapping.template_map.keys + Tilt.default_mapping.lazy_map.keys
+      orig_path, _qs, _anch = strip_query_string_and_anchor(url.to_s)
 
-        # We have to re-add preferred_extension again as we have stripped it in in step 2!
-        extensions += extensions.map{|ext| "#{options[:preferred_extension]}.#{ext}"}
+      output = nil
 
-        if found_extension = extensions.find { |ext| File.exist?(path + "." + ext) }
-          return Pathname.new(path + "." + found_extension)
-        end
+      load_paths.find do |load_path|
+        path = File.join(load_path, orig_path)
 
-        false #Next iteration
+        # If it's an exact match we're done
+        if options[:exact_match] && File.exist?(path)
+          output = Pathname.new(path)
+        else
+          output = find_file_with_extension(path, options[:preferred_extension])
+        end
       end
+
+      output
     end
-    alias :url_to_path :find_template
-    
-    
+    alias_method :url_to_path, :find_template
+
     # Convert a disk path on file to an url
     def path_to_url(path, relative_to = nil)
-
       # Find the parent path we're in
       path = Pathname.new(path).realpath
-      base = self.load_paths.find{|lp| path.to_s =~ /\A#{Regexp.escape(lp.realpath.to_s)}/ }
+      base = load_paths.find { |lp| path.to_s =~ /\A#{Regexp.escape(lp.realpath.to_s)}/ }
 
       path = path.relative_path_from(base).cleanpath
-      
+
       if relative_to
-        if relative_to.to_s =~ /\A\//
-          relative_to = Pathname.new(File.dirname(relative_to.to_s)).relative_path_from(base).cleanpath
-        else
-          relative_to = Pathname.new(File.dirname(relative_to.to_s))
-        end
-        path = Pathname.new("/" + path.to_s).relative_path_from(Pathname.new("/" + relative_to.to_s))
-        path.to_s
+        relative_path_to_url(path, relative_to, base).to_s
       else
-        "/" + path.to_s
+        "/#{path}"
       end
-      
     end
-    
+
     def url_to_relative_url(url, relative_to_path)
       # Skip if the url doesn't start with a / (but not with //)
-      return false unless url =~ /\A\/[^\/]/
-      
+      return false unless url =~ %r{\A/[^/]}
+
       path, qs, anch = strip_query_string_and_anchor(url)
 
       # Get disk path
-      if true_path =  self.url_to_path(path, :exact_match => true)
-        path = self.path_to_url(true_path, relative_to_path)
+      if true_path =  url_to_path(path, exact_match: true)
+        path = path_to_url(true_path, relative_to_path)
         path += qs if qs
         path += anch if anch
         path
@@ -94,26 +74,71 @@ module Roger
         false
       end
     end
-    
+
     def strip_query_string_and_anchor(url)
       url = url.dup
-      
+
       # Strip off anchors
       anchor = nil
       url.gsub!(/(#.+)\Z/) do |r|
         anchor = r
         ""
       end
-              
+
       # Strip off query strings
       query = nil
       url.gsub!(/(\?.+)\Z/) do |r|
         query = r
         ""
       end
-      
+
       [url, query, anchor]
-    end  
-    
+    end
+
+    protected
+
+    # Tries all extensions on path to see what file exists
+    # @return [Pathname,nil] returns a pathname of the full file path if found. nil otherwise
+    def find_file_with_extension(path, preferred_extension)
+      output = nil
+
+      file_path = path
+
+      # If it's a directory, add "/index"
+      file_path = File.join(file_path, "index") if File.directory?(file_path)
+
+      # Strip of extension
+      if path =~ /\.#{preferred_extension}\Z/
+        file_path.sub!(/\.#{preferred_extension}\Z/, "")
+      end
+
+      possible_extensions(preferred_extension).find do |ext|
+        path_with_extension = file_path + "." + ext
+        if File.exist?(path_with_extension)
+          output = Pathname.new(path_with_extension)
+        end
+      end
+      output
+    end
+
+    # Makes a list of all Tilt extensions
+    # Also adds a list of double extensions. Example:
+    # tilt_extensions = %w(erb md); second_extension = "html"
+    # return %w(erb md html.erb html.md)
+    def possible_extensions(second_extension)
+      extensions = Tilt.default_mapping.template_map.keys + Tilt.default_mapping.lazy_map.keys
+      extensions + extensions.map { |ext| "#{second_extension}.#{ext}" }
+    end
+
+    def relative_path_to_url(path, relative_to, base)
+      relative_to = Pathname.new(File.dirname(relative_to.to_s))
+
+      # If relative_to is an absolute path
+      if relative_to.to_s =~ %r{\A/}
+        relative_to = relative_to.relative_path_from(base).cleanpath
+      end
+
+      Pathname.new("/" + path.to_s).relative_path_from(Pathname.new("/" + relative_to.to_s))
+    end
   end
 end