dynamic_paperclip 0.0.4 → 1.0.0a.1

data/README.md

@@ -2,7 +2,7 @@ Dynamic Paperclip
 =================
 
 Dynamic Paperclip is an extension to the wonderful [Paperclip](http://github.com/thoughtbot/paperclip) gem
-and a Ruby on Rails engine that allows for the creation of Paperclip attachment styles on-the-fly.
+and Rack middleware that allows for the creation of Paperclip attachment styles on-the-fly.
 
 Instead of defining your attachment styles in your model, Dynamic Paperclip allows you to generate URL's
 for arbitrary attachment styles (usually in your view), effectively pushing style definition there.
@@ -14,10 +14,7 @@ Getting started
 
 ### Requirements
 
-Dynamic Paperclip requires Paperclip 3.5.0 or above and Rails 3.2.0 or above (although it may work on earlier versions,
-it's just untested at the moment).
-
-It also only currently supports Paperclip's File Storage.
+Dynamic Paperclip requires Paperclip 3.5.0 or above and only currently supports Paperclip's File Storage.
 
 ### Application
 
@@ -29,7 +26,7 @@ gem 'dynamic_paperclip'
 
 Run the ``bundle`` command to install it.
 
-After you install the gem, you need to run the generator:
+After you install the gem, you need to run the generator if you're using Rails:
 
 ```console
 rails generate dynamic_paperclip:install
@@ -38,6 +35,12 @@ rails generate dynamic_paperclip:install
 This will install an initializer that sets up a secret key used in validating that dynamic asset URL's
 originated from your application.
 
+If you are not using Rails, you need to set ``DynamicPaperclip.config.secret`` to some random string during
+your application's boot process, check out [install_generator.rb](lib/generators/dynamic_paperclip/install_generator.rb) to see how the Rails generator does it.
+
+You'll also need to configure your application to use the ``DynamicPaperclip::AttachmentStyleGenerator`` Rack middleware
+if you are not using Rails.  This is configured automatically for Rails applications.
+
 Now, you're ready to start using Dynamic Paperclip. Change any attachment definitions that you'd like to make dynamic from:
 
 ```ruby
@@ -65,9 +68,9 @@ passing it the style definition that you would normally define in the ``:styles`
 
 ### Server Configuration
 
-If you're using Rails to serve static assets, then no configuration is required.  But if you're not,
+If you're using your application to serve static assets, then no configuration is required.  But if you're not,
 which you shouldn't be in any production environment, then you just need to make sure that your HTTP server
-is configured to serve static assets if they exist, but pass the request along to your Rails application
+is configured to serve static assets if they exist, but pass the request along to your application
 if they do not.
 
 For example, on Nginx, this would be accomplished with something along the lines of:
@@ -96,7 +99,7 @@ and is a pretty standard Nginx setup.
 Why?
 ----
 
-Because as your Rails application grows, you may discover that you have a large number of attachment styles.  This is
+Because as your application grows, you may discover that you have a large number of attachment styles.  This is
 slowing down your requests, because every time a user attempts to upload a file, Paperclip must process each and every
 one of those styles right then and there, in the middle of the request.
 
@@ -106,10 +109,11 @@ that needs it, and not in the model.
 How does this wizardry work?
 ---------------------------
 
-It's pretty simple, actually.  When you define a dynamic attachment on your model, Dynamic Paperclip defines
-a route in your application that routes the URL you've specified (or Paperclip's default) to the ``DynamicPaperclip::AttachmentStylesController``.
+It's pretty simple, actually.  Dynamic Paperclip includes a piece of Rack middleware that intercepts requests
+for URLs to any dynamic attachments, generates the requested style if it doesn't exist, and sends it
+back to the browser.
 
-For security purposes, the class is interpolated and thus hardcoded into the route.  So, if your Paperclip attachment definition looks like:
+For example, in your model, you may define a dynamic attachment like this:
 
 ```ruby
 class User
@@ -117,13 +121,7 @@ class User
 end
 ```
 
-Dynamic Paperclip will generate the following route:
-
-```ruby
-get '/system/users/:attachment/:id/dynamic_:definition', to: 'DynamicPaperclip::AttachmentStyles#generate_user'
-```
-
-Now, in your view, you might call something like this:
+Then, in your view, you might call something like this:
 
 ```ruby
 @user.avatar.dynamic_url('50x50')
@@ -135,14 +133,17 @@ Which will return the following url (assuming a JPG avatar and a User ID of 42):
 /system/users/avatars/42/dynamic_50x50.jpg?s=secrethash
 ```
 
-When your visitor's browser requests that URL, if that particular style has already been processed,
-it'll be served up by your HTTP server, but if it hasn't, Rails will route it to our controller,
-which validates that "secrethash" to ensure that the dynamic URL was generated by your application,
-and not some third-party, then simply tells Paperclip to process that style by extracting the definition
-from the stye name, and then sends it back to your visitor via ``#send_file``.
+When the first request comes in for that URL, Dynamic Paperclip's Rack middleware will intercept the request,
+validate that "secrethash" to ensure that the dynamic URL was generated by your application and not some third-party,
+then simply tell Paperclip to process that style by extracting the definition from the stye name,
+and then finally send the processed file back to your visitor's browser.
 
 On subsequent requests, the attachment will already exist, and your HTTP server will simply return it without
-ever hitting your Rails application.  Sweet!
+ever hitting your application.  Sweet!
+
+If your HTTP server is not configured to serve static assets, on subsequent requests, the middleware will simply
+intercept the request and return the asset to the browser. It will not reprocess it. This is still far less efficient
+than having your HTTP server serve the asset itself.
 
 Contributing
 ------------
@@ -152,3 +153,10 @@ Contributing
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+
+Known Issues
+------------
+- Dynamic attachments aren't registered in time when class caching is disabled (Rails development, etc.).
+  Since we register the attachment when it's defined, a request for a dynamic attachment in an environment
+  where the class isn't preloaded will pass through the middleware, since the attachment won't be registered
+  yet, and never generate.

data/lib/dynamic_paperclip/attachment.rb

@@ -13,7 +13,11 @@ module DynamicPaperclip
         style_position = path_with_wildcard.index('dynamic_*')
 
         Dir.glob(path_with_wildcard) do |file|
-          add_dynamic_style! file[style_position..-1].split('/').first
+          style_name = file[style_position..-1].split('/').first
+
+          # In the event that the style name is used as the filename,
+          # we want to remove the extension for our style name
+          add_dynamic_style! File.basename(style_name, File.extname(style_name))
         end
       end
     end

data/lib/dynamic_paperclip/attachment_registry.rb

@@ -0,0 +1,4 @@
+module DynamicPaperclip
+  class AttachmentRegistry < Paperclip::AttachmentRegistry
+  end
+end

data/lib/dynamic_paperclip/attachment_style_generator.rb

@@ -0,0 +1,73 @@
+require 'rack/request'
+require 'action_controller/metal/data_streaming'
+
+module DynamicPaperclip
+  class AttachmentStyleGenerator
+    # Rack middleware that catches requests for dynamic attachment styles
+    # that have not yet been generated and generates them.
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      request = Rack::Request.new(env)
+
+      DynamicPaperclip::AttachmentRegistry.each_definition do |klass, name, options|
+        if match = regexp_for_attachment_url(klass, (options[:url] || Attachment.default_options[:url])).match(request.path)
+          id = id_from_partition(match[:id])
+          attachment = klass.find(id).send(name)
+
+          # The definition will be escaped twice in the URL, so we need to unescape it once.
+          # We should always reference dynamic style names after escaping once - that's how they reside on the FS.
+          style_name = StyleNaming.dynamic_style_name_from_definition(URI.unescape(match[:definition]), false)
+
+          # Validate URL hash against requested style name
+          if DynamicPaperclip::UrlSecurity.valid_hash?(request.params['s'], style_name)
+
+            # Only process style if it doesn't exist,
+            # otherwise we may just be fielding a request for
+            # an existing style
+            attachment.process_dynamic_style style_name unless attachment.exists?(style_name)
+
+            return [
+              200,
+              {
+                'Content-Type' => attachment.content_type,
+                'Content-Transfer-Encoding' => 'binary',
+                'Content-Disposition' => "inline; filename=#{File.basename(attachment.path(style_name))}"
+              },
+              ActionController::DataStreaming::FileBody.new(attachment.path(style_name))
+            ]
+          else
+            # Invalid hash, just 403
+
+            return [403, {}, []]
+          end
+        end
+      end
+
+      @app.call env
+    end
+
+    private
+
+      def regexp_for_attachment_url(klass, url)
+        Regexp.new '^' + url.
+          gsub('.'            , '\.').
+          gsub(':id_partition', '(?<id>.*)').
+          gsub(':class'       , klass.name.underscore.pluralize).
+          gsub(':style'       , "dynamic_#{url_named_capture_group('definition')}").
+          gsub(/\:(\w+)/      , url_named_capture_group('\1')) + '$'
+      end
+
+      def url_named_capture_group(name)
+        "(?<#{name}>[^\/]*)"
+      end
+
+      def id_from_partition(partition)
+        partition.gsub('/', '').to_i
+      end
+
+  end
+end

data/lib/dynamic_paperclip/errors.rb

@@ -3,16 +3,7 @@ module DynamicPaperclip
   end
 
   module Errors
-    class UndefinedAttachment < DynamicPaperclip::Error
-    end
-
-    class MissingID < DynamicPaperclip::Error
-    end
-
     class SecretNotSet < DynamicPaperclip::Error
     end
-
-    class InvalidHash < DynamicPaperclip::Error
-    end
   end
 end

data/lib/dynamic_paperclip/has_attached_file.rb

@@ -1,9 +1,9 @@
 module DynamicPaperclip
   class HasAttachedFile < Paperclip::HasAttachedFile
-    def initialize(klass, name, options)
-      super
+    def register_new_attachment
+      DynamicPaperclip::AttachmentRegistry.register(@klass, @name, @options)
 
-      add_route!
+      super
     end
 
     private
@@ -31,21 +31,5 @@ module DynamicPaperclip
           end
         end
       end
-
-      def add_route!
-        url = (@options[:url] || Attachment.default_options[:url]).
-              gsub(':id_partition', '*id_partition').
-              gsub(':class'       , @klass.name.underscore.pluralize).
-              gsub(':style'       , "dynamic_:definition")
-
-        action = "generate_#{@klass.name.underscore}"
-        default_attachment = @name.to_s.downcase.pluralize
-
-        Rails.application.routes do
-          get url,
-            :to => "DynamicPaperclip::AttachmentStyles##{action}",
-            :defaults => { :attachment => default_attachment }
-        end
-      end
   end
 end

data/lib/dynamic_paperclip/railtie.rb

@@ -0,0 +1,9 @@
+require 'dynamic_paperclip/attachment_style_generator'
+
+module DynamicPaperclip
+  class Railtie < Rails::Railtie
+    initializer 'dynamic_paperclip.insert_middleware' do |app|
+      app.config.middleware.use "DynamicPaperclip::AttachmentStyleGenerator"
+    end
+  end
+end

data/lib/dynamic_paperclip/version.rb

@@ -1,3 +1,3 @@
 module DynamicPaperclip
-  VERSION = "0.0.4"
+  VERSION = "1.0.0a.1"
 end

data/lib/dynamic_paperclip.rb

@@ -1,12 +1,17 @@
 require 'paperclip'
 require "dynamic_paperclip/errors"
 require "dynamic_paperclip/config"
-require "dynamic_paperclip/engine"
 require "dynamic_paperclip/attachment"
 require "dynamic_paperclip/has_attached_file"
 require "dynamic_paperclip/paperclip_shim"
 require "dynamic_paperclip/url_security"
 require "dynamic_paperclip/style_naming"
+require "dynamic_paperclip/attachment_registry"
+
+require 'dynamic_paperclip/railtie' if defined?(Rails)
+
+require 'active_support'
+require 'active_support/core_ext/string/inflections'
 
 module DynamicPaperclip
   extend self

data/lib/generators/dynamic_paperclip/install_generator.rb

@@ -2,9 +2,7 @@ module DynamicPaperclip
   class InstallGenerator < Rails::Generators::Base
     def create_initializer_file
       create_file 'config/initializers/dynamic_paperclip.rb' do
-        <<-init
-DynamicPaperclip.config.secret = '#{SecureRandom.urlsafe_base64(50)}'
-init
+        "DynamicPaperclip.config.secret = '#{SecureRandom.urlsafe_base64(50)}'"
       end
     end
   end