asset_host_core 2.0.0.beta

data/lib/asset_host_core/loaders/url.rb

@@ -0,0 +1,59 @@
+require 'mime/types'
+require 'net/http'
+require 'cgi'
+
+module AssetHostCore
+  module Loaders
+    class URL < Base
+      SOURCE = "URL"
+
+      #-----------
+
+      def self.build_from_url(url)
+        uri = URI.parse(url)
+        return nil unless uri.is_a?(URI::HTTP)
+
+        response  = Net::HTTP.get_response(uri)
+
+        # Check that it's actually an image we're grabbing
+        if response.content_type.match(/image/)
+          self.new(url: url, id: url)
+        else
+          nil
+        end
+      end
+
+      #----------
+
+      def load
+        filename = File.basename(@url)
+
+        # build asset
+        asset = AssetHostCore::Asset.new(
+          :title    => filename,
+          :url      => @url,
+          :notes    => "Fetched from URL: #{@url}",
+          :image    => image_file
+        )
+
+        asset.save!
+        asset
+      end
+
+      #----------
+
+      private
+
+      def image_file
+        @image_file ||= begin
+          response = open(@url)
+
+          tempfile = Tempfile.new('ah-brightcove', encoding: "ascii-8bit")
+          tempfile.write response.read
+
+          tempfile
+        end
+      end
+    end
+  end
+end

data/lib/asset_host_core/loaders/vimeo.rb

@@ -0,0 +1,76 @@
+module AssetHostCore
+  module Loaders
+    class Vimeo < Base
+      SOURCE = "Vimeo"
+
+      #----------------
+
+      def self.build_from_url(url)
+        # Don't need a key just to read from the public API
+        url.match(/vimeo\.com\/(?<id>\d+)/i) do |m|
+          self.new(url: url, id: m[:id])
+        end
+      end
+
+      #----------------
+
+      def load
+        data = fetch_data
+
+        video = data[0]
+        return nil if !video
+
+        native = AssetHostCore::VimeoVideo.create(
+          :videoid => video["id"]
+        )
+
+        asset = AssetHostCore::Asset.new(
+          :image          => image_file(video["thumbnail_large"]),
+          :title          => video["title"],
+          :caption        => video["title"], # Description is too long
+          :url            => @url,
+          :owner          => "#{video["user_name"]} (via Vimeo)",
+          :notes          => "Imported from Vimeo: #{@url}",
+          :image_taken    => video["upload_date"],
+          :native         => native
+        )
+
+        asset.save!
+        asset
+      end
+
+      #----------------
+
+      def fetch_data
+        response = connection.get do |request|
+          request.url "video/#{@id}.json"
+        end
+
+        response.body
+      end
+
+
+      private
+
+      def image_file(url)
+        @image_file ||= begin
+          response = open(url)
+
+          tempfile = Tempfile.new('ah-vimeo', encoding: "ascii-8bit")
+          tempfile.write response.read
+
+          tempfile
+        end
+      end
+
+      def connection
+        @connection ||= begin
+          Faraday.new('http://vimeo.com/api/v2') do |conn|
+            conn.response :json
+            conn.adapter Faraday.default_adapter
+          end
+        end
+      end
+    end
+  end
+end

data/lib/asset_host_core/loaders/youtube.rb

@@ -0,0 +1,90 @@
+module AssetHostCore
+  module Loaders
+    class YouTube < Base
+      SOURCE = "YouTube"
+
+      #----------------
+
+      def self.build_from_url(url)
+        return nil if AssetHostCore.config.google_api_key.blank?
+
+        url.match(/youtube\.com\/watch\?.*v=(?<id>[\w-]+)/i) do |m|
+          self.new(url: url, id: m[:id])
+        end
+      end
+
+      #----------------
+
+      def load
+        data = fetch_data
+
+        video = data["items"][0]
+        return nil if !video
+
+        snippet = video["snippet"]
+        return nil if !snippet
+
+        native = AssetHostCore::YoutubeVideo.create(
+          :videoid => video["id"]
+        )
+
+        thumbnail = snippet["thumbnails"]["maxres"] ||
+                    snippet["thumbnails"]["high"]
+
+        asset = AssetHostCore::Asset.new(
+          :image          => image_file(thumbnail["url"]),
+          :title          => snippet["title"],
+          :caption        => snippet["description"],
+          :url            => @url,
+          :owner          => "#{snippet["channelTitle"]} (via YouTube)",
+          :notes          => "Imported from YouTube: #{@url}",
+          :image_taken    => snippet["publishedAt"],
+          :native         => native
+        )
+
+        asset.save!
+        asset
+      end
+
+      #----------------
+
+      def fetch_data
+        response = client.execute!(
+          :api_method => youtube.videos.list,
+          :parameters => {
+            :id   => @id,
+            :part => 'id,snippet,contentDetails,player'
+          }
+        )
+
+        JSON.parse(response.body)
+      end
+
+      #----------------
+
+      private
+
+      def image_file(url)
+        @image_file ||= begin
+          response = open(url)
+
+          tempfile = Tempfile.new('ah-youtube', encoding: "ascii-8bit")
+          tempfile.write response.read
+
+          @url.match(/ah-noTrim/) ? tempfile : Paperclip::Trimmer.make(tempfile)
+        end
+      end
+
+      def client
+        @client ||= Google::APIClient.new(
+          :key              => AssetHostCore.config.google_api_key,
+          :authorization    => nil
+        )
+      end
+
+      def youtube
+        @youtube ||= client.discovered_api('youtube', 'v3')
+      end
+    end
+  end
+end

data/lib/asset_host_core/model_methods.rb

@@ -0,0 +1,61 @@
+require 'mini_exiftool'
+
+module AssetHostCore
+  module ModelMethods
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def treat_as_image_asset(name)
+        include InstanceMethodsOnActivation
+
+        attachment_definitions[name][:delayed] = true
+
+        define_method "write_exif_data_for_#{name}" do
+          if self.send("#{name}").dirty?
+            # need to extract dimensions from the attachment
+            self.attachment_for(name).write_exif_data
+          end
+        end
+
+        define_method "enqueue_delayed_processing_for_#{name}" do
+          # we render on two things: image fingerprint changed, or image gravity changed
+          if self.previous_changes.include?("image_fingerprint") || self.previous_changes.include?("image_gravity")
+            self.attachment_for(name).enqueue
+          end
+        end
+
+        # register our event handler
+        before_save :"write_exif_data_for_#{name}"
+
+        if respond_to?(:after_commit)
+          after_commit  :"enqueue_delayed_processing_for_#{name}"
+        else
+          after_save  :"enqueue_delayed_processing_for_#{name}"
+        end
+
+        # -- Style fingerprint interpolation -- #
+
+        ::Paperclip.interpolates "sprint" do |attachment, style_name|
+          if style_name == :original
+            'original'
+          elsif ao = attachment.instance.output_by_style(style_name)
+            ao.fingerprint
+          else
+            nil
+          end
+        end
+      end
+
+
+      module InstanceMethodsOnActivation
+        # borrowed from delayed_paperclip... combines with [:delayed] above to turn off the inline processing
+        def attachment_for(name)
+          @_paperclip_attachments ||= {}
+          @_paperclip_attachments[name] ||= ::Paperclip::Attachment.new(name, self, self.class.attachment_definitions[name]).tap do |a|
+            a.post_processing = false if self.class.attachment_definitions[name][:delayed]
+          end
+        end
+      end
+    end # ClassMethods
+  end # Paperclip
+end # AssetHostCore

data/lib/asset_host_core/paperclip.rb

@@ -0,0 +1,4 @@
+require 'paperclip'
+require 'asset_host_core/paperclip/attachment'
+require 'asset_host_core/paperclip/asset_thumbnail'
+require 'asset_host_core/paperclip/trimmer'

data/lib/asset_host_core/paperclip/asset_thumbnail.rb

@@ -0,0 +1,92 @@
+module Paperclip
+  class AssetThumbnail < Paperclip::Thumbnail
+    attr_accessor :prerender, :output, :asset
+
+    def initialize(file, options={}, attachment=nil)
+      @prerender    = options[:prerender]
+      @size         = options[:size]
+      @output       = options[:output]
+      @asset        = attachment ? attachment.instance : nil
+      @attachment   = attachment
+
+      super
+
+      gravity = @asset.image_gravity? ? @asset.image_gravity : "Center"
+
+      @convert_options = [
+        "-gravity #{gravity}",
+        "-strip",
+        "-quality 95",
+        @convert_options
+      ].flatten.compact
+    end
+
+    # Perform processing, if prerender == true or we've had to render
+    # this output before. Afterward, update our AssetOutput entry
+    def make
+      # do we have an AssetOutput already?
+      ao = @asset.outputs.where(output_id: @output).first
+
+      dst = nil
+
+      if @prerender || ao
+        if !ao
+          # register empty AssetObject to denote processing
+          ao = @asset.outputs.create(
+            :output_id            => @output,
+            :image_fingerprint    => @asset.image_fingerprint
+          )
+        end
+
+        if @size =~ /(\d+)?x?(\d+)?([\#>])?$/ && $~[3] == "#"
+          # crop...  scale using dimensions as minimums, then crop to dimensions
+          scale = "-scale #{$~[1]}x#{$~[2]}^"
+          crop  = "-crop #{$~[1]}x#{$~[2]}+0+0"
+
+          @convert_options = [
+            @convert_options.shift,
+            scale,
+            crop,
+            @convert_options
+          ].flatten
+        else
+          # don't crop
+          scale = "-scale '#{$~[1]}x#{$~[2]}#{$~[3]}'"
+          @convert_options = [scale, @convert_options].flatten
+        end
+
+        # call thumbnail generator
+        dst = super
+
+        # need to get dimensions
+        width = height = nil
+
+        begin
+          geo     = Geometry.from_file(dst.path)
+          width   = geo.width.to_i
+          height  = geo.height.to_i
+        rescue NotIdentifiedByImageMagickError => e
+          # hmmm... do nothing?
+        end
+
+        # get fingerprint
+        print = Digest::MD5.hexdigest(dst.read)
+        dst.rewind if dst.respond_to?(:rewind)
+
+        ao.attributes = {
+          :fingerprint          => print,
+          :width                => width,
+          :height               => height,
+          :image_fingerprint    => @asset.image_fingerprint
+        }
+
+        ao.save
+
+        # just to be safe...
+        @asset.outputs(true)
+      end
+
+      dst
+    end
+  end
+end

data/lib/asset_host_core/paperclip/attachment.rb

@@ -0,0 +1,206 @@
+module Paperclip
+  class Attachment
+    # Overwrite styles loader to allow caching despite dynamic loading
+    def styles
+      styling_option = @options[:styles]
+
+      if !@normalized_styles
+        @normalized_styles = ActiveSupport::OrderedHash.new
+        styling_option.call(self).each do |name, args|
+          @normalized_styles[name] = Paperclip::Style.new(name, args.dup, self)
+        end
+      end
+      @normalized_styles
+    end
+
+
+    # overwrite to only delete original when clear() is called.  styles will
+    # be deleted by the thumbnailer
+    def queue_existing_for_delete #:nodoc:
+      return unless file?
+
+      @queued_for_delete = [path(:original)]
+
+      instance_write(:file_name, nil)
+      instance_write(:content_type, nil)
+      instance_write(:file_size, nil)
+      instance_write(:updated_at, nil)
+    end
+
+
+    #----------
+
+    def delete_path(path)
+      @queued_for_delete = [ path ]
+      self.flush_deletes
+    end
+
+    #----------
+
+    def enqueue
+      # queue up any outputs that a) already exist or b) are set to prerender
+      styles = [
+        AssetHostCore::Output.where(prerender: true).map(&:code_sym),
+        self.instance.outputs.map { |ao| ao.output.code_sym }
+      ].flatten.uniq
+
+      enqueue_styles(*styles)
+    end
+
+    def enqueue_styles(*styles)
+      Resque.enqueue(
+        AssetHostCore::ResqueJob,
+        self.instance.class.name,
+        self.instance.id,
+        self.name,
+        styles
+      )
+    end
+
+    #----------
+
+    def width(style = default_style)
+      return nil if !self.instance_read("width")
+
+      if s = self.styles[style]
+        # load dimensions
+        if ao = self.instance.output_by_style(style)
+          return ao.width
+        else
+          # TODO: Need to add code to guess dimensions if we don't yet have an output
+          g = Paperclip::Geometry.parse(s.processor_options[:size])
+          if g.modifier == '#'
+            if g.square?
+              # match w/h from style
+              return g.width.to_i
+            else
+              return g.width.to_i
+            end
+          end
+
+          factor = self._compute_style_ratio(s)
+          width = ((self.instance_read("width") || 0) * factor).round
+          return width < self.instance_read("width") ? width : self.instance_read("width")
+        end
+      end
+
+      nil
+    end
+
+    #----------
+
+    def height(style = default_style)
+      return nil if !self.instance_read("height")
+
+      if s = self.styles[style]
+        # load dimensions
+        if ao = self.instance.output_by_style(style)
+          return ao.height
+        else
+          # TODO: Need to add code to guess dimensions if we don't yet have an output
+          g = Paperclip::Geometry.parse(s.processor_options[:size])
+          if g.modifier == '#'
+            # match w/h from style
+            return g.height.to_i
+          end
+
+          factor = self._compute_style_ratio(s)
+          height = ((self.instance_read("height") || 0) * factor).round
+
+          return height < self.instance_read("height") ? height : self.instance_read("height")
+
+        end
+      end
+
+      nil
+    end
+
+    #----------
+
+    def isPortrait?
+      w = self.instance_read("width")
+      h = self.instance_read("height")
+
+      h > w
+    end
+
+    #----------
+
+    def _compute_style_ratio(style)
+      w = self.instance_read("width")
+      h = self.instance_read("height")
+
+      return 0 if !w || !h
+
+      g = Paperclip::Geometry.parse(style.processor_options[:size])
+      ratio = Paperclip::Geometry.new( g.width/w, g.height/h )
+
+      # we need to compute off the smaller number
+      factor = (ratio.width > ratio.height) ? ratio.height : ratio.width
+    end
+
+    #----------
+
+    def tags(args = {})
+      tags = {}
+
+      self.styles.each do |style,v|
+        tags[style] = self.tag(style,args)
+      end
+
+      tags
+    end
+
+    #----------
+
+    def tag(style = default_style, args={})
+      s = self.styles[style.to_sym]
+      return nil if !s
+
+      if (s.instance_variable_get :@other_args)[:rich] && self.instance.native
+        args = args.merge(self.instance.native.attrs)
+      end
+
+      htmlargs = args.collect { |k,v| %Q!#{k}="#{v}"! }.join(" ")
+
+      %Q(<img src="#{self.url(style)}" width="#{self.width(style)}" height="#{self.height(style)}" alt="#{self.instance.title.to_s.gsub('"', ERB::Util::HTML_ESCAPE['"'])}" #{htmlargs}/>).html_safe
+    end
+
+    #----------
+
+    def write_exif_data
+      return unless @queued_for_write[:original]
+
+      p = ::MiniExiftool.new(@queued_for_write[:original].path)
+
+      # -- determine metadata -- #
+
+      if p.credit =~ /Getty Images/
+        # smart import for Getty Images photos
+        copyright     = [p.by_line,p.credit].join("/")
+        title         = p.headline
+        description   = p.description
+
+      elsif p.credit =~ /AP/
+        # smart import for AP photos
+        copyright     = [p.by_line,p.credit].join("/")
+        title         = p.title
+        description   = p.description
+
+      else
+        copyright     = p.byline || p.credit
+        title         = p.title
+        description   = p.description
+      end
+
+      instance_write(:width, p.image_width)
+      instance_write(:height, p.image_height)
+      instance_write(:title, title)
+      instance_write(:description, description)
+      instance_write(:copyright, copyright)
+      instance_write(:taken, p.datetime_original)
+
+      true
+    end
+  end
+end