meme_captain 0.1.0 → 0.1.1

data/lib/meme_captain/server.rb

@@ -10,9 +10,16 @@ module MemeCaptain
 
     set :root, File.expand_path(File.join('..', '..'), File.dirname(__FILE__))
     set :source_img_max_side, 800
+    set :upload_prefix, 'up/'
     set :watermark, Magick::ImageList.new(File.expand_path(
       File.join('..', '..', 'watermark.png'), File.dirname(__FILE__)))
 
+    # uncomment this to allow other sites to use this site's backend for
+    # generating images, used to allow third-party static only sites
+    # to generate images using memecaptain.com
+
+    # set :protection, :except => :json_csrf
+
     get '/' do
       @u = params[:u]
 
@@ -33,107 +40,110 @@ module MemeCaptain
       erb :index
     end
 
-    def convert_metric(metric, default)
-      case
-        when metric.to_s.empty?; default
-        when metric.index('.'); metric.to_f
-        else; metric.to_i
-      end
-    end
-
     def normalize_params(p)
-      result = {
-        'u' => p[:u],
-
-         # convert to empty string if null
-        't1' => p[:t1].to_s,
-        't2' => p[:t2].to_s,
-      }
-
-      result['t1x'] = convert_metric(p[:t1x], 0.05)
-      result['t1y'] = convert_metric(p[:t1y], 0)
-      result['t1w'] = convert_metric(p[:t1w], 0.9)
-      result['t1h'] = convert_metric(p[:t1h], 0.25)
-
-      result['t2x'] = convert_metric(p[:t2x], 0.05)
-      result['t2y'] = convert_metric(p[:t2y], 0.75)
-      result['t2w'] = convert_metric(p[:t2w], 0.9)
-      result['t2h'] = convert_metric(p[:t2h], 0.25)
+      result = NormParams.new(p)
 
       # 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
+      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)
+      result
     end
 
     def gen(p)
+      logger.debug "params:\n#{MemeCaptain.pretty_format(p)}"
       norm_params = normalize_params(p)
+      logger.debug 'normalized params:'
+      logger.debug(MemeCaptain.pretty_format(norm_params))
 
       if existing = MemeData.first(
-        :source_url => norm_params[:u],
-
-        'texts.0.text' => norm_params[:t1],
-        'texts.0.x' => norm_params[:t1x],
-        'texts.0.y' => norm_params[:t1y],
-        'texts.0.w' => norm_params[:t1w],
-        'texts.0.h' => norm_params[:t1h],
-
-        'texts.1.text' => norm_params[:t2],
-        'texts.1.x' => norm_params[:t2x],
-        'texts.1.y' => norm_params[:t2y],
-        'texts.1.w' => norm_params[:t2w],
-        'texts.1.h' => norm_params[:t2h]
+        :source_url => norm_params.u,
+
+        'texts.0.text' => norm_params.t1,
+        'texts.0.x' => norm_params.t1x,
+        'texts.0.y' => norm_params.t1y,
+        'texts.0.w' => norm_params.t1w,
+        'texts.0.h' => norm_params.t1h,
+
+        'texts.1.text' => norm_params.t2,
+        'texts.1.x' => norm_params.t2x,
+        'texts.1.y' => norm_params.t2y,
+        'texts.1.w' => norm_params.t2w,
+        'texts.1.h' => norm_params.t2h
         )
+        logger.debug 'found existing meme:'
+        logger.debug(MemeCaptain.pretty_format(existing))
         existing
       else
-        if same_source = MemeData.find_by_source_url(norm_params[:u])
+        if same_source = MemeData.find_by_source_url(norm_params.u)
+          logger.debug 'found existing source image'
           source_fs_path = same_source.source_fs_path
+        elsif (norm_params.u.index(settings.upload_prefix) == 0) and
+          (upload = Upload.find_by_upload_id(
+          norm_params.u[settings.upload_prefix.size..-1]))
+
+          logger.debug 'source image is upload:'
+          logger.debug MemeCaptain.pretty_format(upload)
+          source_fs_path = upload.fs_path
         else
-          if source_fetch_fail = SourceFetchFail.find_by_url(norm_params[:u])
+          if source_fetch_fail = SourceFetchFail.find_by_url(norm_params.u)
+            logger.debug 'skipping fetch of previously failed source image:'
+            logger.debug(MemeCaptain.pretty_format(source_fetch_fail))
             source_fetch_fail.requested!
             halt 500, 'Error loading source image url'
           else
             source_img = ImageList::SourceImage.new
             begin
-              source_img.fetch! norm_params[:u]
+              logger.debug "fetch source image: #{norm_params.u}"
+              source_img.fetch! norm_params.u
             rescue => error
-              SourceFetchFail.new(
+              new_source_fetch_fail = SourceFetchFail.new(
                 :attempt_count => 1,
                 :orig_ip => request.ip,
                 :response_code => error.respond_to?(:response_code) ?
                   error.response_code : nil,
-                :url => norm_params[:u]
-              ).save!
+                :url => norm_params.u
+              )
+              logger.debug 'source image fetch failed:'
+              logger.debug(MemeCaptain.pretty_format(new_source_fetch_fail))
+              new_source_fetch_fail.save!
               halt 500, 'Error loading source image url'
             end
             source_img.prepare! settings.source_img_max_side, settings.watermark
-            source_fs_path = source_img.cache(norm_params[:u], 'source_cache')
+            source_fs_path = source_img.cache(norm_params.u, 'source_cache')
+            source_img.each { |frame| frame.destroy! }
           end
         end
 
+        logger.debug "source image filesystem path: #{source_fs_path}"
+
         open(source_fs_path, 'rb') do |source_io|
-          t1 = TextPos.new(norm_params[:t1], norm_params[:t1x],
-            norm_params[:t1y], norm_params[:t1w], norm_params[:t1h])
+          t1 = TextPos.new(norm_params.t1, norm_params.t1x, norm_params.t1y,
+            norm_params.t1w, norm_params.t1h)
 
-          t2 = TextPos.new(norm_params[:t2], norm_params[:t2x],
-            norm_params[:t2y], norm_params[:t2w], norm_params[:t2h])
+          t2 = TextPos.new(norm_params.t2, norm_params.t2x, norm_params.t2y,
+            norm_params.t2w, norm_params.t2h)
 
           meme_img = MemeCaptain.meme(source_io, [t1, t2])
           meme_img.extend ImageList::Cache
 
+          # convert source images in formats other than jpeg, gif or png
+          # to png
+          unless %w{JPEG GIF PNG}.include?(meme_img.format)
+            meme_img.format = 'PNG'
+          end
+
           # convert non-animated gifs to 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)
+          sig = norm_params.signature
+          meme_hash = Digest::SHA1.hexdigest(sig)
 
           meme_id = nil
           (6..meme_hash.size).each do |len|
@@ -141,7 +151,9 @@ module MemeCaptain
             break  unless MemeData.where(:meme_id => meme_id).count > 0
           end
 
-          meme_fs_path = meme_img.cache(params_s, File.join('public', 'meme'))
+          meme_fs_path = meme_img.cache(sig, File.join('public', 'meme'))
+
+          logger.debug "meme filesystem path: #{meme_fs_path}"
 
           meme_img.write(meme_fs_path) {
             self.quality = 100
@@ -153,21 +165,21 @@ module MemeCaptain
             :mime_type => meme_img.mime_type,
             :size => File.size(meme_fs_path),
 
-            :source_url => norm_params[:u],
+            :source_url => norm_params.u,
             :source_fs_path => source_fs_path,
 
             :texts => [{
-              :text => norm_params[:t1],
-              :x => norm_params[:t1x],
-              :y => norm_params[:t1y],
-              :w => norm_params[:t1w],
-              :h => norm_params[:t1h],
+              :text => norm_params.t1,
+              :x => norm_params.t1x,
+              :y => norm_params.t1y,
+              :w => norm_params.t1w,
+              :h => norm_params.t1h,
               }, {
-              :text => norm_params[:t2],
-              :x => norm_params[:t2x],
-              :y => norm_params[:t2y],
-              :w => norm_params[:t2w],
-              :h => norm_params[:t2h],
+              :text => norm_params.t2,
+              :x => norm_params.t2x,
+              :y => norm_params.t2y,
+              :w => norm_params.t2w,
+              :h => norm_params.t2h,
             }],
 
             :request_count => 0,
@@ -175,6 +187,10 @@ module MemeCaptain
             :creator_ip => request.ip
             )
 
+          meme_img.each { |frame| frame.destroy! }
+
+          logger.debug "meme data:\n#{MemeCaptain.pretty_format(meme_data)}"
+
           meme_data.save! :safe => true
 
           meme_data
@@ -184,15 +200,16 @@ module MemeCaptain
     end
 
     get '/g' do
-      raise Sinatra::NotFound  if params[:u].to_s.empty?
-
       begin
         meme_data = gen(params)
 
         [200, { 'Content-Type' => 'application/json' }, {
-          'imageUrl' => url("/#{meme_data.meme_id}")
+          'imageUrl' => url("/#{meme_data.meme_id}"),
+          'templateUrl' => url("/?u=#{Rack::Utils.escape(meme_data.meme_id)}"),
         }.to_json]
       rescue => error
+        logger.error "error generating image: #{error.class} #{error.message}"
+        logger.error(MemeCaptain.pretty_format(error.backtrace))
         [500, { 'Content-Type' => 'text/plain' }, 'Error generating image']
       end
     end
@@ -200,9 +217,7 @@ module MemeCaptain
     def serve_img(meme_data)
       meme_data.requested!
 
-      content_type meme_data.mime_type
-
-      FileBody.new meme_data.fs_path
+      send_file meme_data.fs_path, :type => meme_data.mime_type
     end
 
     get '/i' do
@@ -219,6 +234,51 @@ module MemeCaptain
       end
     end
 
+    post '/upload' do
+      redirect('/')  unless params[:upload]
+
+      img = ImageList::SourceImage.new
+      img.from_blob(params[:upload][:tempfile].read)
+      img.prepare! settings.source_img_max_side, settings.watermark
+      fs_path = img.cache(params[:upload][:filename], 'source_cache')
+
+      filename_hash = Digest::SHA1.hexdigest(params[:upload][:filename])
+
+      len = 6
+      upload_id = filename_hash[0,len]
+      while Upload.where(:upload_id => upload_id).count > 0
+        upload_id = if len < filename_hash.size
+          len += 1
+          filename_hash[0,len]
+        else
+          "#{upload_id}0"
+        end
+      end
+
+      upload = Upload.new(
+        :upload_id => upload_id,
+        :fs_path => fs_path,
+        :mime_type => img.mime_type,
+        :size => File.size(fs_path),
+        :request_count => 0,
+        :creator_ip => request.ip
+        )
+
+      img.each { |frame| frame.destroy! }
+
+      upload.save! :safe => true
+
+      redirect "/?u=#{settings.upload_prefix}#{Rack::Utils.escape(upload_id)}"
+    end
+
+    get %r{/#{settings.upload_prefix}(.+)} do
+      if upload = Upload.find_by_upload_id(params[:captures][0])
+        serve_img upload
+      else
+        raise Sinatra::NotFound
+      end
+    end
+
     not_found do
       @root_url = url('/')
 

data/lib/meme_captain/upload.rb

@@ -0,0 +1,30 @@
+require 'mongo_mapper'
+
+module MemeCaptain
+
+  # Data about uploaded files.
+  class Upload
+    include MongoMapper::Document
+
+    set_collection_name 'upload'
+
+    key :upload_id, String
+    key :fs_path, String
+    key :mime_type, String
+    key :size, Integer
+
+    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/version.rb

@@ -1,3 +1,3 @@
 module MemeCaptain
-  VERSION = '0.1.0'
+  VERSION = '0.1.1'
 end

data/lib/meme_captain.rb

@@ -1,11 +1,14 @@
 require 'meme_captain/caption'
 require 'meme_captain/caption_choice'
 require 'meme_captain/draw'
-require 'meme_captain/file_body'
 require 'meme_captain/image_list'
 require 'meme_captain/meme'
+require 'meme_captain/memebg'
 require 'meme_captain/meme_data'
+require 'meme_captain/norm_params'
+require 'meme_captain/pretty_format'
 require 'meme_captain/server'
 require 'meme_captain/source_fetch_fail'
 require 'meme_captain/text_pos'
+require 'meme_captain/upload'
 require 'meme_captain/version'

data/meme_captain.gemspec

@@ -22,6 +22,7 @@ Gem::Specification.new do |s|
     mongo
     mongo_mapper
     rack
+    rack-contrib
     rack-rewrite
     rmagick
     sinatra
@@ -29,6 +30,7 @@ Gem::Specification.new do |s|
 
   %w{
     rspec
+    webmock
     }.each { |g| s.add_development_dependency g }
 
   s.files = `git ls-files`.split("\n")

data/public/css/screen.css

@@ -4,6 +4,10 @@ body {
   font-family : verdana, helvetica, arial, sans-serif;
 }
 
+a img {
+  border : 0;
+}
+
 a:link {
   color : #edfc72;
 }
@@ -64,3 +68,13 @@ input[type=text] {
 input[type=button] {
   padding : 4px 8px 4px 8px;
 }
+
+input[type=text].attn {
+  background-color : #a7e464;
+}
+
+div.share {
+  display : inline-block;
+  margin-right : 1em;
+  vertical-align : middle;
+}