meme_captain 0.0.8 → 0.0.9

data/.gitignore

@@ -1 +1,2 @@
-img_cache/*
+img_cache/*
+*~

data/ChangeLog

@@ -1,3 +1,36 @@
+0.0.9	2012-01-19
+
+	Design and markup improvements on the site.
+
+	Allow use of all type metrics when comparing caption choices.
+
+	Add ability to use the ids in the URLs of generated images to make
+	new images from the same source by using the id as the source image
+	URL (an example id is abcdef.jpg).
+
+	Add a 404 page to the site.
+
+	Deprecate concept of temporary URLs and permanent URLs for images
+	generated from the site.
+
+	Use MongoDB for the site datastore.
+
+	Add "memecaptain" executable for creating memes using the gem from the
+	command line.
+
+	Add a watermark to images created on the site.
+
+	Shrink large source images to a maximum of 800 pixels per side for
+	images created on the site.
+
+	Define local source images in JSON instead of in the template and load
+	them with Ajax.
+
+	Add Google Image Search to the site.
+
+	Add new source images to the site: all the things 2, cool story bro,
+	aw yeah, Boromir, Ned Stark.
+
 0.0.8
         2011-11-23
 

data/README.md

@@ -47,6 +47,10 @@ Example:
 http://memecaptain.com/g?u=http%3A%2F%2Fmemecaptain.com%2Fyao_ming.jpg&tt=sure+i%27ll+test&tb=the+api
 ```
 
+Note: tempUrl is deprecated and will now always be the same as permUrl. It is
+left for compability with older clients.
+
+
 ```json
 {
   permUrl: "http://memecaptain.com/i?u=http%3A%2F%2Fmemecaptain.com%2Fyao_ming.jpg&tt=sure+i%27ll+test&tb=the+api"

data/bin/memecaptain

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+
+require 'mime/types'
+require 'open-uri'
+require 'optparse'
+
+require 'meme_captain'
+
+options = {}
+
+option_parser = OptionParser.new do |opts|
+  opts.banner = <<-eos
+Usage: memecaptain INPUT_IMAGE [OPTIONS]
+
+INPUT_IMAGE can be a file path, URL or - for stdin.
+
+eos
+
+  opts.on('-t', '--top-text TEXT', 'top text') do |text|
+    options[:top_text] = text
+  end
+
+  opts.on('-b', '--bottom-text TEXT', 'bottom text') do |text|
+    options[:bottom_text] = text
+  end
+
+  opts.on('-o', '--output PATH', 'output path (- for stdout)') do |path|
+    options[:output] = path
+  end
+
+  opts.on('-f', '--font FONT', 'font') do |font|
+    options[:font] = font
+  end
+end
+
+option_parser.parse!
+
+unless ARGV.empty?
+  input = ARGV[0]
+
+  input_io = if input == '-'
+    $stdin
+  else
+    open input, 'rb'
+  end
+
+  meme_options = options.select do |k,v|
+    [
+      :font,
+    ].include? k
+  end
+
+  output_image = MemeCaptain.meme(
+    input_io, options[:top_text], options[:bottom_text], meme_options)
+
+  input_io.close
+
+  output = if options[:output]
+    options[:output] == '-' ? $stdout : options[:output]
+  else
+    "meme.#{MIME::Types[output_image.mime_type][0].extensions[0]}"
+  end
+
+  output_image.write(output) { self.quality = 100 }
+else
+  $stderr.puts option_parser
+  exit 1
+end

data/config.ru

@@ -1,5 +1,7 @@
 $:.unshift(File.join(File.dirname(__FILE__), 'lib'))
 
+require 'mongo'
+require 'mongo_mapper'
 require 'rack'
 
 require 'meme_captain'
@@ -9,4 +11,15 @@ use Rack::Sendfile
 
 use Rack::Static, :urls => %w{/tmp}, :root => 'public'
 
+MongoMapper.connection = Mongo::Connection.new
+MongoMapper.database = 'memecaptain'
+
+MemeCaptain::MemeData.ensure_index :meme_id
+
+MemeCaptain::MemeData.ensure_index [
+  [:source_url, 1],
+  [:top_text, 1],
+  [:bottom_text, 1],
+]
+
 run MemeCaptain::Server

data/lib/meme_captain/caption_choice.rb

@@ -4,18 +4,24 @@ module MemeCaptain
   class CaptionChoice
     include Comparable
 
-    def initialize(fits, pointsize, text)
-      @fits = fits
+    def initialize(pointsize, metrics, text, bound_width, bound_height)
       @pointsize = pointsize
+      @metrics = metrics
       @text = text
+      @bound_width = bound_width
+      @bound_height = bound_height
     end
 
     def num_lines
       text.count("\n") + 1
     end
 
+    def fits
+      metrics.width <= bound_width and metrics.height <= bound_height
+    end
+
     def fits_i
-      fits ? 1: 0
+      fits ? 1 : 0
     end
 
     def <=>(other)
@@ -24,10 +30,11 @@ module MemeCaptain
         other.fits ? -other.num_lines : other.num_lines]
     end
 
-    attr_accessor :fits
     attr_accessor :pointsize
+    attr_accessor :metrics
     attr_accessor :text
-
+    attr_accessor :bound_width
+    attr_accessor :bound_height
   end
 
 end

data/lib/meme_captain/draw.rb

@@ -6,20 +6,22 @@ module MemeCaptain
     # Calculate the largest pointsize for text that will be in a width x
     # height box.
     #
-    # Return [pointsize, fits] where pointsize is the largest pointsize and
-    # fits is true if that pointsize will fit in the box.
+    # Return [pointsize, metrics] where pointsize is the largest pointsize and
+    # metrics is the RMagick multiline type metrics of the best fit.
     def calc_pointsize(width, height, text, min_pointsize)
       current_pointsize = min_pointsize
 
-      fits = false
+      metrics = nil
 
       loop {
         self.pointsize = current_pointsize
+        last_metrics = metrics
         metrics = get_multiline_type_metrics(text)
+
         if metrics.width > width or metrics.height > height
           if current_pointsize > min_pointsize
             current_pointsize -= 1
-            fits = true
+            metrics = last_metrics
           end
           break
         else
@@ -27,7 +29,7 @@ module MemeCaptain
         end
       }
 
-      [current_pointsize, fits]
+      [current_pointsize, metrics]
     end
 
   end

data/lib/meme_captain/image_list/cache.rb

@@ -0,0 +1,49 @@
+require 'digest/sha1'
+require 'fileutils'
+require 'mime/types'
+
+module MemeCaptain
+
+  module ImageList
+
+    # Mix-in for Magick::ImageList to add saving to the filesystem based on a
+    # hash.
+    module Cache
+
+      # Get the extension for this image.
+      def extension
+        {
+          'image/jpeg' => 'jpg',
+        }[mime_type] || MIME::Types[mime_type][0].extensions[0]
+      end
+
+      # Store this image in the filesystem and return its path.
+      def cache(hash_base, dir)
+        hashe = Digest::SHA1.hexdigest(hash_base)
+
+        cache_dir = File.join(dir, hashe[0,3])
+        FileUtils.mkdir_p cache_dir
+
+        file_part = hashe[3..-1]
+        fs_path = File.join(cache_dir, "#{file_part}.#{extension}")
+
+        # If there is a collision add 0's until the filename is unique.
+        zeroes = 0
+        while File.exist? fs_path
+          zeroes += 1
+          fs_path = File.join(cache_dir,
+            "#{file_part}#{'0' * zeroes}.#{extension}")
+        end
+
+        write(fs_path) {
+          self.quality = 100
+        }
+
+        fs_path
+      end
+
+    end
+
+  end
+
+end

data/lib/meme_captain/image_list/fetch.rb

@@ -0,0 +1,26 @@
+require 'curb'
+
+module MemeCaptain
+
+  module ImageList
+
+    # Mix-in for Magick::ImageList to add loading from a URL.
+    module Fetch
+
+      # Load this image from a URL.
+      def fetch!(url)
+        curl = Curl::Easy.perform(url) do |c|
+          c.useragent = 'Meme Captain http://memecaptain.com/'
+        end
+        unless curl.response_code == 200
+          raise "Error loading source image url #{url}"
+        end
+
+        from_blob curl.body_str
+      end
+      
+    end
+
+  end
+
+end

data/lib/meme_captain/image_list/source_image.rb

@@ -0,0 +1,28 @@
+require 'RMagick'
+
+module MemeCaptain
+
+  module ImageList
+
+    # Source image for meme generation.
+    class SourceImage < Magick::ImageList
+      include Cache
+      include Fetch
+      include Watermark
+
+      # Shrink image if necessary and add watermark.
+      def prepare!(max_side, watermark_img)
+        if size == 1 and (columns > max_side or rows > max_side)
+          resize_to_fit! max_side
+        end
+
+        watermark_mc watermark_img
+
+        strip!
+      end
+
+    end
+
+  end
+
+end

data/lib/meme_captain/image_list/watermark.rb

@@ -0,0 +1,24 @@
+require 'RMagick'
+
+module MemeCaptain
+
+  module ImageList
+
+    # Mix-in for Magick::ImageList to add watermark.
+    module Watermark
+
+      # Watermark this image using another image.
+      def watermark_mc(watermark_img)
+        self.each do |frame|
+          frame.composite!(watermark_img, Magick::SouthEastGravity,
+            -frame.page.width + frame.columns + frame.page.x,
+            -frame.page.height + frame.rows + frame.page.y,
+            Magick::OverCompositeOp)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/meme_captain/image_list.rb

@@ -0,0 +1,5 @@
+require 'meme_captain/image_list/cache'
+require 'meme_captain/image_list/fetch'
+require 'meme_captain/image_list/watermark'
+
+require 'meme_captain/image_list/source_image'

data/lib/meme_captain/meme.rb

@@ -69,10 +69,11 @@ module MemeCaptain
       }.uniq
 
       choices = wrap_tries.map do |wrap_try|
-        pointsize, fits = draw.calc_pointsize(
+        pointsize, metrics = draw.calc_pointsize(
           text_width, text_height, wrap_try, min_pointsize)
 
-        CaptionChoice.new(fits, pointsize, wrap_try)
+        CaptionChoice.new(pointsize, metrics, wrap_try, text_width,
+          text_height)
       end
 
       choice = choices.max

data/lib/meme_captain/meme_data.rb

@@ -0,0 +1,34 @@
+require 'mongo_mapper'
+
+module MemeCaptain
+
+  class MemeData
+    include MongoMapper::Document
+
+    set_collection_name 'meme'
+
+    key :meme_id, String
+    key :fs_path, String
+    key :mime_type, String
+    key :size, Integer
+
+    key :source_url, String
+    key :source_fs_path, String
+    key :top_text, String
+    key :bottom_text, String
+
+    key :request_count, Integer
+    key :last_request, Time
+
+    key :creator_ip, String
+
+    timestamps!
+
+    def requested!
+      increment :request_count => 1
+      set :last_request => Time.now
+    end
+
+  end
+
+end

data/lib/meme_captain/server.rb

@@ -1,84 +1,167 @@
 require 'digest/sha1'
-require 'uri'
 
-require 'curb'
 require 'json'
+require 'rack'
 require 'sinatra/base'
 
-require 'meme_captain'
-
 module MemeCaptain
 
   class Server < Sinatra::Base
 
-    ImageExts = %w{.jpeg .gif .png}
-
-    set :root, File.join(File.dirname(__FILE__), '..', '..')
+    set :root, File.expand_path(File.join('..', '..'), File.dirname(__FILE__))
+    set :source_img_max_side, 800
+    set :watermark, Magick::ImageList.new(File.expand_path(
+      File.join('..', '..', 'watermark.png'), File.dirname(__FILE__)))
 
     get '/' do
       @u = params[:u]
       @tt= params[:tt]
       @tb = params[:tb]
 
+      @root_url = url('/')
+
       erb :index
     end
 
-    def gen(params)
-      @processed_cache ||= MemeCaptain::FilesystemCache.new('public/tmp')
-      @source_cache ||= MemeCaptain::FilesystemCache.new('img_cache/source')
+    def normalize_params(p)
+      result = {
+        'u' => p[:u],
+         # convert to empty string if null
+        'tt' => p[:tt].to_s,
+        'tb' => p[:tb].to_s,
+      }
 
-      processed_id = Digest::SHA1.hexdigest(params.sort.map(&:join).join)
-      @processed_cache.get_path(processed_id, ImageExts) {
-        source_id = Digest::SHA1.hexdigest(params[:u])
-        source_img_data = @source_cache.get_data(source_id, ImageExts) {
-          curl = Curl::Easy.perform(params[:u]) do |c|
-            c.useragent = 'Meme Captain http://memecaptain.com/'
-          end
-          unless curl.response_code == 200
-            raise "Error loading source image url #{params[:u]}"
-          end
-          curl.body_str
-        }
+      # if the id of an existing meme is passed in as the source url, use the
+      # source image of that meme for the source image
+      if result['u'][%r{^[a-f0-9]+\.(?:gif|jpg|png)$}]
+        if existing_as_source = MemeData.find_by_meme_id(result['u'])
+          result['u'] = existing_as_source.source_url
+        end
+      end
+
+      # hash with string keys that can be accessed by symbol
+      Hash.new { |hash,key| hash[key.to_s] if Symbol === key }.merge(result)
+    end
 
-        meme_img = MemeCaptain.meme(source_img_data, params[:tt], params[:tb])
-        current_format = meme_img.format
+    def gen(p)
+      norm_params = normalize_params(p)
+
+      if existing = MemeData.first(
+        :source_url => norm_params[:u],
+        :top_text => norm_params[:tt],
+        :bottom_text => norm_params[:tb]
+        )
+        existing
+      else
+        if same_source = MemeData.find_by_source_url(norm_params[:u])
+          source_fs_path = same_source.source_fs_path
+        else
+          source_img = ImageList::SourceImage.new
+          source_img.fetch! norm_params[:u]
+          source_img.prepare! settings.source_img_max_side, settings.watermark
+          source_fs_path = source_img.cache(norm_params[:u], 'source_cache')
+        end
+
+        open(source_fs_path, 'rb') do |source_io|
+          meme_img = MemeCaptain.meme(source_io, norm_params[:tt],
+            norm_params[:tb])
+          meme_img.extend ImageList::Cache
 
-        meme_img.to_blob {
-          self.quality = 100
           # convert non-animated gifs to png
-          if current_format == 'GIF' and meme_img.size == 1
-            self.format = 'PNG'  
+          if meme_img.format == 'GIF' and meme_img.size == 1
+            meme_img.format = 'PNG'
           end
-        }
-      }
+
+          params_s = norm_params.sort.map(&:join).join
+          meme_hash = Digest::SHA1.hexdigest(params_s)
+
+          meme_id = nil
+          (6..meme_hash.size).each do |len|
+            meme_id = "#{meme_hash[0,len]}.#{meme_img.extension}"
+            break  unless MemeData.where(:meme_id => meme_id).count > 0
+          end
+
+          meme_fs_path = meme_img.cache(params_s, File.join('public', 'meme'))
+
+          meme_img.write(meme_fs_path) {
+            self.quality = 100
+          }
+
+          meme_data = MemeData.new(
+            :meme_id => meme_id,
+            :fs_path => meme_fs_path,
+            :mime_type => meme_img.mime_type,
+            :size => File.size(meme_fs_path),
+
+            :source_url => norm_params[:u],
+            :source_fs_path => source_fs_path,
+            :top_text => norm_params[:tt],
+            :bottom_text => norm_params[:tb],
+
+            :request_count => 0,
+
+            :creator_ip => request.ip
+            )
+
+          meme_data.save! :safe => true
+
+          meme_data
+        end
+
+      end
     end
 
     get '/g' do
+      raise Sinatra::NotFound  if params[:u].to_s.empty?
+
       begin
-        processed_cache_path = gen(params)
+        meme_data = gen(params)
 
-        temp_url = URI(request.url)
-        temp_url.path = processed_cache_path.sub('public', '')
-        temp_url.query = nil
+        meme_url = url("/#{meme_data.meme_id}")
 
-        perm_url = URI(request.url)
-        perm_url.path = '/i'
+        template_query = [
+          [:u, meme_data.meme_id],
+          [:tt, meme_data.top_text],
+          [:tb, meme_data.bottom_text],
+          ].map { |k,v|
+            "#{Rack::Utils.escape(k)}=#{Rack::Utils.escape(v)}" }.join('&')
 
         [200, { 'Content-Type' => 'application/json' }, {
-          'tempUrl' => temp_url.to_s,
-          'permUrl' => perm_url.to_s,
+          'tempUrl' => meme_url,
+          'permUrl' => meme_url,
+          'templateUrl' => url("/?#{template_query}"),
         }.to_json]
       rescue => error
         [500, { 'Content-Type' => 'text/plain' }, error.to_s]
       end
     end
 
+    def serve_img(meme_data)
+      meme_data.requested!
+
+      content_type meme_data.mime_type
+
+      FileBody.new meme_data.fs_path
+    end
+
     get '/i' do
-      processed_cache_path = gen(params)
+      raise Sinatra::NotFound  if params[:u].to_s.empty?
+
+      serve_img(gen(params))
+    end
+
+    get %r{^/([a-f0-9]+\.(?:gif|jpg|png))$} do
+      if meme_data = MemeData.find_by_meme_id(params[:captures][0])
+        serve_img meme_data
+      else
+        raise Sinatra::NotFound
+      end
+    end
 
-      content_type MIME::Types.type_for(processed_cache_path)[0].to_s
+    not_found do
+      @root_url = url('/')
 
-      MemeCaptain::FileBody.new(processed_cache_path)
+      erb :'404'
     end
 
     helpers do

data/lib/meme_captain/version.rb

@@ -1,3 +1,3 @@
 module MemeCaptain
-  VERSION = '0.0.8'
+  VERSION = '0.0.9'
 end

data/lib/meme_captain.rb

@@ -2,8 +2,8 @@ require 'meme_captain/caption'
 require 'meme_captain/caption_choice'
 require 'meme_captain/draw'
 require 'meme_captain/file_body'
-require 'meme_captain/filesystem_cache'
+require 'meme_captain/image_list'
 require 'meme_captain/meme'
-require 'meme_captain/mime_type'
+require 'meme_captain/meme_data'
 require 'meme_captain/server'
 require 'meme_captain/version'

data/meme_captain.gemspec

@@ -15,13 +15,17 @@ Gem::Specification.new do |s|
   s.email = %w{matthewm@boedicker.org}
 
   %w{
+    bson_ext
     curb
     json
     mime-types
+    mongo
+    mongo_mapper
     rack
     rmagick
     sinatra
     }.each { |g| s.add_dependency g }
 
   s.files = `git ls-files`.split("\n")
+  s.executables = %w{memecaptain}
 end