meme_captain 0.2.0 → 0.3.0

data/doc/lightweight_front_end.md

@@ -1,64 +0,0 @@
-If you want to host your own custom Meme Captain site but do not want to set
-up the ruby backend you can use the memecaptain.com backend. In this scenario,
-the HTML, Javscript and CSS are hosted on your web server and the meme images
-are created on and hosted on memecaptain.com.
-
-This is an option if you are on shared hosting and do not have access to
-ruby or MongoDB or do not want to deal with setting them up.
-
-Download the files at these locations and save them in your document root:
-
-* http://memecaptain.com/
-* http://memecaptain.com/css/screen.css
-* http://memecaptain.com/js/fabric.min.js
-* http://memecaptain.com/js/meme_captain.js
-* http://memecaptain.com/source_images.json
-
-The css in js should go in css and js directories in your document root so
-that they match the url paths.
-
-Find this line in js/meme_captain.js
-
-```
-genUrl = '/g',
-```
-
-and change it to
-
-```
-genUrl = 'http://memecaptain.com/g',
-```
-
-# Changing the Default Source Images
-
-The source image thumbnails that show up on the page are driven by a JSON
-description and a single image that contain CSS sprites. The JSON and image
-must be regenerated to change them.
-
-The rmagick ruby gem must be installed:
-
-```sh
-gem install rmagick
-```
-
-Get and run the script:
-
-```sh
-wget https://raw.github.com/mmb/meme_captain/master/script/thumb_sprites.rb
-RUBYOPT='r rubygems'
-ruby thumb_sprites.rb -u URL_ROOT -s SOURCE_URL_PREFIX SOURCE_IMAGE_PATH/*
-```
-
-SOURCE_IMAGE_PATH is the directory where the source images are stored.
-URL_ROOT is the root url of the Meme Captain installation. SOURCE_URL_PREFIX
-is the part between the root url and the image filenames in the image urls.
-
-For example if the images are stored in /var/www/meme.com/source and the
-url root is http://meme.com/, use:
-
-```sh
-ruby thumb_sprites.rb -u http://meme.com/ -s source/ /var/www/meme.com/source/*
-```
-
-Copy the generated source_images.json and thumbs_xxx.jpg files to the Meme
-Captain document root.

data/doc/setup.md

@@ -1,13 +0,0 @@
-# Requirements
-
-* a Ruby/Rack web application environment (such as
-[Passenger](http://www.modrails.com/))
-
-* Ruby gem dependencies (see the gemspec)
-
-* [MongoDB](http://www.mongodb.org/)
-
-You will most likely need a dedicated or virtual private server to run
-MongoDB as most shared hosting does not support it. See the lightweight front
-end document for how host the static HTML/CSS/Javascript only and use
-memecaptain.com for the backend.

data/lib/meme_captain/image_list/cache.rb

@@ -1,49 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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/'
-          c.follow_location = true
-          c.max_redirects = 3
-        end
-        unless curl.response_code == 200
-          raise FetchError.new(curl.response_code)
-        end
-
-        from_blob curl.body_str
-      end
-      
-    end
-
-  end
-
-end

data/lib/meme_captain/image_list/fetch_error.rb

@@ -1,17 +0,0 @@
-module MemeCaptain
-
-  module ImageList
-
-    # Error for source image fetch failures.
-    class FetchError < StandardError
-
-      def initialize(response_code)
-        @response_code = response_code
-      end
-
-      attr_accessor :response_code    
-    end
-
-  end
-
-end

data/lib/meme_captain/image_list/source_image.rb

@@ -1,30 +0,0 @@
-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)
-        auto_orient!
-
-        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/meme_data.rb

@@ -1,33 +0,0 @@
-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 :texts, Array
-
-    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/norm_params.rb

@@ -1,92 +0,0 @@
-module MemeCaptain
-
-  # Normalize query string parameters.
-  #
-  # Provide defaults, do some basic validation and convert some parameters
-  # to floats or integers.
-  class NormParams
-
-    def initialize(params={})
-      @u = ''
-      
-      @t1 = ''
-      @t2 = ''
-
-      @t1x = 0.05
-      @t1y = 0
-      @t1w = 0.9
-      @t1h = 0.25
-
-      @t2x = 0.05
-      @t2y = 0.75
-      @t2w = 0.9
-      @t2h = 0.25
-
-      load params
-    end
-
-    # Load query string parameters.
-    #
-    # Do some basic validation and convert some parameters to floats or
-    # integers.
-    def load(params)
-      params.select { |k,v|
-        [
-         :u,
-         :t1,
-         :t2,
-        ].include? k.to_sym }.each do |k,v|
-          send "#{k}=", v.to_s
-        end
-
-      params.select { |k,v|
-        [
-         :t1x,
-         :t1y,
-         :t1w,
-         :t1h,
-
-         :t2x,
-         :t2y,
-         :t2w,
-         :t2h,
-        ].include?(k.to_sym) and !v.to_s.empty? }.each do |k,v|
-          send "#{k}=", convert_metric(v)
-        end
-    end
-
-    # Return a sorted string representation of the fields.
-    def signature
-      instance_variables.sort.map { |v|
-        name = v[1..-1] # remove @
-        "#{name}#{instance_variable_get(v)}"
-      }.join
-    end
-
-    attr_accessor :u
-
-    attr_accessor :t1
-    attr_accessor :t2
-
-    attr_accessor :t1x
-    attr_accessor :t1y
-    attr_accessor :t1w
-    attr_accessor :t1h
-
-    attr_accessor :t2x
-    attr_accessor :t2y
-    attr_accessor :t2w
-    attr_accessor :t2h
-
-    private
-
-    # Convert a metric string to a float or integer.
-    #
-    # Expects a string.
-    def convert_metric(metric)
-      metric.index('.') ? metric.to_f : metric.to_i
-    end
-
-  end
-
-end

data/lib/meme_captain/pretty_format.rb

@@ -1,12 +0,0 @@
-require 'pp'
-
-module MemeCaptain
-
-  module_function
-
-  # Format an object like pp would would and return the formatted string.
-  def pretty_format(o)
-    PP.pp o, dump = ''
-  end
-
-end

data/lib/meme_captain/server.rb

@@ -1,303 +0,0 @@
-require 'digest/sha1'
-
-require 'json'
-require 'rack'
-require 'sinatra/base'
-
-module MemeCaptain
-
-  class Server < Sinatra::Base
-
-    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]
-
-      @t1 = params[:t1]
-      @t1x = params[:t1x]
-      @t1y = params[:t1y]
-      @t1w = params[:t1w]
-      @t1h = params[:t1h]
-
-      @t2 = params[:t2]
-      @t2x = params[:t2x]
-      @t2y = params[:t2y]
-      @t2w = params[:t2w]
-      @t2h = params[:t2h]
-
-      @root_url = url('/')
-
-      erb :index
-    end
-
-    def normalize_params(p)
-      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
-        end
-      end
-
-      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
-        )
-        logger.debug 'found existing meme:'
-        logger.debug(MemeCaptain.pretty_format(existing))
-        existing
-      else
-        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)
-            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
-              logger.debug "fetch source image: #{norm_params.u}"
-              source_img.fetch! norm_params.u
-            rescue => error
-              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
-              )
-              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_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)
-
-          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
-
-          sig = norm_params.signature
-          meme_hash = Digest::SHA1.hexdigest(sig)
-
-          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(sig, File.join('public', 'meme'))
-
-          logger.debug "meme filesystem path: #{meme_fs_path}"
-
-          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,
-
-            :texts => [{
-              :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,
-            }],
-
-            :request_count => 0,
-
-            :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
-        end
-
-      end
-    end
-
-    get '/g' do
-      begin
-        meme_data = gen(params)
-
-        [200, { 'Content-Type' => 'application/json' }, {
-          '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
-
-    def serve_img(meme_data)
-      meme_data.requested!
-
-      if meme_data.respond_to?(:texts)
-        meme_text = meme_data.texts.map do |text|
-          Rack::Utils.escape(text['text'])
-        end.join('&')
-
-        headers 'Meme-Text' => meme_text
-      end
-
-      send_file meme_data.fs_path, :type => meme_data.mime_type
-    end
-
-    get '/i' do
-      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
-
-    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('/')
-
-      erb :'404'
-    end
-
-    helpers do
-      include Rack::Utils
-      alias_method :h, :escape_html
-    end
-
-  end
-
-end