cropper 0.2.1

data/app/views/cropper/uploads/_crop.html.haml

@@ -0,0 +1,34 @@
+- upload ||= @upload
+- prefix = upload.holder_column
+- multiplier ||= (params[:multiplier] || 1).to_i
+
+- target_w = upload.crop_width / multiplier
+- target_h = upload.crop_height / multiplier
+
+- max_w = upload.precrop_width / multiplier
+- max_h = upload.precrop_height / multiplier
+
+- initial_w = upload.scale_width? ? upload.scale_width / multiplier : max_w * 3 / 4
+- initial_h = upload.scale_height? ? upload.scale_height / multiplier : max_h * 3 / 4
+
+- offset_l = upload.offset_left? ? upload.offset_left / multiplier : (target_w - initial_w)/2
+- offset_t = upload.offset_top? ? upload.offset_top / multiplier : (target_h - initial_h)/2
+
+.cropper
+  .preview{:style => "width: #{initial_w}px; height: #{initial_h}px; top: #{offset_t}px; left: #{offset_l}px"}
+    %img{:src => upload.file.url(:precrop)}
+
+  %p.drag_instructions
+    = t :drag_instructions
+    
+  = fields_for upload.holder do |hf|
+    = hf.fields_for :"#{upload.holder_column}_upload", upload do |uf|
+      %fieldset.crop
+        = uf.hidden_field :id, :data => {:"clear-on-detach" => true}
+        = uf.hidden_field :offset_left, :value => offset_l, :class => 'ol'
+        = uf.hidden_field :offset_top, :value => offset_t, :class => 'ot'
+        = uf.hidden_field :multiplier, :value => multiplier
+        .scaler
+          %p.range
+            = uf.range_field :scale_width, :min => target_w, :max => max_w, :value => initial_w, :class => 'sw'
+            = uf.hidden_field :scale_height, :value => initial_h, :class => 'sh'

data/app/views/cropper/uploads/_error.html.haml

@@ -0,0 +1 @@
+= @upload.errors[:file].first

data/app/views/cropper/uploads/_pick.html.haml

@@ -0,0 +1,42 @@
+- upload ||= @upload
+- holder ||= @holder || upload.holder
+- extra_controls ||= false
+
+- multiplier ||= params[:multiplier] || 1
+
+= fields_for holder do |hf|
+  = hf.fields_for :"#{upload.holder_column}_upload", upload do |uf|
+    .uploadbox{:data => {:action => "upload", :url => cropper.uploads_path(:holder_id => holder.id, :holder_type => holder.class.to_s.underscore, :holder_column => upload.holder_column, :multiplier => multiplier, :format => :js)}}
+      .prompt
+        = link_to t(:click_to_upload), '#', :data => {:action => "pick"}
+        .droppable
+          .note
+            = t :drop_to_upload
+      .img<
+        - if upload.persisted?
+          - width = upload.crop_width / multiplier
+          - height = upload.crop_height / multiplier
+          = link_to image_tag(upload.file.url(:cropped), :style => "width: #{width}px; height: #{height}px"), cropper.edit_upload_url(upload, :multiplier => multiplier), :data => {:action => "recrop"}
+          = link_to t(:detach_upload), '#', :class => 'detach', :data => {:action => 'detach'}
+
+      %p.file
+        = uf.file_field :file, :class => 'file_upload', :accept => "image"
+
+      %p.instructions
+        - unless upload.persisted?
+          = link_to t(:click_to_upload), '#', :data => {:action => "pick"}
+          %span.droppable
+            = t :drop_to_upload
+
+      - if extra_controls
+        .controls
+          #uploader.upload.button
+            = link_to t(:upload), '#', :data => {:action => "pick"}
+          .edit.button
+            - if upload && upload.persisted?
+              = link_to t(:edit_crop), cropper.edit_upload_url(upload, :multiplier => multiplier), :data => {:action => "recrop"}
+            - else
+              = link_to t(:edit_crop), '#', :data => {:action => "recrop"}, :class => 'unavailable'
+          .cancel.button
+            = link_to t(:cancel), '#'
+    

data/app/views/cropper/uploads/edit.html.haml

@@ -0,0 +1,6 @@
+/ This we show when setting the crop parameters of an upload. 
+/ It is usually either summoned by a click or returned on a 
+/ redirect from uploads#create. For more direct editing you could 
+/ also nest cropper/uploads/crop in the recipient's edit form.
+.edit_upload
+  = render :partial => "cropper/uploads/crop"

data/app/views/cropper/uploads/new.html.haml

@@ -0,0 +1,5 @@
+/ This we show when first creating an upload. It is a standard base
+/ from which to launch the javascript picker/uploader that will create
+/ an upload object and move us into edit (ie crop) mode.
+.upload
+  = render :partial => "cropper/uploads/pick"

data/app/views/cropper/uploads/show.html.haml

@@ -0,0 +1 @@
+= image_tag @upload.file.url(:cropped)

data/config/locales/en.yml

@@ -0,0 +1,5 @@
+en:
+  click_to_upload: "Click anywhere on the picture to choose and upload an image"
+  drop_to_upload: "(or you can just drop a file here)"
+  drag_instructions: "Drag slider to resize. Drag image to change crop."
+  click_to_upload: "Click to choose and upload an image"

data/config/routes.rb

@@ -0,0 +1,3 @@
+Cropper::Engine.routes.draw do
+  resources :uploads
+end

data/cropper.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cropper/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cropper"
+  s.version     = Cropper::VERSION
+  s.authors     = ["William Ross"]
+  s.email       = ["will@spanner.org"]
+  s.homepage    = ""
+  s.summary     = %q{A simple but specific way to attach (re)croppable uploads to any model}
+  s.description = %q{Provides a mechanism for uploading, cropping and reusing images in any of your models.}
+
+  s.rubyforge_project = "cropper"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "rails", "~> 3.2.0"
+  s.add_dependency('paperclip', '~> 3.3')
+  s.add_dependency('delayed_job_active_record')
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec-rails"
+  s.add_development_dependency "shoulda-matchers"
+  s.add_development_dependency "capybara"
+  s.add_development_dependency "acts_as_fu"
+  s.add_development_dependency "sqlite3"
+  
+end

data/db/migrate/20120510103921_uploads.rb

@@ -0,0 +1,11 @@
+class Uploads < ActiveRecord::Migration
+  def change
+    create_table :cropper_uploads do |t|
+      t.attachment :file
+      t.string :original_extension
+      t.integer :original_width
+      t.integer :original_height
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20130226190434_uploads_hold_crop_data.rb

@@ -0,0 +1,8 @@
+class UploadsHoldCropData < ActiveRecord::Migration
+  def change
+    add_column :cropper_uploads, :scale_width, :integer
+    add_column :cropper_uploads, :scale_height, :integer
+    add_column :cropper_uploads, :offset_left, :integer
+    add_column :cropper_uploads, :offset_top, :integer
+  end
+end

data/db/migrate/20130402074802_upload_holder.rb

@@ -0,0 +1,20 @@
+class UploadHolder < ActiveRecord::Migration
+  def change
+    add_column :cropper_uploads, :holder_id, :integer
+    add_column :cropper_uploads, :holder_type, :string
+    add_column :cropper_uploads, :holder_column, :string
+
+    Cropper::Upload.reset_column_information
+    Cropper::Upload.all.each do |u|
+      puts "finding match for upload #{u.id}"
+      if person = Droom::Person.where(:image_upload_id => u.id).first
+        puts "-> #{person.formal_name}"
+        %w{offset_left offset_top scale_width scale_height}.each do |col|
+          u.update_column(col.to_sym, person.send(:"image_#{col}"))
+        end
+        u.update_column(:holder_type, "Droom::Person")
+        u.update_column(:holder_column, 'image')
+      end
+    end
+  end
+end

data/init.rb

@@ -0,0 +1,4 @@
+require File.join(File.dirname(__FILE__), "lib", "cropper")
+require 'cropper/railtie'
+
+Cropper::Railtie.insert

data/lib/cropper.rb

@@ -0,0 +1,159 @@
+require "paperclip"
+require "paperclip/validators/attachment_height_validator"
+require "paperclip/validators/attachment_width_validator"
+require "paperclip/geometry_transformation"
+require "paperclip_processors/offset_thumbnail"
+require "cropper/engine"
+require "cropper/routing"
+require 'cropper/glue'
+require 'open-uri'
+
+module Cropper
+  # Module configuration is handled in a simple way by accessors on the Cropper module. At the moment
+  # there aren't many. Any, in fact, but we do hold some structural information about the uploading classes.
+  #
+  mattr_accessor :uploadable_classes, :upload_options
+
+  class << self
+    def uploadable_classes
+      @@uploadable_classes ||= {}
+    end
+    
+    def upload_options
+      @@upload_options ||= {}
+    end
+
+    def declare_uploadable(klass, column, options)
+      k = klass.to_s.underscore.to_sym
+      uploadable_classes[k] ||= []
+      uploadable_classes[k].push(column.to_sym)
+      upload_options[k] ||= {}
+      upload_options[k][column.to_sym] = {
+        :precrop_geometry => options[:styles][:precrop],
+        :crop_geometry => options[:geometry]
+      }
+    end
+    
+    def crop_geometry(klass, column)
+      k = klass.to_s.underscore.to_sym
+      upload_options[k][column.to_sym][:crop_geometry]
+    end
+
+    def precrop_geometry(klass, column)
+      k = klass.to_s.underscore.to_sym
+      Rails.logger.warn "precrop_geometry(#{k.inspect}, #{column.inspect})"
+      upload_options[k][column.to_sym][:precrop_geometry]
+    end
+  end
+  
+  # Cropper::ClassMethods is included into ActiveRecord::Base in the same way as the Paperclip module. 
+  # It adds a `has_upload` class method that defines an attachment and adds several instance methods 
+  # that will return the values that determine its cropping. Those values are usually but not  
+  # necessarily given by the user.
+  #
+  module ClassMethods
+    ## Defining upload columns
+    #
+    # *has_upload* brings in the whole machinery of receiving and cropping an uploaded file. The options given are exactly the same
+    # as paperclip's `has_attached_file` call, with the addition of a 'crop' parameter that gives the target dimensions. The crop 
+    # value is applied in the upload object, then any other styles you specify here are applied to that cropped image when it is 
+    # passed to this model.
+    #
+    # The practical effect of this is that your :original file always has your :crop dimensions.
+    #
+    # You can also set an optional :precrop option to set the dimensions of the file that is presented in the cropping interface. 
+    # The default is 1600x1600<, which is often going to be too big and may cause unwanted scaling-up of your source image.
+    # The precrop geometry is also applied in the upload object, when a file is first uploaded.
+    #
+    # The call usually looks like this:
+    #
+    #   class User < ActiveRecord::Base
+    #     has_upload :avatar, 
+    #                :precrop => '1440x960<
+    #                :crop => '720x480#'
+    #                :styles => {
+    #                  :thumbnail => "60x60#"
+    #                }
+    #
+    # The crop geometry will always be treated as a fixed target shape: that is, as though it ended in '#'. Any other suffix will be 
+    # removed. The other styles that you define can be in any form that paperclip understands.
+    #
+    # A model can make more than one has_upload call. The methods we define here are all prefixed with the association name, so you 
+    # usually end up calling methods like `person.icon_upload`.
+    #
+    def has_upload(attachment_name=:image, options={})
+      # unless !table_exists? || column_names.include?("#{attachment_name}_upload_id")
+      #   raise RuntimeError, "has_upload(#{attachment_name}) called on class #{self.to_s} but we have no #{attachment_name}_upload_id column" unless 
+      # end
+      
+      # allow uploads to be assigned to this class and column in the UploadsController.
+      options.reverse_merge!(:geometry => "960x640#", :whiny => true, :styles => {})
+      options[:styles].reverse_merge!({:precrop => "1600x1600<"})
+      Cropper.declare_uploadable(self, attachment_name, options)
+
+      ### Upload association
+      #
+      # [uploads](/app/models/upload.html) are the original image files uploaded and cropped by this person.
+      #
+      has_many :uploads, :class_name => "Cropper::Upload", :as => :holder # so what happens when we call this twice?
+      
+      # Ok, I give in. We have to require an image_upload_id column. It's silly trying to fake the whole association machine.
+      belongs_to :"#{attachment_name}_upload", :class_name => "Cropper::Upload", :autosave => true
+
+      # accepts_nested_attributes_for :"#{attachment_name}_upload"
+      attr_accessible :"#{attachment_name}_upload_attributes"
+      after_save :"connect_to_#{attachment_name}_upload"
+      
+      #...but we still need to intervene to set the holder_column column of the upload when it is assigned
+      define_method :"#{attachment_name}_upload_with_holder_column=" do |upload|
+        upload.holder_column = attachment_name
+        send :"#{attachment_name}_upload_without_holder_column=", upload
+      end
+      alias_method_chain :"#{attachment_name}_upload=", :holder_column
+
+      #...or built.
+      define_method :"build_#{attachment_name}_upload_with_holder_column" do |attributes={}, options={}|
+        attributes[:holder_column] = attachment_name
+        attributes[:holder_type] ||= self.class.to_s unless attributes[:holder]
+        send :"build_#{attachment_name}_upload_without_holder_column", attributes, options
+      end
+      alias_method_chain :"build_#{attachment_name}_upload", :holder_column
+
+      # when a new holder is created, the interface means that the upload will have preceded it. In that
+      # case we will have forced the setting of holder_type to allow crop-dimension lookups. When eventually
+      #  saving, we have to make sure that holder_id is also present.
+      define_method :"connect_to_#{attachment_name}_upload" do
+        if upload = send(:"#{attachment_name}_upload")
+          upload.update_column(:holder_type, self.class.to_s)
+          upload.update_column(:holder_id, self.id)
+          upload.update_column(:holder_column, attachment_name)
+        end
+        Rails.logger.warn "connect_to_#{attachment_name}_upload: upload is #{upload.inspect}. Self is #{self.inspect}"
+        true
+      end
+      
+      define_method :"#{attachment_name}_upload_attributes=" do |attributes|
+        # assign_nested_attributes_for_image_upload_association(:image_upload, attributes, mass_assignment_options)
+        if upload_id = attributes.delete('id')
+          self.send :"#{attachment_name}_upload=", Cropper::Upload.find(upload_id)
+        end
+        if upload = self.send(:"#{attachment_name}_upload")
+          Rails.logger.warn "setting upload attributes for #{upload.inspect} -> #{attributes.inspect}"
+          upload.assign_attributes(attributes)
+        end
+      end
+
+      ### Attachment
+      #
+      # Eventually we get to the point. Image attachments work in the usual Paperclip way except that they are always received from
+      # an upload object, presumably in an already-cropped form.
+      # If this class then generates other styles, they are built from that cropped image rather than the file originally uploaded.
+      #
+      has_attached_file attachment_name, options
+
+      # Note: updates to the attached file are pushed to the holder from the upload after processing is complete, so we won't always
+      # have them immediately. Best course is to display the upload cropped rather than the holder original.
+
+    end
+  end
+end

data/lib/cropper/engine.rb

@@ -0,0 +1,8 @@
+module Cropper
+  class Engine < ::Rails::Engine
+    isolate_namespace Cropper
+    initializer "cropper.integration" do
+      ActiveRecord::Base.send(:include, Cropper::Glue)
+    end
+  end
+end

data/lib/cropper/glue.rb

@@ -0,0 +1,20 @@
+require 'cropper/schema'
+
+module Cropper
+  module Glue
+    def self.included base #:nodoc:
+      
+      # Extend ActiveRecord::Base with Cropper::ClassMethods, as defined in cropper.rb.
+      #
+      base.extend ClassMethods
+
+      # Load migration helpers into all the right places.
+      #
+      if defined?(ActiveRecord)
+        ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:include, Cropper::Schema)
+        ActiveRecord::ConnectionAdapters::Table.send(:include, Cropper::Schema)
+        ActiveRecord::ConnectionAdapters::TableDefinition.send(:include, Cropper::Schema)
+      end
+    end
+  end
+end

data/lib/cropper/routing.rb

@@ -0,0 +1,23 @@
+module ActionDispatch::Routing
+
+  class Mapper
+    def cropper_for(*res)
+      options = res.extract_options!
+      res.map!(&:to_sym)
+
+      # options[:path] ||= "cropper"
+      # options[:as] ||= :cropper
+      # options[:path] = "#{options[:path]}/" unless options[:path].last == '/'
+      # mount Cropper::Engine => options[:path], :as => options[:as]
+
+      Rails.application.routes.draw do
+        resources :uploads, :module => :cropper
+        res.each do |resource|
+          resources resource do
+            resources :uploads, :module => :cropper
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cropper/schema.rb

@@ -0,0 +1,63 @@
+module Cropper
+  # Provides helpers that can be used in migrations. 
+  # Copied from, and often makes calls on, the equivalent file in Paperclip.
+  #
+  module Schema
+    UPLOAD_COLUMNS = {
+      :file_name    => :string,
+      :content_type => :string,
+      :file_size    => :integer,
+      :updated_at   => :datetime,
+      :upload_id    => :integer,
+      :scale_width  => :integer,
+      :scale_height => :integer,
+      :offset_left  => :integer,
+      :offset_top   => :integer
+    }
+
+    def self.included(base)
+      ActiveRecord::ConnectionAdapters::Table.send :include, TableDefinition
+      ActiveRecord::ConnectionAdapters::TableDefinition.send :include, TableDefinition
+      ActiveRecord::ConnectionAdapters::AbstractAdapter.send :include, Statements
+    end
+
+    module Statements
+      def add_upload(table_name, *attachment_names)
+        raise ArgumentError, "Please specify attachment name in your add_upload call in your migration." if attachment_names.empty?
+        
+        attachment_names.each do |attachment_name|
+          UPLOAD_COLUMNS.each_pair do |column_name, column_type|
+            unless column_exists? table_name, "#{attachment_name}_#{column_name}"
+              add_column(table_name, "#{attachment_name}_#{column_name}", column_type)
+            end
+          end
+        end
+      end
+      
+      
+      def remove_upload(table_name, *attachment_names)
+        raise ArgumentError, "Please specify attachment name in your remove_upload call in your migration." if attachment_names.empty?
+
+        attachment_names.each do |attachment_name|
+          COLUMNS.each_pair do |column_name, column_type|
+            if column_exists? table_name, "#{attachment_name}_#{column_name}"
+              remove_column(table_name, "#{attachment_name}_#{column_name}")
+            end
+          end
+        end
+      end
+    end
+    
+    module TableDefinition
+      def cropped_attachment(*attachment_names)
+        attachment_names.each do |attachment_name|
+          UPLOAD_COLUMNS.each_pair do |column_name, column_type|
+            column("#{attachment_name}_#{column_name}", column_type)
+          end
+        end
+      end
+    end
+
+  end
+end
+