active_assets 0.1.0

data/.autotest

@@ -0,0 +1,55 @@
+require 'autotest/restart'
+require 'autotest/bundler'
+
+Autotest.add_hook :initialize do |at|
+  at.testlib = 'test/unit test/autocolor'
+
+  # Remove the old test unit mappings
+  at.clear_mappings
+
+  # Don't track other dirs, this just burns cpu.
+  (File.read('.gitignore').split("\n") + Dir['test/fixtures/**/*']).each do |ignore|
+    next if ignore.nil? or ignore.empty?
+    at.add_exception ignore
+  end
+
+  # Test::Unit is normally test_, so autotest doesn't have this mapping. Tests
+  # want to match themselves, that is, if there's no changes, run them all.
+  at.add_mapping(%r%^test/.*_test\.rb$%) { |f, _| f }
+
+  # Allow for matches of lib files to test files in a flat way
+  at.add_mapping(%r%^lib/(.*)\.rb$%) do |f, md|
+    at.files_matching( %r%^test/#{md[1]}_test\.rb$%)
+  end
+
+  # Make sure that we run all tests if the helper changes:
+  at.add_mapping(%r%^test/helper\.rb$%) do |f, _|
+    at.files_matching %r%.*_test\.rb%
+  end
+
+  # If bundle did something, run all tests again
+  at.add_mapping(%r%^Gemfile\.lock$%) do |f, _|
+    at.files_matching %r%.*_test\.rb%
+  end
+
+  # If update support, run all tests
+  at.add_mapping(%r%^test/support/.*\.rb$%) do |f, _|
+    at.files_matching %r%.*_test\.rb%
+  end
+
+  def at.path_to_classname(path)
+    file = File.basename(path, '.rb')
+
+    file.gsub!('test_', '')
+    file.gsub!('_test', '')
+    file.capitalize + 'Test'
+  end
+
+end
+
+# If the Gemfile gets updated, run bundle install
+Autotest.add_hook :updated do |at, *args|
+  if args.flatten.grep(%r%^Gemfile$|^.*\.gemspec$%).any?
+    system 'bundle'
+  end
+end

data/.gitignore

@@ -0,0 +1,9 @@
+.rvmrc
+pkg/*
+*.gem
+.bundle
+Gemfile.lock
+
+test/fixtures/rails_root/log
+test/fixtures/rails_root/public/stylesheets/cache
+test/fixtures/rails_root/public/javascripts/cache

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in rails-assets.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rake/testtask'
+require 'bundler'
+require 'bundler/setup'
+Bundler::GemHelper.install_tasks
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+task :default => :test

data/active_assets.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+Gem::Specification.new do |s|
+  s.name        = "active_assets"
+  s.version     = '0.1.0'
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Sam Woodard"]
+  s.email       = ["sam@wildfireapp.com"]
+  s.homepage    = ""
+  s.summary     = %q{A Railtie that provides a full asset management system, including support for development and deployment.}
+  s.description = %q{A Railtie that provides a full asset management system, including support for development and deployment.  Currently it is designed to manage javascripts and stylesheets but will handle image sprites in the future.}
+
+  s.rubyforge_project = "rails-assets"
+
+  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"]
+
+  s.add_development_dependency "rails", "3.0.3"
+  s.add_development_dependency "test-unit", "> 2.0"
+  s.add_development_dependency "ZenTest"
+end

data/lib/active_assets/active_expansions/asset.rb

@@ -0,0 +1,63 @@
+module ActiveAssets
+  module ActiveExpansions
+    class Asset < Struct.new(:path, :type, :expansion_name, :group, :cache)
+
+      REQUIRED_PROPS = [:path, :type, :expansion_name]
+      VALID_TYPES = [:js, :css]
+
+      class InvalidContext < StandardError
+        def initialize(msg = nil)
+          msg ||= "You do not have a valid context to create this asset.  Some properties are missing.  They are: #{REQUIRED_PROPS.join(', ')}."
+          super(msg)
+        end
+      end
+
+      class AmbiguousContext < InvalidContext
+        def initilaize(missing_field)
+          super("You do not have a valid context to create this asset.  Some properties are missing.  Our guess is your didn't specify a #{missing_field}")
+        end
+      end
+
+      class ValidationError < InvalidContext
+        attr_reader :asset, :missing_fields
+        def initialize(asset, missing_fields)
+          @asset, @missing_fields = asset, missing_fields
+          super("#{asset} is not valid.  The following fields are missing, #{missing_fields.join(', ')}.")
+        end
+      end
+
+      class InvalidAssetType < StandardError
+        attr_reader :invalid_type
+        def initilaize(invalid_type)
+          @invalid_type = invalid_type
+          super("#{invalid_type} is not a recognized asset type.")
+        end
+      end
+
+      def initialize(*)
+        super
+        self.group ||= :all
+        self.cache = self.cache == false ? false : true
+      end
+
+      def validation_error
+        missing_fields = REQUIRED_PROPS.reject { |meth| send(meth) }
+        if missing_fields.any?
+          ValidationError.new(self, missing_fields)
+        elsif !VALID_TYPES.include?(type)
+          InvalidAssetType.new(type)
+        end
+      end
+
+      def valid?
+        !validation_error
+      end
+
+      def valid!
+        e = validation_error
+        raise e if e
+      end
+
+    end
+  end
+end

data/lib/active_assets/active_expansions/asset_scope.rb

@@ -0,0 +1,29 @@
+module ActiveAssets
+  module ActiveExpansions
+    module AssetScope
+      def group(*groups, &blk)
+        @current_groups = groups
+        instance_eval(&blk)
+      ensure
+        @current_groups = nil
+      end
+
+      def js(&blk)
+        current_type :js, &blk
+      end
+
+      def css(&blk)
+        current_type :css, &blk
+      end
+
+      private
+        def current_type(type, &blk)
+          @current_type = type
+          instance_eval(&blk)
+        ensure
+          @current_type = nil
+        end
+
+    end
+  end
+end

data/lib/active_assets/active_expansions/assets.rb

@@ -0,0 +1,97 @@
+require 'fileutils'
+
+module ActiveAssets
+  module ActiveExpansions
+    class Assets
+      attr_reader :expansions
+
+      def initialize(expansions)
+        @expansions = expansions
+      end
+
+      def has_expansion?(name)
+        @expansions.has_key?(name)
+      end
+
+      def expansion_names
+        @expansion.keys
+      end
+
+      def [](expansion_name)
+        @expansions[expansion_name]
+      end
+
+      def all(&blk)
+        @expansions.values.each(&blk) if block_given?
+        @expansions.values
+      end
+
+      def paths(expansion_name)
+        self[expansion_name].assets.map(&:path)
+      end
+
+      def asset_type
+        raise NoMethodError
+      end
+
+      def register!
+        all do |expansion|
+          paths = if ActionController::Base.perform_caching
+            group_assets = expansion.assets.select do |a|
+              Array(a.group).include?(:deploy) ||
+              Array(a.group).any? {|e| e.to_s != 'all' && Rails.env.send(:"#{e}?") }
+            end
+
+            group_assets.map(&:path) + [File.join("cache#{"/#{expansion.namespace}" if expansion.namespace}", expansion.name.to_s)]
+          else
+            expansion.assets.select {|a| a.group == :all || Array(a.group).any? {|e| Rails.env.send(:"#{e}?") } }.map(&:path)
+          end
+
+          cleanse_paths!(paths)
+
+          ActionView::Helpers::AssetTagHelper.send(:"register_#{asset_type}_expansion", expansion.name => paths)
+        end
+      end
+
+      def cache!
+        all do |expansion|
+          file_path = "#{"#{expansion.namespace}/" if expansion.namespace}#{expansion.name}.#{asset_type_short}"
+          file_path = Rails.root.join('public', asset_type.pluralize, 'cache', file_path)
+
+          paths = expansion.assets.select {|a|
+            a.cache &&
+            (Array(a.group).include?(:all) ||
+            Array(a.group).include?(:deploy) ||
+            Array(a.group).any? {|e| Rails.env.send(:"#{e}?") })
+          }.map(&:path)
+
+          cleanse_paths!(paths)
+
+          FileUtils.mkdir_p(File.dirname(file_path))
+
+          File.open(file_path, 'w+') do |f|
+            paths.each do |path|
+              in_file = Rails.root.join('public', asset_type.pluralize, "#{path}.#{asset_type_short}")
+              f.puts File.read(in_file)
+            end
+          end
+        end
+      end
+
+      private
+        def asset_type_short
+          asset_type == 'javascript' ? 'js' : 'css'
+        end
+
+        def cleanse_paths!(paths)
+          paths.map! do |path|
+            if path =~ %r{^https?}
+              path
+            else
+              File.join(File.dirname(path), File.basename(path, ".#{asset_type_short}"))
+            end
+          end
+        end
+    end
+  end
+end

data/lib/active_assets/active_expansions/configurable.rb

@@ -0,0 +1,14 @@
+require 'active_support/concern'
+
+module ActiveAssets
+  module ActiveExpansions
+    module Configurable
+      extend ActiveSupport::Concern
+
+      included do
+        config_accessor :precache_assets
+        self.precache_assets = false if precache_assets.nil?
+      end
+    end
+  end
+end

data/lib/active_assets/active_expansions/expansion.rb

@@ -0,0 +1,65 @@
+require 'active_support'
+require 'active_support/hash_with_indifferent_access'
+
+module ActiveAssets
+  module ActiveExpansions
+    class Expansion
+      include AssetScope
+      include TypeInferrable
+
+      attr_reader :type, :name, :assets, :namespace
+      alias_method :all, :assets
+      delegate :empty?, :to => :assets
+
+      def initialize(name)
+        @name = name
+        @assets = []
+      end
+
+      def configure(options = {}, &blk)
+        @type, @group, @namespace = options.values_at(:type, :group, :namespace)
+        instance_eval(&blk) if block_given?
+        self
+      end
+
+      def asset(path, options = {})
+        options = HashWithIndifferentAccess.new(options)
+        options.assert_valid_keys(*Asset.members)
+      
+        inferred_type, extension = inferred_type(path)
+
+        options.reverse_merge!(
+          :type => inferred_type || @current_type || extension || type,
+          :expansion_name => name,
+          :group => @current_groups
+        )
+        options.update(:path => path)
+
+        members = options.values_at(*Asset.members)
+        a = Asset.new(*members)
+
+        a.valid!
+        @assets << a
+      end
+      alias_method :a, :asset
+      alias_method :`, :asset
+
+      def group(*groups, &blk)
+        @current_groups = groups
+        instance_eval(&blk)
+      ensure
+        @current_groups = nil
+      end
+
+      def namespace(&blk)
+        raise NoMethodError, "Cannot call namespace from within expansion." if block_given?
+        @namespace
+      end
+
+      private
+        def cleanse_path(path)
+          File.join(File.dirname(path) + File.basename(path, ".#{type}"))
+        end
+    end
+  end
+end

data/lib/active_assets/active_expansions/expansions.rb

@@ -0,0 +1,103 @@
+require 'active_support/configurable'
+
+module ActiveAssets
+  module ActiveExpansions
+    class Expansions
+      include AssetScope
+      include TypeInferrable
+      include ActiveSupport::Configurable
+      include Configurable
+      ActiveSupport.run_load_hooks(:active_expansions, self)
+
+      def initialize
+        @expansions = Hash.new(&method(:build_expansions_hash_with_defaults))
+      end
+
+      def register(&blk)
+        instance_eval(&blk) if block_given?
+        self
+      end
+
+      def namespace(name, &blk)
+        @current_namespace = name
+        instance_eval(&blk)
+      ensure
+        @current_namespace = nil
+      end
+
+      def asset(path, options = {})
+        deferred_expansion_name, deferred_expansion_options = @deferred_expansion_config
+        inferred_type, extension = inferred_type(path)
+
+        options = HashWithIndifferentAccess.new(options).reverse_merge(
+          :type => inferred_type || @current_type,
+          :expansion_name => deferred_expansion_name,
+          :group => @current_groups
+        )
+
+        expansion_options = update_expansion_options(deferred_expansion_options || {}, options[:type])
+
+        # asset call below is executed in the scope of the ActiveAssets::Expansion
+        @expansions[options[:type] || extension][options[:expansion_name]].configure(expansion_options) do
+          asset(path, options)
+        end
+      end
+      alias_method :a, :asset
+      alias_method :`, :asset
+
+      def expansion(name, options = {}, &blk)
+        options = update_expansion_options(options)
+
+        if options[:type].present?
+          @expansions[options[:type]][name].configure(options, &blk)
+        else
+          defer_expansion(name, options, &blk)
+        end
+      end
+
+      def javascripts
+        Javascripts.new(@expansions[:js])
+      end
+
+      def stylesheets
+        Stylesheets.new(@expansions[:css])
+      end
+
+      def all
+        @expansions[:js].values + @expansions[:css].values
+      end
+
+      def clear
+        @expansions.clear
+      end
+
+      private
+        def defer_expansion(name, options, &blk)
+          @deferred_expansion_config = [name, options]
+          instance_eval(&blk)
+        ensure
+          @deferred_expansion_config = nil
+        end
+
+        def build_expansions_hash_with_defaults(expansions, expansion_type)
+          raise Asset::AmbiguousContext.new(:type) if expansion_type.blank?
+          raise Asset::InvalidAssetType.new(expansion_type) unless Asset::VALID_TYPES.include?(expansion_type.to_sym)
+
+          expansions[expansion_type.to_sym] = build_typed_expansion_hash_with_defaults
+        end
+
+        def build_typed_expansion_hash_with_defaults
+          Hash.new do |typed_expansions, expansion_name|
+            raise Asset::AmbiguousContext.new(:name) if expansion_name.blank?
+            typed_expansions[expansion_name] = Expansion.new(expansion_name)
+          end
+        end
+
+        def update_expansion_options(options, asset_type = nil)
+          o = options.reverse_merge(:type => @current_ytpe, :namespace => @current_namespace)
+          o.update(:type => asset_type) if asset_type
+          o
+        end
+    end
+  end
+end

data/lib/active_assets/active_expansions/javascripts.rb

@@ -0,0 +1,9 @@
+module ActiveAssets
+  module ActiveExpansions
+    class Javascripts < Assets
+      def asset_type
+        'javascript'
+      end
+    end
+  end
+end

data/lib/active_assets/active_expansions/railtie.rb

@@ -0,0 +1,52 @@
+require "rails"
+require "rails/active_assets"
+require 'active_support/ordered_options'
+
+module ActiveAssets
+  module ActiveExpansions
+    class Railtie < Rails::Railtie
+      rake_tasks do
+        Dir[File.expand_path("../../../tasks/*.rake", __FILE__)].each {|f| load f}
+      end
+
+      config.active_expansions = ActiveSupport::OrderedOptions.new
+
+      initializer :active_assets_extend_application do
+        Rails.application.extend(Rails::ActiveAssets)
+      end
+
+      initializer :load_active_assets do
+        load_active_assets(Rails.root)
+        Rails.application.railties.engines.each {|e| load_active_assets(e.root) }
+      end
+
+      initializer :register_active_assets_expansions do
+        Rails.application.expansions.javascripts.register! and Rails.application.expansions.stylesheets.register!
+      end
+
+      initializer :set_active_expansion_configs do
+        options = config.active_expansions
+        ActiveSupport.on_load(:active_expansions) do
+          options.each { |k,v| send("#{k}=", v) }
+        end
+      end
+
+      initializer :cache_active_assets do
+        if Expansions.precache_assets
+          Rails.application.expansions.javascripts.cache! and Rails.application.expansions.stylesheets.cache!
+        end
+      end
+
+      private
+        def load_active_assets(root)
+          if File.exists?(File.join(root, 'config/assets.rb'))
+            load File.join(root, 'config/assets.rb')
+          elsif File.directory?(File.join(root, 'config/assets'))
+            Dir[File.join(root, 'config/assets/*.rb')].each do |f|
+              load f
+            end
+          end
+        end
+    end
+  end
+end

data/lib/active_assets/active_expansions/stylesheets.rb

@@ -0,0 +1,9 @@
+module ActiveAssets
+  module ActiveExpansions
+    class Stylesheets < Assets
+      def asset_type
+        'stylesheet'
+      end
+    end
+  end
+end

data/lib/active_assets/active_expansions/type_inferrable.rb

@@ -0,0 +1,12 @@
+module ActiveAssets
+  module ActiveExpansions
+    module TypeInferrable
+      def inferred_type(file_path, allowed_extensions = Asset::VALID_TYPES)
+        file_ext = File.extname(file_path)
+        return [nil, nil] unless file_ext.present? && (3..5).include?(file_ext.size)
+        file_ext = file_ext[1..-1].to_sym
+        [allowed_extensions.include?(file_ext) && file_ext, file_ext]
+      end
+    end
+  end
+end

data/lib/active_assets/active_expansions.rb

@@ -0,0 +1,17 @@
+require 'active_support'
+
+module ActiveAssets
+  module ActiveExpansions
+    extend ActiveSupport::Autoload
+
+    autoload :Asset
+    autoload :AssetScope
+    autoload :TypeInferrable
+    autoload :Configurable
+    autoload :Expansion
+    autoload :Assets
+    autoload :Javascripts
+    autoload :Stylesheets
+    autoload :Expansions
+  end
+end

data/lib/active_assets.rb

@@ -0,0 +1,7 @@
+require 'active_support'
+
+module ActiveAssets
+  extend ActiveSupport::Autoload
+
+  autoload :ActiveExpansions
+end

data/lib/rails/active_assets.rb

@@ -0,0 +1,11 @@
+require 'active_assets'
+
+module Rails
+  module ActiveAssets
+    def expansions(&blk)
+      @expansions ||= ::ActiveAssets::ActiveExpansions::Expansions.new
+      @expansions.instance_eval(&blk) if block_given?
+      @expansions
+    end
+  end
+end

data/lib/tasks/cache.rake

@@ -0,0 +1,6 @@
+namespace :activeexpansions do
+  desc "Cache the active expansions to the {stylesheets,javascripts} cache directory"
+  task :cache => :environment do
+    Rails.application.expansions.javascripts.cache! and Rails.application.expansions.stylesheets.cache!
+  end
+end

data/test/active_assets/active_expansions/asset_test.rb

@@ -0,0 +1,40 @@
+require 'helper'
+
+class AssetTest < Test::Unit::TestCase
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_fields_are_set_to_defaults
+    asset = ActiveAssets::ActiveExpansions::Asset.new
+    assert_equal [nil, nil, nil, :all, true], ActiveAssets::ActiveExpansions::Asset.members.map {|member| asset.send(member)}
+  end
+
+  def test_can_set_fields_through_constructor
+    asset = ActiveAssets::ActiveExpansions::Asset.new('/path/to/asset', :js, :defaults, [:development, :test], false)
+    assert_equal ['/path/to/asset', :js, :defaults, [:development, :test], false], ActiveAssets::ActiveExpansions::Asset.members.map {|member| asset.send(member)}
+  end
+
+  def test_that_cache_will_be_true_unless_set_to_false
+    asset = ActiveAssets::ActiveExpansions::Asset.new('/path/to/asset', :js, :defaults, [:development, :test], "not false")
+    assert asset.cache
+  end
+
+  def test_validation
+    asset = ActiveAssets::ActiveExpansions::Asset.new(nil, :js, :defaults, [:development, :test], "not false")
+    assert !asset.valid?
+
+    asset = ActiveAssets::ActiveExpansions::Asset.new('/path/to/asset', nil, :defaults, [:development, :test], "not false")
+    assert !asset.valid?
+
+    asset = ActiveAssets::ActiveExpansions::Asset.new('/path/to/asset', :js, nil, [:development, :test], "not false")
+    assert !asset.valid?
+  end
+
+  def test_valid_bang
+    asset = ActiveAssets::ActiveExpansions::Asset.new(nil, :js, :defaults, [:development, :test], "not false")
+    assert_raise ActiveAssets::ActiveExpansions::Asset::ValidationError do asset.valid!; end
+  end
+end

data/test/active_assets/active_expansions/expansions_test.rb

@@ -0,0 +1,148 @@
+require 'helper'
+
+class ExpansionsTest < Test::Unit::TestCase
+  def setup
+    initialize_application_or_load_assets!
+  end
+
+  def teardown
+    delete_cached_assets!
+    Rails.application.expansions.clear
+  end
+
+  def test_new
+    assert_nothing_raised do
+      ActiveAssets::ActiveExpansions::Expansions.new
+    end
+  end
+
+  def test_namespace
+    Rails.application.expansions.namespace :fubar do
+      expansion :foo, :type => :js do
+        `bas/bar`
+        `bar/bas`
+      end
+    end
+
+    assert Rails.application.expansions.all.any? {|e| e.namespace == :fubar}
+  end
+
+  def test_namespace_2
+    Rails.application.expansions do
+      namespace :fubar do
+        expansion :foo, :type => :js do
+          `bas/bar`
+          `bar/bas`
+        end
+      end
+    end
+
+    assert Rails.application.expansions.all.any? {|e| e.namespace == :fubar}
+  end
+
+  def test_namespace_3
+    Rails.application.expansions do
+      expansion :foo, :type => :js, :namespace => :fubar do
+        `bas/bar`
+        `bar/bas`
+      end
+    end
+
+    assert Rails.application.expansions.all.any? {|e| e.namespace == :fubar}
+  end
+
+  def test_asset
+    Rails.application.expansions.asset 'bas/bar', :type => :js, :expansion_name => :foo
+  
+    assert Rails.application.expansions.javascripts.has_expansion?(:foo)
+    assert_equal :js, Rails.application.expansions.javascripts[:foo].type
+    assert Rails.application.expansions.javascripts.all.map(&:assets).flatten.any? {|a| "bar/bas" == a.path}
+  end
+  
+  def test_asset_2
+    Rails.application.expansions do
+      expansion :foo do
+        `bas/bar.js`
+      end
+    end
+  
+    assert Rails.application.expansions.javascripts.has_expansion?(:foo)
+    assert_equal :js, Rails.application.expansions.javascripts[:foo].type
+    assert Rails.application.expansions.javascripts.all.map(&:assets).flatten.any? {|a| "bar/bas.js" == a.path}
+  end
+  
+  def test_asset_3
+    Rails.application.expansions do
+      asset "bas/bar", :expansion_name => :foo, :type => :js
+    end
+  
+    assert Rails.application.expansions.javascripts.has_expansion?(:foo)
+    assert_equal :js, Rails.application.expansions.javascripts[:foo].type
+    assert Rails.application.expansions.javascripts.all.map(&:assets).flatten.any? {|a| "bar/bas" == a.path}
+  end
+  
+  def test_asset_4
+    Rails.application.expansions do
+      asset "bas/bar.js", :expansion_name => :foo
+    end
+  
+    assert Rails.application.expansions.javascripts.has_expansion?(:foo)
+    assert_equal :js, Rails.application.expansions.javascripts[:foo].type
+    assert Rails.application.expansions.javascripts.all.map(&:assets).flatten.any? {|a| "bar/bas.js" == a.path}
+  end
+  
+  def test_asset_5
+    Rails.application.expansions do
+      js do
+        asset "bas/bar", :expansion_name => :foo
+      end
+    end
+  
+    assert Rails.application.expansions.javascripts.has_expansion?(:foo)
+    assert_equal :js, Rails.application.expansions.javascripts[:foo].type
+    assert Rails.application.expansions.javascripts.all.map(&:assets).flatten.any? {|a| "bar/bas" == a.path}
+  end
+  
+  def test_asset_6
+    Rails.application.expansions do
+      css do
+        asset "bas/bar", :expansion_name => :foo
+      end
+    end
+  
+    assert Rails.application.expansions.stylesheets.has_expansion?(:foo)
+    assert_equal :css, Rails.application.expansions.stylesheets[:foo].type
+    assert Rails.application.expansions.stylesheets.all.map(&:assets).flatten.any? {|a| "bar/bas" == a.path}
+  end
+
+  def test_asset_7
+    assert Rails.application.expansions.javascripts.has_expansion?(:jazz)
+    assert Rails.application.expansions.stylesheets.has_expansion?(:jazz)
+  end
+
+  def test_asset_8
+    assert Rails.application.expansions.javascripts.has_expansion?(:dev)
+    assert Rails.application.expansions.stylesheets.has_expansion?(:dev)
+  end
+
+  def test_asset_9
+    assert_raise ActiveAssets::ActiveExpansions::Asset::InvalidAssetType do
+      Rails.application.expansions do
+        expansion :foo do
+          `bas/bar.pdf`
+        end
+      end
+    end
+  end
+
+  def test_asset_10
+    assert_raise ActiveAssets::ActiveExpansions::Asset::AmbiguousContext do
+      Rails.application.expansions do
+        expansion :foo do
+          `vendor/jquery.mousewheel`
+        end
+      end
+    end
+  end
+
+end

data/test/autocolor.rb

@@ -0,0 +1,3 @@
+Test::Unit::AutoRunner.setup_option do |auto_runner, opts|
+  auto_runner.runner_options[:use_color] = true
+end

data/test/fixtures/rails_root/config/application.rb

@@ -0,0 +1,10 @@
+require 'rails/all'
+require 'active_assets/active_expansions/railtie'
+
+module ActiveAssetsTest
+  class Application < Rails::Application
+    config.root = File.expand_path('../..', __FILE__)
+  end
+end
+
+Rails.application.config.active_support.deprecation = :stderr

data/test/fixtures/rails_root/config/assets/assets.rb

@@ -0,0 +1,71 @@
+Rails.application.expansions.register do
+  expansion :defaults, :type => :js do
+    `bas/bar`
+    `bar/bas`
+  end
+
+  js do
+    expansion :bas do
+      `bas/bar`
+      `bar/bas`
+    end
+  end
+
+  css do
+    expansion :bas do
+      `bas/bar`
+      `bar/bas`
+    end
+  end
+
+  # for ExpansionsTest#asset_test_7
+  expansion :jazz do
+    js do
+      `bas/bar`
+      `bar/bas`
+    end
+
+    css do
+      `bas/bar`
+      `bar/bas`
+    end
+  end
+
+  # for ExpansionsTest#asset_test_8
+  group :development do
+    expansion :dev do
+      asset 'bas/bar', :type => :js
+      asset 'bas/bar', :type => :css
+    end
+  end
+
+  group :development do
+    expansion :dev2 do
+      js do
+        `bas/bar`
+        `bar/bas`
+      end
+    end
+  end
+
+  expansion :envs do
+    group :development do
+      a 'bar/bas', :type => :css
+      js do
+        `bar/bas`
+      end
+    end
+  end
+
+  expansion :envs2, :type => :js do
+    group :development do
+      `bas/bar`
+      `bar/bas`
+    end
+  end
+
+  expansion :basfoo do
+    `bas/bar.js`
+    `bar/bas.js`
+  end
+end

data/test/fixtures/rails_root/public/javascripts/bar/bas.js

@@ -0,0 +1 @@
+jsbas

data/test/fixtures/rails_root/public/javascripts/bas/bar.js

@@ -0,0 +1 @@
+jsbar

data/test/fixtures/rails_root/public/stylesheets/bar/bas.css

@@ -0,0 +1 @@
+cssbas

data/test/fixtures/rails_root/public/stylesheets/bas/bar.css

@@ -0,0 +1 @@
+cssbar

data/test/helper.rb

@@ -0,0 +1,15 @@
+ENV['RAILS_ENV'] ||= 'test'
+require 'test/unit'
+
+require 'rails/all'
+require 'active_assets'
+
+TEST_RAILS_ROOT = File.expand_path('../fixtures/rails_root', __FILE__)
+
+Dir[File.expand_path('../support/**/*.rb', __FILE__)].each {|f| load f }
+
+load File.join(TEST_RAILS_ROOT, 'config/application.rb')
+
+class Test::Unit::TestCase
+  include RailsHelper
+end

data/test/support/rails_helper.rb

@@ -0,0 +1,32 @@
+require 'fileutils'
+
+module RailsHelper
+  def rails_root
+    @rails_root = TEST_RAILS_ROOT
+  end
+
+  def delete_cached_assets!
+    Dir[File.join(rails_root, 'public/javascripts/cache'), File.join(rails_root, 'public/stylesheets/cache')].each do |dir|
+      FileUtils.rm_rf(dir)
+    end
+  end
+
+  def initialize_application_or_load_assets!
+    load_assets! if Rails.application && Rails.application.instance_variable_defined?(:@ran)
+    initialize_application! unless Rails.application && Rails.application.instance_variable_defined?(:@ran)
+  end
+
+  def load_assets!
+    if File.exists?(File.join(rails_root, 'config/assets.rb'))
+      load File.join(rails_root, 'config/assets.rb')
+    elsif File.directory?(File.join(rails_root, 'config/assets'))
+      Dir[File.join(rails_root, 'config/assets/*.rb')].each do |f|
+        load f
+      end
+    end
+  end
+
+  def initialize_application!
+    ActiveAssetsTest::Application.initialize!
+  end
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification 
+name: active_assets
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Sam Woodard
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-23 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 1
+        segments: 
+        - 3
+        - 0
+        - 3
+        version: 3.0.3
+  type: :development
+  name: rails
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  name: test-unit
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  name: ZenTest
+  requirement: *id003
+description: A Railtie that provides a full asset management system, including support for development and deployment.  Currently it is designed to manage javascripts and stylesheets but will handle image sprites in the future.
+email: 
+- sam@wildfireapp.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .autotest
+- .gitignore
+- Gemfile
+- Rakefile
+- active_assets.gemspec
+- lib/active_assets.rb
+- lib/active_assets/active_expansions.rb
+- lib/active_assets/active_expansions/asset.rb
+- lib/active_assets/active_expansions/asset_scope.rb
+- lib/active_assets/active_expansions/assets.rb
+- lib/active_assets/active_expansions/configurable.rb
+- lib/active_assets/active_expansions/expansion.rb
+- lib/active_assets/active_expansions/expansions.rb
+- lib/active_assets/active_expansions/javascripts.rb
+- lib/active_assets/active_expansions/railtie.rb
+- lib/active_assets/active_expansions/stylesheets.rb
+- lib/active_assets/active_expansions/type_inferrable.rb
+- lib/rails/active_assets.rb
+- lib/tasks/cache.rake
+- test/active_assets/active_expansions/asset_test.rb
+- test/active_assets/active_expansions/expansions_test.rb
+- test/autocolor.rb
+- test/fixtures/rails_root/config/application.rb
+- test/fixtures/rails_root/config/assets/assets.rb
+- test/fixtures/rails_root/public/javascripts/bar/bas.js
+- test/fixtures/rails_root/public/javascripts/bas/bar.js
+- test/fixtures/rails_root/public/stylesheets/bar/bas.css
+- test/fixtures/rails_root/public/stylesheets/bas/bar.css
+- test/helper.rb
+- test/support/rails_helper.rb
+has_rdoc: true
+homepage: ""
+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: rails-assets
+rubygems_version: 1.4.1
+signing_key: 
+specification_version: 3
+summary: A Railtie that provides a full asset management system, including support for development and deployment.
+test_files: 
+- test/active_assets/active_expansions/asset_test.rb
+- test/active_assets/active_expansions/expansions_test.rb
+- test/autocolor.rb
+- test/fixtures/rails_root/config/application.rb
+- test/fixtures/rails_root/config/assets/assets.rb
+- test/fixtures/rails_root/public/javascripts/bar/bas.js
+- test/fixtures/rails_root/public/javascripts/bas/bar.js
+- test/fixtures/rails_root/public/stylesheets/bar/bas.css
+- test/fixtures/rails_root/public/stylesheets/bas/bar.css
+- test/helper.rb
+- test/support/rails_helper.rb