bulldog 0.0.1

data/lib/bulldog/processor/one_shot.rb

@@ -0,0 +1,19 @@
+module Bulldog
+  module Processor
+    class OneShot < Base
+      def initialize(*args)
+        super
+        @styles.clear
+      end
+
+      def process(*args, &block)
+        @style = nil
+        process_style(*args, &block)
+      end
+
+      def output_file(style_name)
+        nil
+      end
+    end
+  end
+end

data/lib/bulldog/reflection.rb

@@ -0,0 +1,234 @@
+module Bulldog
+  class Reflection
+    def initialize(model_class, name)
+      @model_class = model_class
+      @name = name
+
+      @path_template = nil
+      @url_template = nil
+      @styles = StyleSet.new
+      @default_style = :original
+      @stored_attributes = {}
+      @events = Hash.new{|h,k| h[k] = []}
+      @type = nil
+      @type_detector = nil
+    end
+
+    def initialize_copy(other)
+      super
+      instance_variables.each do |name|
+        value = instance_variable_get(name)
+        value = value.clone if value.duplicable?
+        instance_variable_set(name, value)
+      end
+    end
+
+    attr_accessor :model_class, :name, :path_template, :url_template, :styles, :events, :stored_attributes, :type, :type_detector
+    attr_writer :default_style, :path_template, :url_template
+
+    #
+    # Append the given block to this attachment's configuration.
+    #
+    # Using this, you may specialize an attachment's configuration in
+    # a piecemeal fashion; for subclassing, for example.
+    #
+    def configure(&block)
+      Configuration.configure(self, &block) if block
+    end
+
+    def default_style
+      styles[@default_style] or
+        raise Error, "invalid default_style: #{@default_style.inspect}"
+      @default_style
+    end
+
+    def path_template
+      @path_template || Bulldog.default_path_template || File.join(':public_path', url_template)
+    end
+
+    def url_template
+      @url_template || Bulldog.default_url_template
+    end
+
+    #
+    # Return the column name to use for the named storable attribute.
+    #
+    def column_name_for_stored_attribute(attribute)
+      if stored_attributes.fetch(attribute, :not_nil).nil?
+        nil
+      elsif (value = stored_attributes[attribute])
+        value
+      else
+        default_column = "#{name}_#{attribute}"
+        column_exists = model_class.columns_hash.key?(default_column)
+        column_exists ? default_column.to_sym : nil
+      end
+    end
+
+    def self.named_type_detectors
+      @named_type_detectors ||= {}
+    end
+
+    def self.to_detect_type_by(name, &block)
+      named_type_detectors[name] = block
+    end
+
+    def self.reset_type_detectors
+      named_type_detectors.clear
+    end
+
+    to_detect_type_by :default do |record, name, stream|
+      if stream
+        case stream.content_type
+        when %r'\Aimage/'
+          :image
+        when %r'\Avideo/'
+          :video
+        when %r'\Aapplication/pdf'
+          :pdf
+        end
+      end
+    end
+
+    #
+    # Return the attachment type to use for the given record and
+    # stream.
+    #
+    def detect_attachment_type(record, stream)
+      return type if type
+      detector = type_detector || :default
+      if detector.is_a?(Symbol)
+        detector = self.class.named_type_detectors[detector]
+      end
+      detector.call(record, name, stream)
+    end
+
+    class Configuration
+      def self.configure(reflection, &block)
+        new(reflection).instance_eval(&block)
+      end
+
+      def initialize(reflection)
+        @reflection = reflection
+      end
+
+      def path(path_template)
+        @reflection.path_template = path_template
+      end
+
+      def url(url_template)
+        @reflection.url_template = url_template
+      end
+
+      def style(name, attributes={})
+        @reflection.styles << Style.new(name, attributes)
+      end
+
+      def default_style(name)
+        @reflection.default_style = name
+      end
+
+      #
+      # Register the callback to fire for the given types of
+      # attachments.
+      #
+      # Options:
+      #
+      #   * :types - A list of attachment types to process on.  If
+      #     nil, process on any type.
+      #   * :on - The name of the event to run the processor on.
+      #   * :after - Same as prepending 'after_' to the given event.
+      #   * :before - Same as prepending 'before_' to the given event.
+      #   * :with - Use the given processor type.  If nil (the
+      #     default), use the default type for the attachment.
+      #
+      def process(options={}, &callback)
+        event_name = event_name(options)
+        types = Array(options[:types]) if options[:types]
+        @reflection.events[event_name] << Event.new(:processor_type => options[:with],
+                                                    :attachment_types => types,
+                                                    :styles => options[:styles],
+                                                    :callback => callback)
+      end
+
+      def process_once(*types, &callback)
+        options = types.extract_options!
+        options[:with] and
+          raise ArgumentError, "cannot specify a processor (:with option) with #process_once"
+        options[:styles] and
+          raise ArgumentError, "no :styles available for #process_once"
+        options[:with] = :one_shot
+        types << options
+        process(*types, &callback)
+      end
+
+      def store_attributes(*args)
+        stored_attributes = args.extract_options!.symbolize_keys
+        args.each do |attribute|
+          stored_attributes[attribute] = :"#{@reflection.name}_#{attribute}"
+        end
+        @reflection.stored_attributes = stored_attributes
+      end
+
+      #
+      # Always use the given attachment type for this attachment.
+      #
+      # This is equivalent to:
+      #
+      #     detect_type_by do
+      #       type if stream
+      #     end
+      #
+      def type(type)
+        @reflection.type = type
+        @reflection.type_detector = nil
+      end
+
+      #
+      # Specify a procedure to run to determine the type of the
+      # attachment.
+      #
+      # Pass either:
+      #
+      #   * A symbol argument, which names a named type detector.  Use
+      #    +Bulldog.to_detect_type_by+ to register custom named type
+      #    detectors.
+      #
+      #   * A block, which takes the record, attribute name, and
+      #     Stream being assigned, and returns the attachment type to
+      #     use as a Symbol.
+      #
+      #   * A callable object, e.g. a Proc or BoundMethod, which has
+      #     the same signature as the block above.
+      #
+      def detect_type_by(detector=nil, &block)
+        detector && block and
+          raise ArgumentError, "cannot pass argument and a block"
+        @reflection.type = nil
+        @reflection.type_detector = detector || block
+      end
+
+      private  # -----------------------------------------------------
+
+      def event_name(options)
+        name = options[:on] and
+          return name
+        name = options[:after] and
+          return :"after_#{name}"
+        name = options[:before] and
+          return :"before_#{name}"
+        nil
+      end
+    end
+
+    class Event
+      def initialize(attributes={})
+        attributes.each do |name, value|
+          send("#{name}=", value)
+        end
+      end
+
+      attr_accessor :processor_type, :attachment_types, :styles, :callback
+    end
+  end
+end

data/lib/bulldog/saved_file.rb

@@ -0,0 +1,19 @@
+module Bulldog
+  class SavedFile
+    def initialize(path, options={})
+      @path = path
+      @file_name = options[:file_name]
+    end
+
+    attr_reader :path
+
+    #
+    # The original file name as it was uploaded, if any.
+    #
+    attr_reader :file_name
+
+    def size
+      File.size(path)
+    end
+  end
+end

data/lib/bulldog/stream.rb

@@ -0,0 +1,186 @@
+module Bulldog
+  #
+  # Gives IO, StringIO, Tempfile, and SavedFile a common interface.
+  #
+  # In particular, this takes care of writing it to a file so external
+  # programs may be called on it, while keeping the number of file
+  # writes to a minimum.
+  #
+  module Stream
+    def self.new(object)
+      klass =
+        case object
+        when ::Tempfile
+          ForTempfile
+        when File
+          ForFile
+        when SavedFile
+          ForSavedFile
+        when MissingFile
+          ForMissingFile
+        when StringIO
+          ForStringIO
+        when IO
+          ForIO
+        end
+      klass.new(object)
+    end
+
+    class Base
+      def initialize(target)
+        @target = target
+      end
+
+      #
+      # The underlying object.
+      #
+      attr_reader :target
+
+      #
+      # Return the path of a file where the content can be found.
+      #
+      def path
+        @target.path
+      end
+
+      #
+      # Return true if this stream represents a missing file.
+      #
+      def missing?
+        false
+      end
+
+      #
+      # Return the original file name of the underlying object.  This
+      # is the basename of the file as the user uploaded it (for an
+      # uploaded file), or the file on the filesystem (for a File
+      # object).  For other IO objects, return nil.
+      #
+      def file_name
+        if @target.respond_to?(:original_path)
+          @target.original_path
+        else
+          nil
+        end
+      end
+
+      #
+      # Return the size of the content.
+      #
+      def size
+        File.size(path)
+      end
+
+      #
+      # Return the mime-type of the content.
+      #
+      def content_type
+        @content_type ||= `file --brief --mime #{path}`.strip
+      end
+
+      #
+      # Write the content to the given path.
+      #
+      def write_to(path)
+        src, dst = self.path, path
+        unless src == dst
+          FileUtils.mkdir_p File.dirname(path)
+          FileUtils.cp src, dst
+        end
+      end
+    end
+
+    class ForTempfile < Base
+      def initialize(target)
+        super
+        @path = target.path or
+          raise ArgumentError, "Tempfile is closed - cannot retrieve information"
+      end
+
+      def path
+        @target.flush unless @target.closed?
+        super
+      end
+
+      def size
+        # Tempfile#size returns nil when closed.
+        @target.flush unless @target.closed?
+        File.size(@target.path)
+      end
+    end
+
+    class ForFile < Base
+      def path
+        @target.flush unless @target.closed? rescue IOError  # not open for writing
+        super
+      end
+
+      def file_name
+        super || File.basename(@target.path)
+      end
+    end
+
+    class ForSavedFile < Base
+      delegate :file_name, :to => :target
+    end
+
+    class ForMissingFile < Base
+      def missing?
+        true
+      end
+
+      delegate :file_name, :to => :target
+
+      def content_type
+        @target.content_type || super
+      end
+    end
+
+    class ForIO < Base
+      def path
+        return @path if @path
+        # Keep extension if it's available.  Some commands may use the
+        # file extension of the input file, for example.
+        tempfile_name = 'bulldog'
+        if @target.respond_to?(:original_path) && @target.original_path
+          tempfile_name = [tempfile_name, File.extname(@target.original_path)]
+        end
+        Tempfile.open(tempfile_name) do |file|
+          write_to_io(file)
+          @path = file.path
+
+          # Don't let the tempfile be GC'd until the stream is, as the
+          # tempfile's finalizer deletes the file.
+          @tempfile = file
+        end
+        @path
+      end
+
+      def write_to(path)
+        if @path
+          super
+        else
+          open(path, 'w') do |file|
+            write_to_io(file)
+            @path = file.path
+          end
+        end
+      end
+
+      private  # -----------------------------------------------------
+
+      BLOCK_SIZE = 64*1024
+      def write_to_io(io)
+        target.rewind rescue nil  # not rewindable
+        buffer = ""
+        while target.read(BLOCK_SIZE, buffer)
+          io.write(buffer)
+        end
+      end
+    end
+
+    class ForStringIO < ForIO
+      delegate :size, :to => :target
+    end
+  end
+end