rapper 0.0.1

data/lib/rapper/errors.rb

@@ -0,0 +1,23 @@
+module Rapper
+  # Common Rapper errors.
+  module Errors
+    
+    # Raised when an invalid environment param is used. An invalid environment
+    # is one not defined in the current rapper config.
+    class InvalidEnvironment < StandardError; end
+    
+    # Raised when no "definition_root" setting is given for the current
+    # environment.
+    class NoDefinitionRoot < StandardError; end
+    
+    # Raised when an invalid definition type param is used. An invalid
+    # definition type is one that doesn't have a definition YAML file in the
+    # "definition_root" folder (set in the config).
+    class InvalidDefinitionType < StandardError; end
+    
+    # Raised when an invalid asset name param is used. An invalid asset name
+    # is one not defined in a given definition file.
+    class InvalidAssetName < StandardError; end
+    
+  end
+end

data/lib/rapper/logging.rb

@@ -0,0 +1,35 @@
+module Rapper
+  # Basic logging support.
+  module Logging
+    
+    protected
+    
+    PATHY_STRING = /\.|\//
+    
+    # Outputs all arguments (joined with spaces) to:
+    #   * <code>stdout</code> if "log" is set to "stdout" in the environment
+    #     configuration.
+    #   * a text file if "log" appears to be a file path (i.e. has a slash or
+    #     period in it).
+    # 
+    # @param [Symbol] level Log level. :info or :verbose. :verbose level log
+    #   messages are only emitted if the "verbose_logging" setting is truthy.
+    # 
+    # @param [String] message Message to be logged.
+    def log( level, message )
+      return unless destination = get_config( "log" )
+      return if !get_config( "log_verbose" ) && level == :verbose
+      
+      case destination
+        when PATHY_STRING
+          open( destination, "a" ) do |file|
+            file.puts "#{message}\n"
+          end
+        when "stdout"
+          puts message
+      end
+      
+    end
+    
+  end
+end

data/lib/rapper/utils.rb

@@ -0,0 +1,106 @@
+module Rapper
+  # Rapper-wide utility methods for working with paths, files, etc.
+  module Utils
+    
+    protected
+    
+    # =========
+    # = Paths =
+    # =========
+    
+    # @param [String] type Asset type.
+    # 
+    # @return [String] Path to the definition file for the given asset type.
+    def definition_path( type )
+      File.join( env_config["definition_root"], "#{type}.yml")
+    end
+    
+    # @param [String] type Asset type.
+    # 
+    # @param [String] name Name of the asset.
+    # 
+    # @return [String] Path to the packaged asset file for the given type and
+    #   name.
+    def asset_path( type, name )
+      if @definitions[type].nil?
+        raise Rapper::Errors::InvalidDefinitionType,
+          "'#{type}' is not a defined asset type."
+      end
+      
+      file_name = "#{name}.#{@definitions[type]["suffix"]}"
+      
+      File.join( @definitions[type]["destination_root"], file_name )
+    end
+    
+    # @param [String] type Asset type.
+    # 
+    # @param [String] name Name of the asset.
+    # 
+    # @return [Array<String>] Ordered list of asset component file paths.
+    def asset_component_paths( type, name )
+      if @definitions[type].nil?
+        raise Rapper::Errors::InvalidDefinitionType,
+          "'#{type}' is not a defined asset type."
+      end
+      
+      spec = first_hash_with_key( name, @definitions[type]["assets"] )
+      
+      if spec.nil?
+        raise Rapper::Errors::InvalidAssetName,
+          "'#{name}' is not a valid #{type} asset. Make sure it is defined in the definition file."
+      end
+      
+      source_root = @definitions[type]["source_root"]
+      suffix = @definitions[type]["suffix"]
+      files = first_hash_with_key( "files", spec.values.first )["files"] || []
+      
+      files.map do |file|
+        file_name = "#{file}.#{suffix}"
+        File.join( source_root, file_name )
+      end
+    end
+    
+    # =========
+    # = Files =
+    # =========
+    
+    # @param [String] path Path to the desired file.
+    # 
+    # @return [File] Readable File instance.
+    def readable_file( path )
+      File.new( path, 'r' )
+    end
+    
+    # @param [String] path Path to the desired file.
+    # 
+    # @return [File] Writable file instance with 0644 permissions.
+    def writable_file( path )
+      File.new( path, 'w', 0644 )
+    end
+    
+    # Contatenate one or more files. Uses <code>cat</code>.
+    # 
+    # @param [Array<String>,String] source_files A  path or array of paths to
+    #   files to concatenate.
+    # 
+    # @param [String] destination_file Destination for concatenated output.
+    def join_files( source_files, destination_file )
+      source_files = Array( source_files ).uniq.join( " " )
+      system "cat #{source_files} > #{destination_file}"
+    end
+    
+    # =========
+    # = Misc. =
+    # =========
+    
+    # @param [Object] key Key to search for.
+    # 
+    # @param [Array<Hash>] array Array of Hash object to search in.
+    # 
+    # @return [Hash] First hash with the given key.
+    def first_hash_with_key( key, array )
+      array.find { |h| h.keys.include? key }
+    end
+    
+  end
+end

data/lib/rapper/versioning.rb

@@ -0,0 +1,37 @@
+require 'digest/md5'
+
+module Rapper
+  # Asset versioning methods.
+  module Versioning
+    
+    protected
+    
+    # Refresh the version hashes for the given asset types. If no arguments are
+    # passed, version hashes for all asset types will be updated.
+    # 
+    # @param [<String>] types Asset types to refresh versions for.
+    def refresh_versions( *types )
+      types = types.empty? ? asset_types : types
+      
+      log :info, "Refreshing versions for #{types.join( ', ' )}"
+      
+      types.each do |type|
+        @definitions[type]["assets"].each do |asset|
+          name = asset.keys.first
+          spec = asset.values.first
+          path = asset_path( type, name )
+          version = version( path )
+          first_hash_with_key( "version", spec )["version"] = version
+        end
+      end
+    end
+    
+    # @param [String] file_path The path to a file to generate a version for.
+    # 
+    # @return [String] A four-character MD5 hash of the contents of the file.
+    def version( file_path )
+      Digest::MD5.file( file_path ).to_s[0,4]
+    end
+    
+  end
+end

data/lib/yui/css_compressor.rb

@@ -0,0 +1,279 @@
+# Source: https://github.com/rhulse/ruby-css-toolkit
+# 
+# Only minor modifications to module structure, code style, and comments have
+# been made.
+# 
+# Original license:
+# =================
+# 
+# Ruby CSS Compressor Copyright License Agreement (BSD License)
+# 
+# Copyright (c) 2010, Richard Hulse
+# All rights reserved.
+# 
+# YUI CSS files in the test suite are Copyright (c) 2009, Yahoo! Inc. All rights reserved.
+# 
+# Redistribution and use of this software in source and binary forms,
+# with or without modification, are permitted provided that the following
+# conditions are met:
+# 
+# * Redistributions of source code must retain the above
+#   copyright notice, this list of conditions and the
+#   following disclaimer.
+# 
+# * Redistributions in binary form must reproduce the above
+#   copyright notice, this list of conditions and the
+#   following disclaimer in the documentation and/or other
+#   materials provided with the distribution.
+# 
+# * Neither the name of Yahoo! Inc. nor the names of its
+#   contributors may be used to endorse or promote products
+#   derived from this software without specific prior
+#   written permission of Yahoo! Inc.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+module YUI
+  # Methods for working with CSS.
+  class CSS
+    
+    class << self
+      
+      attr_reader :input_size, :output_size
+      
+      # Compress CSS using the Ruby port of the YUI Compressor (by
+      # <a href="https://github.com/rhulse">Richard Hulse</a>).
+      # 
+      # @param [String] css The CSS to be compressed.
+      # 
+      # @param [Integer] line_length (optional) Number of columns to wrap to.
+      #   Default is no wrapping.
+      # 
+      # @return [String] Compressed CSS.
+      def compress(css, line_length=0)
+        @preservedTokens = []
+        @comments = []
+        @output_size = 0
+        @input_size = css.length
+        
+        css = process_comments_and_strings(css)
+        
+        # Normalize all whitespace strings to single spaces. Easier to work with that way.
+        css.gsub!(/\s+/, ' ')
+        
+        # Remove the spaces before the things that should not have spaces before them.
+        # But, be careful not to turn "p :link {...}" into "p:link{...}"
+        # Swap out any pseudo-class colons with the token, and then swap back.
+        css.gsub!(/(?:^|\})[^\{:]+\s+:+[^\{]*\{/) do |match|
+          match.gsub(':', '___PSEUDOCLASSCOLON___')
+        end
+        css.gsub!(/\s+([!\{\};:>+\(\)\],])/, '\1')
+        css.gsub!(/([!\{\}:;>+\(\[,])\s+/, '\1')
+        css.gsub!('___PSEUDOCLASSCOLON___', ':')
+        
+        # special case for IE
+        css.gsub!(/:first-(line|letter)(\{|,)/, ':first-\1 \2')
+        
+        # no space after the end of a preserved comment
+        css.gsub!(/\*\/ /, '*/')
+        
+        # If there is a @charset, then only allow one, and push to the top of the file.
+        css.gsub!(/^(.*)(@charset "[^"]*";)/i, '\2\1')
+        css.gsub!(/^(\s*@charset [^;]+;\s*)+/i, '\1')
+        
+        # Put the space back in some cases, to support stuff like
+        # @media screen and (-webkit-min-device-pixel-ratio:0){
+        css.gsub!(/\band\(/i, "and (")
+        
+        # remove unnecessary semicolons
+        css.gsub!(/;+\}/, '}')
+        
+        # Replace 0(%, em, ex, px, in, cm, mm, pt, pc) with just 0.
+        css.gsub!(/([\s:])([+-]?0)(?:%|em|ex|px|in|cm|mm|pt|pc)/i, '\1\2')
+        
+        # Replace 0 0 0 0; with 0.
+        css.gsub!(/:(?:0 )+0(;|\})/, ':0\1')
+        
+        # Restore background-position:0 0; if required
+        css.gsub!(/background-position:0(;|\})/i, 'background-position:0 0\1')
+        
+        # Replace 0.6 with .6, but only when preceded by : or a space.
+        css.gsub!(/(:|\s)0+\.(\d+)/, '\1.\2')
+        
+        # Shorten colors from rgb(51,102,153) to #336699
+        # This makes it more likely that it'll get further compressed in the next step.
+        css.gsub!(/rgb\s*\(\s*([0-9,\s]+)\s*\)/) do |match|
+          '#' << $1.scan(/\d+/).map{|n| n.to_i.to_s(16).rjust(2, '0') }.join
+        end
+        
+        # Shorten colors from #AABBCC to #ABC. Note that we want to make sure
+        # the color is not preceded by either ", " or =. Indeed, the property
+        #     filter: chroma(color="#FFFFFF");
+        # would become
+        #     filter: chroma(color="#FFF");
+        # which makes the filter break in IE.
+        css.gsub!(/([^"'=\s])(\s?)\s*#([0-9a-f])\3([0-9a-f])\4([0-9a-f])\5/i, '\1\2#\3\4\5')
+        
+        # shorter opacity IE filter
+        css.gsub!(/progid:DXImageTransform\.Microsoft\.Alpha\(Opacity=/i, "alpha(opacity=")
+        
+        # Remove empty rules.
+        css.gsub!(/[^\};\{\/]+\{\}/, '')
+        
+        if (line_length > 0)
+          # Some source control tools don't like it when files containing lines longer
+          # than, say 8000 characters, are checked in. The linebreak option is used in
+          # that case to split long lines after a specific column.
+          startIndex = 0
+          index = 0
+          length = css.length
+          while (index < length)
+            index += 1
+            if (css[index - 1,1] === '}' && index - startIndex > line_length)
+              css = css.slice(0, index) + "\n" + css.slice(index, length)
+              startIndex = index
+            end
+          end
+        end
+        
+        # Replace multiple semi-colons in a row by a single one
+        # See SF bug #1980989
+        css.gsub!(/[;]+/, ';')
+        
+        #restore preserved comments and strings
+        css = restore_preserved_comments_and_strings(css)
+        
+        # top and tail whitespace
+        css.strip!
+        
+        @output_size = css.length
+        css
+      end
+      
+      private
+      
+      # Process comments (preserve special comments, nuke the rest) and strings
+      # (preserve them).
+      def process_comments_and_strings(css_text)
+        css = css_text.clone
+        
+        startIndex = 0
+        endIndex = 0
+        i = 0
+        max = 0
+        token = ''
+        totallen = css.length
+        placeholder = ''
+        
+        # collect all comment blocks
+        while (startIndex = css.index(/\/\*/, startIndex))
+          endIndex = css.index(/\*\//, startIndex + 2)
+          unless endIndex
+            endIndex = totallen
+          end
+          token = css.slice(startIndex+2..endIndex-1)
+          @comments.push(token)
+          css = css.slice(0..startIndex+1).to_s + "___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_" + (@comments.length - 1).to_s + "___" + css.slice(endIndex, totallen).to_s
+          startIndex += 2
+        end
+        
+        # preserve strings so their content doesn't get accidentally minified
+        css.gsub!(/("([^\\"]|\\.|\\)*")|('([^\\']|\\.|\\)*')/) do |match|
+          quote = match[0,1]
+          string = match.slice(1..-2)
+          
+          # maybe the string contains a comment-like substring?
+          # one, maybe more? put'em back then
+          if string =~ /___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_/
+            @comments.each_index do |index|
+              string.gsub!(/___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_#{index.to_s}___/, @comments[index])
+            end
+          end
+          
+          # minify alpha opacity in filter strings
+          string.gsub!(/progid:DXImageTransform\.Microsoft\.Alpha\(Opacity=/i, "alpha(opacity=")
+          @preservedTokens.push(string)
+          
+          quote + "___YUICSSMIN_PRESERVED_TOKEN_" + (@preservedTokens.length - 1).to_s + "___" + quote
+        end
+        
+        # used to jump one index in loop
+        ie5_hack = false
+        # strings are safe, now wrestle the comments
+        @comments.each_index do |index|
+          if ie5_hack
+            ie5_hack = false
+            next
+          end
+          
+          token = @comments[index]
+          placeholder = "___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_" + index.to_s + "___"
+          
+          # ! in the first position of the comment means preserve
+          # so push to the preserved tokens keeping the !
+          if (token[0,1] === "!")
+            @preservedTokens.push(token)
+            css.gsub!( /#{placeholder}/i,  "___YUICSSMIN_PRESERVED_TOKEN_" + (@preservedTokens.length - 1).to_s + "___")
+            next
+          end
+          
+          # \ in the last position looks like hack for Mac/IE5
+          # shorten that to /*\*/ and the next one to /**/
+          if (token[-1,1] === "\\")
+            @preservedTokens.push("\\")
+            css.gsub!( /#{placeholder}/,  "___YUICSSMIN_PRESERVED_TOKEN_" + (@preservedTokens.length - 1).to_s + "___")
+            # keep the next comment but remove its content
+            @preservedTokens.push("")
+            css.gsub!(/___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_#{index+1}___/,  "___YUICSSMIN_PRESERVED_TOKEN_" + (@preservedTokens.length - 1).to_s + "___")
+            ie5_hack = true
+            next
+          end
+          
+          # keep empty comments after child selectors (IE7 hack)
+          # e.g. html >/**/ body
+          if ((token.length === 0) && (startIndex = css.index( /#{placeholder}/)))
+            if (startIndex > 2)
+              if (css[startIndex - 3,1] === '>')
+                @preservedTokens.push("")
+                css.gsub!(/#{placeholder}/,  "___YUICSSMIN_PRESERVED_TOKEN_" + (@preservedTokens.length - 1).to_s + "___")
+              end
+            end
+          end
+          
+          # in all other cases kill the comment
+          css.gsub!( /\/\*#{placeholder}\*\//, "")
+        end
+        
+        css
+      end
+      
+      # Restore @preservedTokens back in to the css.
+      def restore_preserved_comments_and_strings(clean_css)
+        css = clean_css.clone
+        css_length = css.length
+        @preservedTokens.each_index do |index|
+          # slice these back into place rather than regex, because
+          # complex nested strings cause the replacement to fail
+          placeholder = "___YUICSSMIN_PRESERVED_TOKEN_#{index}___"
+          startIndex = css.index(placeholder, 0)
+          next unless startIndex # skip if nil
+          endIndex = startIndex + placeholder.length
+          
+          css = css.slice(0..startIndex-1).to_s + @preservedTokens[index] + css.slice(endIndex, css_length).to_s
+        end
+        
+        css
+      end
+    end
+ end
+
+end