dassets 0.14.3 → 0.15.2

data/lib/dassets/source.rb

@@ -1,25 +1,36 @@
-require 'dassets/engine'
+# frozen_string_literal: true
+
+require "dassets/engine"
 
 module Dassets; end
-class Dassets::Source
 
+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 }
-    @response_headers = Hash.new
+    @engines          = Hash.new{ |hash, key| hash[key] = [] }
+    @response_headers = {}
+  end
+
+  def base_path(value = nil)
+    set_base_path(value) unless value.nil?
+    @base_path
+  end
+
+  def set_base_path(value)
+    @base_path = value
   end
 
   def filter(&block)
     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 +39,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,143 @@
-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
+module Dassets; end
 
-    def self.find_by_digest_path(path, options = nil)
-      Dassets.source_files[path] || NullSourceFile.new(path, options)
-    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
-
-    def asset_file
-      @asset_file ||= Dassets::AssetFile.new(self.digest_path)
-    end
+      }.last
+  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 asset_file
+    @asset_file ||= Dassets::AssetFile.new(digest_path)
+  end
 
-        File.join([digest_dirname(@file_path), digest_basename].reject(&:empty?))
+  def digest_path
+    @digest_path ||=
+      begin
+        digest_basename =
+          @ext_list
+            .reduce([]){ |digest_ext_list, ext|
+              digest_ext_list <<
+                source.engines[ext].reduce(ext)do |ext_acc, engine|
+                  engine.ext(ext_acc)
+                end
+            }
+            .reject(&:empty?)
+            .reverse
+            .join(".")
+
+        File.join(
+          [
+            base_path,
+            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)
+  def compiled
+    @ext_list.reduce(read_file(@file_path)) do |file_acc, ext|
+      source.engines[ext].reduce(file_acc) do |ext_acc, engine|
+        engine.compile(ext_acc)
       end
     end
+  end
 
-    def exists?
-      File.file?(@file_path)
-    end
-
-    def mtime
-      File.mtime(@file_path)
-    end
-
-    def response_headers
-      self.source.nil? ? Hash.new : self.source.response_headers
-    end
+  def exists?
+    File.file?(@file_path)
+  end
 
-    def ==(other_source_file)
-      self.file_path == other_source_file.file_path
-    end
+  def mtime
+    File.mtime(@file_path)
+  end
 
-    private
+  def base_path
+    source&.base_path.to_s
+  end
 
-    # 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 response_headers
+    source.nil? ? {} : source.response_headers
+  end
 
-    def slash_path(path)
-      File.join(path, '')
+  def ==(other)
+    if other.is_a?(self.class)
+      file_path == other.file_path
+    else
+      super
     end
+  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(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)
+    if other.is_a?(self.class)
+      file_path == other.file_path
+    else
+      super
+    end
+  end
 end

data/lib/dassets/source_proxy.rb

@@ -1,42 +1,45 @@
-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
-    "#{self.digest_path} -- #{self.mtime}"
+    "#{digest_path} -- #{mtime}"
   end
 
   def content
-    @content_cache[self.key] ||= source_content
+    @content_cache[key] ||= source_content
   end
 
   def fingerprint
-    @fingerprint_cache[self.key] ||= source_fingerprint
+    @fingerprint_cache[key] ||= source_fingerprint
   end
 
   def mtime
-    @source_files.map{ |f| f.mtime }.compact.max
+    @source_files.map(&:mtime).compact.max
   end
 
   def response_headers
-    @source_files.inject(Hash.new){ |hash, f| hash.merge!(f.response_headers) }
+    @source_files.inject({}){ |hash, f| hash.merge!(f.response_headers) }
   end
 
   def exists?
@@ -46,17 +49,30 @@ class Dassets::SourceProxy
   private
 
   def source_content
-    @source_files.map{ |f| f.compiled }.join("\n")
+    @source_files.map(&:compiled).join("\n")
   end
 
   def source_fingerprint
     Digest::MD5.new.hexdigest(source_content)
   end
 
-  def get_source_files(digest_path, options)
+  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)
+      Dassets::SourceFile.find_by_digest_path(source_digest_path, **options)
     end
   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.3"
+  VERSION = "0.15.2"
 end

data/test/helper.rb

@@ -1,43 +1,49 @@
-# this file is automatically required when you run `assert`
-# put any test helpers here
+# frozen_string_literal: true
+
+# This file is automatically required when you run `assert`
+# put any test helpers here.
 
 # add the root dir to the load path
 $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 "dassets"
 
-require 'pathname'
-TEST_SUPPORT_PATH = Pathname.new(File.expand_path('../support', __FILE__))
+@dumb_engine =
+  Class.new(Dassets::Engine) do
+    def ext(_in_ext)
+      ""
+    end
 
-ENV['DASSETS_TEST_MODE']   = 'yes'
+    def compile(input)
+      "#{input}\nDUMB"
+    end
+  end
 
-require 'dassets'
+@useless_engine =
+  Class.new(Dassets::Engine) do
+    def ext(_in_ext)
+      "no-use"
+    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
+    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