rack-asset-compiler 0.0.2

data/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright 2011 Jonathan Baudanza
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,9 @@
+require "rspec/core"
+require "rspec/core/rake_task"
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:default) do |t|
+  t.rspec_opts = ["--color", "--format", "documentation"]
+  t.verbose = true
+  t.pattern = ['spec/*.rb']
+end

data/Readme.md

@@ -0,0 +1,76 @@
+# rack-asset-compiler
+
+rack-asset-compiler is a Rack middleware that provides a generic interface for compiling static files, such as Sass or CoffeeScript files.
+
+rack-asset-compiler does not use any local file storage and makes use of caching headers such as "Cache-Control" and "If-Modified-Since".  This makes it ideal for running on read-only filesystem systems such as Heroku.
+
+## Installation
+
+    gem install rack-asset-compiler
+
+## Generic form
+
+In this example, we have a set of text files with the extension .lower in the 'lowercase' directory, and
+we want to server .uppercase files out of http://yourhost.com/uppercase
+
+The compilation step is given in the form of a lambda passed as the `:compiler` option.  This lambda will
+be invoked whenever a client requests a file that needs to be compiled.  The source filename will be passed
+in and the compiled output is expected to be returned.
+
+    require 'rack/asset_compiler'
+
+    use Rack::AssetCompiler(
+      :source_dir => 'lowercase',
+      :url => '/uppercase',
+      :content_type => 'text/plain',
+      :source_extension => 'lower',
+      :compiler => lamba { |source_file|
+        File.read(source_file).upcase
+      }
+    )
+
+## Subclassing
+An alternative to passing in a lambda to the :compiler option is to subclass Rack::AssetCompiler and
+override the `compile` method.
+
+This gem comes with two subclasses: one for compiling CoffeeScript and one for Sass.
+
+## Compiling CoffeeScript
+
+config.ru
+    require 'rack/coffee_compiler'
+
+    use Rack::CoffeeCompiler,
+      :source_dir => 'app/coffeescripts'),
+      :url => '/javascripts',
+      :alert_on_error => true  # Generates a window.alert on compile error.  Defaults to (RACK_ENV != 'production')
+
+Gemfile
+    gem 'therubyracer'
+    gem 'coffee-script'
+
+    # On heroku, use this gem instead of therubyracer
+    gem 'therubyracer-heroku', '0.8.1.pre3'
+
+See [examples/jasmine_config.rb](https://github.com/jbaudanza/rack-asset-compiler/tree/master/examples/jasmine_config.rb) for an example of how to use CoffeeScript with your jasmine specs.
+
+## Compiling Sass
+
+On Rails
+
+    require 'rack/sass_compiler'
+
+    # Disable the standard Sass plugin which will write to the filesystem
+    Rails.application.config.middleware.delete(Sass::Plugin::Rack)
+
+    # Insert the new middleware
+    Rails.application.config.middleware.use Rack::SassCompiler,
+      :source_dir => 'app/sass',
+      :url => '/javascripts',
+      :syntax => :scss # :sass or :scss, defaults to :scss
+
+## Thanks
+asset-compiler was inspired by [rack-coffee] by [Matthew Lyon][mattly]
+
+[rack-coffee]: https://github.com/mattly/rack-coffee
+[mattly]: https://github.com/mattly/rack-coffee

data/examples/jasmine_config.rb

@@ -0,0 +1,42 @@
+#
+# spec/javascripts/support/jasmine_config.rb
+#
+require 'rack/coffee_compiler'
+
+module Jasmine
+  class Config
+
+    alias_method :old_js_files, :js_files
+
+    def js_files(spec_filter = nil)
+      # Convert all .coffee files into .js files before putting them in a script tag
+      old_js_files(spec_filter).map do |filename|
+        filename.sub(/\.coffee/, '.js')
+      end
+    end
+
+    def start_server(port=8888)
+      # We can't access the RAILS_ROOT constant from here
+      root = File.expand_path(File.join(File.dirname(__FILE__), '../../..'))
+
+      config = self
+
+      app = Rack::Builder.new do
+        # Compiler for your specs
+        use Rack::CoffeeCompiler,
+            :source_dir => File.join(root, 'spec/javascripts'),
+            :url => config.spec_path
+
+        # Compiler for your app files
+        use Rack::CoffeeCompiler,
+            :source_dir => File.join(root, 'public/javascripts'),
+            :url => '/public/javascripts'
+
+        run Jasmine.app(config)
+      end
+
+      handler = Rack::Handler.default
+      handler.run app, :Port => port, :AccessLog => []
+    end
+  end
+end

data/lib/rack/asset_compiler.rb

@@ -0,0 +1,95 @@
+module Rack
+  class AssetCompiler
+    attr_accessor :url, :source_dir, :source_extension
+
+    F = ::File
+
+    def initialize(app, options={}, &block)
+      @app = app
+
+      options = {
+        :compiler => block,
+        :source_dir => Dir.pwd,
+        :url => '/',
+        :cache => ENV['RACK_ENV'] == 'production'
+      }.merge(options)
+
+      %w(source_extension content_type).each do |field|
+        raise "Missing required option :#{field}" unless options.has_key?(field.to_sym)
+      end
+
+      @compiler = options[:compiler]
+      @source_dir = options[:source_dir]
+      @url = options[:url]
+      @source_extension = options[:source_extension]
+      @content_type = options[:content_type]
+
+      @cache_ttl = options[:cache]
+
+      # Default cache duration is 1 week
+      if(@cache_ttl && !@cache_ttl.kind_of?(Integer))
+        @cache_ttl = 60 * 60 * 24 * 7
+      end
+    end
+
+    def response(status, body)
+      body += "\r\n"
+      [status, {"Content-Type" => 'text/plain',
+           "Content-Length" => body.size.to_s},
+           [body]]
+    end
+
+    def compile(source_file)
+      if @compiler
+        @compiler.call(source_file)
+      else
+        raise "Missing compiler"
+      end
+    end
+
+    def call(env)
+      request_path = Utils.unescape(env["PATH_INFO"])
+      return response( 403, 'Forbidden') if request_path.include? ".."
+
+      match_parts = url.split('/').select{ |str| str.length > 0 }
+      request_parts = request_path.split('/').select{ |str| str.length > 0 }
+
+      if(request_parts.take(match_parts.length) == match_parts)
+        request_base = request_parts[match_parts.length..-1]
+
+        # Swap in the source file extension
+        request_base[-1].sub!(/\.\w+$/, '.' + source_extension)
+
+        source_file = F.join(source_dir, request_base)
+
+        if F.exists?(source_file)
+          last_modified_time = F.mtime(source_file)
+
+          if env['HTTP_IF_MODIFIED_SINCE']
+            cached_time = Time.parse(env['HTTP_IF_MODIFIED_SINCE'])
+            if last_modified_time <= cached_time
+              return [304, {}, "Not modified\r\n"]
+            end
+          end
+
+          body = compile(source_file)
+
+          headers = {
+            'Content-Type' => @content_type,
+            'Content-Length' => body.length.to_s,
+            'Last-Modified' => last_modified_time.httpdate
+          }
+
+          if @cache_ttl
+            headers['Expires'] = (Time.now + @cache_ttl).strftime('%a, %d %b %Y %H:%M:%S GMT')
+            headers['Cache-Control'] = "public,max-age=#{@cache_ttl}"
+          end
+
+          return [200, headers, body]
+        end
+      end
+
+      @app.call(env)
+    end
+  end
+end

data/lib/rack/coffee_compiler.rb

@@ -0,0 +1,43 @@
+require 'rack/asset_compiler'
+require 'coffee-script'
+
+module Rack
+  class CoffeeCompiler < AssetCompiler
+    LOCK = Mutex.new
+
+    def initialize(app, options={})
+      options = {
+        :url => '/javascripts',
+        :content_type => 'text/javascript',
+        :source_extension => 'coffee',
+        :alert_on_error => ENV['RACK_ENV'] != 'production',
+        :lock => LOCK
+      }.merge(options)
+
+      @alert_on_error = options[:alert_on_error]
+      @lock = options[:lock]
+      super
+    end
+
+    def compile(source_file)
+      if @lock
+        @lock.synchronize{ unsynchronized_compile(source_file) }
+      else
+        unsynchronized_compile(source_file)
+      end
+    end
+
+    def unsynchronized_compile(source_file)
+      begin
+        CoffeeScript.compile(::File.read(source_file))
+      rescue CoffeeScript::CompilationError => e
+        if @alert_on_error
+          error_msg = "CoffeeScript compilation error in #{source_file}.coffee:\n\n #{e.to_s}"
+          "window.alert(#{error_msg.to_json});"
+        else
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/rack/sass_compiler.rb

@@ -0,0 +1,31 @@
+require 'rack/asset_compiler'
+require 'sass'
+
+module Rack
+  class SassCompiler < AssetCompiler
+    attr_accessor :syntax
+
+    def initialize(app, options={})
+      options
+
+      options = {
+        :url => '/stylesheets',
+        :content_type => 'text/css',
+        :syntax => :scss
+      }.merge(options)
+
+      @syntax = options[:syntax]
+      options[:source_extension] ||= syntax.to_s
+      super
+    end
+
+    def compile(source_file)
+      sass_options = {
+        :syntax => syntax,
+        :cache => false,
+        :load_paths => [source_dir]
+      }
+      Sass::Engine.new(::File.read(source_file), sass_options).render
+    end
+  end
+end

data/rack-asset-compiler.gemspec

@@ -0,0 +1,18 @@
+Gem::Specification.new do |s|
+  s.name = 'rack-asset-compiler'
+  s.version = "0.0.2"
+  s.author = 'Jonathan Baudanza'
+  s.email = 'jon@jonb.org'
+  s.summary = 'Rack Middleware to facilitate the generic compiling static assets.'
+  s.homepage = 'http://www.github.com/jbaudanza/rack-asset-compiler'
+  s.add_dependency 'rack'
+  s.files =  [ "rack-asset-compiler.gemspec", "Rakefile", "Readme.md", "LICENSE.txt" ]
+  s.files += Dir['lib/rack/*.rb'] + Dir['spec/**/*']
+  s.files += [ "examples/jasmine_config.rb" ]
+  
+  s.description = <<END
+rack-asset-compiler is a Rack middleware that provides a generic interface for compiling static files, such as Sass or CoffeeScript files.
+
+rack-asset-compiler does not use any local file storage and makes use of caching headers such as "Cache-Control" and "If-Modified-Since".  This makes it ideal for running on read-only filesystem systems such as Heroku.  
+END
+end

data/spec/asset_compiler_spec.rb

@@ -0,0 +1,123 @@
+require 'rack/asset_compiler'
+require 'rack/lobster'
+require "rack/test"
+
+include Rack::Test::Methods
+
+describe "AssetCompiler" do
+  before do
+    @compiler = lambda do |source_file|
+      @source_file = source_file
+      'chickenscript'
+    end
+
+    @source_dir = File.join(File.dirname(__FILE__), 'fixtures/eggscripts')
+
+    @options = {
+      :url => '/chickenscripts/',
+      :source_dir => @source_dir,
+      :source_extension => 'eggscript',
+      :content_type => 'text/chicken-script',
+      :compiler => @compiler
+    }
+  end
+
+  def app
+    options = @options
+    Rack::Builder.new {
+      use Rack::Lint
+      use Rack::AssetCompiler, options
+      run Rack::Lobster.new
+    }
+  end
+
+  it "should raise an error if required options are missing" do
+    lambda {
+      @options.delete(:content_type)
+      get '/oops'
+    }.should raise_error
+  end
+
+  it "should match files directly beneath the URL" do
+    get '/chickenscripts/application.chickenscript'
+    @source_file.should == "#{@source_dir}/application.eggscript"
+    last_response.body.should == 'chickenscript'
+  end
+
+  it "should match files underneath a subdirectry" do
+    get '/chickenscripts/subdir/application.chickenscript'
+    @source_file.should == "#{@source_dir}/subdir/application.eggscript"
+    last_response.body.should == 'chickenscript'
+  end
+
+  it "should not call the compiler for missing files" do
+    get '/chickenscripts/missing.chickenscript'
+    @source_file.should be_nil
+  end
+
+  it "should use the correct content-type" do
+    get '/chickenscripts/application.chickenscript'
+    last_response.content_type.should == 'text/chicken-script'
+  end
+
+  it "should not match files outside the URL parameter" do
+    get '/lobster'
+    last_response.body.should include('Lobstericious')
+  end
+
+  it "should include a last-modified header" do
+    get '/chickenscripts/application.chickenscript'
+    last_response.headers["Last-Modified"].should == File.mtime("#{@source_dir}/application.eggscript").httpdate
+  end
+
+  it "should respond with a 304 on a last-modified hit" do
+    last_modified_time = File.mtime("#{@source_dir}/application.eggscript").httpdate
+    get '/chickenscripts/application.chickenscript', {}, {'HTTP_IF_MODIFIED_SINCE' => last_modified_time}
+    last_response.status.should == 304
+    last_response.body.should == "Not modified\r\n"
+  end
+
+  it "should return the compiled code on a last-modified miss" do
+    last_modified_time = (File.mtime("#{@source_dir}/application.eggscript") - 10).httpdate
+    get '/chickenscripts/application.chickenscript', {}, {'HTTP_IF_MODIFIED_SINCE' => last_modified_time}
+    last_response.status.should == 200
+    last_response.body.should == "chickenscript"
+  end
+
+  it "should reject requests with a .." do
+    get '/chickenscript/../somethingbad'
+    last_response.status.should == 403
+  end
+
+  describe "Caching" do
+    it "should not cache by default" do
+      @options.delete(:cache)
+      get '/chickenscripts/application.chickenscript'
+      last_response.headers.should_not include('Cache-Control')
+    end
+
+    it "should cache by default on production" do
+      @options.delete(:cache)
+      old_rack_env = ENV['RACK_ENV']
+      ENV['RACK_ENV'] = 'production'
+      get '/chickenscripts/application.chickenscript'
+      ENV['RACK_ENV'] = old_rack_env
+
+      last_response.headers.should include('Cache-Control')
+    end
+
+    it "should set not the cache header when the cache options is false" do
+      @options[:cache] = false
+      get '/chickenscripts/application.chickenscript'
+      last_response.headers.should_not include('Cache-Control')
+      last_response.headers.should_not include('Expires')
+    end
+
+    it "should set the cache header to a duration of one week when the cache options is true" do
+      @options[:cache] = true
+      get '/chickenscripts/application.chickenscript'
+      last_response.headers['Cache-Control'].should == "public,max-age=604800"
+      last_response.headers.should include('Expires')
+    end
+  end
+end

data/spec/coffee_compiler_spec.rb

@@ -0,0 +1,62 @@
+require 'rack/coffee_compiler'
+require 'rack/lobster'
+require "rack/test"
+
+include Rack::Test::Methods
+
+describe "CoffeeCompiler" do
+  before do
+    @source_dir = File.join(File.dirname(__FILE__), 'fixtures/coffeescripts')
+
+    @options = {
+      :source_dir => @source_dir
+    }
+  end
+
+  def app
+    options = @options
+    Rack::Builder.new {
+      use Rack::Lint
+      use Rack::CoffeeCompiler, options
+      run Rack::Lobster.new
+    }
+  end
+
+  it "should compile the coffeescript" do
+    get '/javascripts/application.js'
+    last_response.body.should == CoffeeScript.compile(File.read("#{@source_dir}/application.coffee"))
+    last_response.status.should == 200
+    last_response.content_type.should == 'text/javascript'
+  end
+
+  describe "when compiling a file with a syntax error" do
+    def do_get
+      get '/javascripts/syntax_error.js'
+    end
+
+    it "should render a window.alert by default" do
+      @options.delete(:alert_on_error)
+      do_get
+      last_response.body.should include('window.alert')
+    end
+
+    it "should not render a window.alert by default on production" do
+      @options.delete(:alert_on_error)
+      old_rack_env = ENV['RACK_ENV']
+      ENV['RACK_ENV'] = 'production'
+      lambda { do_get }.should raise_error(CoffeeScript::CompilationError)
+      ENV['RACK_ENV'] = old_rack_env
+    end
+
+    it "should not render a window.alert if alert_on_error is false" do
+      @options[:alert_on_error] = false
+      lambda { do_get }.should raise_error(CoffeeScript::CompilationError)
+    end
+
+    it "should render a window.alert if alert_on_error is true" do
+      @options[:alert_on_error] = true
+      do_get
+      last_response.body.should include('window.alert')
+    end
+  end
+end

data/spec/fixtures/coffeescripts/application.coffee

@@ -0,0 +1 @@
+console.log('hello world')

data/spec/fixtures/coffeescripts/syntax_error.coffee

@@ -0,0 +1 @@
+almost_called_a_function(1,2

data/spec/fixtures/eggscripts/application.eggscript

@@ -0,0 +1 @@
+EggScript is an imaginary language that can be compiled into ChickenScript

data/spec/fixtures/eggscripts/subdir/application.eggscript

@@ -0,0 +1 @@
+EggScript is an imaginary language that can be compiled into ChickenScript

data/spec/fixtures/sass/style.sass

@@ -0,0 +1,2 @@
+#compiled_with_sass
+  background-color: red

data/spec/fixtures/sass/style.scss

@@ -0,0 +1,3 @@
+#compiled_with_scss {
+  background-color: blue;
+}

data/spec/sass_compiler_spec.rb

@@ -0,0 +1,41 @@
+require 'rack/sass_compiler'
+require 'rack/lobster'
+require "rack/test"
+
+include Rack::Test::Methods
+
+describe "SassCompiler" do
+  before do
+    @source_dir = File.join(File.dirname(__FILE__), 'fixtures/sass')
+
+    @options = {
+      :source_dir => @source_dir
+    }
+  end
+
+  def app
+    options = @options
+    Rack::Builder.new {
+      use Rack::Lint
+      use Rack::SassCompiler, options
+      run Rack::Lobster.new
+    }
+  end
+
+  it "should compile scss" do
+    get '/stylesheets/style.css'
+    last_response.body.should ==
+      Sass::Engine.new(File.read("#{@source_dir}/style.scss"), :syntax => :scss).render
+    last_response.status.should == 200
+    last_response.content_type.should == 'text/css'
+  end
+
+  it "should compile sass" do
+    @options[:syntax] = :sass
+    get '/stylesheets/style.css'
+    last_response.body.should ==
+      Sass::Engine.new(File.read("#{@source_dir}/style.sass"), :syntax => :sass).render
+    last_response.status.should == 200
+    last_response.content_type.should == 'text/css'
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: rack-asset-compiler
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Jonathan Baudanza
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-25 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: |
+  rack-asset-compiler is a Rack middleware that provides a generic interface for compiling static files, such as Sass or CoffeeScript files.
+  
+  rack-asset-compiler does not use any local file storage and makes use of caching headers such as "Cache-Control" and "If-Modified-Since".  This makes it ideal for running on read-only filesystem systems such as Heroku.  
+
+email: jon@jonb.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- rack-asset-compiler.gemspec
+- Rakefile
+- Readme.md
+- LICENSE.txt
+- lib/rack/asset_compiler.rb
+- lib/rack/coffee_compiler.rb
+- lib/rack/sass_compiler.rb
+- spec/asset_compiler_spec.rb
+- spec/coffee_compiler_spec.rb
+- spec/fixtures/coffeescripts/application.coffee
+- spec/fixtures/coffeescripts/syntax_error.coffee
+- spec/fixtures/eggscripts/application.eggscript
+- spec/fixtures/eggscripts/subdir/application.eggscript
+- spec/fixtures/sass/style.sass
+- spec/fixtures/sass/style.scss
+- spec/sass_compiler_spec.rb
+- examples/jasmine_config.rb
+has_rdoc: true
+homepage: http://www.github.com/jbaudanza/rack-asset-compiler
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: Rack Middleware to facilitate the generic compiling static assets.
+test_files: []
+