alphasights-sinatra-sprockets 0.0.2

data/Gemfile

@@ -0,0 +1,10 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem 'sprockets', '~> 2.0'
+gem 'uglifier'
+gem 'closure-compiler'
+gem 'yui-compressor', :require => "yui/compressor"
+gem 'execjs'
+gem 'therubyracer'

data/lib/sinatra/sprockets/asset_paths.rb

@@ -0,0 +1,131 @@
+module Sinatra
+  module Sprockets
+    class AssetPaths
+      attr_reader :config
+      
+      class AssetNotPrecompiledError < StandardError; end
+      
+      def initialize(config)
+        @config = config
+      end
+      
+      def asset_for(source, ext)
+        source = source.to_s
+        return nil if is_uri?(source)
+        source = rewrite_extension(source, nil, ext)
+        config.environment[source]
+      rescue ::Sprockets::FileOutsidePaths
+        nil
+      end
+      
+      def digest_for(logical_path)
+        if config.digest_assets? && config.digests && (digest = config.digests[logical_path])
+          digest
+        else
+          if config.compile_assets?
+            if config.digest_assets? && asset = config.environment[logical_path]
+              asset.digest_path
+            else
+              logical_path
+            end
+          else
+            raise AssetNotPrecompiledError.new("#{logical_path} isn't precompiled")
+          end
+        end
+      end
+      
+      def compute_public_path(source, dir, options = {})
+        source = source.to_s
+        unless is_uri?(source)
+          source = rewrite_extension(source, dir, options[:ext]) if options[:ext]
+          source = rewrite_asset_path(source, dir, options)
+          source = rewrite_relative_url_root(source, config.relative_url_root)
+          source = rewrite_host_and_protocol(source, options[:protocol])
+        end
+        source
+      end
+      
+      def is_uri?(path)
+        path =~ %r{^[-a-z]+://|^cid:|^//}
+      end
+      
+      def rewrite_host_and_protocol(source, protocol = nil)
+        host = compute_asset_host(source)
+        if host && !is_uri?(host)
+          if (protocol || default_protocol) == :request && !has_request?
+            host = nil
+          else
+            host = "#{compute_protocol(protocol)}#{host}"
+          end
+        end
+        host ? "#{host}#{source}" : source
+      end
+      
+      def rewrite_relative_url_root(source, relative_url_root)
+        relative_url_root && !source.starts_with?("#{relative_url_root}/") ? "#{relative_url_root}#{source}" : source
+      end
+      
+      def rewrite_asset_path(source, dir, options = {})
+        if source[0] == ?/
+          source
+        else
+          source = digest_for(source) unless options[:digest] == false
+          source = File.join(dir, source)
+          source = "/#{source}" unless source =~ /^\//
+          source
+        end
+      end
+
+      def rewrite_extension(source, dir, ext)
+        if ext && File.extname(source).empty?
+          "#{source}.#{ext}"
+        else
+          source
+        end
+      end
+      
+      def compute_asset_host(source)
+        if host = config.host
+          if host.respond_to?(:call)
+            args = [source]
+            arity = arity_of(host)
+            if arity > 1 && request.nil?
+              invalid_asset_host!("Remove the second argument to your asset_host Proc if you do not need the request.")
+            end
+            args << current_request if (arity > 1 || arity < 0) && has_request?
+            host.call(*args)
+          else
+            (host =~ /%d/) ? host % (Zlib.crc32(source) % 4) : host
+          end
+        end
+      end
+      
+      def default_protocol
+        config.default_protocol || (request.nil?? :relative : :request)
+      end
+      
+      def compute_protocol(protocol)
+        protocol ||= default_protocol
+        case protocol
+        when :request
+          if request.nil?
+            invalid_asset_host!("The protocol requested was :request. Consider using :relative instead.")
+          end
+          request.protocol
+        when :relative
+          "//"
+        else
+          "#{protocol}://"
+        end
+      end
+
+      def arity_of(callable)
+        callable.respond_to?(:arity) ? callable.arity : callable.method(:call).arity
+      end
+      
+      def invalid_asset_host!(help_message)
+        raise ActionController::RoutingError, "This asset host cannot be computed without a request in scope. #{help_message}"
+      end
+    end
+  end
+end

data/lib/sinatra/sprockets/configuration.rb

@@ -0,0 +1,71 @@
+module Sinatra
+  module Sprockets
+    class Configuration
+      DEFAULTS = {
+        :digest => true, 
+        :debug => false, 
+        :compile => false, 
+        :compress => true,
+        :prefix => "assets", 
+        :host => nil, 
+        :relative_url_root => ENV['RACK_RELATIVE_URL_ROOT'],
+        :precompile => [ /\w+\.(?!js|css).+/, /application.(css|js)$/ ], 
+        :manifest_path => "public/assets",
+        :app => nil,
+        :js_compressor => nil,
+        :css_compressor => nil
+      }
+      OPTIONS = DEFAULTS.keys
+      
+      OPTIONS.each do |option|
+        define_method "#{option}=" do |value|
+          (@_config ||= {})[option] = value
+        end
+
+        define_method "#{option}" do
+          (@_config ||= {})[option]
+        end
+      end
+      
+      [:digest, :debug, :compile, :compress].each do |option|
+        define_method "#{option}_assets?" do
+          !! @_config[option]
+        end
+      end
+      
+      def initialize
+        @_config = DEFAULTS
+        @_digests = {}
+        @_paths = []
+      end
+      
+      def digests
+        @_digests
+      end
+      
+      def digests=(value)
+        @_digests = value
+      end
+      
+      def append_path(path)
+        @_paths << path
+      end
+      
+      def paths=(value)
+        @_paths = value.to_a
+      end
+      
+      def paths
+        @_paths
+      end
+      
+      def inspect
+        @_config.inspect
+      end
+      
+      def environment
+        Sinatra::Sprockets.environment
+      end
+    end
+  end
+end

data/lib/sinatra/sprockets/helpers.rb

@@ -0,0 +1,152 @@
+module Sinatra
+  module Sprockets
+    module Helpers
+      BOOLEAN_ATTRIBUTES = %w(disabled readonly multiple checked autobuffer
+                           autoplay controls loop selected hidden scoped async
+                           defer reversed ismap seemless muted required
+                           autofocus novalidate formnovalidate open pubdate).to_set
+      BOOLEAN_ATTRIBUTES.merge(BOOLEAN_ATTRIBUTES.map {|attribute| attribute.to_sym })
+      
+      def favicon_link_tag(source='favicon.ico', options={})
+        tag('link', {
+          :rel  => 'shortcut icon',
+          :type => 'image/vnd.microsoft.icon',
+          :href => asset_path(source)
+        }.merge(options.symbolize_keys))
+      end
+      
+      def image_tag(source, options = {})
+        options.symbolize_keys!
+        
+        options[:src] = asset_path(source)
+        
+        if size = options.delete(:size)
+          options[:width], options[:height] = size.split("x") if size =~ %r{^\d+x\d+$}
+        end
+        
+        tag("img", options)
+      end
+      
+      def video_tag(sources, options = {})
+        options.symbolize_keys!
+        
+        options[:poster] = asset_path(options[:poster]) if options[:poster]
+        
+        if size = options.delete(:size)
+          options[:width], options[:height] = size.split("x") if size =~ %r{^\d+x\d+$}
+        end
+        
+        if sources.is_a?(Array)
+          content_tag("video", options) do
+            sources.map { |source| tag("source", :src => source) }.join.html_safe
+          end
+        else
+          options[:src] = asset_path(sources)
+          tag("video", options)
+        end
+      end
+      
+      def audio_tag(source, options = {})
+        options.symbolize_keys!
+        options[:src] = asset_path(source)
+        tag("audio", options)
+      end
+      
+      def javascript_include_tag(*sources)
+        options = sources.extract_options!
+        debug = options.key?(:debug) ? options.delete(:debug) : config.debug_assets?
+        body  = options.key?(:body)  ? options.delete(:body)  : false
+        digest  = options.key?(:digest)  ? options.delete(:digest)  : config.digest_assets?
+        
+        sources.collect do |source|
+          if debug && asset = asset_paths.asset_for(source, 'js')
+            asset.to_a.map { |dep|
+              src = asset_path(dep, :ext => 'js', :body => true, :digest => digest)
+              content_tag("script", "", { "type" => "application/javascript", "src" => src }.merge!(options))
+            }
+          else
+            src = asset_path(source, :ext => 'js', :body => body, :digest => digest)
+            content_tag("script", "", { "type" => "application/javascript", "src" => src }.merge!(options))
+          end
+        end.join("\n").html_safe
+      end
+      
+      def stylesheet_link_tag(*sources)
+        options = sources.extract_options!
+        debug   = options.key?(:debug) ? options.delete(:debug) : config.debug_assets?
+        body    = options.key?(:body)  ? options.delete(:body)  : false
+        digest  = options.key?(:digest)  ? options.delete(:digest)  : config.digest_assets?
+        
+        sources.collect do |source|
+          if debug && asset = asset_paths.asset_for(source, 'css')
+            asset.to_a.map { |dep|
+              href = asset_path(dep, :ext => 'css', :body => true, :protocol => :request, :digest => digest)
+              tag("link", { "rel" => "stylesheet", "type" => "text/css", "media" => "screen", "href" => href }.merge!(options))
+            }
+          else
+            href = asset_path(source, :ext => 'css', :body => body, :protocol => :request, :digest => digest)
+            tag("link", { "rel" => "stylesheet", "type" => "text/css", "media" => "screen", "href" => href }.merge!(options))
+          end
+        end.join("\n").html_safe
+      end
+    
+      def asset_path(source, options={})
+        source = source.logical_path if source.respond_to?(:logical_path)
+        path = asset_paths.compute_public_path(source, config.prefix, options.merge(:body => true))
+        options[:body] ? "#{path}?body=1" : path
+      end
+    
+      def tag(name, options = nil, open = false, escape = true)
+        "<#{name}#{tag_options(options, escape) if options}#{open ? ">" : " />"}".html_safe
+      end
+    
+      def content_tag(name, content_or_options_with_block = nil, options = nil, escape = true, &block)
+        if block_given?
+          options = content_or_options_with_block if content_or_options_with_block.is_a?(Hash)
+          content_tag_string(name, block.call, options, escape)
+        else
+          content_tag_string(name, content_or_options_with_block, options, escape)
+        end
+      end
+    
+      private
+    
+      def asset_paths
+        @asset_paths ||= AssetPaths.new(Sinatra::Sprockets.config)
+      end
+    
+      def config
+        Sinatra::Sprockets.config
+      end
+    
+      def tag_options(options, escape = true)
+        unless options.blank?
+          attrs = []
+          options.each_pair do |key, value|
+            if key.to_s == 'data' && value.is_a?(Hash)
+              value.each do |k, v|
+                if !v.is_a?(String) && !v.is_a?(Symbol)
+                  v = v.to_json
+                end
+                v = ERB::Util.html_escape(v) if escape
+                attrs << %(data-#{k.to_s.dasherize}="#{v}")
+              end
+            elsif BOOLEAN_ATTRIBUTES.include?(key)
+              attrs << %(#{key}="#{key}") if value
+            elsif !value.nil?
+              final_value = value.is_a?(Array) ? value.join(" ") : value
+              final_value = ERB::Util.html_escape(final_value) if escape
+              attrs << %(#{key}="#{final_value}")
+            end
+          end
+          " #{attrs.sort * ' '}".html_safe unless attrs.empty?
+        end
+      end
+    
+      def content_tag_string(name, content, options, escape = true)
+        tag_options = tag_options(options, escape) if options
+        "<#{name}#{tag_options}>#{escape ? ERB::Util.h(content) : content}</#{name}>".html_safe
+      end
+    end
+  end
+end

data/lib/sinatra/sprockets/rake.rb

@@ -0,0 +1,41 @@
+require "fileutils"
+
+namespace :assets do
+  desc "Compile all the assets named in config.assets.precompile"
+  task :precompile do
+    Rake::Task["assets:clean:all"].invoke 
+    Rake::Task["assets:precompile:all"].invoke
+  end
+
+  namespace :precompile do
+    task :all => ["environment"] do
+      config = Sinatra::Sprockets.config
+      config.compile ||= true
+      config.digest  ||= true
+      config.digests ||= {}
+
+      env      = Sinatra::Sprockets.environment
+      target   = File.join(config.app.settings.public_path, config.prefix)
+      compiler = Sinatra::Sprockets::StaticCompiler.new(env,
+                                               target,
+                                               config.precompile,
+                                               :manifest_path => config.manifest_path,
+                                               :digest => config.digest,
+                                               :manifest => true)
+      compiler.compile
+    end
+  end
+
+  desc "Remove compiled assets"
+  task :clean do
+    Rake::Task["assets:clean:all"].invoke
+  end
+
+  namespace :clean do
+    task :all => ["environment"] do
+      config = Sinatra::Sprockets.config
+      public_asset_path = File.join(config.app.settings.public_path, config.prefix)
+      rm_rf public_asset_path, :secure => true
+    end
+  end
+end

data/lib/sinatra/sprockets/static_compiler.rb

@@ -0,0 +1,64 @@
+module Sinatra
+  module Sprockets
+    class StaticCompiler
+      require 'fileutils'
+      attr_accessor :env, :target, :paths
+
+      def initialize(env, target, paths, options = {})
+        @env = env
+        @target = target
+        @paths = paths
+        @digest = options.key?(:digest) ? options.delete(:digest) : true
+        @manifest = options.key?(:manifest) ? options.delete(:manifest) : true
+        @manifest_path = options.delete(:manifest_path) || target
+      end
+
+      def compile
+        manifest = {}
+        env.each_logical_path do |logical_path|
+          next unless compile_path?(logical_path)
+          if asset = env.find_asset(logical_path)
+            manifest[logical_path] = write_asset(asset)
+          end
+        end
+        write_manifest(manifest) if @manifest
+      end
+
+      def write_manifest(manifest)
+        FileUtils.mkdir_p(@manifest_path)
+        File.open("#{@manifest_path}/manifest.yml", 'wb') do |f|
+          YAML.dump(manifest, f)
+        end
+      end
+
+      def write_asset(asset)
+        path_for(asset).tap do |path|
+          filename = File.join(target, path)
+          FileUtils.mkdir_p File.dirname(filename)
+          asset.write_to(filename)
+          asset.write_to("#{filename}.gz") if filename.to_s =~ /\.(css|js)$/
+        end
+      end
+
+      def compile_path?(logical_path)
+        answer = false
+        paths.each do |path|
+          case path
+          when Regexp
+            answer = path.match(logical_path)
+          when Proc
+            answer = path.call(logical_path)
+          else
+            answer = File.fnmatch(path.to_s, logical_path)
+          end
+          break if answer
+        end
+        answer
+      end
+
+      def path_for(asset)
+        @digest ? asset.digest_path : asset.logical_path
+      end
+    end
+  end
+end

data/lib/sinatra/sprockets/version.rb

@@ -0,0 +1,5 @@
+module Sinatra
+  module Sprockets
+    VERSION = "0.0.2"
+  end
+end

data/lib/sinatra/sprockets.rb

@@ -0,0 +1,51 @@
+require 'sinatra/sprockets/configuration'
+require 'sinatra/sprockets/asset_paths'
+require 'sinatra/sprockets/helpers'
+require 'sinatra/sprockets/static_compiler'
+
+module Sinatra
+  module Sprockets
+    def self.configure(&block)
+      block.call(config)
+      raise ArgumentError, "Cannot initialize Sprockets Environment without an app reference" if config.app.nil?
+      
+      @environment = ::Sprockets::Environment.new(config.app.root)
+      
+      config.paths.each do |path|
+        environment.append_path(File.join(config.app.root, path))
+      end
+      
+      if config.compress_assets?
+        environment.js_compressor = config.js_compressor || Closure::Compiler.new
+        environment.css_compressor = config.css_compressor || YUI::CssCompressor.new
+      else
+        environment.js_compressor = false
+        environment.css_compressor = false
+      end
+      
+      if config.manifest_path
+        path = File.join(config.app.root, config.manifest_path, "manifest.yml")
+      else
+        path = File.join(config.app.settings.public_path, 'assets', "manifest.yml")
+      end
+
+      if File.exist?(path)
+        YAML.load_file(path).each do |path, value|
+          config.digests[path] = value
+        end
+      end
+      
+      environment.context_class.instance_eval do
+        include Helpers
+      end
+    end
+    
+    def self.config
+      @config ||= Configuration.new
+    end
+    
+    def self.environment
+      @environment
+    end
+  end
+end

data/lib/sinatra-sprockets.rb

@@ -0,0 +1 @@
+require 'sinatra/sprockets'

data/sinatra-sprockets.gemspec

@@ -0,0 +1,33 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "sinatra/sprockets/version"
+
+Gem::Specification.new do |s|
+  s.name        = "alphasights-sinatra-sprockets"
+  s.version     = Sinatra::Sprockets::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["thegorgon"]
+  s.email       = ["jessereiss@gmail.com"]
+  s.homepage    = "http://github.com/thegorgon/sinatra-sprockets"
+  s.summary     = %q{Sinatra helpers for Sprockets integration.}
+  s.description = %q{Use Sprockets effectively with Sinatra.}
+
+  s.rubyforge_project = s.name
+
+  s.add_runtime_dependency 'sprockets',       '~> 2.0'
+
+  s.files = [
+    "Gemfile",
+    "sinatra-sprockets.gemspec",
+    "lib/sinatra-sprockets.rb",
+    "lib/sinatra/sprockets.rb",
+    "lib/sinatra/sprockets/asset_paths.rb",
+    "lib/sinatra/sprockets/configuration.rb",
+    "lib/sinatra/sprockets/helpers.rb",
+    "lib/sinatra/sprockets/rake.rb",
+    "lib/sinatra/sprockets/static_compiler.rb",
+    "lib/sinatra/sprockets/version.rb"
+  ]
+
+  s.require_paths << "lib"
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: alphasights-sinatra-sprockets
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- thegorgon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sprockets
+  requirement: &70244933078240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70244933078240
+description: Use Sprockets effectively with Sinatra.
+email:
+- jessereiss@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- sinatra-sprockets.gemspec
+- lib/sinatra-sprockets.rb
+- lib/sinatra/sprockets.rb
+- lib/sinatra/sprockets/asset_paths.rb
+- lib/sinatra/sprockets/configuration.rb
+- lib/sinatra/sprockets/helpers.rb
+- lib/sinatra/sprockets/rake.rb
+- lib/sinatra/sprockets/static_compiler.rb
+- lib/sinatra/sprockets/version.rb
+homepage: http://github.com/thegorgon/sinatra-sprockets
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: alphasights-sinatra-sprockets
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Sinatra helpers for Sprockets integration.
+test_files: []