asset-trip 0.1.0

data/lib/asset_trip/manifest_writer.rb

@@ -0,0 +1,35 @@
+module AssetTrip
+  class ManifestWriter
+
+    def initialize(assets)
+      @assets = assets
+    end
+
+    def write!
+      FileWriter.new(path).write!(contents)
+    end
+
+  private
+
+    def contents
+      source = StringIO.new
+
+      source.puts "module AssetTrip"
+      source.puts "  @manifest = Manifest.new"
+
+      @assets.each do |asset|
+        source.puts "  @manifest[#{asset.name.inspect}] = #{asset.md5sum.first(11).inspect}"
+      end
+
+      source.puts "end"
+
+      return source.string
+    end
+
+    def path
+      AssetTrip.app_root.join("config", "asset_trip", "manifest.rb")
+    end
+
+  end
+end
+

data/lib/asset_trip/memoizable.rb

@@ -0,0 +1,28 @@
+module AssetTrip
+  module Memoizable
+
+    def self.memoized_ivar_for(symbol)
+      "@_memoized_#{symbol.to_s.sub(/\?\Z/, '_query').sub(/!\Z/, '_bang')}".to_sym
+    end
+
+    def memoize(symbol)
+      original_method = :"_unmemoized_#{symbol}"
+      memoized_ivar = AssetTrip::Memoizable.memoized_ivar_for(symbol)
+
+      raise "Already memoized #{symbol}" if method_defined?(original_method)
+      alias_method original_method, symbol
+
+      class_eval <<-EOS, __FILE__, __LINE__
+        def #{symbol}(*args)                              # def mime_type(*args)
+          if !defined?(#{memoized_ivar})                  #   if !defined?(@_memoized_mime_type)
+            #{memoized_ivar} = #{original_method}(*args)  #     @_memoized_mime_type = _unmemoized_mime_type(*args)
+          end                                             #   end
+          #{memoized_ivar}                                #   @_memoized_mime_type
+        end                                               # end
+      EOS
+
+      private symbol if private_method_defined?(original_method)
+    end
+
+  end
+end

data/lib/asset_trip/middleware.rb

@@ -0,0 +1,109 @@
+# This is based on Rack::Static and Rack::File
+module AssetTrip
+  class Middleware
+    URL_PREFIX = "/__asset_trip__"
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      dup._call(env)
+    end
+
+    def _call(env)
+      @env = env
+
+      if matches_url_prefix?
+        process
+      else
+        pass
+      end
+    end
+
+    def each
+      File.open(path, "rb") do |file|
+        while part = file.read(8192)
+          yield part
+        end
+      end
+    end
+
+  private
+
+    def matches_url_prefix?
+      path_info.index(URL_PREFIX) == 0
+    end
+
+    def process
+      return forbidden if path_info.include?("..")
+
+      if path.file? && path.readable?
+        serve_file
+      else
+        not_found
+      end
+    rescue UnknownAssetError
+      return not_found
+    end
+
+    def pass
+      @app.call(@env)
+    end
+
+    def path
+      @path ||= AssetTrip.config.resolve_file(asset_type.to_sym, filename)
+    end
+
+    def filename
+      @filename ||= path_info[("/#{URL_PREFIX}/#{asset_type}".size)..-1]
+    end
+
+    def path_info
+      @path_info ||= Rack::Utils.unescape(@env["PATH_INFO"])
+    end
+
+    def asset_type
+      path_parts[2]
+    end
+
+    def path_parts
+      path_info.split("/")
+    end
+
+    def serve_file
+      # NOTE:
+      #   We check via File::size? whether this file provides size info
+      #   via stat (e.g. /proc files often don't), otherwise we have to
+      #   figure it out by reading the whole file into memory. And while
+      #   we're at it we also use this as body then.
+      if size = File.size?(@path)
+        body = self
+      else
+        body = [File.read(@path)]
+        size = Rack::Utils.bytesize(body.first)
+      end
+
+      [200, {
+        "Last-Modified"  => File.mtime(@path).httpdate,
+        "Content-Type"   => Rack::Mime.mime_type(File.extname(@path), 'text/plain'),
+        "Content-Length" => size.to_s
+      }, body]
+    end
+
+    def forbidden
+      body = "Forbidden\n"
+      [403, {"Content-Type" => "text/plain",
+             "Content-Length" => body.size.to_s},
+       [body]]
+    end
+
+    def not_found
+      body = "File not found: #{@path_info}\n"
+      [404, {"Content-Type" => "text/plain",
+         "Content-Length" => body.size.to_s},
+       [body]]
+    end
+
+  end
+end

data/lib/asset_trip/ssl_stylesheet.rb

@@ -0,0 +1,15 @@
+module AssetTrip
+  class SSLStylesheet < Stylesheet
+
+    def name
+      "#{@name}.ssl.css"
+    end
+
+  private
+
+    def url_rewriter(path)
+      UrlRewriter.new("https", path)
+    end
+
+  end
+end

data/lib/asset_trip/stylesheet.rb

@@ -0,0 +1,44 @@
+module AssetTrip
+  class Stylesheet < Asset
+
+    def name
+      "#{@name}.css"
+    end
+
+    def ssl_stylesheet
+      SSLStylesheet.new(@config, @name, @files)
+    end
+
+  private
+
+    def joined_contents
+      paths.map do |path|
+        url_rewriter(path).rewrite(File.read(path))
+      end.join("\n\n")
+    end
+
+    def compressor
+      Compressor.new("css")
+    end
+
+    def url_rewriter(filesystem_path)
+      public_path = AssetTrip.app_root.join("public")
+
+      if filesystem_path.to_s.starts_with?(public_path)
+        foo = Pathname.new("/").join(filesystem_path.relative_path_from(public_path))
+        UrlRewriter.new("http", foo)
+      else
+        UrlRewriter.new("http")
+      end
+    end
+
+    def asset_type
+      :stylesheets
+    end
+
+    def extension
+      ".css"
+    end
+
+  end
+end

data/lib/asset_trip/url_rewriter.rb

@@ -0,0 +1,82 @@
+require "action_controller"
+require "action_view"
+require "ostruct"
+require "uri"
+
+module AssetTrip
+  class UrlRewriter
+    include ActionView::Helpers::AssetTagHelper
+
+    def initialize(scheme, stylesheet_path = nil)
+      @scheme = scheme
+      @stylesheet_path = stylesheet_path
+
+      setup_fake_controller_for_asset_host_computation
+    end
+
+    def rewrite(contents)
+      contents.gsub(/url *\(([^\)]+)\)/) do
+        "url(#{add_asset_host_to_path($1)})"
+      end
+    end
+
+  private
+
+    def setup_fake_controller_for_asset_host_computation
+      environment = {}
+      environment["HTTPS"] = "on" if @scheme == "https"
+      @controller = OpenStruct.new(:request => ActionController::Request.new(environment)) # Used by Rails compute_asset_host method from ActionView::Helpers::AssetTagHelper
+    end
+
+    def add_asset_host_to_path(path)
+      strip_quotes!(path)
+
+      if prepend_asset_host?(path)
+        path = rewrite_relative_path(path) unless @stylesheet_path.blank?
+        URI::Generic.build(uri_components(path)).to_s
+      else
+        path
+      end
+    end
+
+    def uri_components(path)
+      opts = { :path => path }
+
+      if (asset_id = rails_asset_id(path)).present?
+        opts[:query] = asset_id
+      end
+
+      if (host = compute_asset_host(path)).present?
+        opts[:host]   = strip_scheme(host)
+        opts[:scheme] = @scheme
+      end
+
+      return opts
+    end
+
+    def rewrite_relative_path(relative_url)
+      if relative_url.starts_with?("/")
+        return relative_url
+      else
+        Pathname.new(File.join(@stylesheet_path.dirname, relative_url)).cleanpath
+      end
+    end
+
+    def prepend_asset_host?(path)
+      uri = URI.parse(path)
+
+      uri.relative? &&
+      File.extname(uri.path) != '.htc'
+    end
+
+    def strip_scheme(host)
+      host.gsub(/^[a-z]+:\/\//, '')
+    end
+
+    def strip_quotes!(path)
+      path.gsub!(/^\s*['"]*/, "")
+      path.gsub!(/['"]*\s*$/, "")
+    end
+
+  end
+end

data/lib/asset_trip.rb

@@ -0,0 +1,66 @@
+require "active_support"
+
+module AssetTrip
+  autoload :Asset, "asset_trip/asset"
+  autoload :Compressor, "asset_trip/compressor"
+  autoload :Config, "asset_trip/config"
+  autoload :FileWriter, "asset_trip/file_writer"
+  autoload :Helper, "asset_trip/helper"
+  autoload :Javascript, "asset_trip/javascript"
+  autoload :LoadPath, "asset_trip/load_path"
+  autoload :Manifest, "asset_trip/manifest"
+  autoload :ManifestWriter, "asset_trip/manifest_writer"
+  autoload :Middleware, "asset_trip/middleware"
+  autoload :Memoizable, "asset_trip/memoizable"
+  autoload :SSLStylesheet, "asset_trip/ssl_stylesheet"
+  autoload :Stylesheet, "asset_trip/stylesheet"
+  autoload :UrlRewriter, "asset_trip/url_rewriter"
+
+  class CompressorError < StandardError
+  end
+
+  class UnknownAssetError < StandardError
+  end
+
+  class NoManifestError < StandardError
+  end
+
+  VERSION = "0.1.0"
+
+  mattr_accessor :bundle
+  self.bundle = true
+
+  def self.bundle!
+    config.bundle!
+  end
+
+  def self.prune!
+    manifest.prune!
+  end
+
+  def self.config
+    @config ||= Config.from_file(config_path)
+  end
+
+  def self.manifest
+    raise NoManifestError if @manifest.nil?
+    @manifest
+  end
+
+  def self.app_root
+    Pathname.new(".").expand_path
+  end
+
+  def self.root
+    Pathname.new(__FILE__).dirname.join("..").expand_path
+  end
+
+  def self.assets_path
+    app_root.join("public", "assets")
+  end
+
+  def self.config_path
+    app_root.join("config", "asset_trip")
+  end
+
+end

data/spec/asset_trip/asset_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+describe AssetTrip::Asset do
+  before do
+    AssetTrip::Compressor.stub!(:new => DummyCompressor.new)
+    File.stub!(:read => "contents")
+  end
+
+  describe "#bundle!" do
+    it "splits the MD5 into two nested directories" do
+      path = AssetTrip.assets_path.join("d4", "1d8cd98f0", "asset.js")
+      AssetTrip::FileWriter.should_receive(:new).with(path).and_return(stub(:write! => nil))
+      asset = AssetTrip::Javascript.new(stub, "asset")
+      asset.bundle!
+    end
+
+    it "writes the contents to the file" do
+      writer = stub
+      writer.should_receive(:write!).with("contents")
+      AssetTrip::FileWriter.stub!(:new => writer)
+      asset = AssetTrip::Javascript.new(stub(:resolve_file => "foo.js"), "asset", [Pathname.new("foo.js")])
+      asset.bundle!
+    end
+  end
+
+  describe "#md5sum" do
+    it "calculates the MD5 if there are no files" do
+      asset = AssetTrip::Javascript.new(stub, "asset")
+      asset.md5sum.should == "d41d8cd98f00b204e9800998ecf8427e"
+    end
+
+    it "calculates the MD5 for one file" do
+      asset = AssetTrip::Javascript.new(stub(:resolve_file => "foo"), "asset") do
+        include "foo"
+      end
+      asset.md5sum.should == "98bf7d8c15784f0a3d63204441e1e2aa"
+    end
+
+    it "calculates the MD5 for multiple file" do
+      asset = AssetTrip::Javascript.new(stub(:resolve_file => "foo"), "asset") do
+        include "foo"
+        include "bar"
+      end
+      asset.md5sum.should == "237c43254a0799392cac71f795d9250e"
+    end
+  end
+end

data/spec/asset_trip/compressor_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+
+describe AssetTrip::Compressor do
+  let(:compressor) do
+    AssetTrip::Compressor.new(Pathname.new("css"))
+  end
+
+  describe "#compress" do
+    it "builds a command with the proper --type option" do
+      POpen4.should_receive(:popen4).with(/--type css/).and_return(stub(:success? => true))
+      compressor.compress("a { color: red }")
+    end
+
+    it "builds a command to run the vendored jar file" do
+      POpen4.should_receive(:popen4).with(/java -jar .*vendor\/yuicompressor-2.4.2.jar/).and_return(stub(:success? => true))
+      compressor.compress("a { color: red }")
+    end
+
+    it "sends the uncompressed contents via STDIN" do
+      stdin = stub(:close => nil)
+
+      POpen4.stub!(:popen4) do |command, block|
+        block.call(stub(:read => "STDOUT"), stub(:read => "STDERR"), stdin)
+        stub(:success? => true)
+      end
+
+      stdin.should_receive(:puts).with("a { color: red }")
+      compressor.compress("a { color: red }").should == "STDOUT"
+    end
+
+    it "returns the STDOUT from the java process" do
+      POpen4.stub!(:popen4) do |command, block|
+        block.call(stub(:read => "STDOUT"), stub(:read => "STDERR"), stub(:puts => nil, :close => nil))
+        stub(:success? => true)
+      end
+      compressor.compress("a { color: red }").should == "STDOUT"
+    end
+
+    it "raises a CompressorError if the java process is not successful" do
+      POpen4.stub!(:popen4 => stub(:success? => false))
+      lambda {
+        compressor.compress("a { color: red }")
+      }.should raise_error(AssetTrip::CompressorError)
+    end
+  end
+end

data/spec/asset_trip/config_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+
+describe AssetTrip::Config do
+  # TODO: it would be great to avoid needing this for these specs
+  setup_sandbox_app!
+
+  it "can bundle files included with the file extension" do
+    config = AssetTrip::Config.new do
+      js_asset "signup" do
+        include "main.js"
+      end
+    end
+
+    asset_config = config.assets.first
+    asset_config.paths.should == [app_javascript("main.js")]
+  end
+
+  it "can bundle files in subdirectories of the load path" do
+    config = AssetTrip::Config.new do
+      js_asset "signup" do
+        include "main/new"
+      end
+    end
+
+    asset_config = config.assets.first
+    asset_config.paths.should == [app_javascript("main", "new.js")]
+  end
+
+  it "supports writing an asset to a subdirectory" do
+    config = AssetTrip::Config.new do
+      js_asset "signup/foo" do
+        include "main.js"
+      end
+    end
+
+    asset_config = config.assets.first
+    asset_config.name.should == "signup/foo.js"
+  end
+
+  it "supports adding to the JS load paths" do
+    config = AssetTrip::Config.new do
+      load_paths[:javascripts] << "foo"
+    end
+
+    config.load_paths[:javascripts].should == AssetTrip::LoadPath.new([
+      Pathname.new("app/javascripts"),
+      Pathname.new("foo")
+    ])
+  end
+
+  it "supports adding to the CSS load paths" do
+    config = AssetTrip::Config.new do
+      load_paths[:stylesheets] << "foo"
+    end
+
+    config.load_paths[:stylesheets].should == AssetTrip::LoadPath.new([
+      Pathname.new("app/stylesheets"),
+      Pathname.new("foo")
+    ])
+  end
+end