bulldog 0.0.1

data/lib/bulldog/attachment/unknown.rb

@@ -0,0 +1,11 @@
+module Bulldog
+  module Attachment
+    #
+    # Represents an attachment we don't know anything about.
+    #
+    # This simply inherits Base.
+    #
+    class Unknown < Base
+    end
+  end
+end

data/lib/bulldog/attachment/video.rb

@@ -0,0 +1,143 @@
+module Bulldog
+  module Attachment
+    class Video < Base
+      handle :video
+
+      #
+      # Return the width and height of the named style, as a 2-element
+      # array.
+      #
+      # This runs ffmpeg for, and only for, the original style.
+      #
+      # +style_name+ defaults to the attribute's #default_style.
+      #
+      def dimensions(style_name)
+        video_tracks(style_name).first.dimensions
+      end
+
+      include HasDimensions
+
+      #
+      # Return the duration of the named style, as an
+      # ActiveSupport::Duration.
+      #
+      # This runs ffmpeg for, and only for, the original style.
+      #
+      # +style_name+ defaults to the attribute's #default_style.
+      #
+      def duration(style_name)
+        # TODO: support styles with different durations
+        if stream.missing?
+          0
+        else
+          examine
+          @original_duration
+        end
+      end
+
+      #
+      # Return the video tracks of the named style, as an array of
+      # VideoTrack objects.
+      #
+      # Each VideoTrack has:
+      #
+      #  * <tt>#dimension</tt> - the dimensions of the video track,
+      #    [width, height].
+      #
+      def video_tracks(style_name=nil)
+        style_name ||= reflection.default_style
+        if style_name == :original
+          if stream.missing?
+            [VideoTrack.new(:dimensions => [2, 2])]
+          else
+            examine
+            if @original_video_tracks.empty?
+              @original_video_tracks << VideoTrack.new(:dimensions => [2, 2])
+            end
+            @original_video_tracks
+          end
+        else
+          style = reflection.styles[style_name]
+          target_dimensions = style[:size].split(/x/).map(&:to_i)
+          video_tracks(:original).map do |video_track|
+            dimensions = resized_dimensions(dimensions(:original), target_dimensions, style[:filled])
+            dimensions.map!{|i| i &= -2}  # some codecs require multiples of 2
+            VideoTrack.new(:dimensions => dimensions)
+          end
+        end
+      end
+
+      #
+      # Return the video tracks of the named style, as an array of
+      # AudioTrack objects.
+      #
+      # AudioTrack objects do not yet have any useful methods.
+      #
+      def audio_tracks(style_name)
+        examine
+        @original_audio_tracks
+      end
+
+      storable_attribute :duration    , :per_style => true, :memoize => true
+
+      protected  # ---------------------------------------------------
+
+      #
+      # Return the default processor class to use for this attachment.
+      #
+      def default_processor_type
+        :ffmpeg
+      end
+
+      private  # -----------------------------------------------------
+
+      #
+      # Read the original image metadata with ffmpeg.
+      #
+      def run_examination
+        return false if stream.missing?
+        output = `ffmpeg -i #{stream.path} 2>&1`
+        parse_output(output)
+      end
+
+      def parse_output(output)
+        result = false
+        @original_duration = 0
+        @original_video_tracks = []
+        @original_audio_tracks = []
+        io = StringIO.new(output)
+        while (line = io.gets)
+          case line
+          when /^Input #0, (.*?), from '(?:.*)':$/
+            result = true
+          when /^  Duration: (\d+):(\d+):(\d+)\.(\d+)/
+            @original_duration = $1.to_i.hours + $2.to_i.minutes + $3.to_i.seconds
+          when /Stream #(?:.*?): Video: /
+            if $' =~ /(\d+)x(\d+)/
+              dimensions = [$1.to_i, $2.to_i]
+            end
+            @original_video_tracks << VideoTrack.new(:dimensions => dimensions)
+          when /Stream #(?:.*?): Audio: (.*?)/
+            @original_audio_tracks << AudioTrack.new
+          end
+        end
+        result
+      end
+
+      class Track
+        def initialize(attributes={})
+          attributes.each do |name, value|
+            send("#{name}=", value)
+          end
+        end
+      end
+
+      class VideoTrack < Track
+        attr_accessor :dimensions
+      end
+
+      class AudioTrack < Track
+      end
+    end
+  end
+end

data/lib/bulldog/error.rb

@@ -0,0 +1,5 @@
+module Bulldog
+  Error = Class.new(::RuntimeError)
+  ConfigurationError = Class.new(Error)
+  ProcessingError = Class.new(Error)
+end

data/lib/bulldog/has_attachment.rb

@@ -0,0 +1,214 @@
+module Bulldog
+  module HasAttachment
+    def self.included(base)
+      base.extend ClassMethods
+      base.instance_variable_set(:@attachment_reflections, {})
+
+      # We need to store the attachment changes ourselves, since
+      # they're unavailable in an after_save.
+      base.before_save :store_original_attachments
+      base.after_save :save_attachments
+      base.after_save :clear_original_attachments
+
+      base.before_save :update_attachment_timestamps
+      base.after_destroy :destroy_attachments
+
+      # Force initialization of attachments, as #destroy will freeze
+      # the attributes afterwards.
+      base.before_destroy :initialize_remaining_attachments
+
+      %w[validation save create update].each do |event|
+        base.send("before_#{event}", "process_attachments_for_before_#{event}")
+        base.send("after_#{event}", "process_attachments_for_after_#{event}")
+      end
+    end
+
+    def save_attachments
+      attachment_reflections.each do |name, reflection|
+        original_attachment = @original_attachments[name] and
+          original_attachment.destroy
+        _attachment_for(name).save
+      end
+    end
+
+    def destroy_attachments
+      attachment_reflections.each do |name, reflection|
+        _attachment_for(name).destroy
+      end
+    end
+
+    def update_attachment_timestamps
+      attachment_reflections.each do |name, reflection|
+        next unless send("#{name}_changed?")
+        setter = "#{name}_updated_at="
+        if respond_to?(setter)
+          send(setter, Time.now)
+        end
+      end
+    end
+
+    def process_attachment(name, event, *args)
+      reflection = attachment_reflections[name] or
+        raise ArgumentError, "no such attachment: #{name}"
+      _attachment_for(name).process(event, *args)
+    end
+
+    def attachment_reflection_for(name)
+      self.class.attachment_reflections[name]
+    end
+
+    private  # -------------------------------------------------------
+
+    # Prefixed with '_', as it would collide with paperclip otherwise.
+    def _attachment_for(name)
+      read_attribute(name) or
+        initialize_attachment(name)
+    end
+
+    def initialize_attachment(name)
+      if new_record?
+        value = nil
+      else
+        reflection = attachment_reflection_for(name)
+        file_name_column = reflection.column_name_for_stored_attribute(:file_name)
+        file_name = file_name_column ? send(file_name_column) : nil
+        if file_name_column && file_name.nil?
+          value = nil
+        else
+          template = reflection.path_template
+          style = reflection.styles[:original]
+          original_path = Interpolation.interpolate(template, self, name, style, :basename => file_name)
+          if File.exist?(original_path)
+            value = SavedFile.new(original_path, :file_name => file_name)
+          else
+            if file_name_column
+              value = MissingFile.new(:file_name => file_name)
+            else
+              value = nil
+            end
+          end
+        end
+      end
+
+      attachment = make_attachment_for(name, value)
+      write_attribute_without_dirty(name, attachment)
+      attachment.read_storable_attributes
+      attachment
+    end
+
+    def assign_attachment(name, value)
+      old_attachment = _attachment_for(name)
+      unless old_attachment.value == value
+        old_attachment.clear_stored_attributes
+        new_attachment = make_attachment_for(name, value)
+        new_attachment.set_stored_attributes
+        write_attribute(name, new_attachment)
+      end
+    end
+
+    def make_attachment_for(name, value)
+      return Attachment.none(self, name) if value.nil?
+      stream = Stream.new(value)
+      reflection = attachment_reflection_for(name)
+      type = reflection.detect_attachment_type(self, stream)
+      Attachment.of_type(type, self, name, stream)
+    end
+
+    def store_original_attachments
+      @original_attachments = {}
+      attachment_reflections.each do |name, reflection|
+        if send("#{name}_changed?")
+          @original_attachments[name] = send("#{name}_was")
+        end
+      end
+    end
+
+    def clear_original_attachments
+      remove_instance_variable :@original_attachments
+    end
+
+    def process_attachments_for_event(event, *args)
+      self.class.attachment_reflections.each do |name, reflection|
+        _attachment_for(reflection.name).process(event, *args)
+      end
+    end
+
+    def initialize_remaining_attachments
+      self.attachment_reflections.each do |name, reflection|
+        _attachment_for(name)  # force initialization
+      end
+    end
+
+    %w[validation save create update].each do |event|
+      module_eval <<-EOS
+        def process_attachments_for_before_#{event}
+          process_attachments_for_event(:before_#{event})
+        end
+        def process_attachments_for_after_#{event}
+          process_attachments_for_event(:after_#{event})
+        end
+      EOS
+    end
+
+    delegate :attachment_reflections, :to => 'self.class'
+
+    module ClassMethods
+      def attachment_reflections
+        @attachment_reflections ||=
+          begin
+            hash = {}
+            superhash = superclass.attachment_reflections
+            superhash.map do |name, reflection|
+              hash[name] = reflection.clone
+            end
+            hash
+          end
+      end
+
+      #
+      # Declare that this model has an attachment.
+      #
+      # TODO: example that shows all the options.
+      #
+      def has_attachment(name, &block)
+        reflection = attachment_reflections[name] || Reflection.new(self, name)
+        reflection.configure(&block)
+        attachment_reflections[name] = reflection
+        define_attachment_accessors(reflection.name)
+        define_attachment_attribute_methods(reflection.name)
+      end
+
+      def define_attachment_accessors(name)
+        module_eval <<-EOS, __FILE__, __LINE__
+          def #{name}
+            _attachment_for(:#{name})
+          end
+
+          def #{name}=(value)
+            assign_attachment(:#{name}, value)
+          end
+
+          def #{name}?
+            _attachment_for(:#{name}).present?
+          end
+        EOS
+      end
+
+      def define_attachment_attribute_methods(name)
+        # HACK: Without this, methods defined via
+        # #attribute_method_suffix (e.g., #ATTACHMENT_changed?) won't
+        # be defined unless the attachment is assigned first.
+        # ActiveRecord appears to give us no other way without
+        # defining an after_initialize, which is slow.
+        attribute_method_suffixes.each do |suffix|
+          next unless suffix[0] == ?_  # skip =, ?.
+          class_eval <<-EOS
+            def #{name}#{suffix}(*args, &block)
+              attribute#{suffix}('#{name}', *args, &block)
+            end
+          EOS
+        end
+      end
+    end
+  end
+end

data/lib/bulldog/interpolation.rb

@@ -0,0 +1,73 @@
+module Bulldog
+  module Interpolation
+    Error = Class.new(Bulldog::Error)
+
+    def self.interpolate(template, record, name, style, overrides={})
+      # TODO: would be nice if this wasn't such a special case.
+      if overrides[:basename]
+        extension = File.extname(overrides[:basename]).sub(/\A./, '')
+        overrides[:extension] ||= extension
+      end
+      template.gsub(/:(?:(\w+)|\{(\w+?)\})/) do
+        key = ($1 || $2).to_sym
+        if (override = overrides[key])
+          override
+        elsif @interpolations.key?(key)
+          @interpolations[key].call(record, name, style)
+        else
+          raise Error, "no such interpolation key: #{key}"
+        end
+      end
+    end
+
+    def self.to_interpolate(key, &substitution)
+      @interpolations[key] = substitution
+    end
+
+    def self.reset
+      @interpolations = {}
+
+      to_interpolate :class do |record, name, style|
+        record.class.name.underscore.pluralize
+      end
+
+      to_interpolate :id do |record, name, style|
+        record.send(record.class.primary_key)
+      end
+
+      to_interpolate :id_partition do |record, name, style|
+        id = record.send(record.class.primary_key)
+        ("%09d" % id).scan(/\d{3}/).join("/")
+      end
+
+      to_interpolate :attachment do |record, name, style|
+        name
+      end
+
+      to_interpolate :style do |record, name, style|
+        style.name
+      end
+
+      to_interpolate :basename do |record, name, style|
+        reflection = record.attachment_reflection_for(name)
+        column_name = reflection.column_name_for_stored_attribute(:file_name) or
+          raise Error, ":basename interpolation requires storing the file name - add a column #{name}_file_name or use store_attributes"
+        record.send(column_name)
+      end
+
+      to_interpolate :extension do |record, name, style|
+        reflection = record.attachment_reflection_for(name)
+        column_name = reflection.column_name_for_stored_attribute(:file_name) or
+          raise Error, ":extension interpolation requires storing the file name - add a column #{name}_file_name or use store_attributes"
+        basename = record.send(column_name) or
+          raise Error, ":extension interpolation used when file_name not set - if you need to interpolate the url, pass a :basename override"
+        File.extname(basename).sub(/\A\./, '')
+      end
+    end
+
+    #
+    # Reset the list of interpolation definitions.
+    #
+    reset
+  end
+end