sundawg-sinatra-assetpack-fork 0.0.12.pre1

data/lib/sinatra/assetpack/engines/yui.rb

@@ -0,0 +1,22 @@
+module Sinatra::AssetPack
+  class YuiEngine < Engine
+    def initialize
+      require 'yui/compressor'
+    end
+
+    def js(str, options={})
+      YUI::JavaScriptCompressor.new(options).compress(str)
+    rescue LoadError
+      nil
+    end
+
+    def css(str, options={})
+      YUI::CssCompressor.new.compress(str)
+    rescue Errno::ENOENT
+      nil
+    end
+  end
+
+  Compressor.register :js,  :yui, YuiEngine
+  Compressor.register :css, :yui, YuiEngine
+end

data/lib/sinatra/assetpack/hasharray.rb

@@ -0,0 +1,66 @@
+module Sinatra
+  module AssetPack
+    # Class: HashArray
+    # A stopgap solution to Ruby 1.8's lack of ordered hashes.
+    #
+    # A HashArray, for all intents and purposes, acts like an array. However, the
+    # common stuff are overloaded to work with hashes.
+    #
+    # ## Basic usage
+    #
+    # #### Creating
+    # You can create a HashArray by passing it an array.
+    #
+    #     dict = HashArray.new([
+    #       { :good_morning => "Bonjour" },
+    #       { :goodbye      => "Au revoir" },
+    #       { :good_evening => "Bon nuit" }
+    #     ])
+    #
+    # #### Converting
+    # You may also use it like so:
+    #
+    #     letters = [ { :a => "Aye"}, { :b => "Bee" } ].to_hash_array
+    #
+    # #### Iterating
+    # Now you can use the typical enumerator functions:
+    #
+    #     dict.each do |(key, value)|
+    #       puts "#{key} is #{value}"
+    #     end
+    #
+    #     #=> :good_morning is "Bonjour"
+    #     #   :goodbye is "Au revoir"
+    #     #   :good_evening is "Bon nuit"
+    #
+    class HashArray < Array
+      def self.[](*arr)
+        new arr.each_slice(2).map { |(k, v)| Hash[k, v] }
+      end
+
+      # Works like Hash#values.
+      def values
+        inject([]) { |a, (k, v)| a << v; a }
+      end
+
+      # Returns everything as a hash.
+      def to_hash
+        inject({}) { |hash, (k, v)| hash[k] = v; hash }
+      end
+
+      def keys
+        inject([]) { |a, (k, v)| a << k; a }
+      end
+
+      [:each, :map, :map!, :reject, :reject!, :select, :select!].each do |meth|
+        send(:define_method, meth) { |*a, &block|
+          if block.respond_to?(:call)
+            super(*a) { |hash| block.call *hash.to_a }
+          else
+            super(*a)
+          end
+        }
+      end
+    end
+  end
+end

data/lib/sinatra/assetpack/helpers.rb

@@ -0,0 +1,62 @@
+module Sinatra
+  module AssetPack
+    module Helpers
+      def css(*args)
+        show_asset_pack :css, *args
+      end
+
+      def js(*args)
+        show_asset_pack :js, *args
+      end
+
+      def img(src, options={})
+        attrs = { :src => src }.merge(options)
+
+        local = settings.assets.local_file_for src
+        if local
+          i = Image[local]
+          attrs[:src] = BusterHelpers.add_cache_buster(src, local)
+          if i.dimensions?
+            attrs[:width]  ||= i.width
+            attrs[:height] ||= i.height
+          end
+        end
+
+        "<img#{HtmlHelpers.kv attrs} />"
+      end
+
+      def show_asset_pack(type, *args)
+        names = Array.new
+        while args.first.is_a?(Symbol)
+          names << args.shift
+        end
+
+        options = args.shift  if args.first.is_a?(Hash)
+
+        names.map { |name|
+          show_one_asset_pack type, name, (options || Hash.new)
+        }.join "\n"
+      end
+
+      def show_one_asset_pack(type, name, options={})
+        pack = settings.assets.packages["#{name}.#{type}"]
+        return ""  unless pack
+
+        # force production packageing for override, stage, or production
+        if ENV['ASSETPACK_FORCE_PRODUCTION'] || settings.stage? || settings.production?
+          pack.to_production_html options
+        else
+          pack.to_development_html options
+        end
+      end
+
+      def asset_filter_css(str)
+        Css.preproc str, settings.assets
+      end
+
+      def asset_path_for(file, from)
+        settings.assets.dyn_local_file_for file, from
+      end
+    end
+  end
+end

data/lib/sinatra/assetpack/html_helpers.rb

@@ -0,0 +1,17 @@
+module Sinatra
+  module AssetPack
+    module HtmlHelpers
+      extend self
+
+      def e(str)
+        re = Rack::Utils.escape_html str
+        re = re.gsub("/", '/')  # Rack sometimes insists on munging slashes in Ruby 1.8.
+        re
+      end
+
+      def kv(hash)
+        hash.map { |k, v| " #{e k}='#{e v}'" }.join('')
+      end
+    end
+  end
+end

data/lib/sinatra/assetpack/image.rb

@@ -0,0 +1,59 @@
+module Sinatra
+  module AssetPack
+    # An image.
+    #
+    # == Common usage
+    #
+    #     i = Image['/app/images/background.png']    # Local file path
+    #
+    #     i.dimensions     # Tuple for [ width, height ]
+    #     i.width
+    #     i.height
+    #
+    #     i.dimensions?    # True if dimensions are available
+    #                      # (e.g., if ImageMagick is installed and working)
+    #
+    class Image
+      # Looks up an image.
+      # This makes each image only have one associated instance forever.
+      def self.[](fname)
+        fname = File.expand_path(fname) || fname
+
+        @cache        ||= Hash.new
+        @cache[fname] ||= new fname
+      end
+
+      def initialize(file)
+        @file = file
+      end
+
+      def dimensions
+        return @dimensions  unless @dimensions.nil?
+
+         _, _, dim = `identify "#{@file}"`.split(' ')
+         w, h = dim.split('x')
+
+         if w.to_i != 0 && h.to_i != 0
+           @dimensions = [w.to_i, h.to_i]
+         else
+           @dimensions = false
+         end
+
+      rescue => e
+        @dimensions = false
+      end
+
+      def dimensions?
+        !! dimensions
+      end
+
+      def width
+        dimensions? && dimensions[0]
+      end
+
+      def height
+        dimensions? && dimensions[1]
+      end
+    end
+  end
+end

data/lib/sinatra/assetpack/options.rb

@@ -0,0 +1,329 @@
+module Sinatra
+  module AssetPack
+    # Assets.
+    #
+    # == Common usage
+    #
+    #     SinatraApp.assets {
+    #       # dsl stuff here
+    #     }
+    #
+    #     a = SinatraApp.assets
+    #
+    # Getting options:
+    #
+    #     a.js_compression
+    #     a.output_path
+    #
+    # Served:
+    #
+    #     a.served         # { '/js' => '/var/www/project/app/js', ... }
+    #                      # (URL path => local path)
+    #
+    # Packages:
+    #
+    #     a.packages       # { 'app.css' => #<Package>, ... }
+    #                      # (name.type => package instance)
+    #
+    # Build:
+    #
+    #     a.build! { |path| puts "Building #{path}" }
+    #
+    # Lookup:
+    #
+    #     a.local_path_for('/images/bg.gif')
+    #     a.served?('/images/bg.gif')
+    #
+    #     a.glob(['/js/*.js', '/js/vendor/**/*.js'])
+    #     # Returns a HashArray of (local => remote)
+    #
+    class Options
+      include Configurator
+
+      def initialize(app, &blk)
+        unless app.root?
+          raise Error, "Please set :root in your Sinatra app."
+        end
+
+        @app             = app
+        @js_compression  = :jsmin
+        @css_compression = :simple
+
+        begin
+          @output_path   = app.public
+        rescue NoMethodError
+          @output_path   = app.public_folder
+        end
+
+        @js_compression_options  = Hash.new
+        @css_compression_options = Hash.new
+
+        @ignored = Array.new
+
+        reset!
+
+        # Defaults!
+        serve '/css',    :from => 'app/css'
+        serve '/js',     :from => 'app/js'
+        serve '/images', :from => 'app/images'
+
+        ignore '.*'
+        ignore '_*'
+
+        blk.arity <= 0 ? instance_eval(&blk) : yield(self)  if block_given?
+      end
+
+      # =====================================================================
+      # DSL methods
+
+      def serve(path, options={})
+        raise Error  unless options[:from]
+        return  unless File.directory?(File.join(app.root, options[:from]))
+
+        @served[path] = options[:from]
+      end
+
+      # Undo defaults.
+      def reset!
+        @served   = Hash.new
+        @packages = Hash.new
+      end
+
+      # Ignores a given path spec.
+      def ignore(spec)
+        if spec[0] == '/'
+          @ignored << "#{spec}"
+          @ignored << "#{spec}/**"
+        else
+          @ignored << "**/#{spec}"
+          @ignored << "**/#{spec}/**"
+        end
+      end
+
+      # Makes nothing ignored. Use this if you don't want to ignore dotfiles and underscore files.
+      def clear_ignores!
+        @ignored  = Array.new
+      end
+
+      # Checks if a given path is ignored.
+      def ignored?(fn)
+        @ignored.any? { |spec| File.fnmatch spec, fn }
+      end
+
+      # Adds some JS packages.
+      #
+      #     js :foo, [ '/js/vendor/jquery.*.js', ... ]
+      #     js :foo, '/js/foo.js', [ '/js/vendor/jquery.*.js', ... ]
+      #
+      def js(name, *args)
+        js_or_css :js, name, *args
+      end
+
+      # Adds some CSS packages.
+      #
+      #     css :app, [ '/css/screen.css', ... ]
+      #     css :app, '/css/app.css', [ '/css/screen.css', ... ]
+      #
+      def css(name, *args) #path, files=[])
+        js_or_css :css, name, *args
+      end
+
+      def js_or_css(type, name, *args)
+        # Account for "css :name, '/path/to/css', [ files ]"
+        if args[0].is_a?(String) && args[1].respond_to?(:each)
+          path, files = args
+
+        # Account for "css :name, [ files ]"
+        elsif args[0].respond_to?(:each)
+          path  = "/assets/#{name}.#{type}" # /assets/foobar.css by default
+          files = args[0]
+
+        else
+          raise ArgumentError
+        end
+
+        @packages["#{name}.#{type}"] = Package.new(self, name, type, path, files)
+      end
+
+      attr_reader   :app        # Sinatra::Base instance
+      attr_reader   :packages   # Hash, keys are "foo.js", values are Packages
+      attr_reader   :served     # Hash, paths to be served.
+                                # Key is URI path, value is local path
+
+      attrib :js_compression    # Symbol, compression method for JS
+      attrib :css_compression   # Symbol, compression method for CSS
+      attrib :output_path       # '/public'
+
+      attrib :js_compression_options   # Hash
+      attrib :css_compression_options  # Hash
+
+      attrib :prebuild          # Bool
+
+      def js_compression(name=nil, options=nil)
+        @js_compression = name  unless name.nil?
+        @js_compression_options = options  if options.is_a?(Hash)
+        @js_compression
+      end
+
+      def css_compression(name=nil, options=nil)
+        @css_compression = name  unless name.nil?
+        @css_compression_options = options  if options.is_a?(Hash)
+        @css_compression
+      end
+
+      # =====================================================================
+      # Stuff
+
+      attr_reader :served
+
+      def build!(&blk)
+        session = Rack::Test::Session.new app
+
+        get = lambda { |path|
+          response = session.get(path)
+          out      = response.body
+          mtime    = Time.parse(response.headers['Last-Modified'])  if response.headers['Last-Modified']
+
+          [ out, mtime ]
+        }
+
+        packages.each { |_, pack|
+          out, mtime = get[pack.path]
+
+          write pack.path, out, mtime, &blk
+          write pack.production_path, out, mtime, &blk
+        }
+
+        files.each { |path, local|
+          out, mtime = get[path]
+
+          write path, out, mtime, &blk
+          write BusterHelpers.add_cache_buster(path, local), out, mtime, &blk
+        }
+      end
+
+      # Caches the packages.
+      def cache!(&blk)
+        return false  if app.reload_templates
+
+        session = Rack::Test::Session.new app
+        packages.each { |_, pack|
+          yield pack.path  if block_given?
+          session.get(pack.path)
+        }
+
+        true
+      end
+
+      def served?(path)
+        !! local_file_for(path)
+      end
+
+      # Returns the local file for a given URI path.
+      # Returns nil if a file is not found.
+      def local_file_for(path)
+        path = path.squeeze('/')
+
+        uri, local = served.detect { |uri, local| path[0...uri.size] == uri }
+
+        if local
+          path = path[uri.size..-1]
+          path = File.join app.root, local, path
+
+          path  if File.exists?(path)
+        end
+      end
+
+      # Returns the local file for a given URI path. (for dynamic files)
+      # Returns nil if a file is not found.
+      # TODO: consolidate with local_file_for
+      def dyn_local_file_for(requested_file, from)
+        # Remove extension
+        file = requested_file
+        extension = ''
+
+        file.sub(/^(.*)(\.[^\.]+)$/) { file, extension = $1, $2 }
+
+        # Remove cache-buster (/js/app.28389.js => /js/app)
+        file = $1  if file =~ /^(.*)\.[0-9]+$/
+
+        Dir[File.join(app.root, from, "#{file}#{extension}")].first
+      end
+
+      # Writes `public/#{path}` based on contents of `output`.
+      def write(path, output, mtime=nil)
+        require 'fileutils'
+
+        path = File.join(@output_path, path)
+        yield path  if block_given?
+
+        FileUtils.mkdir_p File.dirname(path)
+        File.open(path, 'w') { |f| f.write output }
+
+        if mtime
+          File.utime mtime, mtime, path
+        end
+      end
+
+      # Returns the files as a hash.
+      def files(match=nil)
+          # All
+          # A buncha tuples
+          tuples = @served.map { |prefix, local_path|
+            path = File.expand_path(File.join(@app.root, local_path))
+            spec = File.join(path, '**', '*')
+
+            Dir[spec].map { |f|
+              [ to_uri(f, prefix, path), f ]  unless File.directory?(f)
+            }
+          }.flatten.compact
+
+          Hash[*tuples]
+      end
+
+      # Returns an array of URI paths of those matching given globs.
+      #
+      #     glob('spec')
+      #     glob(['spec1', 'spec2' ...])
+      #     glob('spec', preserve: true)
+      #
+      # If `preserve` is set to true, it will preserve any specs that are not
+      # wildcards that don't match anything.
+      #
+      def glob(match, options={})
+
+        match = [*match]  # Force array-ness
+
+        paths = match.map { |spec|
+          if options[:preserve] && !spec.include?('*')
+            spec
+          else
+            files.keys.select { |f| File.fnmatch?(spec, f) }.sort
+          end
+        }.flatten
+
+        paths  = paths.uniq
+        tuples = paths.map { |key| [key, files[key]] }
+
+        HashArray[*tuples.flatten]
+      end
+
+    private
+      # Returns a URI for a given file
+      #     path = '/projects/x/app/css'
+      #     to_uri('/projects/x/app/css/file.sass', '/styles', path) => '/styles/file.css'
+      #
+      def to_uri(f, prefix, path)
+        fn = (prefix + f.gsub(path, '')).squeeze('/')
+
+        # Switch the extension ('x.sass' => 'x.css')
+        file_ext = File.extname(fn).to_s[1..-1]
+        out_ext  = AssetPack.tilt_formats[file_ext]
+
+        fn = fn.gsub(/\.#{file_ext}$/, ".#{out_ext}")  if file_ext && out_ext
+
+        fn
+      end
+    end
+  end
+end

data/lib/sinatra/assetpack/package.rb

@@ -0,0 +1,126 @@
+module Sinatra
+  module AssetPack
+    # A package.
+    #
+    # == Common usage
+    #
+    #     package = assets.packages['application.css']
+    #
+    #     package.files   # List of local files
+    #     package.paths   # List of URI paths
+    #
+    #     package.type    # :css or :js
+    #     package.css?
+    #     package.js?
+    #
+    #     package.path    # '/css/application.css' => where to serve the compressed file
+    #
+    #     package.to_development_html
+    #     package.to_production_html
+    #
+    class Package
+      include HtmlHelpers
+      include BusterHelpers
+
+      def initialize(assets, name, type, path, filespecs)
+        @assets      = assets     # Options instance
+        @name        = name       # "application"
+        @type        = type       # :js or :css
+        @path        = path       # '/js/app.js' -- where to served the compressed file
+        @filespecs   = filespecs  # [ '/js/*.js' ]
+      end
+
+      attr_reader :type
+      attr_reader :path
+      attr_reader :filespecs
+      attr_reader :name
+
+      # Returns a list of URIs
+      def paths_and_files
+        list = @assets.glob(@filespecs, :preserve => true)
+        list.reject! { |path, file| @assets.ignored?(path) }
+        list
+      end
+
+      def files
+        paths_and_files.values
+      end
+
+      def paths
+        paths_and_files.keys
+      end
+
+      def mtime
+        BusterHelpers.mtime_for(files)
+      end
+
+      # Returns the regex for the route, including cache buster crap.
+      def route_regex
+        re = @path.gsub(/(.[^.]+)$/) { |ext| "(?:\.[0-9]+)?#{ext}" }
+        /^#{re}$/
+      end
+
+      def to_development_html(options={})
+        paths_and_files.map { |path, file|
+          path = add_cache_buster(path, file)  # app.css => app.829378.css
+          link_tag(path, options)
+        }.join("\n")
+      end
+
+      # The URI path of the minified file (with cache buster)
+      def production_path
+        add_cache_buster @path, *files
+      end
+
+      def to_production_html(options={})
+        link_tag production_path, options
+      end
+
+      def minify
+        engine  = @assets.send(:"#{@type}_compression")
+        options = @assets.send(:"#{@type}_compression_options")
+
+        Compressor.compress combined, @type, engine, options
+      end
+
+      # The cache hash.
+      def hash
+        if @assets.app.development?
+          "#{name}.#{type}/#{mtime}"
+        else
+          "#{name}.#{type}"
+        end
+      end
+
+      def combined
+        session = Rack::Test::Session.new(@assets.app)
+        paths.map { |path|
+          result = session.get(path)
+          response_encoding = result.content_type.split(/;\s*charset\s*=\s*/).last.upcase rescue 'ASCII-8BIT'
+          # p [:combined, path, result.body.encoding.name, response_encoding]
+          result.body.force_encoding(response_encoding).encode(Encoding.default_external || 'ASCII-8BIT')  if result.status == 200
+        }.join("\n")
+      end
+
+      def js?()  @type == :js; end
+      def css?() @type == :css; end
+
+    private
+      def link_tag(file, options={})
+        # allow for building of assets from an application context and CDN host
+        context = options[:context]
+        host = options[:host]
+        file = "#{context}#{file}" unless context.nil? || context.empty?
+        file = "#{host}#{file}" unless host.nil? || host.empty?
+        options_copy = options.clone
+        options_copy.delete(:context)
+        options_copy.delete(:host)
+        if js?
+          "<script src='#{e file}'#{kv options_copy}></script>"
+        elsif css?
+          "<link rel='stylesheet' href='#{e file}'#{kv options_copy} />"
+        end
+      end
+    end
+  end
+end

data/lib/sinatra/assetpack/rake.rb

@@ -0,0 +1,29 @@
+unless defined?(APP_FILE) && defined?(APP_CLASS)
+  $stderr.write "Error: Please set APP_FILE and APP_CLASS before setting up AssetPack rake tasks.\n"
+  $stderr.write "Example:\n"
+  $stderr.write "    APP_FILE  = 'init.rb'\n"
+  $stderr.write "    APP_CLASS = 'Application'\n"
+  $stderr.write "    require 'sinatra/assetpack/rake'\n"
+  $stderr.write "\n"
+  exit
+end
+
+def class_from_string(str)
+  str.split('::').inject(Object) do |mod, class_name|
+    mod.const_get(class_name)
+  end
+end
+
+def app
+  require File.expand_path(APP_FILE, Dir.pwd)
+  class_from_string(APP_CLASS)
+end
+
+namespace :assetpack do
+  desc "Build assets"
+  task :build do
+    app.assets.build! { |file|
+      puts "+ #{file.gsub(Dir.pwd, '')}"
+    }
+  end
+end