dassets 0.5.0 → 0.6.0

data/README.md

@@ -14,22 +14,13 @@ require 'dassets'
 
 Dassets.configure do |c|
 
-  # tell Dassets what the root path of your app is
-  c.root_path '/path/to/app/root'
-
-  # tell Dassets where to look for source files and (optionally) how to filter those files
-  c.source_path 'lib/asset_files' # default: '{root_path}/app/assets'
-  c.source_filter proc{ |paths| paths.select{ |p| ... } }
-  # --OR--
-  c.source 'lib/asset_files' do |paths|
-    # return the filtered source path list
-    paths.select{ |p| ... }
-  end
+  # tell Dassets where to look for source files
+  c.source '/path/to/app/assets'
 
   # (optional) tell Dassets where to store digested asset files
   # if none given, Dassets will not write any digested output
   # use this to "cache" digested assets to the public dir (for example)
-  c.file_store 'public' # default: `NullFileStore.new`
+  c.file_store '/path/to/public' # default: `NullFileStore.new`
 
 end
 ```
@@ -81,7 +72,7 @@ TODO: programmatically cache asset files
 
 ## Compiling
 
-Dassets can handle compiling your asset source as part of its digest pipeline.  It does this via "engines".  Engines transform source extensions and content.
+Dassets compiles your asset source as part of its digest pipeline using "engines".  Engines transform source extensions and content.
 
 Engines are "registered" with dassets based on source extensions.  Name your source file with registered extensions and those engines will be used to compile your source content.
 
@@ -98,6 +89,10 @@ TODO
 * override the `compile` method to specify how the input content should be transformed
 * register your engine class with Dassets
 
+## Sources
+
+TODO: filtering files, registering engines
+
 ## Combinations
 
 TODO

data/lib/dassets/asset_file.rb

@@ -1,18 +1,18 @@
 require 'rack/utils'
 require 'rack/mime'
-require 'dassets/source_cache'
+require 'dassets/source_proxy'
 
 module Dassets; end
 class Dassets::AssetFile
 
-  attr_reader :digest_path, :dirname, :extname, :basename, :source_cache
+  attr_reader :digest_path, :dirname, :extname, :basename, :source_proxy
 
   def initialize(digest_path)
     @digest_path = digest_path
     @dirname  = File.dirname(@digest_path)
     @extname  = File.extname(@digest_path)
     @basename = File.basename(@digest_path, @extname)
-    @source_cache = Dassets::SourceCache.new(@digest_path, Dassets.config.cache)
+    @source_proxy = Dassets::SourceProxy.new(@digest_path, Dassets.config.cache)
   end
 
   def digest!
@@ -33,17 +33,17 @@ class Dassets::AssetFile
 
   def fingerprint
     return nil if !self.exists?
-    @fingerprint ||= @source_cache.fingerprint
+    @fingerprint ||= @source_proxy.fingerprint
   end
 
   def content
     return nil if !self.exists?
-    @content ||= @source_cache.content
+    @content ||= @source_proxy.content
   end
 
   def mtime
     return nil if !self.exists?
-    @mtime ||= @source_cache.mtime
+    @mtime ||= @source_proxy.mtime.httpdate
   end
 
   def size
@@ -57,7 +57,7 @@ class Dassets::AssetFile
   end
 
   def exists?
-    @source_cache.exists?
+    @source_proxy.exists?
   end
 
   def ==(other_asset_file)

data/lib/dassets/digest_cmd.rb

@@ -5,6 +5,11 @@ require 'dassets/source_file'
 module Dassets; end
 class Dassets::DigestCmd
 
+  # TODO: need digest cmd to be aware of and digest combinations as well.
+  # going to wait on this for now b/c there are changes coming to how sources
+  # are obtained and the future of the digest cmd and I want to see how thost
+  # end up first.
+
   attr_reader :paths
 
   def initialize(abs_paths)
@@ -15,7 +20,7 @@ class Dassets::DigestCmd
     files = @paths
     if @paths.empty?
       # always get the latest source list
-      files = Dassets::SourceList.new(Dassets.config)
+      files = Dassets.source_list
     end
 
     log io, "digesting #{files.count} source file(s) ..."

data/lib/dassets/file_store.rb

@@ -1,12 +1,11 @@
 require 'thread'
-require 'dassets/root_path'
 
 module Dassets; end
 class Dassets::FileStore
   attr_reader :root
 
   def initialize(root)
-    @root = Dassets::RootPath.new(root)
+    @root = root
     @save_mutex = ::Mutex.new
   end
 

data/lib/dassets/server/request.rb

@@ -17,7 +17,7 @@ class Dassets::Server
     # - then check if for a digested asset resource (kinda fast)
     # - then check if source exists for the digested asset (slower)
     def for_asset_file?
-      !!((get? || head?) && for_digested_asset? && asset_file.source_cache.exists?)
+      !!((get? || head?) && for_digested_asset? && asset_file.exists?)
     end
 
     def asset_path

data/lib/dassets/source.rb

@@ -0,0 +1,38 @@
+require 'dassets/engine'
+
+module Dassets; end
+class Dassets::Source
+
+  attr_reader :path, :engines
+
+  def initialize(path)
+    @path = path.to_s
+    @filter = proc{ |paths| paths }
+    @engines = Hash.new{ |h,k| Dassets::NullEngine.new }
+  end
+
+  def filter(&block)
+    block.nil? ? @filter : @filter = block
+  end
+
+  def engine(input_ext, engine_class, registered_opts=nil)
+    default_opts = { 'source_path' => @path }
+    engine_opts = default_opts.merge(registered_opts || {})
+    @engines[input_ext.to_s] = engine_class.new(engine_opts)
+  end
+
+  def files
+    apply_filter(glob_files).sort
+  end
+
+  private
+
+  def glob_files
+    Dir.glob(File.join(@path, "**/*"  )).reject!{ |p| !File.file?(p) }
+  end
+
+  def apply_filter(files)
+    @filter.call(files)
+  end
+
+end

data/lib/dassets/source_file.rb

@@ -1,4 +1,3 @@
-require 'digest/md5'
 require 'fileutils'
 require 'dassets'
 require 'dassets/asset_file'
@@ -8,22 +7,30 @@ module Dassets
   class SourceFile
 
     def self.find_by_digest_path(path)
-      # always look at the freshest source list to make sure you get all sources
-      # not just the ones Dassets has cached
-      sources = Dassets::SourceList.new(Dassets.config).map{ |p| self.new(p) }
+      # look in the configured source list
+      source_files = Dassets.source_list.map{ |p| self.new(p) }
 
-      # get the last matching one in case two sources have the same digest path
-      # the last one *should* be correct since it was last to be digested
-      sources.select{ |s| s.digest_path == path }.last || NullSourceFile.new(path)
+      # get the last matching one (in case two source files have the same digest
+      # path the last one *should* be correct since it was last to be configured)
+      source_files.select{ |s| s.digest_path == path }.last || NullSourceFile.new(path)
     end
 
     attr_reader :file_path
 
     def initialize(file_path)
-      @file_path = file_path
+      @file_path = file_path.to_s
       @ext_list = File.basename(@file_path).split('.').reverse
     end
 
+    # get the last matching one (in the case two sources with the same path are
+    # configured) since we select the last matching source file (from the last
+    # configured source) in `find_by_digest_path` above.
+    def source
+      @source ||= Dassets.config.sources.select do |source|
+        @file_path =~ /^#{slash_path(source.path)}/
+      end.last
+    end
+
     def asset_file
       @asset_file ||= Dassets::AssetFile.new(self.digest_path)
     end
@@ -31,32 +38,25 @@ module Dassets
     def digest_path
       @digest_path ||= begin
         digest_basename = @ext_list.inject([]) do |digest_ext_list, ext|
-          digest_ext_list << Dassets.config.engines[ext].ext(ext)
-        end.reject{ |e| e.empty? }.reverse.join('.')
+          digest_ext_list << self.source.engines[ext].ext(ext)
+        end.reject(&:empty?).reverse.join('.')
 
-        File.join([
-          digest_dirname(@file_path, Dassets.config.source_path),
-          digest_basename
-        ].reject{ |p| p.empty? })
+        File.join([digest_dirname(@file_path), digest_basename].reject(&:empty?))
       end
     end
 
     def compiled
       @compiled ||= @ext_list.inject(read_file(@file_path)) do |content, ext|
-        Dassets.config.engines[ext].compile(content)
+        self.source.engines[ext].compile(content)
       end
     end
 
-    def fingerprint
-      @fingerprint ||= Digest::MD5.new.hexdigest(self.compiled)
-    end
-
     def exists?
       File.file?(@file_path)
     end
 
     def mtime
-      File.mtime(@file_path).httpdate
+      File.mtime(@file_path)
     end
 
     def ==(other_source_file)
@@ -65,8 +65,9 @@ module Dassets
 
     private
 
-    def digest_dirname(file_path, source_path)
-      slash_path(File.dirname(file_path)).sub(slash_path(source_path), '')
+    # remove the source path from the dirname (if it exists)
+    def digest_dirname(file_path)
+      slash_path(File.dirname(file_path)).sub(slash_path(self.source.path), '')
     end
 
     def slash_path(path)
@@ -86,7 +87,6 @@ module Dassets
       @ext_list = []
       @digest_path = digest_path
     end
-    def digest; end
     def ==(other_source_file)
       self.file_path == other_source_file.file_path
     end

data/lib/dassets/source_proxy.rb

@@ -0,0 +1,56 @@
+require 'digest/md5'
+require 'dassets/source_file'
+
+module Dassets; end
+class Dassets::SourceProxy
+
+  attr_reader :digest_path, :source_files, :cache
+
+  def initialize(digest_path, cache=nil)
+    @digest_path  = digest_path
+    @source_files = get_source_files(@digest_path)
+    @cache = cache || NoCache.new
+  end
+
+  def key
+    "#{self.digest_path} -- #{self.mtime}"
+  end
+
+  def content
+    @cache["#{self.key} -- content"] ||= source_content
+  end
+
+  def fingerprint
+    @cache["#{self.key} -- fingerprint"] ||= source_fingerprint
+  end
+
+  def mtime
+    @source_files.map{ |f| f.mtime }.max
+  end
+
+  def exists?
+    @source_files.inject(true){ |res, f| res && f.exists? }
+  end
+
+  private
+
+  def source_content
+    @source_content ||= @source_files.map{ |f| f.compiled }.join("\n")
+  end
+
+  def source_fingerprint
+    @source_fingerprint ||= Digest::MD5.new.hexdigest(source_content)
+  end
+
+  def get_source_files(digest_path)
+    Dassets.config.combinations[digest_path.to_s].map do |source_digest_path|
+      Dassets::SourceFile.find_by_digest_path(source_digest_path)
+    end
+  end
+
+  class NoCache
+    def [](key); end
+    def []=(key, value); end
+  end
+
+end

data/lib/dassets/version.rb

@@ -1,3 +1,3 @@
 module Dassets
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/dassets.rb

@@ -3,10 +3,9 @@ require 'set'
 require 'ns-options'
 
 require 'dassets/version'
-require 'dassets/root_path'
 require 'dassets/file_store'
 require 'dassets/default_cache'
-require 'dassets/engine'
+require 'dassets/source'
 require 'dassets/asset_file'
 
 ENV['DASSETS_ASSETS_FILE'] ||= 'config/assets'
@@ -23,13 +22,16 @@ module Dassets
       require self.config.assets_file
     rescue LoadError
     end
-    raise 'no Dassets `root_path` specified' if !self.config.required_set?
   end
 
   def self.[](digest_path)
     AssetFile.new(digest_path)
   end
 
+  def self.source_list
+    SourceList.new(self.config.sources)
+  end
+
   # Cmds
 
   def self.digest_source_files(paths=nil)
@@ -40,38 +42,31 @@ module Dassets
   class Config
     include NsOptions::Proxy
 
-    option :root_path,     Pathname,  :required => true
     option :assets_file,   Pathname,  :default => ENV['DASSETS_ASSETS_FILE']
-    option :source_path,   RootPath,  :default => proc{ "app/assets" }
-    option :source_filter, Proc,      :default => proc{ |paths| paths }
     option :file_store,    FileStore, :default => proc{ NullFileStore.new }
 
-    attr_reader :engines
+    attr_reader :sources, :combinations
     attr_accessor :cache
 
     def initialize
       super
-      @engines = Hash.new{ |k,v| Dassets::NullEngine.new }
+      @sources = []
+      @combinations = Hash.new{ |h,k| [k] } # digest pass-thru if none defined
       @cache = DefaultCache.new
     end
 
-    def source(path=nil, &filter)
-      self.source_path   = path  if path
-      self.source_filter = filter if filter
+    def source(path, &block)
+      @sources << Source.new(path).tap{ |s| block.call(s) if block }
     end
 
-    def engine(input_ext, engine_class, opts=nil)
-      @engines[input_ext.to_s] = engine_class.new(opts)
+    def combination(key_digest_path, value_digest_paths)
+      @combinations[key_digest_path.to_s] = [*value_digest_paths]
     end
   end
 
   module SourceList
-    def self.new(config)
-      paths = Set.new
-      paths += Dir.glob(File.join(config.source_path, "**/*"))
-      paths.reject!{ |path| !File.file?(path) }
-
-      config.source_filter.call(paths).sort
+    def self.new(sources)
+      sources.inject([]){ |list, source| list += source.files }
     end
   end
 

data/test/helper.rb

@@ -7,6 +7,9 @@ $LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
 # require pry for debugging (`binding.pry`)
 require 'pry'
 
+require 'pathname'
+TEST_SUPPORT_PATH = Pathname.new(File.expand_path('../support', __FILE__))
+
 ENV['DASSETS_TEST_MODE']   = 'yes'
 ENV['DASSETS_ASSETS_FILE'] = 'test/support/config/assets'
 require 'dassets'

data/test/support/config/assets.rb

@@ -10,10 +10,11 @@ end
 end
 
 Dassets.configure do |c|
-  c.root_path File.expand_path("../..", __FILE__)
+  c.source TEST_SUPPORT_PATH.join("app/assets") do |s|
+    s.engine 'dumb', @dumb_engine
+    s.engine 'useless', @useless_engine
+  end
 
-  c.engine 'dumb', @dumb_engine
-  c.engine 'useless', @useless_engine
   c.cache = nil # use no cache
 
 end

data/test/system/digest_cmd_run_tests.rb

@@ -7,7 +7,7 @@ module Dassets
   class DigestCmdRunTests < Assert::Context
     desc "the DigestCmd"
     setup do
-      Dassets.config.file_store = 'public'
+      Dassets.config.file_store = TEST_SUPPORT_PATH.join('public').to_s
       clear_store_path(Dassets.config.file_store.root)
       Dassets.digest_source_files
 
@@ -52,7 +52,7 @@ module Dassets
     private
 
     def source_path(file)
-      File.join(File.join(Dassets.config.source_path, file))
+      File.join(Dassets.config.sources.first.path, file)
     end
 
     def store_path(file)

data/test/system/rack_tests.rb

@@ -40,7 +40,7 @@ module Dassets
 
   class DigestTests < SuccessTests
     setup do
-      Dassets.config.file_store = 'public'
+      Dassets.config.file_store = TEST_SUPPORT_PATH.join('public').to_s
       @url = 'file1-daa05c683a4913b268653f7a7e36a5b4.txt'
       @url_file = Dassets.config.file_store.store_path(@url)
       FileUtils.rm(@url_file)

data/test/unit/asset_file_tests.rb

@@ -1,7 +1,7 @@
 require 'assert'
 require 'fileutils'
 require 'dassets/file_store'
-require 'dassets/source_cache'
+require 'dassets/source_proxy'
 require 'dassets/asset_file'
 
 class Dassets::AssetFile
@@ -13,7 +13,7 @@ class Dassets::AssetFile
     end
     subject{ @asset_file }
 
-    should have_readers :digest_path, :dirname, :extname, :basename, :source_cache
+    should have_readers :digest_path, :dirname, :extname, :basename, :source_proxy
     should have_imeths  :digest!, :url, :fingerprint, :content
     should have_imeths  :href, :mtime, :size, :mime_type, :exists?, :==
 
@@ -25,7 +25,7 @@ class Dassets::AssetFile
     end
 
     should "use its source file attrs as its own" do
-      assert_equal subject.source_cache.mtime, subject.mtime
+      assert_equal subject.source_proxy.mtime.httpdate, subject.mtime
       assert_equal Rack::Utils.bytesize(subject.content), subject.size
       assert_equal "text/plain", subject.mime_type
       assert subject.exists?
@@ -37,19 +37,19 @@ class Dassets::AssetFile
       assert_not null_file.exists?
     end
 
-    should "know its source cache" do
-      assert_not_nil subject.source_cache
-      assert_kind_of Dassets::SourceCache, subject.source_cache
-      assert_equal subject.digest_path, subject.source_cache.digest_path
+    should "know its source proxy" do
+      assert_not_nil subject.source_proxy
+      assert_kind_of Dassets::SourceProxy, subject.source_proxy
+      assert_equal subject.digest_path, subject.source_proxy.digest_path
     end
 
     should "have a fingerprint" do
       assert_not_nil subject.fingerprint
     end
 
-    should "get its fingerprint from its source cache if none is given" do
+    should "get its fingerprint from its source proxy if none is given" do
       af = Dassets::AssetFile.new('file1.txt')
-      assert_equal af.source_cache.fingerprint, af.fingerprint
+      assert_equal af.source_proxy.fingerprint, af.fingerprint
     end
 
     should "know it's content" do
@@ -59,7 +59,7 @@ class Dassets::AssetFile
       assert_nil null_file.content
     end
 
-    should "get its content from its source cache if no output file" do
+    should "get its content from its source proxy if no output file" do
       digest_path = 'nested/a-thing.txt.no-use'
       exp_content = "thing\n\nDUMB\nUSELESS"
 
@@ -86,7 +86,7 @@ class Dassets::AssetFile
   class DigestTests < BaseTests
     desc "being digested with an output path configured"
     setup do
-      Dassets.config.file_store = 'public'
+      Dassets.config.file_store = TEST_SUPPORT_PATH.join('public').to_s
       @save_path = @asset_file.digest!
       @outfile = Dassets.config.file_store.store_path(@asset_file.url)
     end

data/test/unit/config_tests.rb

@@ -12,46 +12,37 @@ class Dassets::Config
     end
     subject{ @config }
 
-    should have_option :root_path, Pathname, :required => true
-    should have_option :assets_file, Pathname, :default => ENV['DASSETS_ASSETS_FILE']
-    should have_options :source_path, :source_filter, :file_store
+    should have_option :assets_file, Pathname,  :default => ENV['DASSETS_ASSETS_FILE']
+    should have_options :file_store
 
-    should have_reader :engines
-    should have_imeth :source, :engine
+    should have_reader :combinations
+    should have_imeth :source, :combination
 
-    should "should use `apps/assets` as the default source path" do
-      exp_path = Dassets.config.root_path.join("app/assets").to_s
-      assert_equal exp_path, subject.source_path
-    end
-
-    should "set the source path and filter proc with the `sources` method" do
-      path = Dassets::RootPath.new 'app/asset_files'
+    should "register new sources with the `source` method" do
+      path = '/path/to/app/assets'
       filter = proc{ |paths| [] }
+      subject.source(path){ |s| s.filter(&filter) }
 
-      subject.source(path, &filter)
-      assert_equal path, subject.source_path
-      assert_equal filter, subject.source_filter
+      assert_equal 1, subject.sources.size
+      assert_kind_of Dassets::Source, subject.sources.first
+      assert_equal path, subject.sources.first.path
+      assert_equal filter, subject.sources.first.filter
     end
 
-    should "know its engines and return a NullEngine by default" do
-      assert_kind_of ::Hash, subject.engines
-      assert_kind_of Dassets::NullEngine, subject.engines['some']
-      assert_kind_of Dassets::NullEngine, subject.engines['thing']
+    should "know its combinations and return the keyed digest path by default" do
+      assert_kind_of ::Hash, subject.combinations
+      assert_equal ['some/digest.path'], subject.combinations['some/digest.path']
     end
 
-    should "allow registering new engines" do
-      empty_engine = Class.new(Dassets::Engine) do
-        def ext(input_ext); ''; end
-        def compile(input); ''; end
-      end
-
-      assert_kind_of Dassets::NullEngine, subject.engines['empty']
-      subject.engine 'empty', empty_engine, 'an' => 'opt'
-      assert_kind_of empty_engine, subject.engines['empty']
+    should "allow registering new combinations" do
+      assert_equal ['some/digest.path'], subject.combinations['some/digest.path']
+      exp_combination = ['some/other.path', 'and/another.path']
+      subject.combination 'some/digest.path', exp_combination
+      assert_equal exp_combination, subject.combinations['some/digest.path']
 
-      assert_equal({'an' => 'opt'}, subject.engines['empty'].opts)
-      assert_equal '', subject.engines['empty'].ext('empty')
-      assert_equal '', subject.engines['empty'].compile('some content')
+      assert_equal ['test/digest.path'], subject.combinations['test/digest.path']
+      subject.combination 'test/digest.path', ['some/other.path']
+      assert_equal ['some/other.path'], subject.combinations['test/digest.path']
     end
 
   end

data/test/unit/dassets_tests.rb

@@ -9,7 +9,7 @@ module Dassets
     subject{ Dassets }
 
     should have_imeths :config, :configure, :init, :[]
-    should have_imeths :digest_source_files
+    should have_imeths :source_list, :digest_source_files
 
     should "return a `Config` instance with the `config` method" do
       assert_kind_of Config, subject.config
@@ -23,54 +23,14 @@ module Dassets
       assert_equal 'd41d8cd98f00b204e9800998ecf8427e', file.fingerprint
     end
 
-    should "return an asset file with unknown source if digest path not found" do
+    should "return an asset file that doesn't exist if digest path not found" do
       file = subject['path/not/found.txt']
-
-      assert_kind_of Dassets::SourceCache, file.source_cache
-      assert_kind_of Dassets::NullSourceFile, file.source_cache.source_file
-      assert_not file.source_cache.exists?
+      assert_not file.exists?
     end
 
-    should "complain if trying to init without setting the root path" do
-      orig_root = Dassets.config.root_path
-
-      Dassets.config.root_path = nil
-      assert_raises(RuntimeError){ Dassets.init }
-
-      Dassets.config.root_path = orig_root
-    end
-
-  end
-
-  class SourceListTests < BaseTests
-    desc "source list"
-
-    should "build from the configured source path and filter proc" do
-      config = Dassets::Config.new
-      config.source_path = "source_files" # test/support/source_files
-      exp_list = [
-        'test1.txt', '_ignored.txt', 'nested/test2.txt', 'nested/_nested_ignored.txt'
-      ].map{ |p| File.expand_path(p, config.source_path) }.sort
-
-      assert_equal exp_list, Dassets::SourceList.new(config)
-    end
-
-    should "run the supplied source filter on the paths" do
-      config = Dassets::Config.new
-      config.source_path = "source_files" # test/support/source_files
-      config.source_filter = proc do |paths|
-        paths.reject{ |path| File.basename(path) =~ /^_/ }
-      end
-      exp_list = [
-        'test1.txt', 'nested/test2.txt'
-      ].map{ |p| File.expand_path(p, config.source_path) }.sort
-
-      assert_equal exp_list, Dassets::SourceList.new(config)
-
-      config.source "source_files" do |paths|
-        paths.reject{ |path| File.basename(path) =~ /^_/ }
-      end
-      assert_equal exp_list, Dassets::SourceList.new(config)
+    should "know its list of configured source files" do
+      exp_configured_list = Dassets::SourceList.new(Dassets.config.sources)
+      assert_equal exp_configured_list, subject.source_list
     end
 
   end

data/test/unit/file_store_tests.rb

@@ -1,10 +1,9 @@
 require 'assert'
-require 'dassets/root_path'
 require 'dassets/file_store'
 
 class Dassets::FileStore
 
-  class BaseTests < Assert::Context
+  class NullTests < Assert::Context
     desc "Dassets::NullFileStore"
     subject{ Dassets::NullFileStore.new }
 
@@ -15,14 +14,16 @@ class Dassets::FileStore
       assert_kind_of Dassets::FileStore, subject
     end
 
-    should "build its root based on the config's root_path" do
-      assert_equal Dassets::RootPath.new(''), subject.root
+    should "know its root path" do
+      assert_equal '', subject.root
     end
 
     should "build the store path based on a given url" do
+      assert_equal '/some/url', subject.store_path('some/url')
     end
 
     should "return the store path on save" do
+      assert_equal '/some/url', subject.save('some/url')
     end
 
   end

data/test/unit/source_file_tests.rb

@@ -7,18 +7,18 @@ class Dassets::SourceFile
   class BaseTests < Assert::Context
     desc "Dassets::SourceFile"
     setup do
-      @file_path = File.join(Dassets.config.source_path, 'file1.txt')
+      @file_path = TEST_SUPPORT_PATH.join('app/assets/file1.txt').to_s
       @source_file = Dassets::SourceFile.new(@file_path)
     end
     subject{ @source_file }
 
     should have_readers :file_path
-    should have_imeths :asset_file, :digest_path
-    should have_imeths :compiled, :fingerprint, :exists?, :mtime
+    should have_imeths :source, :asset_file, :digest_path
+    should have_imeths :compiled, :exists?, :mtime
     should have_cmeth :find_by_digest_path
 
     should "know its file path" do
-      assert_equal @file_path, subject.file_path
+      assert_equal @file_path.to_s, subject.file_path
     end
 
     should "know if it exists" do
@@ -26,7 +26,7 @@ class Dassets::SourceFile
     end
 
     should "use the mtime of its file as its mtime" do
-      assert_equal File.mtime(subject.file_path).httpdate, subject.mtime
+      assert_equal File.mtime(subject.file_path), subject.mtime
     end
 
     should "know its digest path" do
@@ -38,8 +38,9 @@ class Dassets::SourceFile
       assert_equal Dassets::AssetFile.new(subject.digest_path), subject.asset_file
     end
 
-    should "know its compiled content fingerprint" do
-      assert_equal 'daa05c683a4913b268653f7a7e36a5b4', subject.fingerprint
+    should "know its configured source" do
+      exp_source = Dassets.config.sources.select{ |s| @file_path.include?(s.path) }.last
+      assert_equal exp_source, subject.source
     end
 
     should "be findable by its digest path" do
@@ -62,7 +63,7 @@ class Dassets::SourceFile
   class EngineTests < BaseTests
     desc "compiled against engines"
     setup do
-      @file_path = File.join(Dassets.config.source_path, 'nested/a-thing.txt.useless.dumb')
+      @file_path = TEST_SUPPORT_PATH.join('app/assets/nested/a-thing.txt.useless.dumb')
       @source_file = Dassets::SourceFile.new(@file_path)
     end
 

data/test/unit/source_proxy_tests.rb

@@ -0,0 +1,92 @@
+require 'assert'
+require 'digest/md5'
+require 'dassets/source_file'
+require 'dassets/source_proxy'
+
+class Dassets::SourceProxy
+
+  class BaseTests < Assert::Context
+    desc "Dassets::SourceProxy"
+    setup do
+      @source_proxy = Dassets::SourceProxy.new('file1.txt')
+    end
+    subject{ @source_proxy }
+
+    should have_readers :digest_path, :source_files
+    should have_imeths :content, :fingerprint, :key, :mtime, :exists?
+
+    should "know its digest path" do
+      assert_equal 'file1.txt', subject.digest_path
+    end
+
+    should "know its source file" do
+      exp_source_file = Dassets::SourceFile.find_by_digest_path('file1.txt')
+      assert_equal 1, subject.source_files.size
+      assert_equal exp_source_file, subject.source_files.first
+    end
+
+    should "exist if its source file exists" do
+      assert_equal subject.source_files.first.exists?, subject.exists?
+    end
+
+    should "use its source file's mtime as its mtime" do
+      assert_equal subject.source_files.first.mtime, subject.mtime
+    end
+
+    should "use its digest path and mtime as its key" do
+      exp_key = "#{subject.digest_path} -- #{subject.mtime}"
+      assert_equal exp_key, subject.key
+    end
+
+    should "get its fingerprint by MD5 hashing the compiled source" do
+      exp_fp = Digest::MD5.new.hexdigest(subject.content)
+      assert_equal exp_fp, subject.fingerprint
+    end
+
+    should "get its content from the compiled source" do
+      assert_equal subject.source_files.first.compiled, subject.content
+    end
+
+  end
+
+  class CombinationTests < BaseTests
+    desc "when the digest path is a combination to multiple source files"
+    setup do
+      Dassets.config.combination 'file3.txt', ['file1.txt', 'file2.txt']
+      @source_proxy = Dassets::SourceProxy.new('file3.txt')
+      @exp_source_files = [
+        Dassets::SourceFile.find_by_digest_path('file1.txt'),
+        Dassets::SourceFile.find_by_digest_path('file2.txt')
+      ]
+    end
+    teardown do
+      Dassets.config.combinations.delete('file3.txt')
+    end
+
+    should "know its digest path" do
+      assert_equal 'file3.txt', subject.digest_path
+    end
+
+    should "know its source file" do
+      assert_equal 2, subject.source_files.size
+      assert_equal @exp_source_files, subject.source_files
+    end
+
+    should "exist if its source file exists" do
+      exp_exists = @exp_source_files.inject(true){ |res, f| res && f.exists? }
+      assert_equal exp_exists, subject.exists?
+    end
+
+    should "use its source file's mtime as its mtime" do
+      exp_mtime = @exp_source_files.map{ |f| f.mtime }.max
+      assert_equal exp_mtime, subject.mtime
+    end
+
+    should "get its content from the compiled source" do
+      exp_content = @exp_source_files.map{ |f| f.compiled }.join("\n")
+      assert_equal exp_content, subject.content
+    end
+
+  end
+
+end

data/test/unit/source_tests.rb

@@ -0,0 +1,89 @@
+require 'assert'
+require 'dassets/source'
+
+class Dassets::Source
+
+  class BaseTests < Assert::Context
+    desc "Dassets::Source"
+    setup do
+      @source_path = TEST_SUPPORT_PATH.join("source_files")
+      @source = Dassets::Source.new(@source_path)
+    end
+    subject{ @source }
+
+    should have_reader :path, :engines
+    should have_imeth :files, :filter, :engine
+
+    should "know its path and default filter" do
+      assert_equal @source_path.to_s, subject.path
+      assert_kind_of Proc, subject.filter
+      assert_equal ['file1', 'file2'], subject.filter.call(['file1', 'file2'])
+    end
+
+    should "know its files" do
+      exp_files = [
+        @source_path.join('test1.txt').to_s,
+        @source_path.join('_ignored.txt').to_s,
+        @source_path.join('nested/test2.txt').to_s,
+        @source_path.join('nested/_nested_ignored.txt').to_s
+      ].sort
+      assert_equal exp_files, subject.files
+    end
+
+    should "run the supplied source filter on the paths" do
+      subject.filter do |paths|
+        paths.reject{ |path| File.basename(path) =~ /^_/ }
+      end
+      exp_files = [
+        @source_path.join('test1.txt').to_s,
+        @source_path.join('nested/test2.txt').to_s,
+      ].sort
+
+      assert_equal exp_files, subject.files
+    end
+
+    should "know its engines and return a NullEngine by default" do
+      assert_kind_of ::Hash, subject.engines
+      assert_kind_of Dassets::NullEngine, subject.engines['something']
+    end
+
+  end
+
+  class EngineRegistrationTests < BaseTests
+    desc "when registering an engine"
+    setup do
+      @empty_engine = Class.new(Dassets::Engine) do
+        def ext(input_ext); ''; end
+        def compile(input); ''; end
+      end
+    end
+
+    should "allow registering new engines" do
+      assert_kind_of Dassets::NullEngine, subject.engines['empty']
+      subject.engine 'empty', @empty_engine, 'an' => 'opt'
+      assert_kind_of @empty_engine, subject.engines['empty']
+      assert_equal 'opt', subject.engines['empty'].opts['an']
+      assert_equal '', subject.engines['empty'].ext('empty')
+      assert_equal '', subject.engines['empty'].compile('some content')
+    end
+
+    should "register with the source path as a default option" do
+      subject.engine 'empty', @empty_engine
+      exp_opts = { 'source_path' => subject.path }
+      assert_equal exp_opts, subject.engines['empty'].opts
+
+      subject.engine 'empty', @empty_engine, 'an' => 'opt'
+      exp_opts = {
+        'source_path' => subject.path,
+        'an' => 'opt'
+      }
+      assert_equal exp_opts, subject.engines['empty'].opts
+
+      subject.engine 'empty', @empty_engine, 'source_path' => 'something'
+      exp_opts = { 'source_path' => 'something' }
+      assert_equal exp_opts, subject.engines['empty'].opts
+    end
+
+  end
+
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: dassets
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 7
   prerelease: 
   segments: 
   - 0
-  - 5
+  - 6
   - 0
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Kelly Redding
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-05-02 00:00:00 Z
+date: 2013-05-09 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: assert
@@ -118,13 +118,13 @@ files:
 - lib/dassets/digest_cmd.rb
 - lib/dassets/engine.rb
 - lib/dassets/file_store.rb
-- lib/dassets/root_path.rb
 - lib/dassets/runner.rb
 - lib/dassets/server.rb
 - lib/dassets/server/request.rb
 - lib/dassets/server/response.rb
-- lib/dassets/source_cache.rb
+- lib/dassets/source.rb
 - lib/dassets/source_file.rb
+- lib/dassets/source_proxy.rb
 - lib/dassets/version.rb
 - log/.gitkeep
 - test/helper.rb
@@ -157,8 +157,9 @@ files:
 - test/unit/server/request_tests.rb
 - test/unit/server/response_tests.rb
 - test/unit/server_tests.rb
-- test/unit/source_cache_tests.rb
 - test/unit/source_file_tests.rb
+- test/unit/source_proxy_tests.rb
+- test/unit/source_tests.rb
 - tmp/.gitkeep
 homepage: http://github.com/redding/dassets
 licenses: []
@@ -224,5 +225,6 @@ test_files:
 - test/unit/server/request_tests.rb
 - test/unit/server/response_tests.rb
 - test/unit/server_tests.rb
-- test/unit/source_cache_tests.rb
 - test/unit/source_file_tests.rb
+- test/unit/source_proxy_tests.rb
+- test/unit/source_tests.rb

data/lib/dassets/root_path.rb

@@ -1,12 +0,0 @@
-# This takes a path string relative to the configured root path and tranforms
-# to the full qualifed root path.  The goal here is to specify path options
-# with root-relative path strings.
-
-module Dassets; end
-class Dassets::RootPath < String
-
-  def initialize(path_string)
-    super(Dassets.config.root_path.join(path_string).to_s)
-  end
-
-end

data/lib/dassets/source_cache.rb

@@ -1,39 +0,0 @@
-require 'dassets/source_file'
-
-module Dassets; end
-class Dassets::SourceCache
-
-  attr_reader :digest_path, :source_file, :cache
-
-  def initialize(digest_path, cache=nil)
-    @digest_path = digest_path
-    @source_file = Dassets::SourceFile.find_by_digest_path(digest_path)
-    @cache = cache || NoCache.new
-  end
-
-  def content
-    @cache["#{self.key} -- content"] ||= @source_file.compiled
-  end
-
-  def fingerprint
-    @cache["#{self.key} -- fingerprint"] ||= @source_file.fingerprint
-  end
-
-  def key
-    "#{self.digest_path} -- #{self.mtime}"
-  end
-
-  def mtime
-    @source_file.mtime
-  end
-
-  def exists?
-    @source_file.exists?
-  end
-
-  class NoCache
-    def [](key); end
-    def []=(key, value); end
-  end
-
-end

data/test/unit/source_cache_tests.rb

@@ -1,50 +0,0 @@
-require 'assert'
-require 'dassets/source_file'
-require 'dassets/source_cache'
-
-class Dassets::SourceCache
-
-  class BaseTests < Assert::Context
-    desc "Dassets::SourceCache"
-    setup do
-      @source_cache = Dassets::SourceCache.new('file1.txt')
-    end
-    subject{ @source_cache }
-
-    should have_readers :digest_path, :source_file
-    should have_imeths :content, :fingerprint, :key, :mtime, :exists?
-
-    should "know its digest path" do
-      assert_equal 'file1.txt', subject.digest_path
-    end
-
-    should "know its source file" do
-      exp_source_file = Dassets::SourceFile.find_by_digest_path('file1.txt')
-      assert_equal exp_source_file, subject.source_file
-    end
-
-    should "exist if its source file exists" do
-      assert_equal subject.source_file.exists?, subject.exists?
-    end
-
-    should "use its source file's mtime as its mtime" do
-      assert_equal subject.source_file.mtime, subject.mtime
-    end
-
-    should "use its digest path and mtime as its key" do
-      exp_key = "#{subject.digest_path} -- #{subject.mtime}"
-      assert_equal exp_key, subject.key
-    end
-
-    should "get its fingerprint from the source file" do
-      assert_equal subject.source_file.fingerprint, subject.fingerprint
-    end
-
-    should "get its content from the source file" do
-      assert_equal subject.source_file.compiled, subject.content
-    end
-
-
-  end
-
-end