dassets 0.14.2 → 0.15.1

data/lib/dassets/engine.rb

@@ -1,31 +1,19 @@
-module Dassets
+# frozen_string_literal: true
 
-  class Engine
+module Dassets; end
 
-    attr_reader :opts
-
-    def initialize(opts=nil)
-      @opts = opts || {}
-    end
-
-    def ext(input_ext)
-      raise NotImplementedError
-    end
-
-    def compile(input)
-      raise NotImplementedError
-    end
+class Dassets::Engine
+  attr_reader :opts
 
+  def initialize(opts = nil)
+    @opts = opts || {}
   end
 
-  class NullEngine < Engine
-    def ext(input_ext)
-      input_ext
-    end
-
-    def compile(input)
-      input
-    end
+  def ext(input_ext)
+    raise NotImplementedError
   end
 
+  def compile(input)
+    raise NotImplementedError
+  end
 end

data/lib/dassets/file_store.rb

@@ -1,38 +1,38 @@
-require 'thread'
+# frozen_string_literal: true
 
-module Dassets
+require "thread"
 
-  class FileStore
-    attr_reader :root
+module Dassets; end
 
-    def initialize(root)
-      @root       = root
-      @save_mutex = ::Mutex.new
-    end
-
-    def save(url, &block)
-      @save_mutex.synchronize do
-        store_path(url).tap do |path|
-          FileUtils.mkdir_p(File.dirname(path))
-          File.open(path, "w"){ |f| f.write(block.call) }
-        end
-      end
-    end
+class Dassets::FileStore
+  attr_reader :root
 
-    def store_path(url)
-      File.join(@root, url)
-    end
-
-    class NullStore < FileStore
-      def initialize
-        super('')
-      end
+  def initialize(root)
+    @root       = root
+    @save_mutex = ::Mutex.new
+  end
 
-      def save(url, &block)
-        store_path(url) # no-op, just return the store path like the base does
+  def save(url_path, &block)
+    @save_mutex.synchronize do
+      store_path(url_path).tap do |path|
+        FileUtils.mkdir_p(File.dirname(path))
+        File.open(path, "w"){ |f| f.write(block.call) }
       end
     end
+  end
+
+  def store_path(url_path)
+    File.join(@root, url_path)
+  end
+end
 
+class Dassets::NullFileStore < Dassets::FileStore
+  def initialize
+    super("")
   end
 
+  def save(url_path)
+    # No-op, just return the store path like the base does.
+    store_path(url_path)
+  end
 end

data/lib/dassets/server.rb

@@ -1,37 +1,37 @@
-require 'dassets/server/request'
-require 'dassets/server/response'
+# frozen_string_literal: true
+
+require "dassets/server/request"
+require "dassets/server/response"
 
 # Rack middleware for serving Dassets asset files
 
-module Dassets
-  class Server
+module Dassets; end
 
-    def initialize(app)
-      @app = app
-    end
+class Dassets::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
+  # 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
+  # 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

data/lib/dassets/server/request.rb

@@ -1,56 +1,59 @@
-require 'rack'
+# frozen_string_literal: true
 
-module Dassets; end
-class Dassets::Server
-
-  class Request < Rack::Request
+require "rack"
 
-    # 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
+module Dassets; end
+class Dassets::Server; end
+
+class Dassets::Server::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'].sub(dassets_base_url, '')
-    end
+  def path_info
+    @env["PATH_INFO"].sub(dassets_base_url, "")
+  end
 
-    def dassets_base_url
-      Dassets.config.base_url.to_s
-    end
+  def dassets_base_url
+    Dassets.config.base_url.to_s
+  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 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.exists?)
-    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 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.exists?)
+  end
 
-    def asset_path
-      @asset_path ||= path_digest_match.captures.select{ |m| !m.empty? }.join
-    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
+  def asset_file
+    @asset_file ||= Dassets.asset_file(asset_path)
+  end
 
-    private
+  private
 
-    def for_digested_asset?
-      !path_digest_match.captures.empty?
-    end
+  def for_digested_asset?
+    !path_digest_match.captures.empty?
+  end
 
-    def path_digest_match
-      @path_digest_match ||= begin
-        path_info.match(/\/(.+)-[a-f0-9]{32}(\..+|)$/i) || NullDigestMatch.new
-      end
+  def path_digest_match
+    @path_digest_match ||= begin
+      path_info.match(%r{/(.+)-[a-f0-9]{32}(\..+|)$}i) || NullDigestMatch.new
     end
+  end
 
-    class NullDigestMatch
-      def captures; []; end
+  class NullDigestMatch
+    def captures
+      []
     end
-
   end
 end

data/lib/dassets/server/response.rb

@@ -1,108 +1,129 @@
-require 'rack/response'
-require 'rack/utils'
-require 'rack/mime'
+# frozen_string_literal: true
+
+require "rack/response"
+require "rack/utils"
+require "rack/mime"
 
 module Dassets; end
-class Dassets::Server
+class Dassets::Server; end
+
+class Dassets::Server::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("Last-Modified" => mtime),
+        [],
+      ]
+    elsif !@asset_file.exists?
+      [
+        404,
+        Rack::Utils::HeaderHash.new,
+        ["Not Found"],
+      ]
+    else
+      @asset_file.digest!
+      body = Body.new(env, @asset_file)
+      [
+        body.partial? ? 206 : 200,
+        Rack::Utils::HeaderHash
+          .new
+          .merge(@asset_file.response_headers).tap do |h|
+            h["Last-Modified"]  = mtime.to_s
+            h["Content-Type"]   = @asset_file.mime_type.to_s
+            h["Content-Length"] = body.size.to_s
+            h["Content-Range"]  = body.content_range if body.partial?
+          end,
+        env["REQUEST_METHOD"] == "HEAD" ? [] : body,
+      ]
+    end
+  end
 
-  class Response
+  def to_rack
+    [@status, @headers.to_hash, @body]
+  end
+
+  # This class borrows from the body range handling in Rack::File and adapts
+  # it for use with Dasset's asset files and their generic string content.
+  class Body
+    CHUNK_SIZE = (8 * 1024) # 8k
 
-    attr_reader :asset_file, :status, :headers, :body
+    attr_reader :asset_file, :size, :content_range
 
     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('Last-Modified' => mtime), [] ]
-      elsif !@asset_file.exists?
-        [ 404, Rack::Utils::HeaderHash.new, ["Not Found"] ]
-      else
-        @asset_file.digest!
-        body = Body.new(env, @asset_file)
-        [ body.partial? ? 206 : 200,
-          Rack::Utils::HeaderHash.new.merge(@asset_file.response_headers).tap do |h|
-            h['Last-Modified']  = mtime
-            h['Content-Type']   = @asset_file.mime_type.to_s
-            h['Content-Length'] = body.size.to_s
-            h['Content-Range']  = body.content_range if body.partial?
-          end,
-          env["REQUEST_METHOD"] == "HEAD" ? [] : body
-        ]
-      end
+      @range, @content_range = get_range_info(env, @asset_file)
+      @size = range_end - range_begin + 1
     end
 
-    def to_rack
-      [@status, @headers.to_hash, @body]
+    def partial?
+      !@content_range.nil?
     end
 
-    class Body
-
-      # this class borrows from the body range handling in Rack::File and adapts
-      # it for use with Dasset's asset files and their generic string content.
-
-      CHUNK_SIZE = (8*1024).freeze # 8k
-
-      attr_reader :asset_file, :size, :content_range
-
-      def initialize(env, asset_file)
-        @asset_file = asset_file
-        @range, @content_range = get_range_info(env, @asset_file)
-        @size = self.range_end - self.range_begin + 1
-      end
-
-      def partial?
-        !@content_range.nil?
-      end
+    def range_begin
+      @range.begin
+    end
 
-      def range_begin; @range.begin; end
-      def range_end;   @range.end;   end
+    def range_end
+      @range.end
+    end
 
-      def each
-        StringIO.open(@asset_file.content, "rb") do |io|
-          io.seek(@range.begin)
-          remaining_len = self.size
-          while remaining_len > 0
-            part = io.read([CHUNK_SIZE, remaining_len].min)
-            break if part.nil?
+    def each
+      StringIO.open(@asset_file.content, "rb") do |io|
+        io.seek(@range.begin)
+        remaining_len = size
+        while remaining_len > 0
+          part = io.read([CHUNK_SIZE, remaining_len].min)
+          break if part.nil?
 
-            remaining_len -= part.length
-            yield part
-          end
+          remaining_len -= part.length
+          yield part
         end
       end
+    end
 
-      def inspect
-        "#<#{self.class}:#{'0x0%x' % (self.object_id << 1)} " \
-          "digest_path=#{self.asset_file.digest_path} " \
-          "range_begin=#{self.range_begin} range_end=#{self.range_end}>"
-      end
+    def inspect
+      "#<#{self.class}:#{"0x0%x" % (object_id << 1)} " \
+        "digest_path=#{asset_file.digest_path} " \
+        "range_begin=#{range_begin} range_end=#{range_end}>"
+    end
 
-      def ==(other_body)
-        self.asset_file  == other_body.asset_file  &&
-        self.range_begin == other_body.range_begin &&
-        self.range_end   == other_body.range_end
+    def ==(other)
+      if other.is_a?(self.class)
+        asset_file  == other.asset_file  &&
+        range_begin == other.range_begin &&
+        range_end   == other.range_end
+      else
+        super
       end
+    end
 
-      private
-
-      def get_range_info(env, asset_file)
-        content_size = asset_file.size
-        # legacy rack version, just return full size
-        return full_size_range_info(content_size) if !Rack::Utils.respond_to?(:byte_ranges)
-        ranges = Rack::Utils.byte_ranges(env, content_size)
-        # No ranges or multiple ranges are not supported, just return full size
-        return full_size_range_info(content_size) if ranges.nil? || ranges.empty? || ranges.length > 1
-        # single range
-        [ranges[0], "bytes #{ranges[0].begin}-#{ranges[0].end}/#{content_size}"]
+    private
+
+    def get_range_info(env, asset_file)
+      content_size = asset_file.size
+      # legacy rack version, just return full size
+      unless Rack::Utils.respond_to?(:byte_ranges)
+        return full_size_range_info(content_size)
       end
 
-      def full_size_range_info(content_size)
-        [(0..content_size-1), nil]
+      ranges = Rack::Utils.byte_ranges(env, content_size)
+      # No ranges or multiple ranges are not supported, just return full size
+      if ranges.nil? || ranges.empty? || ranges.length > 1
+        return full_size_range_info(content_size)
       end
 
+      # single range
+      [ranges[0], "bytes #{ranges[0].begin}-#{ranges[0].end}/#{content_size}"]
     end
 
+    def full_size_range_info(content_size)
+      [(0..content_size - 1), nil]
+    end
   end
-
 end