RubyGems - pinion - Versions diffs - 0.1.2 → 0.1.3 - Mend

pinion 0.1.2 → 0.1.3

Files changed (7) hide show

data/README.md +33 -18
data/lib/pinion/asset.rb +23 -0
data/lib/pinion/conversion.rb +18 -9
data/lib/pinion/directory_watcher.rb +37 -0
data/lib/pinion/server.rb +57 -71
data/lib/pinion/version.rb +1 -1
metadata +8 -12

data/README.md CHANGED Viewed

@@ -15,13 +15,15 @@ simple and lightweight solution. It is driven by these core goals (bold goals ar
 * **No added syntax to your assets (e.g. no `//= require my_other_asset`)**
 * **Recompile all compiled assets when they change (or dependencies change) in development and set mtimes**
 * Recompile asynchronously from requests (no polling allowed)
-* Compile assets one time in production
+* **Compile assets one time in production**
 Installation
 ============
     $ gem install pinion
+You should add pinion to your project's Gemfile.
 Usage
 =====
@@ -32,37 +34,50 @@ The easiest way to use Pinion is to map your desired asset mount point to a `Pin
 require "pinion"
 require "your_app.rb"
-map "/assets" do
-  server = Pinion::Server.new
-  # Tell Pinion each type of conversion it should perform
-  server.convert :scss => :css # Sass and Coffeescript will just work if you have the gems installed
-  server.convert :coffee => :js # Conversion types correspond to file extensions. .coffee -> .js
-  server.convert :styl => :css do |file_contents|
-    Stylus.compile file_contents # Requires the stylus gem
-  end
-  # Tell Pinion the paths to watch
-  server.watch "public/javascripts"
-  server.watch "public/scss"
-  server.watch "public/stylus"
+MOUNT_POINT = "/assets"
+pinion = Pinion::Server.new(MOUNT_POINT)
+# Tell Pinion each type of conversion it should perform
+pinion.convert :scss => :css # Sass and Coffeescript will just work if you have the gems installed
+pinion.convert :coffee => :js # Conversion types correspond to file extensions. .coffee -> .js
+pinion.convert :styl => :css do |file_contents|
+  Stylus.compile file_contents # Requires the stylus gem
+end
+# Tell Pinion the paths to watch
+pinion.watch "public/javascripts"
+pinion.watch "public/scss"
+pinion.watch "public/stylus"
+map MOUNT_POINT do
   # Boom
-  run server
+  run pinion
 end
 map "/" do
-  run Your::App.new
+  # You should pass pinion into your app in order to use its helper methods.
+  run Your::App.new(pinion)
 end
 ```
+In your app, you will use pinion's helper methods to construct urls:
+``` erb
+<head>
+  <title>My App</title>
+  <link type="text/css" rel="stylesheet" href="<%= pinion.asset_url("/assets/style.css") %>" />
+  <!-- Shorthand equivalent -->
+  <%= pinion.css_url("style.css") %>
+</head>
+```
 Notes
 -----
-* Everything in `/assets` (in the example) will be served as-is. No conversions will be performed on those
-  files (unless you add `/assets` as a watch path).
 * Currently, Pinion sidesteps the dependency question by invalidating its cache of each file of a particular
   type (say, all `.scss` files) when any such source file is changed.
 * The order that paths are added to the watch list is a priority order in case of conflicting assets. (For
   intance, if `foo/bar` and `foo/baz` are both on the watch list, and both of the files `foo/bar/style.scss`
-  and `foo/baz/style.scss` exist, then `foo/bar/style.scss` will be used if a request occurs for `/style.css`.
+  and `foo/baz/style.scss` exist, then `foo/bar/style.scss` will be used if a request occurs for
+  `/style.css`.)
 You can see an example app using Pinion and Sinatra in the `example/` directory.

data/lib/pinion/asset.rb ADDED Viewed

@@ -0,0 +1,23 @@
+require "digest/md5"
+module Pinion
+  class Asset
+    attr_reader :uncompiled_path, :compiled_path, :from_type, :to_type, :compiled_contents, :length, :mtime,
+                :content_type, :checksum
+    def initialize(uncompiled_path, compiled_path, conversion, mtime)
+      @uncompiled_path = uncompiled_path
+      @compiled_path = compiled_path
+      @from_type = conversion.from_type
+      @to_type = conversion.to_type
+      @compiled_contents = conversion.convert(File.read(uncompiled_path))
+      @length = Rack::Utils.bytesize(@compiled_contents)
+      @mtime = mtime
+      @content_type = conversion.content_type
+      @checksum = Digest::MD5.hexdigest(@compiled_contents)
+    end
+    # Allow the Asset to be served as a rack response body
+    def each() yield @compiled_contents end
+  end
+end

data/lib/pinion/conversion.rb CHANGED Viewed

@@ -22,6 +22,7 @@ module Pinion
     attr_reader :from_type, :to_type, :gem_required
     def initialize(from_type, to_type)
+      @loaded = false
       @from_type = from_type
       @to_type = to_type
       @gem_required = nil
@@ -45,16 +46,11 @@ module Pinion
         raise Error, "No known content-type for #{@to_type}."
       end
     end
-    def convert(file_contents) @conversion_fn.call(file_contents, @environment) end
-    def add_watch_directory(path) @watch_fn.call(path, @environment) end
-    def require_dependency
-      return unless @gem_required
-      begin
-        require @gem_required
-      rescue LoadError => e
-        raise "Tried to load conversion for #{signature.inspect}, but failed to load the #{@gem_required} gem"
-      end
+    def convert(file_contents)
+      require_dependency
+      @conversion_fn.call(file_contents, @environment)
     end
+    def add_watch_directory(path) @watch_fn.call(path, @environment) end
     def verify
       unless [@from_type, @to_type].all? { |s| s.is_a? Symbol }
@@ -64,6 +60,19 @@ module Pinion
         raise Error, "Must provide a conversion function with convert { |file_contents| ... }."
       end
     end
+    private
+    def require_dependency
+      return if @loaded
+      @loaded = true
+      return unless @gem_required
+      begin
+        require @gem_required
+      rescue LoadError => e
+        raise "Tried to load conversion for #{signature.inspect}, but failed to load the #{@gem_required} gem"
+      end
+    end
   end
   # Define built-in conversions

data/lib/pinion/directory_watcher.rb ADDED Viewed

@@ -0,0 +1,37 @@
+require "set"
+require "time"
+module Pinion
+  class DirectoryWatcher
+    def initialize(root = ".")
+      @root = root
+      @watch_directories = Set.new
+    end
+    def <<(directory) @watch_directories << File.join(@root, directory) end
+    def glob(pattern, &block)
+      enumerator = Enumerator.new do |yielder|
+        @watch_directories.each do |directory|
+          Dir.glob(File.join(directory, pattern)) { |filename| yielder.yield filename }
+        end
+      end
+      enumerator.each(&block)
+    end
+    def find(path)
+      @watch_directories.each do |directory|
+        result = File.join(directory, path)
+        return result if File.file? result
+      end
+      nil
+    end
+    def latest_mtime_with_suffix(suffix)
+      pattern = "**/*#{DirectoryWatcher.sanitize_for_glob(suffix)}"
+      glob(pattern).reduce(Time.at(0)) { |latest, path| [latest, File.stat(path).mtime].max }
+    end
+    def self.sanitize_for_glob(pattern) pattern.gsub(/[\*\?\[\]\{\}]/) { |match| "\\#{match}" } end
+  end
+end

data/lib/pinion/server.rb CHANGED Viewed

@@ -1,23 +1,19 @@
-#require "fssm"
-require "pinion/error"
+require "pinion/asset"
 require "pinion/conversion"
-require "time"
-require "set"
+require "pinion/directory_watcher"
+require "pinion/error"
 module Pinion
   class Server
-    Asset = Struct.new :from_path, :to_path, :from_type, :to_type, :compiled_contents, :length, :mtime,
-                       :content_type
-    Watch = Struct.new :path, :from_type, :to_type, :conversion
-    def initialize
-      @running = false
-      @watch_directories = []
-      @watches = []
+    # TODO: is there a way to figure out the mount point ourselves? The only way I can find would be to wait
+    # for a request and compare REQUEST_PATH to PATH_INFO, but that's super hacky and won't work anyway
+    # because we need that information before requests are handled due to #asset_url
+    def initialize(mount_point)
+      @mount_point = mount_point
+      @watcher = DirectoryWatcher.new
       @cached_assets = {}
-      @conversions_used = Set.new
       @file_server = Rack::File.new(Dir.pwd)
+      @environment = (defined?(RACK_ENV) && RACK_ENV) || ENV["RACK_ENV"] || "development"
     end
     def convert(from_and_to, &block)
@@ -42,15 +38,13 @@ module Pinion
     def watch(path)
       raise Error, "#{path} is not a directory." unless File.directory? path
-      @watch_directories << path
+      @watcher << path
       Conversion.add_watch_directory path
     end
     # Boilerplate mostly stolen from sprockets
     # https://github.com/sstephenson/sprockets/blob/master/lib/sprockets/server.rb
     def call(env)
-      start unless @running
       # Avoid modifying the session state, don't set cookies, etc
       env["rack.session.options"] ||= {}
       env["rack.session.options"].merge! :defer => true, :skip => true
@@ -62,7 +56,12 @@ module Pinion
         return [403, { "Content-Type" => "text/plain", "Content-Length" => "9" }, ["Forbidden"]]
       end
-      real_file = get_real_file(path)
+      # Pull out the md5sum if it's part of the given path
+      # e.g. foo/bar-a95c53a7a0f5f492a74499e70578d150.js -> a95c53a7a0f5f492a74499e70578d150
+      checksum_tag = path[/-([\da-f]{32})\..+$/, 1]
+      path.sub!("-#{checksum_tag}", "") if checksum_tag
+      real_file = @watcher.find path
       if real_file
         # Total hack; this is probably a big misuse of Rack::File but I don't want to have to reproduce a lot
         # of its logic
@@ -71,17 +70,23 @@ module Pinion
         return @file_server.call(env)
       end
-      asset = get_asset(path)
+      asset = find_asset(path)
+      # If the ETag matches, give a 304
+      return [304, {}, []] if env["HTTP_IF_NONE_MATCH"] == %Q["#{asset.checksum}"]
       if asset
+        # Cache for a year in production; don't cache in dev
+        cache_policy = checksum_tag ? "max-age=31536000" : "must-revalidate"
         headers = {
           "Content-Type" => asset.content_type,
           "Content-Length" => asset.length.to_s,
-          # TODO: set a long cache in prod mode when implemented
-          "Cache-Control" => "public, must-revalidate",
+          "ETag" => %Q["#{asset.checksum}"],
+          "Cache-Control" => "public, #{cache_policy}",
           "Last-Modified" => asset.mtime.httpdate,
         }
         return [200, headers, []] if env["REQUEST_METHOD"] == "HEAD"
-        [200, headers, asset.compiled_contents]
+        [200, headers, asset]
       else
         [404, { "Content-Type" => "text/plain", "Content-Length" => "9" }, ["Not found"]]
       end
@@ -93,28 +98,40 @@ module Pinion
       raise
     end
-    private
+    # Helper methods for an application to generate urls (with fingerprints in production)
+    def asset_url(path)
+      path.sub!(%r[^(#{@mount_point})?/?], "")
+      mounted_path = "#{@mount_point}/#{path}"
-    def get_real_file(path)
-      @watch_directories.each do |directory|
-        file = File.join(directory, path)
-        return file if File.file? file
-      end
-      nil
+      # TODO: Change the real file behavior if I replace the use of Rack::File above
+      return mounted_path if @watcher.find(path)
+      return mounted_path unless @environment == "production"
+      # Add on a checksum tag in production
+      asset = find_asset(path)
+      raise "Error: no such asset available: #{path}" unless asset
+      mounted_path, dot, extension = mounted_path.rpartition(".")
+      return mounted_path if dot.empty?
+      "#{mounted_path}-#{asset.checksum}.#{extension}"
     end
+    def css_url(path) %Q{<link type="text/css" rel="stylesheet" href="#{asset_url(path)}" />} end
+    def js_url(path) %Q{<script type="application/javascript" src="#{asset_url(path)}"></script>} end
-    def get_asset(to_path)
+    private
+    def find_asset(to_path)
       asset = @cached_assets[to_path]
       if asset
         mtime = asset.mtime
-        latest = latest_mtime_of_type(asset.from_type)
+        latest = @watcher.latest_mtime_with_suffix(asset.from_type.to_s)
         if latest > mtime
           invalidate_all_assets_of_type(asset.from_type)
-          return get_asset(to_path)
+          return find_asset(to_path)
         end
       else
         begin
-          asset = get_uncached_asset(to_path)
+          asset = find_uncached_asset(to_path)
         rescue Error
           return nil
         end
@@ -123,41 +140,22 @@ module Pinion
       asset
     end
-    def latest_mtime_of_type(type)
-      latest = Time.at(0)
-      @watch_directories.each do |directory|
-        Dir[File.join(directory, "**/*.#{type}")].each do |file|
-          mtime = File.stat(file).mtime
-          latest = mtime if mtime > latest
-        end
-      end
-      latest
-    end
-    def get_uncached_asset(to_path)
+    def find_uncached_asset(to_path)
       from_path, conversion = find_source_file_and_conversion(to_path)
       # If we reach this point we've found the asset we're going to compile
-      conversion.require_dependency unless @conversions_used.include? conversion
-      @conversions_used << conversion
       # TODO: log at info: compiling asset ...
-      contents = conversion.convert(File.read(from_path))
-      length = File.stat(from_path).size
-      mtime = latest_mtime_of_type(conversion.from_type)
-      content_type = conversion.content_type
-      return Asset.new from_path, to_path, conversion.from_type, conversion.to_type,
-                       [contents], contents.length, mtime, content_type
+      mtime = @watcher.latest_mtime_with_suffix(conversion.to_type.to_s)
+      Asset.new from_path, to_path, conversion, mtime
     end
     def find_source_file_and_conversion(to_path)
       path, dot, suffix = to_path.rpartition(".")
       conversions = Conversion.conversions_for(suffix.to_sym)
       raise Error, "No conversion for for #{to_path}" if conversions.empty?
-      @watch_directories.each do |directory|
-        conversions.each do |conversion|
-          Dir[File.join(directory, "#{path}.#{conversion.from_type}")].each do |from_path|
-            return [from_path, conversion]
-          end
-        end
+      conversions.each do |conversion|
+        filename = "#{path}.#{conversion.from_type}"
+        from_path = @watcher.find filename
+        return [from_path, conversion] if from_path
       end
       raise Error, "No source file found for #{to_path}"
     end
@@ -170,17 +168,5 @@ module Pinion
       status, headers, body = response
       [status, headers.merge({ "Content-Length" => Rack::Utils.bytesize(body).to_s }), body]
     end
-    def update_asset(asset)
-    end
-    def start
-      @running = true
-      # TODO: mad threadz
-      # Start a thread with an FSSM watch on each directory. Upon detecting a change to a compiled file that
-      # is a dependency of any asset in @required_assets, call update_asset for each affected asset.
-      #
-      # There are some tricky threading issues here.
-    end
   end
 end

data/lib/pinion/version.rb CHANGED Viewed

@@ -1,3 +1,3 @@
 module Pinion
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

metadata CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pinion
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
   prerelease:
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-03-01 00:00:00.000000000Z
+date: 2012-04-27 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
-  requirement: &70301404900360 !ruby/object:Gem::Requirement
+  requirement: &23433260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '1.0'
   type: :runtime
   prerelease: false
-  version_requirements: *70301404900360
+  version_requirements: *23433260
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70301404899940 !ruby/object:Gem::Requirement
+  requirement: &23432840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,7 +32,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70301404899940
+  version_requirements: *23432840
 description: ! 'Pinion is a Rack application that you can use to compile and serve
   assets (such as Javascript and CSS).
@@ -44,9 +44,11 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
+- lib/pinion/asset.rb
 - lib/pinion/conversion.rb
 - lib/pinion/error.rb
 - lib/pinion/server.rb
+- lib/pinion/directory_watcher.rb
 - lib/pinion/version.rb
 - lib/pinion.rb
 homepage: https://github.com/ooyala/pinion
@@ -61,18 +63,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -3405067065911020567
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -3405067065911020567
 requirements: []
 rubyforge_project: pinion
 rubygems_version: 1.8.10