dassets 0.14.1 → 0.15.0

data/lib/dassets/source.rb

@@ -1,14 +1,15 @@
-require 'dassets/engine'
+# frozen_string_literal: true
+
+require "dassets/engine"
 
 module Dassets; end
 class Dassets::Source
-
   attr_reader :path, :engines, :response_headers
 
   def initialize(path)
     @path             = path.to_s
     @filter           = proc{ |paths| paths }
-    @engines          = Hash.new{ |h,k| Dassets::NullEngine.new }
+    @engines          = Hash.new{ |hash, key| hash[key] = [] }
     @response_headers = Hash.new
   end
 
@@ -16,10 +17,10 @@ class Dassets::Source
     block.nil? ? @filter : @filter = block
   end
 
-  def engine(input_ext, engine_class, registered_opts=nil)
-    default_opts = { 'source_path' => @path }
+  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)
+    @engines[input_ext.to_s] << engine_class.new(engine_opts)
   end
 
   def files
@@ -28,12 +29,16 @@ class Dassets::Source
 
   private
 
+  # Use "**{,/*/**}/*" to glob following symlinks and returning immediate-child
+  # matches. See https://stackoverflow.com/a/2724048.
   def glob_files
-    Dir.glob(File.join(@path, "**/*")).reject!{ |p| !File.file?(p) }
+    Dir
+      .glob(File.join(@path, "**{,/*/**}/*"))
+      .uniq
+      .reject{ |path| !File.file?(path) }
   end
 
   def apply_filter(files)
     @filter.call(files)
   end
-
 end

data/lib/dassets/source_file.rb

@@ -1,114 +1,132 @@
-require 'fileutils'
-require 'dassets'
-require 'dassets/asset_file'
-require 'dassets/source_proxy'
+# frozen_string_literal: true
 
-module Dassets
+require "fileutils"
+require "dassets"
+require "dassets/asset_file"
+require "dassets/source_proxy"
 
-  class SourceFile
-
-    def self.find_by_digest_path(path, options = nil)
-      Dassets.source_files[path] || NullSourceFile.new(path, options)
-    end
+module Dassets; end
+class Dassets::SourceFile
+  def self.find_by_digest_path(path, **options)
+    Dassets.source_files[path] || Dassets::NullSourceFile.new(path, **options)
+  end
 
-    attr_reader :file_path
+  attr_reader :file_path
 
-    def initialize(file_path)
-      @file_path = file_path.to_s
-      @ext_list  = File.basename(@file_path).split('.').reverse
-    end
+  def initialize(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|
+  # 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 { |source|
         @file_path =~ /^#{slash_path(source.path)}/
-      end.last
-    end
+      }.last
+  end
 
-    def asset_file
-      @asset_file ||= Dassets::AssetFile.new(self.digest_path)
-    end
+  def asset_file
+    @asset_file ||= Dassets::AssetFile.new(self.digest_path)
+  end
 
-    def digest_path
-      @digest_path ||= begin
-        digest_basename = @ext_list.inject([]) do |digest_ext_list, ext|
-          digest_ext_list << self.source.engines[ext].ext(ext)
-        end.reject(&:empty?).reverse.join('.')
+  def digest_path
+    @digest_path ||=
+      begin
+        digest_basename =
+          @ext_list
+            .reduce([]) { |digest_ext_list, ext|
+              digest_ext_list <<
+                self.source.engines[ext].reduce(ext) { |ext_acc, engine|
+                  engine.ext(ext_acc)
+                }
+            }
+            .reject(&:empty?)
+            .reverse
+            .join(".")
 
         File.join([digest_dirname(@file_path), digest_basename].reject(&:empty?))
       end
-    end
+  end
 
-    def compiled
-      @ext_list.inject(read_file(@file_path)) do |content, ext|
-        self.source.engines[ext].compile(content)
-      end
-    end
+  def compiled
+    @ext_list.reduce(read_file(@file_path)) { |file_acc, ext|
+      self.source.engines[ext].reduce(file_acc) { |ext_acc, engine|
+        engine.compile(ext_acc)
+      }
+    }
+  end
 
-    def exists?
-      File.file?(@file_path)
-    end
+  def exists?
+    File.file?(@file_path)
+  end
 
-    def mtime
-      File.mtime(@file_path)
-    end
+  def mtime
+    File.mtime(@file_path)
+  end
 
-    def response_headers
-      self.source.nil? ? Hash.new : self.source.response_headers
-    end
+  def response_headers
+    self.source.nil? ? Hash.new : self.source.response_headers
+  end
 
-    def ==(other_source_file)
+  def ==(other_source_file)
+    if other_source_file.is_a?(self.class)
       self.file_path == other_source_file.file_path
+    else
+      super
     end
+  end
 
-    private
-
-    # 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)
-      File.join(path, '')
-    end
-
-    def read_file(path)
-      File.send(File.respond_to?(:binread) ? :binread : :read, path.to_s)
-    end
+  private
 
+  # 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
 
-  # A null source file is used to represent source that either doesn't exist
-  # or source that is a proxy (ie a combination)
+  def slash_path(path)
+    File.join(path, "")
+  end
 
-  class NullSourceFile < SourceFile
+  def read_file(path)
+    File.send(File.respond_to?(:binread) ? :binread : :read, path.to_s)
+  end
+end
 
-    def initialize(digest_path, options = nil)
-      @file_path, @ext_list = '', []
-      @digest_path = digest_path
-      @source_proxy = if Dassets.config.combination?(@digest_path)
-        SourceProxy.new(@digest_path, options)
+# A null source file is used to represent source that either doesn't exist
+# or source that is a proxy (ie a combination)
+class Dassets::NullSourceFile < Dassets::SourceFile
+  def initialize(digest_path, **options)
+    @file_path    = ""
+    @ext_list     = []
+    @digest_path  = digest_path
+    @source_proxy =
+      if Dassets.config.combination?(@digest_path)
+        Dassets::SourceProxy.new(@digest_path, **options)
       else
-        NullSourceProxy.new
+        Dassets::NullSourceProxy.new
       end
-    end
-
-    def compiled; @source_proxy.content; end
-    def exists?;  @source_proxy.exists?; end
-    def mtime;    @source_proxy.mtime;   end
+  end
 
-    def ==(other_source_file)
-      self.file_path == other_source_file.file_path
-    end
+  def compiled
+    @source_proxy.content
+  end
 
-    class NullSourceProxy
-      def content; nil;   end
-      def exists?; false; end
-      def mtime;   nil;   end
-    end
+  def exists?
+    @source_proxy.exists?
+  end
 
+  def mtime
+    @source_proxy.mtime
   end
 
+  def ==(other_source_file)
+    if other_source_file.is_a?(self.class)
+      self.file_path == other_source_file.file_path
+    else
+      super
+    end
+  end
 end

data/lib/dassets/source_proxy.rb

@@ -1,22 +1,25 @@
-require 'digest/md5'
-require 'dassets/cache'
-require 'dassets/source_file'
+# frozen_string_literal: true
+
+require "digest/md5"
+require "dassets/cache"
+require "dassets/source_file"
 
 module Dassets; end
-class Dassets::SourceProxy
 
+class Dassets::SourceProxy
   attr_reader :digest_path, :content_cache, :fingerprint_cache
   attr_reader :source_files
 
-  def initialize(digest_path, options = nil)
-    options ||= {}
+  def initialize(digest_path, **options)
     @digest_path       = digest_path
-    @content_cache     = options[:content_cache]     || Dassets::Cache::NoCache.new
-    @fingerprint_cache = options[:fingerprint_cache] || Dassets::Cache::NoCache.new
-    @source_files      = get_source_files(@digest_path, {
-      :content_cache     => @content_cache,
-      :fingerprint_cache => @fingerprint_cache
-    })
+    @content_cache     = options[:content_cache]     || Dassets::NoCache.new
+    @fingerprint_cache = options[:fingerprint_cache] || Dassets::NoCache.new
+    @source_files      =
+      get_source_files(
+        @digest_path,
+        content_cache:     @content_cache,
+        fingerprint_cache: @fingerprint_cache,
+      )
   end
 
   def key
@@ -53,10 +56,23 @@ class Dassets::SourceProxy
     Digest::MD5.new.hexdigest(source_content)
   end
 
-  def get_source_files(digest_path, options)
-    Dassets.config.combinations[digest_path.to_s].map do |source_digest_path|
-      Dassets::SourceFile.find_by_digest_path(source_digest_path, options)
-    end
+  def get_source_files(digest_path, **options)
+    Dassets.config.combinations[digest_path.to_s].map { |source_digest_path|
+      Dassets::SourceFile.find_by_digest_path(source_digest_path, **options)
+    }
+  end
+end
+
+class Dassets::NullSourceProxy
+  def content
+    nil
+  end
+
+  def exists?
+    false
   end
 
+  def mtime
+    nil
+  end
 end

data/lib/dassets/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Dassets
-  VERSION = "0.14.1"
+  VERSION = "0.15.0"
 end

data/test/helper.rb

@@ -5,39 +5,33 @@
 $LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
 
 # require pry for debugging (`binding.pry`)
-require 'pry'
+require "pry"
 
-require 'test/support/factory'
+require "test/support/factory"
 
-# 1.8.7 backfills
+require "pathname"
+TEST_SUPPORT_PATH = Pathname.new(File.expand_path("../support", __FILE__))
 
-# Array#sample
-if !(a = Array.new).respond_to?(:sample) && a.respond_to?(:choice)
-  class Array
-    alias_method :sample, :choice
-  end
-end
+ENV["DASSETS_TEST_MODE"]   = "yes"
 
-require 'pathname'
-TEST_SUPPORT_PATH = Pathname.new(File.expand_path('../support', __FILE__))
+require "dassets"
 
-ENV['DASSETS_TEST_MODE']   = 'yes'
-
-require 'dassets'
+@dumb_engine =
+  Class.new(Dassets::Engine) do
+    def ext(in_ext); ""; end
+    def compile(input); "#{input}\nDUMB"; end
+  end
 
-@dumb_engine = Class.new(Dassets::Engine) do
-  def ext(in_ext); ''; end
-  def compile(input); "#{input}\nDUMB"; end
-end
-@useless_engine = Class.new(Dassets::Engine) do
-  def ext(in_ext); 'no-use'; end
-  def compile(input); "#{input}\nUSELESS"; end
-end
+@useless_engine =
+  Class.new(Dassets::Engine) do
+    def ext(in_ext); "no-use"; end
+    def compile(input); "#{input}\nUSELESS"; end
+  end
 
 Dassets.configure do |c|
   c.source TEST_SUPPORT_PATH.join("app/assets") do |s|
-    s.engine 'dumb', @dumb_engine
-    s.engine 'useless', @useless_engine
+    s.engine "dumb", @dumb_engine
+    s.engine "useless", @useless_engine
     s.response_headers[Factory.string] = Factory.string
   end
 end

data/test/support/app.rb

@@ -1,10 +1,8 @@
-require 'sinatra/base'
+require "sinatra/base"
 
 class SinatraApp < Sinatra::Base
-
   configure do
-    set :root, File.expand_path('..', __FILE__)
-    set :public_dir, File.expand_path('./app_public', __FILE__)
+    set :root,       File.expand_path("..", __FILE__)
+    set :public_dir, File.expand_path("./app_public", __FILE__)
   end
-
 end

data/test/support/factory.rb

@@ -1,4 +1,4 @@
-require 'assert/factory'
+require "assert/factory"
 
 module Factory
   extend Assert::Factory
@@ -6,5 +6,4 @@ module Factory
   def self.base_url
     Factory.boolean ? Factory.url : nil
   end
-
 end

data/test/support/source_files/linked

@@ -0,0 +1 @@
+../linked_source_files/

data/test/support/source_files/linked_file2.txt

@@ -0,0 +1 @@
+../linked_source_files/linked_file.txt

data/test/system/rack_tests.rb

@@ -1,13 +1,12 @@
-require 'assert'
-require 'dassets'
+require "assert"
+require "dassets"
 
-require 'assert-rack-test'
-require 'fileutils'
-require 'dassets/server'
-require 'test/support/app'
+require "assert-rack-test"
+require "fileutils"
+require "dassets/server"
+require "test/support/app"
 
 module Dassets
-
   class RackTests < Assert::Context
     include Assert::Rack::Test
 
@@ -19,121 +18,118 @@ module Dassets
     def app
       @app ||= SinatraApp
     end
-
   end
 
   class SuccessTests < RackTests
     desc "requesting an existing asset file"
 
     should "return a successful response" do
-      resp = get '/file1-daa05c683a4913b268653f7a7e36a5b4.txt'
-      assert_equal 200, resp.status
-      assert_equal Dassets['file1.txt'].content, resp.body
+      resp = get "/file1-daa05c683a4913b268653f7a7e36a5b4.txt"
+
+      assert_that(resp.status).equals(200)
+      assert_that(resp.body).equals(Dassets["file1.txt"].content)
     end
 
     should "return a successful response with no body on HEAD requests" do
-      resp = head '/file2-9bbe1047cffbb590f59e0e5aeff46ae4.txt'
-      assert_equal 200, resp.status
-      assert_equal Dassets['file2.txt'].size.to_s, resp.headers['Content-Length']
-      assert_empty resp.body
+      resp = head "/file2-9bbe1047cffbb590f59e0e5aeff46ae4.txt"
+
+      assert_that(resp.status).equals(200)
+      assert_that(resp.headers["Content-Length"])
+        .equals(Dassets["file2.txt"].size.to_s)
+      assert_that(resp.body).is_empty
     end
 
     should "return a partial content response on valid partial content requests" do
-      content = Dassets['file1.txt'].content
+      content = Dassets["file1.txt"].content
       size    = Factory.integer(content.length)
-
       # see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35
-      env = { 'HTTP_RANGE' => "bytes=0-#{size}" }
+      env = { "HTTP_RANGE" => "bytes=0-#{size}" }
+      resp = get "/file1-daa05c683a4913b268653f7a7e36a5b4.txt", {}, env
 
-      resp = get '/file1-daa05c683a4913b268653f7a7e36a5b4.txt', {}, env
-      assert_equal 206, resp.status
-      assert_equal content[0..size], resp.body
+      assert_that(resp.status).equals(206)
+      assert_that(resp.body).equals(content[0..size])
     end
 
     should "return a full response on no-range partial content requests" do
       # see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35
-      env = { 'HTTP_RANGE' => 'bytes=' }
+      env = { "HTTP_RANGE" => "bytes=" }
+      resp = get "/file1-daa05c683a4913b268653f7a7e36a5b4.txt", {}, env
 
-      resp = get '/file1-daa05c683a4913b268653f7a7e36a5b4.txt', {}, env
-      assert_equal 200, resp.status
-      assert_equal Dassets['file1.txt'].content, resp.body
+      assert_that(resp.status).equals(200)
+      assert_that(resp.body).equals(Dassets["file1.txt"].content)
     end
 
     should "return a full response on multiple-range partial content requests" do
       # see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35
-      env = { 'HTTP_RANGE' => 'bytes=0-1,2-3' }
+      env = { "HTTP_RANGE" => "bytes=0-1,2-3" }
+      resp = get "/file1-daa05c683a4913b268653f7a7e36a5b4.txt", {}, env
 
-      resp = get '/file1-daa05c683a4913b268653f7a7e36a5b4.txt', {}, env
-      assert_equal 200, resp.status
-      assert_equal Dassets['file1.txt'].content, resp.body
+      assert_that(resp.status).equals(200)
+      assert_that(resp.body).equals(Dassets["file1.txt"].content)
     end
 
     should "return a full response on invalid-range partial content requests" do
       # see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35
-      env = { 'HTTP_RANGE' => ['bytes=3-2', 'bytes=abc'].sample }
+      env = { "HTTP_RANGE" => ["bytes=3-2", "bytes=abc"].sample }
+      resp = get "/file1-daa05c683a4913b268653f7a7e36a5b4.txt", {}, env
 
-      resp = get '/file1-daa05c683a4913b268653f7a7e36a5b4.txt', {}, env
-      assert_equal 200, resp.status
-      assert_equal Dassets['file1.txt'].content, resp.body
+      assert_that(resp.status).equals(200)
+      assert_that(resp.body).equals(Dassets["file1.txt"].content)
     end
-
   end
 
   class DigestTests < SuccessTests
     setup do
       base_url = Factory.base_url
       Assert.stub(Dassets.config, :base_url){ base_url }
-      Dassets.config.file_store TEST_SUPPORT_PATH.join('public').to_s
-      @url = Dassets['file1.txt'].url
+      Dassets.config.file_store TEST_SUPPORT_PATH.join("public").to_s
+      @url = Dassets["file1.txt"].url
       @url_file = Dassets.config.file_store.store_path(@url)
     end
+
     teardown do
       FileUtils.rm(@url_file)
-      Dassets.config.file_store FileStore::NullStore.new
+      Dassets.config.file_store Dassets::NullFileStore.new
     end
 
     should "digest the asset" do
-      assert_not_file_exists @url_file
+      assert_that(@url_file).is_not_a_file
 
       resp = get @url
-      assert_equal 200, resp.status
-      assert_file_exists @url_file
+      assert_that(resp.status).equals(200)
+      assert_that(@url_file).is_a_file
     end
-
   end
 
   class NotModifiedTests < RackTests
     desc "requesting an existing asset file that has not been modified"
-    setup do
-      @resp = get('/file1-daa05c683a4913b268653f7a7e36a5b4.txt', {}, {
-        'HTTP_IF_MODIFIED_SINCE' => Dassets['file1.txt'].mtime.to_s
-      })
-    end
 
     should "return a successful response" do
-      assert_equal 304, @resp.status
-      assert_empty @resp.body
-    end
+      resp =
+        get("/file1-daa05c683a4913b268653f7a7e36a5b4.txt", {}, {
+          "HTTP_IF_MODIFIED_SINCE" => Dassets["file1.txt"].mtime.to_s
+        })
 
+      assert_that(resp.status).equals(304)
+      assert_that(resp.body).is_empty
+    end
   end
 
   class NotFoundTests < RackTests
     desc "requesting an non-existing asset file"
 
     should "return a not found response" do
-      resp = get '/file1-daa05c683a4913b268.txt'
-      assert_equal 404, resp.status
+      resp = get "/file1-daa05c683a4913b268.txt"
+      assert_that(resp.status).equals(404)
 
-      get '/file1-.txt'
-      assert_equal 404, resp.status
+      resp = get "/file1-.txt"
+      assert_that(resp.status).equals(404)
 
-      get '/file1.txt'
-      assert_equal 404, resp.status
+      resp = get "/file1.txt"
+      assert_that(resp.status).equals(404)
 
-      get '/something-not-found'
-      assert_equal 404, resp.status
+      resp = get "/something-not-found"
+      assert_that(resp.status).equals(404)
     end
-
   end
-
 end