locomotive_carrierwave 0.5.0.1.beta1

data/lib/carrierwave/uploader/versions.rb

@@ -0,0 +1,157 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module Versions
+      extend ActiveSupport::Concern
+
+      include CarrierWave::Uploader::Callbacks
+
+      included do
+        after :cache, :cache_versions!
+        after :store, :store_versions!
+        after :remove, :remove_versions!
+        after :retrieve_from_cache, :retrieve_versions_from_cache!
+        after :retrieve_from_store, :retrieve_versions_from_store!
+      end
+
+      module ClassMethods
+
+        def version_names
+          @version_names ||= []
+        end
+
+        ##
+        # Adds a new version to this uploader
+        #
+        # === Parameters
+        #
+        # [name (#to_sym)] name of the version
+        # [&block (Proc)] a block to eval on this version of the uploader
+        #
+        def version(name, &block)
+          name = name.to_sym
+          unless versions[name]
+            versions[name] = Class.new(self)
+            versions[name].version_names.push(*version_names)
+            versions[name].version_names.push(name)
+            class_eval <<-RUBY
+              def #{name}
+                versions[:#{name}]
+              end
+            RUBY
+          end
+          versions[name].class_eval(&block) if block
+          versions[name]
+        end
+
+        ##
+        # === Returns
+        #
+        # [Hash{Symbol => Class}] a list of versions available for this uploader
+        #
+        def versions
+          @versions ||= {}
+        end
+
+      end # ClassMethods
+
+      ##
+      # Returns a hash mapping the name of each version of the uploader to an instance of it
+      #
+      # === Returns
+      #
+      # [Hash{Symbol => CarrierWave::Uploader}] a list of uploader instances
+      #
+      def versions
+        return @versions if @versions
+        @versions = {}
+        self.class.versions.each do |name, klass|
+          @versions[name] = klass.new(model, mounted_as)
+        end
+        @versions
+      end
+
+      ##
+      # === Returns
+      #
+      # [String] the name of this version of the uploader
+      #
+      def version_name
+        self.class.version_names.join('_').to_sym unless self.class.version_names.blank?
+      end
+
+      ##
+      # When given a version name as a parameter, will return the url for that version
+      # This also works with nested versions.
+      #
+      # === Example
+      #
+      #     my_uploader.url                 # => /path/to/my/uploader.gif
+      #     my_uploader.url(:thumb)         # => /path/to/my/thumb_uploader.gif
+      #     my_uploader.url(:thumb, :small) # => /path/to/my/thumb_small_uploader.gif
+      #
+      # === Parameters
+      #
+      # [*args (Symbol)] any number of versions
+      #
+      # === Returns
+      #
+      # [String] the location where this file is accessible via a url
+      #
+      def url(*args)
+        if(args.first)
+          raise ArgumentError, "Version #{args.first} doesn't exist!" if versions[args.first.to_sym].nil?
+          # recursively proxy to version
+          versions[args.first.to_sym].url(*args[1..-1])
+        else
+          super()
+        end
+      end
+
+      ##
+      # Recreate versions and reprocess them. This can be used to recreate
+      # versions if their parameters somehow have changed.
+      #
+      def recreate_versions!
+        with_callbacks(:recreate_versions, file) do
+          versions.each { |name, v| v.store!(file) }
+        end
+      end
+
+    private
+
+      def full_filename(for_file)
+        [version_name, super(for_file)].compact.join('_')
+      end
+
+      def full_original_filename
+        [version_name, super].compact.join('_')
+      end
+
+      def cache_versions!(new_file)
+        versions.each do |name, v|
+          v.send(:cache_id=, cache_id)
+          v.cache!(new_file)
+        end
+      end
+
+      def store_versions!(new_file)
+        versions.each { |name, v| v.store!(new_file) }
+      end
+
+      def remove_versions!
+        versions.each { |name, v| v.remove! }
+      end
+
+      def retrieve_versions_from_cache!(cache_name)
+        versions.each { |name, v| v.retrieve_from_cache!(cache_name) }
+      end
+
+      def retrieve_versions_from_store!(identifier)
+        versions.each { |name, v| v.retrieve_from_store!(identifier) }
+      end
+
+    end # Versions
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module CarrierWave
+
+  ##
+  # See CarrierWave::Uploader::Base
+  #
+  module Uploader
+
+    ##
+    # An uploader is a class that allows you to easily handle the caching and storage of
+    # uploaded files. Please refer to the README for configuration options.
+    #
+    # Once you have an uploader you can use it in isolation:
+    #
+    #     my_uploader = MyUploader.new
+    #     my_uploader.cache!(File.open(path_to_file))
+    #     my_uploader.retrieve_from_store!('monkey.png')
+    #
+    # Alternatively, you can mount it on an ORM or other persistence layer, with
+    # +CarrierWave::Mount#mount_uploader+. There are extensions for activerecord and datamapper
+    # these are *very* simple (they are only a dozen lines of code), so adding your own should
+    # be trivial.
+    #
+    class Base
+      attr_reader :file
+
+      include CarrierWave::Uploader::Callbacks
+      include CarrierWave::Uploader::Proxy
+      include CarrierWave::Uploader::Url
+      include CarrierWave::Uploader::Mountable
+      include CarrierWave::Uploader::Cache
+      include CarrierWave::Uploader::Store
+      include CarrierWave::Uploader::Download
+      include CarrierWave::Uploader::Remove
+      include CarrierWave::Uploader::ExtensionWhitelist
+      include CarrierWave::Uploader::Processing
+      include CarrierWave::Uploader::Versions
+      include CarrierWave::Uploader::DefaultUrl
+      include CarrierWave::Uploader::Configuration
+      include CarrierWave::Uploader::Rename
+    end # Base
+
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/validations/active_model.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+require 'active_model/validator'
+require 'active_support/concern'
+
+
+module CarrierWave
+
+  # == Active Model Presence Validator
+  module Validations
+    module ActiveModel
+      extend ActiveSupport::Concern
+
+      class ProcessingValidator < ::ActiveModel::EachValidator
+
+        def validate_each(record, attribute, value)
+          if record.send("#{attribute}_processing_error")
+            record.errors.add(attribute, :carrierwave_processing_error)
+          end
+        end
+      end
+
+      class IntegrityValidator < ::ActiveModel::EachValidator
+
+        def validate_each(record, attribute, value)
+          if record.send("#{attribute}_integrity_error")
+            record.errors.add(attribute, :carrierwave_integrity_error)
+          end
+        end
+      end
+
+      module HelperMethods
+
+        ##
+        # Makes the record invalid if the file couldn't be uploaded due to an integrity error
+        #
+        # Accepts the usual parameters for validations in Rails (:if, :unless, etc...)
+        #
+        # === Note
+        #
+        # Set this key in your translations file for I18n:
+        #
+        #     carrierwave:
+        #       errors:
+        #         integrity: 'Here be an error message'
+        #
+        def validates_integrity_of(*attr_names)
+          validates_with IntegrityValidator, _merge_attributes(attr_names)
+        end
+
+        ##
+        # Makes the record invalid if the file couldn't be processed (assuming the process failed
+        # with a CarrierWave::ProcessingError)
+        #
+        # Accepts the usual parameters for validations in Rails (:if, :unless, etc...)
+        #
+        # === Note
+        #
+        # Set this key in your translations file for I18n:
+        #
+        #     carrierwave:
+        #       errors:
+        #         processing: 'Here be an error message'
+        #
+        def validates_processing_of(*attr_names)
+          validates_with ProcessingValidator, _merge_attributes(attr_names)
+        end
+      end
+
+      included do
+        extend HelperMethods
+        include HelperMethods
+      end
+    end
+  end
+end
+
+I18n.load_path << File.join(File.dirname(__FILE__), "..", "locale", 'en.yml')
+

data/lib/carrierwave/version.rb

@@ -0,0 +1,3 @@
+module CarrierWave
+  VERSION = "0.5.0.1.beta1"
+end

data/lib/carrierwave.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+
+require 'fileutils'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/class/inheritable_attributes'
+require 'active_support/concern'
+
+module CarrierWave
+
+  class << self
+    attr_accessor :root
+
+    def configure(&block)
+      CarrierWave::Uploader::Base.configure(&block)
+    end
+
+    def clean_cached_files!
+      CarrierWave::Uploader::Base.clean_cached_files!
+    end
+  end
+
+  class UploadError < StandardError; end
+  class IntegrityError < UploadError; end
+  class InvalidParameter < UploadError; end
+  class ProcessingError < UploadError; end
+  class DownloadError < UploadError; end
+
+  autoload :SanitizedFile, 'carrierwave/sanitized_file'
+  autoload :Mount, 'carrierwave/mount'
+  autoload :RMagick, 'carrierwave/processing/rmagick'
+  autoload :ImageScience, 'carrierwave/processing/image_science'
+  autoload :MiniMagick, 'carrierwave/processing/mini_magick'
+  autoload :VERSION, 'carrierwave/version'
+
+  module Storage
+    autoload :Abstract, 'carrierwave/storage/abstract'
+    autoload :File, 'carrierwave/storage/file'
+    autoload :S3, 'carrierwave/storage/s3'
+    autoload :GridFS, 'carrierwave/storage/grid_fs'
+    autoload :RightS3, 'carrierwave/storage/right_s3'
+    autoload :CloudFiles, 'carrierwave/storage/cloud_files'
+  end
+
+  module Uploader
+    autoload :Base, 'carrierwave/uploader'
+    autoload :Cache, 'carrierwave/uploader/cache'
+    autoload :Store, 'carrierwave/uploader/store'
+    autoload :Download, 'carrierwave/uploader/download'
+    autoload :Callbacks, 'carrierwave/uploader/callbacks'
+    autoload :Processing, 'carrierwave/uploader/processing'
+    autoload :Versions, 'carrierwave/uploader/versions'
+    autoload :Remove, 'carrierwave/uploader/remove'
+    autoload :ExtensionWhitelist, 'carrierwave/uploader/extension_whitelist'
+    autoload :DefaultUrl, 'carrierwave/uploader/default_url'
+    autoload :Proxy, 'carrierwave/uploader/proxy'
+    autoload :Url, 'carrierwave/uploader/url'
+    autoload :Mountable, 'carrierwave/uploader/mountable'
+    autoload :Configuration, 'carrierwave/uploader/configuration'
+    autoload :Rename, 'carrierwave/uploader/rename'
+  end
+
+  module Compatibility
+    autoload :Paperclip, 'carrierwave/compatibility/paperclip'
+  end
+
+  module Test
+    autoload :Matchers, 'carrierwave/test/matchers'
+  end
+
+end
+
+if defined?(Merb)
+
+  CarrierWave.root = Merb.dir_for(:public)
+  Merb::BootLoader.before_app_loads do
+    # Setup path for uploaders and load all of them before classes are loaded
+    Merb.push_path(:uploaders, Merb.root / 'app' / 'uploaders', '*.rb')
+    Dir.glob(File.join(Merb.load_paths[:uploaders])).each {|f| require f }
+  end
+
+elsif defined?(Rails)
+
+  module CarrierWave
+    class Railtie < Rails::Railtie
+      initializer "carrierwave.setup_paths" do
+        CarrierWave.root = Rails.root.join(Rails.public_path).to_s
+      end
+    end
+  end
+
+elsif defined?(Sinatra)
+
+  CarrierWave.root = Sinatra::Application.public
+
+end
+
+
+require 'carrierwave/orm/activerecord' if defined?(ActiveRecord)
+require 'carrierwave/orm/datamapper' if defined?(DataMapper)
+require 'carrierwave/orm/sequel' if defined?(Sequel)
+require 'carrierwave/orm/mongoid' if defined?(Mongoid)

data/lib/generators/templates/uploader.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+class <%= class_name %>Uploader < CarrierWave::Uploader::Base
+
+  # Include RMagick or ImageScience support:
+  # include CarrierWave::RMagick
+  # include CarrierWave::ImageScience
+
+  # Choose what kind of storage to use for this uploader:
+  storage :file
+  # storage :s3
+
+  # Override the directory where uploaded files will be stored.
+  # This is a sensible default for uploaders that are meant to be mounted:
+  def store_dir
+    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+  end
+
+  # Provide a default URL as a default if there hasn't been a file uploaded:
+  # def default_url
+  #   "/images/fallback/" + [version_name, "default.png"].compact.join('_')
+  # end
+
+  # Process files as they are uploaded:
+  # process :scale => [200, 300]
+  #
+  # def scale(width, height)
+  #   # do something
+  # end
+
+  # Create different versions of your uploaded files:
+  # version :thumb do
+  #   process :scale => [50, 50]
+  # end
+
+  # Add a white list of extensions which are allowed to be uploaded.
+  # For images you might use something like this:
+  # def extension_white_list
+  #   %w(jpg jpeg gif png)
+  # end
+
+  # Override the filename of the uploaded files:
+  # def filename
+  #   "something.jpg" if original_filename
+  # end
+
+end

data/lib/generators/uploader_generator.rb

@@ -0,0 +1,7 @@
+class UploaderGenerator < Rails::Generators::NamedBase
+  source_root File.expand_path("../templates", __FILE__)
+
+  def create_uploader_file
+    template "uploader.rb", "app/uploaders/#{file_name}_uploader.rb"
+  end
+end