dassets 0.0.1 → 0.1.0

data/README.md

@@ -1,10 +1,64 @@
 # Dassets
 
-Digest and serve asset files.
+Digest and serve HTML asset files.
 
 ## Usage
 
-TODO: Write code samples and usage instructions here
+You have some css, js, images, etc files.  You want to update, deploy, and serve them in an efficient way.  Dassets can help.
+
+### Setup
+
+```ruby
+# in config/dassets.rb
+require 'dassets'
+
+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'
+
+end
+```
+
+### Digest
+
+```
+$ dassets digest                      # rebuild the .digests for all asset files, OR
+$ dassets digest /path/to/asset/file  # update the digest for just one file
+```
+
+Use the CLI to build your digests file.  Protip: use guard to auto rebuild digests every time you edit an asset file.  TODO: link to some guard tools or docs.
+
+### Link To
+
+```rb
+Dassets.init
+Dassets['css/site.css'].href       # => "/css/site-123abc.css"
+Dassets['img/logos/main.jpg'].href # => "/img/logos/main-a1b2c3.jpg"
+```
+
+### Serve
+
+In development, use the Dassets middleware to serve your digested asset files:
+
+```ruby
+# `app` is a rack application
+require 'dassets/server'
+app.use Dassets::Server
+```
+
+In production, use the CLI to cache your digested asset files to the public dir:
+
+```
+# call the CLI in your deploy scripts or whatever
+$ dassets cache /path/to/public/dir
+```
 
 ## Installation
 

data/bin/dassets

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+#
+# Copyright (c) 2013-Present Kelly Redding and Collin Redding
+#
+
+require 'dassets/cli'
+Dassets::CLI.run *ARGV

data/dassets.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |gem|
   gem.version     = Dassets::VERSION
   gem.authors     = ["Kelly Redding", "Collin Redding"]
   gem.email       = ["kelly@kellyredding.com", "collin.redding@me.com"]
-  gem.description = %q{Digest and serve asset files}
-  gem.summary     = %q{Digested Assets}
+  gem.description = %q{Digest and serve HTML asset files}
+  gem.summary     = %q{Digested asset files}
   gem.homepage    = "http://github.com/redding/dassets"
 
   gem.files         = `git ls-files`.split($/)
@@ -17,6 +17,12 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_development_dependency("assert")
+  gem.add_development_dependency("assert", ["~> 2.0"])
+  gem.add_development_dependency('assert-rack-test', ["~> 1.0"])
+  gem.add_development_dependency("sinatra", ["~> 1.4"])
+
+
+  gem.add_dependency('ns-options', ["~> 1.1"])
+  gem.add_dependency("rack",       ["~> 1.0"])
 
 end

data/lib/dassets/asset_file.rb

@@ -0,0 +1,65 @@
+require 'digest/md5'
+require 'rack/utils'
+require 'rack/mime'
+
+module Dassets; end
+class Dassets::AssetFile
+
+  def self.from_abs_path(abs_path)
+    rel_path = abs_path.sub("#{Dassets.config.files_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
+
+  def initialize(rel_path, md5)
+    @path, @md5 = rel_path, md5
+    @dirname  = File.dirname(@path)
+    @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}"
+  end
+
+  def content
+    @content ||= if File.exists?(@files_path) && File.file?(@files_path)
+      File.read(@files_path)
+    end
+  end
+
+  def mtime
+    @mtime ||= if File.exists?(@files_path) && File.file?(@files_path)
+      File.mtime(@files_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)
+    end
+  end
+
+  def mime_type
+    @mime_type ||= if File.exists?(@files_path) && File.file?(@files_path)
+      Rack::Mime.mime_type(@extname)
+    end
+  end
+
+  def exists?
+    File.exists?(@files_path) && File.file?(@files_path)
+  end
+
+  def ==(other_asset_file)
+    other_asset_file.kind_of?(Dassets::AssetFile) &&
+    self.path == other_asset_file.path &&
+    self.md5 == other_asset_file.md5
+  end
+
+end

data/lib/dassets/cli.rb

@@ -0,0 +1,109 @@
+require 'dassets/version'
+require 'dassets/runner'
+
+module Dassets
+
+  class CLI
+
+    def self.run(*args)
+      self.new.run(*args)
+    end
+
+    def initialize
+      @cli = CLIRB.new
+    end
+
+    def run(*args)
+      begin
+        @cli.parse!(args)
+        Dassets::Runner.new(@cli.args, @cli.opts).run
+      rescue CLIRB::HelpExit
+        puts help
+      rescue CLIRB::VersionExit
+        puts Dassets::VERSION
+      rescue Dassets::Runner::UnknownCmdError => err
+        $stderr.puts "#{err.message}\n\n"
+        $stderr.puts help
+        exit(1)
+      rescue Dassets::Runner::CmdError => err
+        $stderr.puts "#{err.message}"
+        exit(1)
+      rescue Dassets::Runner::CmdFail => err
+        exit(1)
+      rescue CLIRB::Error => exception
+        $stderr.puts "#{exception.message}\n\n"
+        $stderr.puts help
+        exit(1)
+      rescue Exception => exception
+        $stderr.puts "#{exception.class}: #{exception.message}"
+        $stderr.puts exception.backtrace.join("\n")
+        exit(1)
+      end
+      exit(0)
+    end
+
+    def help
+      "Usage: dassets [options] COMMAND\n"\
+      "\n"\
+      "Options:"\
+      "#{@cli}"
+    end
+
+  end
+
+  class CLIRB  # Version 1.0.0, https://github.com/redding/cli.rb
+    Error    = Class.new(RuntimeError);
+    HelpExit = Class.new(RuntimeError); VersionExit = Class.new(RuntimeError)
+    attr_reader :argv, :args, :opts, :data
+
+    def initialize(&block)
+      @options = []; instance_eval(&block) if block
+      require 'optparse'
+      @data, @args, @opts = [], [], {}; @parser = OptionParser.new do |p|
+        p.banner = ''; @options.each do |o|
+          @opts[o.name] = o.value; p.on(*o.parser_args){ |v| @opts[o.name] = v }
+        end
+        p.on_tail('--version', ''){ |v| raise VersionExit, v.to_s }
+        p.on_tail('--help',    ''){ |v| raise HelpExit,    v.to_s }
+      end
+    end
+
+    def option(*args); @options << Option.new(*args); end
+    def parse!(argv)
+      @args = (argv || []).dup.tap do |args_list|
+        begin; @parser.parse!(args_list)
+        rescue OptionParser::ParseError => err; raise Error, err.message; end
+      end; @data = @args + [@opts]
+    end
+    def to_s; @parser.to_s; end
+    def inspect
+      "#<#{self.class}:#{'0x0%x' % (object_id << 1)} @data=#{@data.inspect}>"
+    end
+
+    class Option
+      attr_reader :name, :opt_name, :desc, :abbrev, :value, :klass, :parser_args
+
+      def initialize(name, *args)
+        settings, @desc = args.last.kind_of?(::Hash) ? args.pop : {}, args.pop || ''
+        @name, @opt_name, @abbrev = parse_name_values(name, settings[:abbrev])
+        @value, @klass = gvalinfo(settings[:value])
+        @parser_args = if [TrueClass, FalseClass, NilClass].include?(@klass)
+          ["-#{@abbrev}", "--[no-]#{@opt_name}", @desc]
+        else
+          ["-#{@abbrev}", "--#{@opt_name} #{@opt_name.upcase}", @klass, @desc]
+        end
+      end
+
+      private
+
+      def parse_name_values(name, custom_abbrev)
+        [ (processed_name = name.to_s.strip.downcase), processed_name.gsub('_', '-'),
+          custom_abbrev || processed_name.gsub(/[^a-z]/, '').chars.first || 'a'
+        ]
+      end
+      def gvalinfo(v); v.kind_of?(Class) ? [nil,gklass(v)] : [v,gklass(v.class)]; end
+      def gklass(k); k == Fixnum ? Integer : k; end
+    end
+  end
+
+end

data/lib/dassets/digests_file.rb

@@ -0,0 +1,70 @@
+require 'dassets/asset_file'
+
+module Dassets
+
+  class DigestsFile
+
+    attr_reader :path
+
+    def initialize(file_path)
+      @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 each(*args, &block); @hash.each(*args, &block); end
+
+    def keys;   @hash.keys;   end
+    def values; @hash.values; end
+    def empty?; @hash.empty?; end
+
+    def asset_files
+      @hash.map{ |path, md5| Dassets::AssetFile.new(path, md5) }
+    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)
+    end
+
+    private
+
+    def decode(file_path)
+      Hash.new.tap do |h|
+        if File.exists?(file_path)
+          File.open(file_path, 'r').each_line do |l|
+            path, md5 = l.split(','); path ||= ''; path.strip!; md5 ||= ''; md5.strip!
+            h[path] = md5 if !path.empty?
+          end
+        end
+      end
+    end
+
+    def encode(hash, file_path)
+      File.open(file_path, 'w') do |f|
+        hash.keys.sort.each{ |path| f.write("#{path.strip},#{hash[path].strip}\n") }
+      end
+    end
+
+  end
+
+  module NullDigestsFile
+
+    def self.new
+      DigestsFile.new('/dev/null')
+    end
+
+  end
+
+end

data/lib/dassets/root_path.rb

@@ -0,0 +1,12 @@
+# 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/runner/cache_command.rb

@@ -0,0 +1,46 @@
+require 'pathname'
+require 'fileutils'
+require 'dassets/asset_file'
+require 'dassets/digests_file'
+
+module Dassets; end
+class Dassets::Runner; end
+class Dassets::Runner::CacheCommand
+
+  attr_reader :files_root_path, :cache_root_path, :digests_file, :asset_files
+
+  def initialize(cache_root_path)
+    unless cache_root_path && File.directory?(cache_root_path)
+      raise Dassets::Runner::CmdError, "specify an existing cache directory"
+    end
+
+    @files_root_path = Pathname.new(Dassets.config.files_path)
+    @cache_root_path = Pathname.new(cache_root_path)
+    @digests_file = Dassets::DigestsFile.new(Dassets.config.digests_file_path)
+    @asset_files = @digests_file.asset_files
+  end
+
+  def run(write_files=true)
+    begin
+      @asset_files.each do |file|
+        files_path = @files_root_path.join(file.path).to_s
+        cache_path = @cache_root_path.join(file.cache_path).to_s
+
+        if write_files
+          FileUtils.mkdir_p File.dirname(cache_path)
+          FileUtils.cp(files_path, cache_path)
+        end
+      end
+      unless ENV['DASSETS_TEST_MODE']
+        $stdout.puts "#{@asset_files.size} files written to #{@cache_root_path}"
+      end
+      return write_files
+    rescue Exception => e
+      unless ENV['DASSETS_TEST_MODE']
+        $stderr.puts e, *e.backtrace; $stderr.puts ""
+      end
+      raise Dassets::Runner::CmdFail
+    end
+  end
+
+end

data/lib/dassets/runner/digest_command.rb

@@ -0,0 +1,65 @@
+require 'set'
+require 'dassets/asset_file'
+require 'dassets/digests_file'
+
+module Dassets; end
+class Dassets::Runner; end
+class Dassets::Runner::DigestCommand
+
+  attr_reader :asset_files, :digests_file
+
+  def initialize(file_paths)
+    @pwd = ENV['PWD']
+    @asset_files = if (file_paths || []).empty?
+      get_asset_files([*Dassets.config.files_path])
+    else
+      get_asset_files(file_paths)
+    end
+    @digests_file = Dassets::DigestsFile.new(Dassets.config.digests_file_path)
+  end
+
+  def run(save=true)
+    begin
+      digest_paths = @digests_file.keys
+      asset_paths  = @asset_files.map{ |f| f.path }
+
+      (digest_paths - asset_paths).each{ |file| @digests_file.delete(file) }
+      @asset_files.each{ |f| @digests_file[f.path] = f.md5 }
+
+      @digests_file.save! if save
+      unless ENV['DASSETS_TEST_MODE']
+        $stdout.puts "digested #{@asset_files.size} assets, saved to #{@digests_file.path}"
+      end
+      return save
+    rescue Exception => e
+      unless ENV['DASSETS_TEST_MODE']
+        $stderr.puts e, *e.backtrace; $stderr.puts ""
+      end
+      raise Dassets::Runner::CmdFail
+    end
+  end
+
+  private
+
+  # Get all file paths fuzzy-matching the given paths.  Each path must be a
+  # file that exists and is in the `config.files_path` tree.  Return them
+  # as sorted AssetFile objects.
+  def get_asset_files(paths)
+    fuzzy_paths(paths).
+      select{ |p| is_asset_file?(p) }.
+      sort.
+      map{ |p| Dassets::AssetFile.from_abs_path(p) }
+  end
+
+  def fuzzy_paths(paths)
+    paths.inject(Set.new) do |paths, path|
+      p = File.expand_path(path, @pwd)
+      paths += Dir.glob("#{p}*") + Dir.glob("#{p}*/**/*")
+    end
+  end
+
+  def is_asset_file?(path)
+    File.file?(path) && path.include?("#{Dassets.config.files_path}/")
+  end
+
+end

data/lib/dassets/runner.rb

@@ -0,0 +1,42 @@
+require 'dassets'
+
+ENV['DASSETS_CONFIG_FILE'] ||= 'config/assets'
+
+module Dassets; end
+class Dassets::Runner
+  UnknownCmdError = Class.new(ArgumentError)
+  CmdError = Class.new(RuntimeError)
+  CmdFail = Class.new(RuntimeError)
+
+  attr_reader :cmd_name, :cmd_args, :opts
+
+  def initialize(args, opts)
+    @opts = opts
+    @cmd_name = args.shift || ""
+    @cmd_args = args
+  end
+
+  def run
+    require ENV['DASSETS_CONFIG_FILE']
+
+    case @cmd_name
+    when 'digest'
+      require 'dassets/runner/digest_command'
+      DigestCommand.new(@cmd_args).run
+    when 'cache'
+      require 'dassets/runner/cache_command'
+      CacheCommand.new(@cmd_args.first).run
+    when 'null'
+      NullCommand.new.run
+    else
+      raise UnknownCmdError, "unknown command `#{@cmd_name}`"
+    end
+  end
+
+  class NullCommand
+    def run
+      # if this was a real command it would do something here
+    end
+  end
+
+end

data/lib/dassets/server/request.rb

@@ -0,0 +1,48 @@
+require 'rack/request'
+
+class Dassets::Server
+
+  class Request < Rack::Request
+
+    # The HTTP request method. This is the standard implementation of this
+    # method but is respecified here due to libraries that attempt to modify
+    # the behavior to respect POST tunnel method specifiers. We always want
+    # the real request method.
+    def request_method; @env['REQUEST_METHOD']; end
+    def path_info;      @env['PATH_INFO'];      end
+
+    # Determine if the request is for an asset file
+    # This will be called on every request so speed is an issue
+    # - first check if the request is a GET or HEAD (fast)
+    # - then check if for a digest resource (kinda fast)
+    # - then check if on a path in the digests (slower)
+    def for_asset_file?
+      !!((get? || head?) && for_digest_file? && Dassets.digests[asset_path])
+    end
+
+    def asset_path
+      @asset_path ||= path_digest_match.captures.select{ |m| !m.empty? }.join
+    end
+
+    def asset_file
+      @asset_file ||= Dassets[asset_path]
+    end
+
+    private
+
+    def for_digest_file?
+      !path_digest_match.nil?
+    end
+
+    def path_digest_match
+      @path_digest_match ||= begin
+        path_info.match(/\/(.+)-[a-f0-9]{32}(\..+|)$/i) || NullDigestMatch.new
+      end
+    end
+
+    class NullDigestMatch
+      def captures; []; end
+    end
+
+  end
+end

data/lib/dassets/server/response.rb

@@ -0,0 +1,36 @@
+require 'rack/response'
+require 'rack/utils'
+require 'rack/mime'
+
+class Dassets::Server
+
+  class Response
+    attr_reader :asset_file, :status, :headers, :body
+
+    def initialize(env, asset_file)
+      @asset_file = asset_file
+
+      mtime = @asset_file.mtime.to_s
+      @status, @headers, @body = if env['HTTP_IF_MODIFIED_SINCE'] == mtime
+        [ 304, Rack::Utils::HeaderHash.new, [] ]
+      elsif !@asset_file.exists?
+        [ 404, Rack::Utils::HeaderHash.new, [] ]
+      else
+        [ 200,
+          Rack::Utils::HeaderHash.new.tap do |h|
+            h["Content-Type"]   = @asset_file.mime_type.to_s
+            h["Content-Length"] = @asset_file.size.to_s
+            h["Last-Modified"]  = mtime
+          end,
+          env["REQUEST_METHOD"] == "HEAD" ? [] : [ @asset_file.content ]
+        ]
+      end
+    end
+
+    def to_rack
+      [@status, @headers.to_hash, @body]
+    end
+
+  end
+
+end

data/lib/dassets/server.rb

@@ -0,0 +1,37 @@
+require 'dassets/server/request'
+require 'dassets/server/response'
+
+# Rack middleware for serving Dassets asset files
+
+module Dassets
+  class Server
+
+    def initialize(app)
+      @app = app
+    end
+
+    # The Rack call interface. The receiver acts as a prototype and runs
+    # each request in a clone object unless the +rack.run_once+ variable is
+    # set in the environment. Ripped from:
+    # http://github.com/rtomayko/rack-cache/blob/master/lib/rack/cache/context.rb
+    def call(env)
+      if env['rack.run_once']
+        call! env
+      else
+        clone.call! env
+      end
+    end
+
+    # The real Rack call interface.
+    # if an asset file is being requested, this is an endpoint - otherwise, call
+    # on up to the app as normal
+    def call!(env)
+      if (request = Request.new(env)).for_asset_file?
+        Response.new(env, request.asset_file).to_rack
+      else
+        @app.call(env)
+      end
+    end
+
+  end
+end

data/lib/dassets/version.rb

@@ -1,3 +1,3 @@
 module Dassets
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/dassets.rb

@@ -1,5 +1,35 @@
-require "dassets/version"
+require 'pathname'
+require 'ns-options'
+
+require 'dassets/version'
+require 'dassets/root_path'
+require 'dassets/digests_file'
 
 module Dassets
-  # TODO: your code goes here...
+
+  def self.config; Config; end
+  def self.configure(&block); Config.define(&block); end
+
+  def self.init
+    @digests_file = DigestsFile.new(self.config.digests_file_path)
+  end
+
+  def self.reset
+    @digests_file = nil
+  end
+
+  def self.digests; @digests_file || NullDigestsFile.new; end
+  def self.[](asset_path)
+    self.digests.asset_file(asset_path)
+  end
+
+  class Config
+    include NsOptions::Proxy
+
+    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" }
+
+  end
+
 end

data/test/helper.rb

@@ -7,4 +7,6 @@ $LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
 # require pry for debugging (`binding.pry`)
 require 'pry'
 
-# TODO: put test helpers here...
+ENV['DASSETS_TEST_MODE'] = 'yes'
+ENV['DASSETS_CONFIG_FILE'] = 'test/support/config/assets'
+require ENV['DASSETS_CONFIG_FILE']