plowdawg-carrierwave 0.5.8

data/lib/carrierwave/uploader/url.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module CarrierWave
+  module Uploader
+    module Url
+
+      ##
+      # === Returns
+      #
+      # [String] the location where this file is accessible via a url
+      #
+      def url
+        if file.respond_to?(:url) and not file.url.blank?
+          file.url
+        elsif current_path
+          File.expand_path(current_path).gsub(File.expand_path(root), '')
+        end
+      end
+
+      alias_method :to_s, :url
+
+      ##
+      # === Returns
+      #
+      # [Hash] the locations where this file and versions are accessible via a url
+      #
+      def as_json(options = nil)
+        h = { :url => url }
+        h.merge Hash[versions.map { |name, version| [name, { :url => version.url }] }]
+      end
+
+      ##
+      # FIXME to_xml should work like to_json, but this is the best we've been able to do so far.
+      # This hack fixes issue #337.
+      #
+      # === Returns
+      #
+      # [nil]
+      #
+      def to_xml(options = nil)
+      end
+
+    end # Url
+  end # Uploader
+end # CarrierWave

data/lib/carrierwave/uploader/versions.rb

@@ -0,0 +1,237 @@
+# encoding: utf-8
+
+require 'active_support/deprecation'
+
+module CarrierWave
+  module Uploader
+    module Versions
+      extend ActiveSupport::Concern
+
+      include CarrierWave::Uploader::Callbacks
+
+      included do
+        ##
+        # Add configuration options for versions
+        # class_inheritable_accessor was deprecated in Rails 3.1 and removed for 3.2.
+        # class_attribute was added in 3.0, but doesn't support omitting the instance_reader until 3.0.10
+        # For max compatibility, always use class_inheritable_accessor when possible
+        if respond_to?(:class_inheritable_accessor)
+          ActiveSupport::Deprecation.silence do
+            class_inheritable_accessor :versions, :version_names, :instance_reader => false, :instance_writer => false
+          end
+        else
+          class_attribute :versions, :version_names, :instance_reader => false, :instance_writer => false
+        end
+
+        self.versions = {}
+        self.version_names = []
+
+        attr_accessor :parent_cache_id
+
+        after :cache, :assign_parent_cache_id
+        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
+
+        ##
+        # Adds a new version to this uploader
+        #
+        # === Parameters
+        #
+        # [name (#to_sym)] name of the version
+        # [options (Hash)] optional options hash
+        # [&block (Proc)] a block to eval on this version of the uploader
+        #
+        # === Examples
+        #
+        #     class MyUploader < CarrierWave::Uploader::Base
+        #
+        #       version :thumb do
+        #         process :scale => [200, 200]
+        #       end
+        #
+        #       version :preview, :if => :image? do
+        #         process :scale => [200, 200]
+        #       end
+        #
+        #     end
+        #
+        def version(name, options = {}, &block)
+          name = name.to_sym
+          unless versions[name]
+            uploader = Class.new(self)
+            uploader.versions = {}
+
+            # Define the enable_processing method for versions so they get the
+            # value from the parent class unless explicitly overwritten
+            uploader.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def self.enable_processing(value=nil)
+                self.enable_processing = value if value
+                if !@enable_processing.nil?
+                  @enable_processing
+                else
+                  superclass.enable_processing
+                end
+              end
+            RUBY
+
+            # Add the current version hash to class attribute :versions
+            current_version = {}
+            current_version[name] = {
+              :uploader => uploader,
+              :options  => options
+            }
+            self.versions = versions.merge(current_version)
+
+            versions[name][:uploader].version_names += [name]
+
+            class_eval <<-RUBY
+              def #{name}
+                versions[:#{name}]
+              end
+            RUBY
+            # as the processors get the output from the previous processors as their
+            # input we must not stack the processors here
+            versions[name][:uploader].processors = versions[name][:uploader].processors.dup
+            versions[name][:uploader].processors.clear
+          end
+          versions[name][:uploader].class_eval(&block) if block
+          versions[name]
+        end
+
+        def recursively_apply_block_to_versions(&block)
+          versions.each do |name, version|
+            version[:uploader].class_eval(&block)
+            version[:uploader].recursively_apply_block_to_versions(&block)
+          end
+        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, version|
+          @versions[name] = version[:uploader].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!
+        # Some files could possibly not be stored on the local disk. This
+        # doesn't play nicely with processing. Make sure that we're only
+        # processing a cached file
+        #
+        # The call to store! will trigger the necessary callbacks to both
+        # process this version and all sub-versions
+        cache_stored_file! if !cached?
+
+        store!
+      end
+
+    private
+      def assign_parent_cache_id(file)
+        active_versions.each do |name, uploader|
+          uploader.parent_cache_id = @cache_id
+        end
+      end
+
+      def active_versions
+        versions.select do |name, uploader|
+          condition = self.class.versions[name][:options][:if]
+          not condition or send(condition, file)
+        end
+      end
+
+      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)
+        # We might have processed the new_file argument after the callbacks were
+        # initialized, so get the actual file based off of the current state of
+        # our file
+        processed_parent = SanitizedFile.new :tempfile => self.file,
+          :filename => new_file.original_filename
+
+        active_versions.each do |name, v|
+          v.send(:cache_id=, cache_id)
+          v.cache!(processed_parent)
+        end
+      end
+
+      def store_versions!(new_file)
+        active_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/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.8"
+end

data/lib/generators/templates/uploader.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+class <%= class_name %>Uploader < CarrierWave::Uploader::Base
+
+  # Include RMagick or ImageScience support:
+  # include CarrierWave::RMagick
+  # include CarrierWave::MiniMagick
+  # include CarrierWave::ImageScience
+
+  # Choose what kind of storage to use for this uploader:
+  storage :file
+  # storage :fog
+
+  # 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:
+  # Avoid using model.id or version_name here, see uploader/store.rb for details.
+  # 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

metadata

@@ -0,0 +1,215 @@
+--- !ruby/object:Gem::Specification
+name: plowdawg-carrierwave
+version: !ruby/object:Gem::Version
+  version: 0.5.8
+  prerelease: 
+platform: ruby
+authors:
+- Jonas Nicklas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-15 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &19315860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *19315860
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &19315440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: *19315440
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &19315140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *19315140
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: &19314792 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *19314792
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &19314468 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *19314468
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &19298616 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: *19298616
+- !ruby/object:Gem::Dependency
+  name: sham_rack
+  requirement: &19298352 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *19298352
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: &19298076 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *19298076
+- !ruby/object:Gem::Dependency
+  name: cloudfiles
+  requirement: &19297824 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *19297824
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: &19297512 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *19297512
+- !ruby/object:Gem::Dependency
+  name: mini_magick
+  requirement: &19297164 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *19297164
+- !ruby/object:Gem::Dependency
+  name: rmagick
+  requirement: &19296900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *19296900
+description: Upload files in your Ruby applications, map them to a range of ORMs,
+  store them on different backends.
+email:
+- jonas.nicklas@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- lib/carrierwave/compatibility/paperclip.rb
+- lib/carrierwave/locale/en.yml
+- lib/carrierwave/mount.rb
+- lib/carrierwave/orm/activerecord.rb
+- lib/carrierwave/processing/mime_types.rb
+- lib/carrierwave/processing/mini_magick.rb
+- lib/carrierwave/processing/rmagick.rb
+- lib/carrierwave/sanitized_file.rb
+- lib/carrierwave/storage/abstract.rb
+- lib/carrierwave/storage/cloud_files.rb
+- lib/carrierwave/storage/file.rb
+- lib/carrierwave/storage/fog.rb
+- lib/carrierwave/storage/right_s3.rb
+- lib/carrierwave/storage/s3.rb
+- lib/carrierwave/test/matchers.rb
+- lib/carrierwave/uploader/cache.rb
+- lib/carrierwave/uploader/callbacks.rb
+- lib/carrierwave/uploader/configuration.rb
+- lib/carrierwave/uploader/default_url.rb
+- lib/carrierwave/uploader/download.rb
+- lib/carrierwave/uploader/extension_whitelist.rb
+- lib/carrierwave/uploader/mountable.rb
+- lib/carrierwave/uploader/processing.rb
+- lib/carrierwave/uploader/proxy.rb
+- lib/carrierwave/uploader/remove.rb
+- lib/carrierwave/uploader/store.rb
+- lib/carrierwave/uploader/url.rb
+- lib/carrierwave/uploader/versions.rb
+- lib/carrierwave/uploader.rb
+- lib/carrierwave/validations/active_model.rb
+- lib/carrierwave/version.rb
+- lib/carrierwave.rb
+- lib/generators/templates/uploader.rb
+- lib/generators/uploader_generator.rb
+- README.md
+homepage: https://github.com/jnicklas/carrierwave
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: carrierwave
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Ruby file upload library
+test_files: []