unified-assets 0.0.1

data/.gitignore

@@ -0,0 +1 @@
+unified-assets-*.gem

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2013 Jake Gordon and contributors
+
+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/README.md

@@ -0,0 +1,99 @@
+Unified Assets (v0.0.1)
+=======================
+
+A small utility for unifying (and minifying) static javascript and css asset
+files, either at build time or at run-time.
+
+You declare a list of source files, and the gem will unify and minify them.
+
+The gem also provides a simple rack-based web server that will serve up your
+static website files and automatically recreate the unified files if the underlying
+source files have been modified.
+
+**NOTE:**
+
+This gem is really for my own personal use when building some of my HTML-only games. They
+consist of pure client-side html, javascript and css, with no dynamic server back end, but I 
+still want to auto-generate unified and minified scripts and styles.
+
+**You will almost certainly be better off with** more robust tools such as:
+
+ * [sprockets](https://github.com/sstephenson/sprockets) - if you have a ruby/rails back end
+ * [gears](https://github.com/gears/gears) - if you have a python back end
+ * [mincer](https://github.com/nodeca/mincer) - if you have a node back end
+ * [requirejs](http://requirejs.org/) - if you want to do it the AMD way
+
+This is just a tiny little gem that works well for **my** specific purposes and might not be the
+best tool for others. Use your own judgement.
+
+Installation
+============
+
+    $ gem install unified-assets
+
+Usage
+=====
+
+To generate a unified/minified `scripts.js` and `styles.css` add tasks to your Rakefile
+
+    require 'unified_assets/tasks'
+
+    UnifiedAssets::Tasks.new do |t|
+      t.minify = true
+      t.assets = {
+
+        "scripts.js"  => [
+          'js/game/vendor/stats.js',            # https://github.com/mrdoob/stats.js
+          'js/game/vendor/sizzle.js',           # http://sizzlejs.com/
+          'js/game/vendor/animator.js',         # http://berniesumption.com/software/animator/
+          'js/game/vendor/audio-fx.js',         # https://github.com/jakesgordon/javascript-audio-fx
+          'js/game/vendor/state-machine.js',    # https://github.com/jakesgordon/javascript-state-machine
+          'js/game/base.js',
+          'js/game/game.js',
+          'js/game/dom.js',
+          'js/game/menu.js',
+          'js/game/key.js',
+          'js/game/math.js',
+          'js/game/vector.js',
+          'js/snakes.js'
+        ],
+
+        "styles.css" => [
+          'css/vendor/normalize.css',
+          'css/snakes.css'
+        ]
+
+      }
+    end
+
+Will make 3 rake tasks available to you:
+
+    > rake -T
+
+    rake assets:clear     # clear unified asset files
+    rake assets:create    # create unified asset files
+    rake assets:server    # simple webserver that auto-regenerates assets if they are out of date
+
+Use `rake assets:create` whenever your source files have changed to recreate the unified/minified versions.
+
+Use `rake assets:server` to run a simple rack-based web server that can serve up your static website
+and will automatically regenerate your unified assets if the source files have been changed.
+
+TODO
+====
+
+ * command line scripts
+ * support templating (e.g. sass, coffeescript, erb)
+
+License
+=======
+
+[MIT](http://en.wikipedia.org/wiki/MIT_License) license.
+
+Contact
+=======
+
+If you have any ideas, feedback, requests or bug reports, you can reach me at
+[jake@codeincomplete.com](mailto:jake@codeincomplete.com), or via
+my website: [Code inComplete](http://codeincomplete.com).
+

data/RELEASE_NOTES.md

@@ -0,0 +1,4 @@
+February 9th 2013 - v0.0.1
+--------------------------
+ * MVP - first rough release
+

data/Rakefile

@@ -0,0 +1,34 @@
+$LOAD_PATH << File.dirname(__FILE__) + "/lib"
+require "rake/testtask"
+require "unified_assets/tasks"
+
+task :default => :test
+
+#------------------------------------------------------------------------------
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/**/*_test.rb"]
+  t.verbose = true
+end
+
+#------------------------------------------------------------------------------
+
+UnifiedAssets::Tasks.new do |t|
+  t.minify = true
+  t.assets = {
+    "test/reference/unified.js" => [
+      'test/js/a.js',
+      'test/js/b.js',
+      'test/js/c.js'
+    ],
+    "test/reference/unified.css" => [
+      'test/css/a.css',
+      'test/css/b.css',
+      'test/css/c.css'
+    ]
+  }
+end
+
+#------------------------------------------------------------------------------
+

data/lib/unified_assets.rb

@@ -0,0 +1,22 @@
+require 'unified_assets/builder'
+require 'unified_assets/minifier'
+
+module UnifiedAssets
+
+  #----------------------------------------------------------------------------
+
+  VERSION     = "0.0.1"
+  SUMMARY     = "Unify and minify JS and CSS website assets"
+  DESCRIPTION = "Simple tool to automatically unify and minify javascript and css website assets"
+  LIB         = File.dirname(__FILE__)
+
+  #----------------------------------------------------------------------------
+
+  def self.build(files, unified_file_name, options = {})
+    Builder.new(files, unified_file_name, options).build
+  end
+
+  #----------------------------------------------------------------------------
+
+end # module UnifiedAssets
+

data/lib/unified_assets/builder.rb

@@ -0,0 +1,72 @@
+module UnifiedAssets
+  class Builder
+
+    attr :files
+    attr :unified_file_name
+    attr :unified_file_mtime
+    attr :minified_file_name
+    attr :minified_file_mtime
+    attr :options
+
+    def initialize(files, unified_file_name, options = {})
+      @options             = options
+      @files               = Array(files)
+      @unified_file_name   = unified_file_name
+      @unified_file_mtime  = File.stat(unified_file_name).mtime if File.exists?(unified_file_name)
+      @minified_file_name  = Minifier.minified_name(unified_file_name) if minifying?
+      @minified_file_mtime = File.stat(minified_file_name).mtime if minifying? && File.exists?(minified_file_name)
+    end
+
+    def unified_file_missing?
+      unified_file_mtime.nil?
+    end
+
+    def minified_file_missing?
+      minifying? && minified_file_mtime.nil?
+    end
+
+    def minifying?
+      !!options[:minify] && Minifier.enabled?(unified_file_name)
+    end
+
+    def rebuild?
+      if @rebuild_because.nil?
+        @rebuild_because = []
+        @rebuild_because << "UNIFIED FILE IS MISSING" if unified_file_missing?
+        @rebuild_because << "MINIFIED FILE IS MISSING" if minified_file_missing?
+        @rebuild_because << "MINIFIED FILE IS OUT OF DATE" if minifying? && !minified_file_missing? && !unified_file_missing? && (minified_file_mtime < unified_file_mtime)
+        unless unified_file_missing?
+          files.each do |name|
+            file_mtime = File.stat(name).mtime
+            if (file_mtime > unified_file_mtime)
+              @rebuild_because << "#{name} IS OUT OF DATE"
+            end
+          end
+        end
+      end
+      !@rebuild_because.empty?
+    end
+
+    def rebuild_reason
+      @rebuild_because.join(', ') if rebuild?
+    end
+
+    def build
+      if rebuild?
+        debug("**** REGENERATING #{unified_file_name} BECAUSE #{rebuild_reason} ****", options)
+        File.open(unified_file_name, 'w') do |uf|
+          files.each do |filename|
+            debug("**** RENDERING #{filename}")
+            uf << IO.read(filename)
+          end
+        end
+        Minifier.minify(unified_file_name) if minifying?
+      end
+    end
+
+    def debug(msg, options = {})
+      puts msg if options[:debug]
+    end
+
+  end # class Builder
+end # module UnifiedAssets

data/lib/unified_assets/minifier.rb

@@ -0,0 +1,38 @@
+module UnifiedAssets
+  module Minifier
+
+    class << self
+      attr_accessor :enabled
+      attr_accessor :extensions
+      attr_accessor :jarfile
+    end
+    self.enabled    = true
+    self.extensions = ['.js', '.css']
+    self.jarfile    = "#{File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "vendor", "yuicompressor"))}/yuicompressor-2.4.6.jar"
+
+    def self.available?
+      @available ||= !`which java`.empty?   # warning: linux only way of checking if java is available
+    end
+
+    def self.enabled?(name = nil)
+      enabled && available? && (name.nil? || extensions.include?(File.extname(name)))
+    end
+
+    def self.minified_name(name)
+      if enabled?(name)
+        ext = File.extname(name)
+        name.sub(ext, ".min#{ext}")
+      else
+        name
+      end
+    end
+
+    def self.minify(name)
+      if name && enabled?(name) && File.exists?(name)
+        minified_name = minified_name(name)
+        `java -jar "#{jarfile}" "#{name}" -o "#{minified_name}"`
+      end
+    end
+
+  end # module Minifier
+end # module UnifiedAssets

data/lib/unified_assets/server.rb

@@ -0,0 +1,47 @@
+module UnifiedAssets
+  class Server
+
+    def initialize(app, options)
+      @app    = app
+      @root   = options[:root] or raise ArgumentError, ":root option is required"
+      @assets = options[:assets]
+      @minify = options[:minify]
+      @debug  = options[:debug]
+    end
+
+    def call(env)
+
+      path_info = Rack::Utils.unescape(env["PATH_INFO"])
+      path      = File.join(@root, path_info)
+
+      # redirect with trailing slash if necessary
+      if File.directory?(path) && path_info !~ /\/$/
+        new_path_info = path_info + "/"
+        return [
+          302,
+          { 'Location' => new_path_info, 'Content-Type' => 'text/html' },
+          [ "Redirecting you to #{new_path_info}…" ]
+        ]
+      end
+
+      # add index.html if necessary
+      new_env = env.dup
+      if File.directory?(path) 
+        path_to_index = File.join(path, "index.html")
+        if File.file?(path_to_index)
+          new_env["PATH_INFO"] = File.join(path_info, "index.html")
+        end
+      end
+
+      # regenerate assets if necessary
+      asset = path_info[1..-1] # trim leading slash
+      if @assets && @assets.keys.include?(asset)
+        UnifiedAssets.build(@assets[asset], asset, :minify => @minify, :debug => @debug)
+      end
+    
+      @app.call(new_env)
+
+    end
+
+  end # class Server
+end # module UnifiedAssets

data/lib/unified_assets/tasks.rb

@@ -0,0 +1,74 @@
+require 'rake/tasklib'
+require 'unified_assets'
+
+module UnifiedAssets
+  class Tasks < Rake::TaskLib
+
+    attr_accessor :assets
+    attr_accessor :minify
+    attr_accessor :server
+
+    def initialize(options = {})
+      @assets = options[:assets]
+      @minify = options[:minify]
+      @server = options[:server] || {}
+      yield(self) if block_given?
+      define
+    end
+
+    def define
+      namespace :assets do
+        define_clear_task
+        define_create_task
+        define_server_task
+      end
+    end
+
+    def define_clear_task
+      desc "clear unified asset files"
+      task :clear do
+        assets.keys.each do |asset|
+          Dir[asset, Minifier.minified_name(asset)].each {|f| File.delete(f) if File.exists?(f) }
+        end
+      end
+    end
+
+    def define_create_task
+      desc "create unified asset files"
+      task :create do
+        Rake::Task["assets:clear"].invoke
+        assets.keys.each do |asset|
+          UnifiedAssets.build(assets[asset], asset, :minify => minify)
+        end
+      end
+    end
+
+    def define_server_task
+      desc "simple webserver that auto-regenerates assets if they are out of date"
+      task :server do |t, args|
+        require 'rack'
+        require 'unified_assets/server'
+        options = {
+          :root   => ENV['ROOT']  || server[:root]  || '.',
+          :port   => ENV['PORT']  || server[:port]  || 3000,
+          :debug  => ENV['DEBUG'] || server[:debug] || true,
+          :assets => assets
+        }
+        app = Rack::Builder.new do
+          use Rack::CommonLogger
+          use Rack::ShowExceptions
+          use Rack::Lint
+          use UnifiedAssets::Server, options
+          run Rack::File.new(options[:root])
+        end.to_app
+        handler   = Rack::Handler.get(ENV['HANDLER'] || server[:handler])
+        handler ||= begin; Rack::Handler::Thin;    rescue LoadError; end
+        handler ||= begin; Rack::Handler::Mongrel; rescue LoadError; end
+        handler ||= Rack::Handler::WEBrick
+        handler.run(app, :Port => options[:port])
+      end
+    end
+
+  end # class Tasks
+end # module UnifiedAsset
+

data/test/builder_test.rb

@@ -0,0 +1,151 @@
+require "test_helper"
+
+class BuilderTest < Test::Unit::TestCase
+
+  #----------------------------------------------------------------------------
+
+  def test_unified_javascript_file
+    UnifiedAssets.build(SOURCE_JS, UNIFIED_JS)
+    assert_equal(REF_UNIFIED_JS, IO.read(UNIFIED_JS))
+  end
+
+  def test_unified_css_file
+    UnifiedAssets.build(SOURCE_CSS, UNIFIED_CSS)
+    assert_equal(REF_UNIFIED_CSS, IO.read(UNIFIED_CSS))
+  end
+
+  #----------------------------------------------------------------------------
+
+  def test_minified_javascript_file
+    UnifiedAssets.build(SOURCE_JS, UNIFIED_JS, :minify => true)
+    assert_equal(REF_UNIFIED_JS, IO.read(UNIFIED_JS))
+    assert_equal(REF_MINIFIED_JS, IO.read(MINIFIED_JS))
+  end
+
+  def test_minified_css_file
+    UnifiedAssets.build(SOURCE_CSS, UNIFIED_CSS, :minify => true)
+    assert_equal(REF_UNIFIED_CSS, IO.read(UNIFIED_CSS))
+    assert_equal(REF_MINIFIED_CSS, IO.read(MINIFIED_CSS))
+  end
+
+  #----------------------------------------------------------------------------
+
+  def test_rebuild_required_because_unified_file_is_missing
+    ua = UnifiedAssets::Builder.new(SOURCE_JS, UNIFIED_JS)
+    assert_equal(SOURCE_JS,                 ua.files)
+    assert_equal(UNIFIED_JS,                ua.unified_file_name)
+    assert_equal(nil,                       ua.unified_file_mtime)
+    assert_equal(nil,                       ua.minified_file_name)
+    assert_equal(nil,                       ua.minified_file_mtime)
+    assert_equal(true,                      ua.unified_file_missing?)
+    assert_equal(false,                     ua.minified_file_missing?)
+    assert_equal(false,                     ua.minifying?)
+    assert_equal(true,                      ua.rebuild?)
+    assert_equal("UNIFIED FILE IS MISSING", ua.rebuild_reason)
+  end
+
+  def test_rebuild_required_because_unified_file_is_out_of_date
+    with_unified_js do
+      tickle SOURCE_JS[0]
+      ua = UnifiedAssets::Builder.new(SOURCE_JS, UNIFIED_JS)
+      assert_equal(SOURCE_JS,                        ua.files)
+      assert_equal(UNIFIED_JS,                       ua.unified_file_name)
+      assert_equal(File.stat(UNIFIED_JS).mtime,      ua.unified_file_mtime)
+      assert_equal(nil,                              ua.minified_file_name)
+      assert_equal(nil,                              ua.minified_file_mtime)
+      assert_equal(false,                            ua.unified_file_missing?)
+      assert_equal(false,                            ua.minified_file_missing?)
+      assert_equal(false,                            ua.minifying?)
+      assert_equal(true,                             ua.rebuild?)
+      assert_equal("#{SOURCE_JS[0]} IS OUT OF DATE", ua.rebuild_reason)
+    end
+  end
+
+  def test_rebuild_not_required
+    with_unified_js do
+      ua = UnifiedAssets::Builder.new(SOURCE_JS, UNIFIED_JS)
+      assert_equal(SOURCE_JS,                   ua.files)
+      assert_equal(UNIFIED_JS,                  ua.unified_file_name)
+      assert_equal(File.stat(UNIFIED_JS).mtime, ua.unified_file_mtime)
+      assert_equal(nil,                         ua.minified_file_name)
+      assert_equal(nil,                         ua.minified_file_mtime)
+      assert_equal(false,                       ua.unified_file_missing?)
+      assert_equal(false,                       ua.minified_file_missing?)
+      assert_equal(false,                       ua.minifying?)
+      assert_equal(false,                       ua.rebuild?)
+      assert_equal(nil,                         ua.rebuild_reason)
+    end
+  end
+
+  #----------------------------------------------------------------------------
+
+  def test_rebuild_required_because_minified_file_is_missing
+    with_unified_js do
+      ua = UnifiedAssets::Builder.new(SOURCE_JS, UNIFIED_JS, :minify => true)
+      assert_equal(SOURCE_JS,                   ua.files)
+      assert_equal(UNIFIED_JS,                  ua.unified_file_name)
+      assert_equal(File.stat(UNIFIED_JS).mtime, ua.unified_file_mtime)
+      assert_equal(MINIFIED_JS,                 ua.minified_file_name)
+      assert_equal(nil,                         ua.minified_file_mtime)
+      assert_equal(false,                       ua.unified_file_missing?)
+      assert_equal(true,                        ua.minified_file_missing?)
+      assert_equal(true,                        ua.minifying?)
+      assert_equal(true,                        ua.rebuild?)
+      assert_equal("MINIFIED FILE IS MISSING",  ua.rebuild_reason)
+    end
+  end
+
+  def test_rebuild_required_because_minified_file_is_out_of_date
+    with_minified_js do
+      tickle UNIFIED_JS
+      ua = UnifiedAssets::Builder.new(SOURCE_JS, UNIFIED_JS, :minify => true)
+      assert_equal(SOURCE_JS,                      ua.files)
+      assert_equal(UNIFIED_JS,                     ua.unified_file_name)
+      assert_equal(File.stat(UNIFIED_JS).mtime,    ua.unified_file_mtime)
+      assert_equal(MINIFIED_JS,                    ua.minified_file_name)
+      assert_equal(File.stat(MINIFIED_JS).mtime,   ua.minified_file_mtime)
+      assert_equal(false,                          ua.unified_file_missing?)
+      assert_equal(false,                          ua.minified_file_missing?)
+      assert_equal(true,                           ua.minifying?)
+      assert_equal(true,                           ua.rebuild?)
+      assert_equal("MINIFIED FILE IS OUT OF DATE", ua.rebuild_reason)
+    end
+  end
+
+  def test_rebuild_not_required_when_minifying
+    with_minified_js do
+      ua = UnifiedAssets::Builder.new(SOURCE_JS, UNIFIED_JS, :minify => true)
+      assert_equal(SOURCE_JS,                    ua.files)
+      assert_equal(UNIFIED_JS,                   ua.unified_file_name)
+      assert_equal(File.stat(UNIFIED_JS).mtime,  ua.unified_file_mtime)
+      assert_equal(MINIFIED_JS,                  ua.minified_file_name)
+      assert_equal(File.stat(MINIFIED_JS).mtime, ua.minified_file_mtime)
+      assert_equal(false,                        ua.unified_file_missing?)
+      assert_equal(false,                        ua.minified_file_missing?)
+      assert_equal(true,                         ua.minifying?)
+      assert_equal(false,                        ua.rebuild?)
+      assert_equal(nil,                          ua.rebuild_reason)
+    end
+  end
+
+  #----------------------------------------------------------------------------
+
+  def test_minify_is_ignored_if_minifier_is_not_enabled
+    UnifiedAssets::Minifier.enabled = false
+    ua = UnifiedAssets::Builder.new(SOURCE_JS, UNIFIED_JS, :minify => true)
+    assert_equal(SOURCE_JS,                   ua.files)
+    assert_equal(UNIFIED_JS,                  ua.unified_file_name)
+    assert_equal(nil,                         ua.unified_file_mtime)
+    assert_equal(nil,                         ua.minified_file_name)
+    assert_equal(nil,                         ua.minified_file_mtime)
+    assert_equal(true,                        ua.unified_file_missing?)
+    assert_equal(false,                       ua.minified_file_missing?)
+    assert_equal(false,                       ua.minifying?)
+    assert_equal(true,                        ua.rebuild?)
+    assert_equal("UNIFIED FILE IS MISSING",   ua.rebuild_reason)
+  end
+
+  #----------------------------------------------------------------------------
+
+end
+

data/test/css/a.css

@@ -0,0 +1 @@
+.a { border: 1px solid aqua; }

data/test/css/b.css

@@ -0,0 +1 @@
+.b { border: 1px solid blue; }

data/test/css/c.css

@@ -0,0 +1 @@
+.c { border: 1px solid coral; }

data/test/js/a.js

@@ -0,0 +1 @@
+A = "Antelope";

data/test/js/b.js

@@ -0,0 +1 @@
+B = "Bear";

data/test/js/c.js

@@ -0,0 +1 @@
+C = "Centipede";

data/test/minifier_test.rb

@@ -0,0 +1,54 @@
+require "test_helper"
+
+class MinifierTest < Test::Unit::TestCase
+
+  def test_minifier_defaults
+    assert_equal(true,            UnifiedAssets::Minifier.enabled)
+    assert_equal(['.js', '.css'], UnifiedAssets::Minifier.extensions)
+    assert_equal(true,            UnifiedAssets::Minifier.available?)
+  end
+
+  def test_minifier_enabled
+    UnifiedAssets::Minifier.enabled = true
+    assert_equal(true,          UnifiedAssets::Minifier.enabled?("foo.js"))
+    assert_equal(true,          UnifiedAssets::Minifier.enabled?("foo.css"))
+    assert_equal(false,         UnifiedAssets::Minifier.enabled?("foo.png"), ".png is not appopriate for minifying")
+    assert_equal("foo.min.js",  UnifiedAssets::Minifier.minified_name("foo.js"))
+    assert_equal("foo.min.css", UnifiedAssets::Minifier.minified_name("foo.css"))
+    assert_equal("foo.png",     UnifiedAssets::Minifier.minified_name("foo.png"), ".png is not appropriate for minifying")
+  end
+
+  def test_minifier_disabled
+    UnifiedAssets::Minifier.enabled = false
+    assert_equal(false,     UnifiedAssets::Minifier.enabled?("foo.js"))
+    assert_equal(false,     UnifiedAssets::Minifier.enabled?("foo.css"))
+    assert_equal(false,     UnifiedAssets::Minifier.enabled?("foo.png"))
+    assert_equal("foo.js",  UnifiedAssets::Minifier.minified_name("foo.js"))
+    assert_equal("foo.css", UnifiedAssets::Minifier.minified_name("foo.css"))
+    assert_equal("foo.png", UnifiedAssets::Minifier.minified_name("foo.png"))
+  end
+
+  def test_minify_javascript
+    with_unified_js do
+      assert_equal(true,  File.exists?(UNIFIED_JS),  "preconditions")
+      assert_equal(false, File.exists?(MINIFIED_JS), "preconditions")
+      UnifiedAssets::Minifier.minify(UNIFIED_JS)
+      assert_equal(true, File.exists?(UNIFIED_JS))
+      assert_equal(true, File.exists?(MINIFIED_JS))
+      assert_equal(REF_MINIFIED_JS, IO.read(MINIFIED_JS))
+    end
+  end
+
+  def test_minify_css
+    with_unified_css do
+      assert_equal(true,  File.exists?(UNIFIED_CSS),  "preconditions")
+      assert_equal(false, File.exists?(MINIFIED_CSS), "preconditions")
+      UnifiedAssets::Minifier.minify(UNIFIED_CSS)
+      assert_equal(true, File.exists?(UNIFIED_CSS))
+      assert_equal(true, File.exists?(MINIFIED_CSS))
+      assert_equal(REF_MINIFIED_CSS, IO.read(MINIFIED_CSS))
+    end
+  end
+
+end
+

data/test/reference/unified.css

@@ -0,0 +1,3 @@
+.a { border: 1px solid aqua; }
+.b { border: 1px solid blue; }
+.c { border: 1px solid coral; }

data/test/reference/unified.js

@@ -0,0 +1,3 @@
+A = "Antelope";
+B = "Bear";
+C = "Centipede";

data/test/reference/unified.min.css

@@ -0,0 +1 @@
+.a{border:1px solid aqua}.b{border:1px solid blue}.c{border:1px solid coral}

data/test/reference/unified.min.js

@@ -0,0 +1 @@
+A="Antelope";B="Bear";C="Centipede";

data/test/test_helper.rb

@@ -0,0 +1,72 @@
+require "test/unit"
+require 'fileutils'
+require "unified_assets"
+
+class Test::Unit::TestCase
+
+  #----------------------------------------------------------------------------
+
+  SOURCE_JS    = ["test/js/a.js", "test/js/b.js", "test/js/c.js"]
+  SOURCE_CSS   = ["test/css/a.css", "test/css/b.css", "test/css/c.css"]
+
+  UNIFIED_JS   = "test/unified.js"
+  UNIFIED_CSS  = "test/unified.css"
+  MINIFIED_JS  = "test/unified.min.js"
+  MINIFIED_CSS = "test/unified.min.css"
+
+  REF_UNIFIED_JS   = IO.read("test/reference/unified.js")
+  REF_UNIFIED_CSS  = IO.read("test/reference/unified.css")
+  REF_MINIFIED_JS  = IO.read("test/reference/unified.min.js")
+  REF_MINIFIED_CSS = IO.read("test/reference/unified.min.css")
+
+  #----------------------------------------------------------------------------
+
+  def setup
+    [UNIFIED_JS, UNIFIED_CSS, MINIFIED_JS, MINIFIED_CSS].each{|name| assert(!File.exists?(name), "preconditions") }
+    assert(UnifiedAssets::Minifier.enabled, "preconditions")
+  end
+
+  def teardown
+    [UNIFIED_JS, UNIFIED_CSS, MINIFIED_JS, MINIFIED_CSS].each{|name| File.delete(name) if File.exists?(name) }
+    UnifiedAssets::Minifier.enabled = true
+  end
+
+  #----------------------------------------------------------------------------
+
+  def with_ref(source, target)
+    FileUtils.cp(source, target)
+    yield
+    File.delete(target)
+  end
+
+  def with_unified_js(&block)
+    with_ref("test/reference/unified.js", UNIFIED_JS, &block)
+  end
+
+  def with_unified_css(&block)
+    with_ref("test/reference/unified.css", UNIFIED_CSS, &block)
+  end
+
+  def with_minified_js(&block)
+    with_ref("test/reference/unified.js", UNIFIED_JS) do
+      with_ref("test/reference/unified.min.js", MINIFIED_JS, &block)
+    end
+  end
+
+  def with_minified_css(&block)
+    with_ref("test/reference/unified.css", UNIFIED_CSS) do
+      with_ref("test/reference/unified.min.css", MINIFIED_CSS, &block)
+    end
+  end
+
+  #----------------------------------------------------------------------------
+
+  def tickle(file)
+    sleep(0.1)
+    `touch #{file}`
+  end
+
+  #----------------------------------------------------------------------------
+
+end
+

data/unified_assets.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.push File.expand_path("lib", File.dirname(__FILE__))
+require 'unified_assets'
+
+Gem::Specification.new do |s|
+
+  s.name        = "unified-assets"
+  s.version     = UnifiedAssets::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jake Gordon"]
+  s.email       = ["jake@codeincomplete.com"]
+  s.homepage    = "https://github.com/jakesgordon/unified-assets"
+  s.summary     = UnifiedAssets::SUMMARY
+  s.description = UnifiedAssets::DESCRIPTION
+
+  s.add_dependency('rack') # for rake assets:server
+
+  s.has_rdoc         = false
+  s.extra_rdoc_files = ["README.md"]
+  s.rdoc_options     = ["--charset=UTF-8"]
+  s.files            = `git ls-files `.split("\n")
+  s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths    = ["lib"]
+
+end
+
+

data/vendor/yuicompressor/LICENSE.TXT

@@ -0,0 +1,54 @@
+YUI Compressor Copyright License Agreement (BSD License)
+
+Copyright (c) 2010, 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.
+
+This software also requires access to software from the following sources:
+
+The Jarg Library v 1.0 ( http://jargs.sourceforge.net/ ) is available
+under a BSD License � Copyright (c) 2001-2003 Steve Purcell,
+Copyright (c) 2002 Vidar Holen, Copyright (c) 2002 Michal Ceresna and
+Copyright (c) 2005 Ewan Mellor.
+
+The Rhino Library ( http://www.mozilla.org/rhino/ ) is dually available
+under an MPL 1.1/GPL 2.0 license, with portions subject to a BSD license.
+
+Additionally, this software contains modified versions of the following
+component files from the Rhino Library:
+
+[org/mozilla/javascript/Decompiler.java]
+[org/mozilla/javascript/Parser.java]
+[org/mozilla/javascript/Token.java]
+[org/mozilla/javascript/TokenStream.java]
+
+The modified versions of these files are distributed under the MPL v 1.1
+( http://www.mozilla.org/MPL/MPL-1.1.html )

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: unified-assets
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jake Gordon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simple tool to automatically unify and minify javascript and css website
+  assets
+email:
+- jake@codeincomplete.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- .gitignore
+- LICENSE
+- README.md
+- RELEASE_NOTES.md
+- Rakefile
+- lib/unified_assets.rb
+- lib/unified_assets/builder.rb
+- lib/unified_assets/minifier.rb
+- lib/unified_assets/server.rb
+- lib/unified_assets/tasks.rb
+- test/builder_test.rb
+- test/css/a.css
+- test/css/b.css
+- test/css/c.css
+- test/js/a.js
+- test/js/b.js
+- test/js/c.js
+- test/minifier_test.rb
+- test/reference/unified.css
+- test/reference/unified.js
+- test/reference/unified.min.css
+- test/reference/unified.min.js
+- test/test_helper.rb
+- unified_assets.gemspec
+- vendor/yuicompressor/LICENSE.TXT
+- vendor/yuicompressor/yuicompressor-2.4.6.jar
+homepage: https://github.com/jakesgordon/unified-assets
+licenses: []
+post_install_message: 
+rdoc_options:
+- --charset=UTF-8
+require_paths:
+- 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: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Unify and minify JS and CSS website assets
+test_files: []