dassets 0.2.0 → 0.3.0

data/README.md

@@ -17,11 +17,21 @@ Dassets.configure do |c|
   # tell Dassets what the root path of your app is
   c.root_path '/path/to/app/root'
 
-  # it works best to *not* keep the asset files in your public dir
-  c.files_path '/path/to/not/public' # default: '{root_path}/app/assets/public'
-
-  # you can choose the file to write the digests to, if you want
-  c.digests_file_path '/path/to/.digests' # default: '{files_path}/app/assets/.digests'
+  # tell Dassets where to write the digests
+  c.digests_path '/path/to/.digests' # default: '{source_path}/.digests'
+
+  # 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.sources 'lib/asset_files' do |paths|
+    # return the filtered source path list
+    paths.select{ |p| ... }
+  end
+
+  # tell Dassets where to write output files to
+  # it works best to *not* output to your public dir if using fingerprinting
+  c.output_path '/lib/assets_output' # default: '{source_path}/public'
 
 end
 ```

data/lib/dassets.rb

@@ -1,39 +1,86 @@
 require 'pathname'
+require 'set'
 require 'ns-options'
 
 require 'dassets/version'
 require 'dassets/root_path'
-require 'dassets/digests_file'
+require 'dassets/digests'
+require 'dassets/engine'
 
 ENV['DASSETS_ASSETS_FILE'] ||= 'config/assets'
 
 module Dassets
 
-  def self.config; Config; end
-  def self.configure(&block); Config.define(&block); end
+  def self.config;  @config  ||= Config.new;      end
+  def self.sources; @sources ||= Set.new;         end
+  def self.digests; @digests ||= NullDigests.new; end
 
-  def self.init
-    require self.config.assets_file
-    @digests_file = DigestsFile.new(self.config.digests_file_path)
+  def self.configure(&block)
+    block.call(self.config)
   end
 
   def self.reset
-    @digests_file = nil
+    @sources = @digests = nil
+  end
+
+  def self.init
+    require self.config.assets_file
+    @sources = SourceList.new(self.config)
+    @digests = Digests.new(self.config.digests_path)
   end
 
-  def self.digests; @digests_file || NullDigestsFile.new; end
   def self.[](asset_path)
     self.digests.asset_file(asset_path)
   end
 
+  # Cmds
+
+  def self.digest_source_files(paths=nil)
+    require 'dassets/cmds/digest_cmd'
+    Cmds::DigestCmd.new(paths).run
+  end
+
   class Config
     include NsOptions::Proxy
 
-    option :assets_file, Pathname, :default => ENV['DASSETS_ASSETS_FILE']
-    option :root_path,   Pathname, :required => true
-    option :files_path,  RootPath, :default => proc{ "app/assets/public" }
-    option :digests_file_path, RootPath, :default => proc{ "app/assets/.digests" }
+    option :root_path,    Pathname, :required => true
+    option :digests_path, Pathname, :required => true
+    option :output_path,  RootPath, :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 }
+
+    attr_reader :engines
+
+    def initialize
+      super({
+        :digests_path => proc{ File.join(self.source_path, '.digests') },
+        :output_path  => proc{ File.join(self.source_path, 'public')   }
+      })
+      @engines = Hash.new{ |k,v| Dassets::NullEngine.new }
+    end
+
+    def source(path=nil, &filter)
+      self.source_path   = path  if path
+      self.source_filter = filter if filter
+    end
+
+    def engine(input_ext, engine_class, opts=nil)
+      @engines[input_ext.to_s] = engine_class.new(opts)
+    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) }
+      paths.reject!{ |path| path =~ /^#{config.output_path}/ }
+      paths.reject!{ |path| path =~ /^#{config.digests_path}/ }
 
+      config.source_filter.call(paths).sort
+    end
   end
 
 end

data/lib/dassets/asset_file.rb

@@ -6,13 +6,13 @@ module Dassets; end
 class Dassets::AssetFile
 
   def self.from_abs_path(abs_path)
-    rel_path = abs_path.sub("#{Dassets.config.files_path}/", '')
+    rel_path = abs_path.sub("#{Dassets.config.output_path}/", '')
     md5  = Digest::MD5.file(abs_path).hexdigest
     self.new(rel_path, md5)
   end
 
   attr_reader :path, :md5, :dirname, :extname, :basename
-  attr_reader :files_path, :cache_path, :href
+  attr_reader :output_path, :url, :href
 
   def initialize(rel_path, md5)
     @path, @md5 = rel_path, md5
@@ -20,40 +20,41 @@ class Dassets::AssetFile
     @extname  = File.extname(@path)
     @basename = File.basename(@path, @extname)
 
-    file_name = "#{@basename}-#{@md5}#{@extname}"
-    @files_path = File.join(Dassets.config.files_path, @path)
-    @cache_path = File.join(@dirname, file_name).sub(/^\.\//, '').sub(/^\//, '')
-    @href = "/#{@cache_path}"
+    @output_path = File.join(Dassets.config.output_path, @path)
+
+    url_basename = "#{@basename}-#{@md5}#{@extname}"
+    @url = File.join(@dirname, url_basename).sub(/^\.\//, '').sub(/^\//, '')
+    @href = "/#{@url}"
   end
 
   def content
-    @content ||= if File.exists?(@files_path) && File.file?(@files_path)
-      File.read(@files_path)
+    @content ||= if File.exists?(@output_path) && File.file?(@output_path)
+      File.read(@output_path)
     end
   end
 
   def mtime
-    @mtime ||= if File.exists?(@files_path) && File.file?(@files_path)
-      File.mtime(@files_path).httpdate
+    @mtime ||= if File.exists?(@output_path) && File.file?(@output_path)
+      File.mtime(@output_path).httpdate
     end
   end
 
   # We check via File::size? whether this file provides size info via stat,
   # otherwise we have to figure it out by reading the whole file into memory.
   def size
-    @size ||= if File.exists?(@files_path) && File.file?(@files_path)
-      File.size?(@files_path) || Rack::Utils.bytesize(self.content)
+    @size ||= if File.exists?(@output_path) && File.file?(@output_path)
+      File.size?(@output_path) || Rack::Utils.bytesize(self.content)
     end
   end
 
   def mime_type
-    @mime_type ||= if File.exists?(@files_path) && File.file?(@files_path)
+    @mime_type ||= if File.exists?(@output_path) && File.file?(@output_path)
       Rack::Mime.mime_type(@extname)
     end
   end
 
   def exists?
-    File.exists?(@files_path) && File.file?(@files_path)
+    File.exists?(@output_path) && File.file?(@output_path)
   end
 
   def ==(other_asset_file)

data/lib/dassets/cmds/cache_cmd.rb

@@ -0,0 +1,33 @@
+require 'pathname'
+require 'fileutils'
+require 'dassets'
+require 'dassets/digests'
+
+module Dassets; end
+class Dassets::Cmds; end
+class Dassets::Cmds::CacheCmd
+
+  attr_reader :cache_root_path, :digests
+
+  def initialize(cache_root_path)
+    @cache_root_path = Pathname.new(cache_root_path)
+    @digests = Dassets::Digests.new(Dassets.config.digests_path)
+  end
+
+  def run(io=nil)
+    log io, "caching #{@digests.asset_files.count} asset file(s) to `#{@cache_root_path}` ..."
+    @digests.asset_files.each do |file|
+      cache_path = @cache_root_path.join(file.url).to_s
+
+      FileUtils.mkdir_p File.dirname(cache_path)
+      FileUtils.cp(file.output_path, cache_path)
+    end
+  end
+
+  private
+
+  def log(io, msg)
+    io.puts msg if io
+  end
+
+end

data/lib/dassets/cmds/digest_cmd.rb

@@ -0,0 +1,53 @@
+require 'fileutils'
+require 'dassets'
+require 'dassets/source_file'
+
+module Dassets; end
+class Dassets::Cmds; end
+class Dassets::Cmds::DigestCmd
+
+  attr_reader :paths
+
+  def initialize(abs_paths)
+    @paths = abs_paths || []
+  end
+
+  def run(io=nil)
+    files = paths
+
+    if @paths.empty?
+      log io, "clearing `#{Dassets.config.output_path}`"
+      clear_output_path(Dassets.config.output_path)
+
+      # always clear the digests in use
+      log io, "clearing `#{Dassets.digests.file_path}`"
+      clear_digests(Dassets.digests)
+
+      # always get the latest source list
+      files = Dassets::SourceList.new(Dassets.config)
+    end
+
+    log io, "digesting #{files.count} source file(s) ..."
+    digest_the_files(files)
+  end
+
+  private
+
+  def clear_output_path(path)
+    Dir.glob(File.join(path, '*')).each{ |p| FileUtils.rm_r(p) } if path
+  end
+
+  def clear_digests(digests)
+    digests.clear.save! if digests
+  end
+
+  def digest_the_files(files)
+    files.map{ |f| Dassets::SourceFile.new(f).digest }
+  end
+
+  def log(io, msg)
+    io.puts msg if io
+  end
+
+end
+

data/lib/dassets/{digests_file.rb → digests.rb}

@@ -2,40 +2,33 @@ require 'dassets/asset_file'
 
 module Dassets
 
-  class DigestsFile
+  class Digests
 
-    attr_reader :path
+    attr_reader :file_path
 
     def initialize(file_path)
-      @path, @hash = file_path, decode(file_path)
+      @file_path, @hash = file_path, decode(file_path)
     end
 
-    def [](*args);  @hash.send('[]', *args);  end
-    def []=(*args); @hash.send('[]=', *args); end
-    def delete(*args); @hash.delete(*args);   end
+    def [](*args);     @hash.send('[]', *args);  end
+    def []=(*args);    @hash.send('[]=', *args); end
+    def delete(*args); @hash.delete(*args);      end
+    def clear(*args);  @hash.clear(*args); self  end
 
-    def each(*args, &block); @hash.each(*args, &block); end
-
-    def keys;   @hash.keys;   end
-    def values; @hash.values; end
-    def empty?; @hash.empty?; end
+    def paths
+      @hash.keys
+    end
 
     def asset_files
-      @hash.map{ |path, md5| Dassets::AssetFile.new(path, md5) }
+      self.paths.map{ |path| self.asset_file(path) }
     end
 
     def asset_file(path)
       Dassets::AssetFile.new(path, @hash[path] || '')
     end
 
-    def to_hash
-      Hash.new.tap do |to_hash|
-        @hash.each{ |k, v| to_hash[k] = v }
-      end
-    end
-
     def save!
-      encode(@hash, @path)
+      encode(@hash, @file_path)
     end
 
     private
@@ -59,12 +52,10 @@ module Dassets
 
   end
 
-  module NullDigestsFile
-
+  module NullDigests
     def self.new
-      DigestsFile.new('/dev/null')
+      Digests.new('/dev/null')
     end
-
   end
 
 end

data/lib/dassets/engine.rb

@@ -0,0 +1,33 @@
+module Dassets
+
+  class Engine
+
+    attr_reader :opts
+
+    def initialize(opts=nil)
+      @opts = opts || {}
+    end
+
+    def ext(input_ext)
+      raise NotImplementedError
+    end
+
+    def compile(input)
+      raise NotImplementedError
+    end
+
+  end
+
+  class NullEngine < Engine
+
+    def ext(input_ext)
+      input_ext
+    end
+
+    def compile(input)
+      input
+    end
+
+  end
+
+end

data/lib/dassets/runner.rb

@@ -12,6 +12,7 @@ class Dassets::Runner
     @opts = opts
     @cmd_name = args.shift || ""
     @cmd_args = args
+    @pwd = ENV['PWD']
   end
 
   def run
@@ -19,11 +20,16 @@ class Dassets::Runner
 
     case @cmd_name
     when 'digest'
-      require 'dassets/runner/digest_command'
-      DigestCommand.new(@cmd_args).run
+      require 'dassets/cmds/digest_cmd'
+      abs_paths = @cmd_args.map{ |path| File.expand_path(path, @pwd) }
+      Dassets::Cmds::DigestCmd.new(abs_paths).run($stdout)
     when 'cache'
-      require 'dassets/runner/cache_command'
-      CacheCommand.new(@cmd_args.first).run
+      require 'dassets/cmds/cache_cmd'
+      cache_root_path = File.expand_path(@cmd_args.first, @pwd)
+      unless cache_root_path && File.directory?(cache_root_path)
+        raise CmdError, "specify an existing cache directory"
+      end
+      Dassets::Cmds::CacheCmd.new(cache_root_path).run($stdout)
     when 'null'
       NullCommand.new.run
     else

data/lib/dassets/server/response.rb

@@ -14,7 +14,7 @@ class Dassets::Server
       @status, @headers, @body = if env['HTTP_IF_MODIFIED_SINCE'] == mtime
         [ 304, Rack::Utils::HeaderHash.new, [] ]
       elsif !@asset_file.exists?
-        [ 404, Rack::Utils::HeaderHash.new, [] ]
+        [ 404, Rack::Utils::HeaderHash.new, ["Not Found"] ]
       else
         [ 200,
           Rack::Utils::HeaderHash.new.tap do |h|

data/lib/dassets/source_file.rb

@@ -0,0 +1,71 @@
+require 'digest/md5'
+require 'fileutils'
+require 'dassets'
+require 'dassets/asset_file'
+
+module Dassets
+
+  class SourceFile
+
+    attr_reader :file_path
+
+    def initialize(file_path)
+      @file_path = file_path
+      @ext_list = File.basename(@file_path).split('.').reverse
+    end
+
+    def exists?
+      File.file?(@file_path)
+    end
+
+    def digest
+      return if !self.exists?
+
+      Dassets::AssetFile.new(self.digest_path, self.fingerprint).tap do |asset_file|
+        FileUtils.mkdir_p(File.dirname(asset_file.output_path))
+        File.open(asset_file.output_path, "w"){ |f| f.write(self.compiled) }
+        Dassets.digests[self.digest_path] = self.fingerprint
+        Dassets.digests.save!
+      end
+    end
+
+    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('.')
+
+        File.join([
+          digest_dirname(@file_path, Dassets.config.source_path),
+          digest_basename
+        ].reject{ |p| p.empty? })
+      end
+    end
+
+    def compiled
+      @compiled ||= @ext_list.inject(read_file(@file_path)) do |content, ext|
+        Dassets.config.engines[ext].compile(content)
+      end
+    end
+
+    def fingerprint
+      @fingerprint ||= Digest::MD5.new.hexdigest(self.compiled)
+    end
+
+    private
+
+    def digest_dirname(file_path, source_path)
+      slash_path(File.dirname(file_path)).sub(slash_path(source_path), '')
+    end
+
+    def slash_path(path)
+      File.join(path, '')
+    end
+
+    def read_file(path)
+      File.send(File.respond_to?(:binread) ? :binread : :read, path.to_s)
+    end
+
+  end
+
+end