mini-smart-pkg 0.0.1

data/carrierwave-3.1.3/lib/carrierwave/uploader/versions.rb

@@ -0,0 +1,352 @@
+require "active_support/core_ext/object/deep_dup"
+
+module CarrierWave
+  module Uploader
+    module Versions
+      class Builder
+        def initialize(name)
+          @name = name
+          @options = {}
+          @blocks = []
+          @klass = nil
+        end
+
+        def configure(options, &block)
+          @options.merge!(options)
+          @blocks << block if block
+          @klass = nil
+        end
+
+        def build(superclass)
+          return @klass if @klass
+          @klass = Class.new(superclass)
+          superclass.const_set("VersionUploader#{@name.to_s.camelize}", @klass)
+
+          @klass.version_names += [@name]
+          @klass.versions = {}
+          @klass.processors = []
+          @klass.version_options = @options
+          @klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            # Define the enable_processing method for versions so they get the
+            # value from the parent class unless explicitly overwritten
+            def self.enable_processing(value=nil)
+              self.enable_processing = value if value
+              if defined?(@enable_processing) && !@enable_processing.nil?
+                @enable_processing
+              else
+                superclass.enable_processing
+              end
+            end
+
+            # Regardless of what is set in the parent uploader, do not enforce the
+            # move_to_cache config option on versions because it moves the original
+            # file to the version's target file.
+            #
+            # If you want to enforce this setting on versions, override this method
+            # in each version:
+            #
+            # version :thumb do
+            #   def move_to_cache
+            #     true
+            #   end
+            # end
+            #
+            def move_to_cache
+              false
+            end
+
+            # Need to rely on the parent version's identifier, as versions don't have its own one.
+            def identifier
+              parent_version.identifier
+            end
+          RUBY
+          @blocks.each { |block| @klass.class_eval(&block) }
+          @klass
+        end
+
+        def deep_dup
+          other = dup
+          other.instance_variable_set(:@blocks, @blocks.dup)
+          other
+        end
+
+        def method_missing(name, *args)
+          super
+        rescue NoMethodError => e
+          raise e.exception <<~ERROR
+            #{e.message}
+            If you're trying to configure a version, do it inside a block like `version(:thumb) { self.#{name} #{args.map(&:inspect).join(', ')} }`.
+          ERROR
+        end
+
+        def respond_to_missing?(*)
+          super
+        end
+      end
+
+      extend ActiveSupport::Concern
+
+      include CarrierWave::Uploader::Callbacks
+
+      included do
+        class_attribute :versions, :version_names, :version_options, :instance_reader => false, :instance_writer => false
+
+        self.versions = {}
+        self.version_names = []
+
+        attr_accessor :parent_version
+
+        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!
+
+        prepend Module.new {
+          def initialize(*)
+            super
+            @versions = nil
+          end
+        }
+      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
+        #
+        #       version :square, :unless => :invalid_image_type? do
+        #         process :scale => [100, 100]
+        #       end
+        #
+        #     end
+        #
+        def version(name, options = {}, &block)
+          name = name.to_sym
+          versions[name] ||= Builder.new(name)
+          versions[name].configure(options, &block)
+
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}
+              versions[:#{name}]
+            end
+          RUBY
+
+          versions[name]
+        end
+
+      private
+
+        def inherited(subclass)
+          # To prevent subclass version changes affecting superclass versions
+          subclass.versions = versions.deep_dup
+          super
+        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.build(self.class).new(model, mounted_as)
+          @versions[name].parent_version = self
+        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
+
+      ##
+      #
+      # === Parameters
+      #
+      # [name (#to_sym)] name of the version
+      #
+      # === Returns
+      #
+      # [Boolean] True when the version satisfy its :if or :unless condition
+      #
+      def version_active?(name)
+        name = name.to_sym
+
+        return false unless versions.has_key?(name)
+
+        if_condition = versions[name].class.version_options[:if]
+        unless_condition = versions[name].class.version_options[:unless]
+
+        if if_condition
+          if if_condition.respond_to?(:call)
+            if_condition.call(self, :version => name, :file => file)
+          else
+            send(if_condition, file)
+          end
+        elsif unless_condition
+          if unless_condition.respond_to?(:call)
+            !unless_condition.call(self, :version => name, :file => file)
+          else
+            !send(unless_condition, file)
+          end
+        else
+          true
+        end
+      end
+      alias_method :version_exists?, :version_active?
+      CarrierWave.deprecator.deprecate_methods(self, version_exists?: :version_active?)
+
+      ##
+      # Copies the parent's cache_id when caching a version file.
+      # This behavior is not essential but it makes easier to understand
+      # that the cached files are generated by the single upload attempt.
+      #
+      def cache!(*args)
+        self.cache_id = parent_version.cache_id if parent_version
+
+        super
+      end
+
+      ##
+      # When given a version name as a parameter, will return the url for that version
+      # This also works with nested versions.
+      # When given a query hash as a parameter, will return the url with signature that contains query params
+      # Query hash only works with AWS (S3 storage).
+      #
+      # === 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
+      #     my_uploader.url(:query => {"response-content-disposition" => "attachment"})
+      #     my_uploader.url(:version, :sub_version, :query => {"response-content-disposition" => "attachment"})
+      #
+      # === Parameters
+      #
+      # [*args (Symbol)] any number of versions
+      # OR/AND
+      # [Hash] query params
+      #
+      # === Returns
+      #
+      # [String] the location where this file is accessible via a url
+      #
+      def url(*args)
+        if (version = args.first) && version.respond_to?(:to_sym)
+          raise ArgumentError, "Version #{version} doesn't exist!" if versions[version.to_sym].nil?
+          # recursively proxy to version
+          versions[version.to_sym].url(*args[1..-1])
+        elsif args.first
+          super(args.first)
+        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!(*names)
+        # As well as specified versions, we need to reprocess versions
+        # that are the source of another version.
+
+        self.cache_id = CarrierWave.generate_cache_id
+        derived_versions.each_value do |v|
+          v.cache!(file) if names.empty? || !(v.descendant_version_names & names).empty?
+        end
+        active_versions.each do |name, v|
+          v.store! if names.empty? || names.include?(name)
+        end
+      ensure
+        @cache_id = nil
+      end
+
+    protected
+
+      def descendant_version_names
+        [version_name] + derived_versions.flat_map do |name, version|
+          version.descendant_version_names
+        end
+      end
+
+      def active_versions
+        versions.select do |name, uploader|
+          version_active?(name)
+        end
+      end
+
+    private
+
+      def derived_versions
+        active_versions.reject do |name, v|
+          v.class.version_options[:from_version]
+        end.merge(active_sibling_versions.select do |name, v|
+          v.class.version_options[:from_version] == self.class.version_names.last
+        end)
+      end
+
+      def active_sibling_versions
+        parent_version&.active_versions || {}
+      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)
+        derived_versions.each_value { |v| v.cache!(new_file) }
+      end
+
+      def store_versions!(new_file)
+        active_versions.each_value { |v| v.store!(new_file) }
+      end
+
+      def remove_versions!
+        versions.each_value { |v| v.remove! }
+      end
+
+      def retrieve_versions_from_cache!(cache_name)
+        active_versions.each_value { |v| v.retrieve_from_cache!(cache_name) }
+      end
+
+      def retrieve_versions_from_store!(identifier)
+        active_versions.each_value { |v| v.retrieve_from_store!(identifier) }
+      end
+
+    end # Versions
+  end # Uploader
+end # CarrierWave

data/carrierwave-3.1.3/lib/carrierwave/uploader.rb

@@ -0,0 +1,69 @@
+require "carrierwave/uploader/configuration"
+require "carrierwave/uploader/callbacks"
+require "carrierwave/uploader/proxy"
+require "carrierwave/uploader/url"
+require "carrierwave/uploader/mountable"
+require "carrierwave/uploader/cache"
+require "carrierwave/uploader/store"
+require "carrierwave/uploader/download"
+require "carrierwave/uploader/remove"
+require "carrierwave/uploader/extension_allowlist"
+require "carrierwave/uploader/extension_denylist"
+require "carrierwave/uploader/content_type_allowlist"
+require "carrierwave/uploader/content_type_denylist"
+require "carrierwave/uploader/file_size"
+require "carrierwave/uploader/dimension"
+require "carrierwave/uploader/processing"
+require "carrierwave/uploader/versions"
+require "carrierwave/uploader/default_url"
+
+require "carrierwave/uploader/serialization"
+
+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::Configuration
+      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::ExtensionAllowlist
+      include CarrierWave::Uploader::ExtensionDenylist
+      include CarrierWave::Uploader::ContentTypeAllowlist
+      include CarrierWave::Uploader::ContentTypeDenylist
+      include CarrierWave::Uploader::FileSize
+      include CarrierWave::Uploader::Dimension
+      include CarrierWave::Uploader::Processing
+      include CarrierWave::Uploader::Versions
+      include CarrierWave::Uploader::DefaultUrl
+      include CarrierWave::Uploader::Serialization
+    end # Base
+
+  end # Uploader
+end # CarrierWave

data/carrierwave-3.1.3/lib/carrierwave/utilities/file_name.rb

@@ -0,0 +1,47 @@
+module CarrierWave
+  module Utilities
+    module FileName
+
+      ##
+      # Returns the part of the filename before the extension. So if a file is called 'test.jpeg'
+      # this would return 'test'
+      #
+      # === Returns
+      #
+      # [String] the first part of the filename
+      #
+      def basename
+        split_extension(filename)[0] if filename
+      end
+
+      ##
+      # Returns the file extension
+      #
+      # === Returns
+      #
+      # [String] extension of file or "" if the file has no extension
+      #
+      def extension
+        split_extension(filename)[1] if filename
+      end
+
+    private
+
+      def split_extension(filename)
+        # regular expressions to try for identifying extensions
+        extension_matchers = [
+          /\A(.+)\.(tar\.([glx]?z|bz2))\z/, # matches "something.tar.gz"
+          /\A(.+)\.([^\.]+)\z/ # matches "something.jpg"
+        ]
+
+        extension_matchers.each do |regexp|
+          if filename =~ regexp
+            return $1, $2
+          end
+        end
+
+        [filename, ""] # In case we weren't able to split the extension
+      end
+    end # FileName
+  end # Utilities
+end # CarrierWave

data/carrierwave-3.1.3/lib/carrierwave/utilities/uri.rb

@@ -0,0 +1,26 @@
+require 'uri'
+
+module CarrierWave
+  module Utilities
+    module Uri
+      # based on Ruby < 2.0's URI.encode
+      PATH_SAFE = URI::RFC2396_REGEXP::PATTERN::UNRESERVED + '\/'
+      PATH_UNSAFE = Regexp.new("[^#{PATH_SAFE}]", false)
+      NON_ASCII = /[^[:ascii:]]/.freeze
+
+    private
+
+      def encode_path(path)
+        URI::DEFAULT_PARSER.escape(path, PATH_UNSAFE)
+      end
+
+      def encode_non_ascii(str)
+        URI::DEFAULT_PARSER.escape(str, NON_ASCII)
+      end
+
+      def decode_uri(str)
+        URI::DEFAULT_PARSER.unescape(str)
+      end
+    end # Uri
+  end # Utilities
+end # CarrierWave

data/carrierwave-3.1.3/lib/carrierwave/utilities.rb

@@ -0,0 +1,7 @@
+require 'carrierwave/utilities/uri'
+require 'carrierwave/utilities/file_name'
+
+module CarrierWave
+  module Utilities
+  end
+end

data/carrierwave-3.1.3/lib/carrierwave/validations/active_model.rb

@@ -0,0 +1,76 @@
+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)
+          record.__send__("#{attribute}_processing_errors").each do |e|
+            record.errors.add(attribute, :carrierwave_processing_error, message: (e.message != e.class.to_s) && e.message)
+          end
+        end
+      end
+
+      class IntegrityValidator < ::ActiveModel::EachValidator
+
+        def validate_each(record, attribute, value)
+          record.__send__("#{attribute}_integrity_errors").each do |e|
+            record.errors.add(attribute, :carrierwave_integrity_error, message: (e.message != e.class.to_s) && e.message)
+          end
+        end
+      end
+
+      class DownloadValidator < ::ActiveModel::EachValidator
+
+        def validate_each(record, attribute, value)
+          record.__send__("#{attribute}_download_errors").each do |e|
+            record.errors.add(attribute, :carrierwave_download_error, message: (e.message != e.class.to_s) && e.message)
+          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...)
+        #
+        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...)
+        #
+        def validates_processing_of(*attr_names)
+          validates_with ProcessingValidator, _merge_attributes(attr_names)
+        end
+
+        #
+        ##
+        # Makes the record invalid if the remote file couldn't be downloaded
+        #
+        # Accepts the usual parameters for validations in Rails (:if, :unless, etc...)
+        #
+        def validates_download_of(*attr_names)
+          validates_with DownloadValidator, _merge_attributes(attr_names)
+        end
+      end
+
+      included do
+        extend HelperMethods
+        include HelperMethods
+      end
+    end
+  end
+end

data/carrierwave-3.1.3/lib/carrierwave/version.rb

@@ -0,0 +1,3 @@
+module CarrierWave
+  VERSION = "3.1.3".freeze
+end

data/carrierwave-3.1.3/lib/carrierwave.rb

@@ -0,0 +1,108 @@
+require 'fileutils'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/concern'
+require 'active_support/deprecation'
+
+module CarrierWave
+
+  class << self
+    attr_accessor :root, :base_path
+    attr_writer :tmp_path
+
+    def configure(&block)
+      CarrierWave::Uploader::Base.configure(&block)
+    end
+
+    def clean_cached_files!(seconds=60*60*24)
+      CarrierWave::Uploader::Base.clean_cached_files!(seconds)
+    end
+
+    def tmp_path
+      @tmp_path ||= File.expand_path(File.join('..', 'tmp'), root)
+    end
+
+    def deprecator
+      @deprecator ||= ActiveSupport::Deprecation.new("#{CarrierWave::VERSION.split('.')[0].to_i + 1}.0", "CarrierWave")
+    end
+  end
+
+end
+
+if defined?(Jets)
+
+  module CarrierWave
+    class Turbine < Jets::Turbine
+      initializer "carrierwave.setup_paths" do |app|
+        CarrierWave.root = Jets.root.to_s
+        CarrierWave.tmp_path = "/tmp/carrierwave"
+        CarrierWave.configure do |config|
+          config.cache_dir = "/tmp/carrierwave/uploads/tmp"
+        end
+      end
+
+      initializer "carrierwave.active_record" do
+        ActiveSupport.on_load :active_record do
+          require 'carrierwave/orm/activerecord'
+        end
+      end
+    end
+  end
+
+elsif defined?(Rails)
+
+  module CarrierWave
+    class Railtie < Rails::Railtie
+      initializer "carrierwave.setup_paths" do |app|
+        CarrierWave.root = Rails.root.join(Rails.public_path).to_s
+        CarrierWave.base_path = ENV['RAILS_RELATIVE_URL_ROOT']
+        available_locales = Array(app.config.i18n.available_locales || [])
+        if available_locales.blank? || available_locales.include?(:en)
+          I18n.load_path.prepend(File.join(File.dirname(__FILE__), 'carrierwave', 'locale', "en.yml"))
+        end
+      end
+
+      initializer "carrierwave.active_record" do
+        ActiveSupport.on_load :active_record do
+          require 'carrierwave/orm/activerecord'
+        end
+      end
+
+      initializer "carrierwave.deprecator" do |app|
+        app.deprecators[:carrierwave] = CarrierWave.deprecator if app.respond_to?(:deprecators)
+      end
+
+      config.before_eager_load do
+        CarrierWave::Storage::Fog.eager_load
+      end
+    end
+  end
+
+elsif defined?(Sinatra)
+  if defined?(Padrino) && defined?(PADRINO_ROOT)
+    CarrierWave.root = File.join(PADRINO_ROOT, "public")
+  else
+
+    CarrierWave.root =
+      if Sinatra::Application.respond_to?(:public_folder)
+        # Sinatra >= 1.3
+        Sinatra::Application.public_folder
+      else
+        # Sinatra < 1.3
+        Sinatra::Application.public
+      end
+  end
+end
+
+require "carrierwave/utilities"
+require "carrierwave/error"
+require "carrierwave/sanitized_file"
+require "carrierwave/mounter"
+require "carrierwave/mount"
+require "carrierwave/processing"
+require "carrierwave/version"
+require "carrierwave/storage"
+require "carrierwave/uploader"
+require "carrierwave/compatibility/paperclip"
+require "carrierwave/test/matchers"