useless-museum 1.2.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 98f22e2e08471ec4ead397a73c79909897b0874a
+  data.tar.gz: 4e0d973edf0d8f32469f21d38fb55952bf4dee5e
+SHA512:
+  metadata.gz: 95056d8612069499e3e89d68eea0bdf9a51e0e24940cbe8d2df632467c9fdabe5bcab6d5ea4539ab59072ae355962e5f34cedc3c9d5a4a6f0306788cf56f9190
+  data.tar.gz: 59fc975e3558874f1d79497ac36cd2734a6f5d2bd733124cddaa5ca44cbbb71cfa0e9ee30f95ea0663e35725aa4ea376a49502a631b494b07b57dd74e04b5b85

data/.gitignore

@@ -0,0 +1,3 @@
+Gemfile.lock
+log/*.log
+tmp/

data/.rbenv-version

@@ -0,0 +1 @@
+2.0.0-p0

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/RESEARCH.md

@@ -0,0 +1,5 @@
+http://en.wikipedia.org/wiki/Museum_studies
+http://en.wikipedia.org/wiki/Cultural_informatics
+http://en.wikipedia.org/wiki/Folksonomy
+http://en.wikipedia.org/wiki/.museum
+http://www.steve.museum/

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/useless/museum/image.rb

@@ -0,0 +1,112 @@
+require 'mini_magick'
+require 'exifr'
+
+module Useless
+  class Museum
+    # Museum::Image is a utility class that provides two types of
+    # functionality:
+    #   * image resizing based upon the Useless::Musuem specifications
+    #   * access to the following image metadata: latitude, longitude, shot_at
+    # It takes an IO object upon initialization. The resize methods return
+    # instances of MiniMagick::Image.
+    class Image
+      def initialize(raw_io)
+        @raw_io = raw_io
+      end
+
+      # MiniMagick::Image for the original image
+      def base
+        @base ||= minimagick_copy
+      end
+
+      # Only JPEGs are considered valid
+      def valid?
+        base and ['JPEG', 'TIFF', 'PNG', 'GIF'].include?(base['format'])
+      end
+
+      # A 'small' image's longest side is 100 pixels,
+      def small
+        @small ||= version('100x100')
+      end
+
+      # 'medium' is 500 pixels
+      def medium
+        @medium ||= version('500x500')
+      end
+
+      # and 'large' is 1024 pixels
+      def large
+        @large ||= version('1024x1024')
+      end
+
+      # Just grab latitude
+      def latitude
+        @latitude ||= exifr.gps.latitude if exifr and exifr.gps
+      end
+
+      # and longitude from EXIFR
+      def longitude
+        @longitude ||= exifr.gps.longitude if exifr and exifr.gps
+      end
+
+      # Shot at is just the date_time provide from EXIFR
+      def shot_at
+        @shot_at ||= exifr.date_time if exifr
+      end
+
+      private
+
+      # An EXIFR::JPEG instance, which provides access to the image metadata.
+      def exifr
+        return nil unless base
+
+        @exifr ||= case base['format']
+          when 'JPEG' then EXIFR::JPEG.new(StringIO.new(blob))
+          when 'TIFF' then EXIFR::TIFF.new(StringIO.new(blob))
+          else nil
+          end
+      end
+
+      def version(dimensions)
+        # Copy the image if possible,
+        if image = minimagick_copy
+
+          # resize it to the specified dimensions
+          image.resize dimensions
+
+          # and return
+          image
+        end
+      end
+
+      def minimagick_copy
+        # Just instantiate a new instance with the raw image blob.
+        MiniMagick::Image.read(blob)
+
+        # If the 'image' cannot be parsed,
+      rescue MiniMagick::Invalid
+
+        # just return nil
+        nil
+      end
+
+      # A binary blob of the original image
+      def blob
+        @blob ||= begin
+          # Make sure the pointer is up front,
+          @raw_io.rewind
+
+          # read the bytes,
+          blob = @raw_io.read
+
+          # make sure they're un-encoded (encodings can cause multiple bytes to
+          # be interpreted as one, which is no good for images),
+          blob.force_encoding('BINARY')
+
+          # and return
+          blob
+        end
+      end
+    end
+  end
+end

data/lib/useless/museum/version.rb

@@ -0,0 +1,5 @@
+module Useless
+  class Museum
+    VERSION = '1.2.3'
+  end
+end

data/lib/useless/museum.rb

@@ -0,0 +1,158 @@
+require 'sinatra/base'
+require 'json'
+
+require 'useless/doc/server/sinatra'
+require 'useless/rack/files'
+
+module Useless
+  class Museum < Sinatra::Base
+    require 'useless/museum/image'
+    require 'useless/museum/version'
+
+    use Useless::Rack::Files
+
+    register Useless::Doc::Server::Sinatra
+
+    enable :raise_errors
+    disable :show_exceptions, :dump_errors
+    set :logging, nil
+
+    doc 'Museum' do
+      url 'http://museum.useless.io'
+
+      description <<-DESC
+        The Museum of Whatever
+      DESC
+    end
+
+    get '/' do
+      redirect 'http://museum.doc.useless.io'
+    end
+
+    doc.get '/photos/:id' do
+      description 'Retrieve information about a photo.'
+      authentication_required false
+      parameter 'id', 'The ID of the desired photo.', type: 'path'
+
+      response 404, 'A photo with the specified ID could not be found.'
+      response 200, 'The photo was returned successfully.' do
+        body do
+          content_type 'application/json'
+          attribute 'id', 'The ID of the photo.'
+          attribute 'file_urls',
+            ['An object containing each of files of the photo\'s sizes. "small" has a',
+             'longest side of 100 pixels, "medium" has a longest side of 500 pixels and',
+             '"large" has a longest side of 1024 pixels.'].join("\n"), type: 'object'
+          attribute 'latitude', 'The latitude where the photo was shot.', type: 'number'
+          attribute 'longitude', 'The longitude where the photo was shot.', type: 'number'
+          attribute 'shot_at', 'The date and time when the photo was shot.'
+          attribute 'description', 'A description of the photo provided by the owner.'
+          attribute 'created_by', 'The user who created the photo.', type: 'object'
+          attribute 'created_at', 'When the photo was created.'
+        end
+      end
+    end
+
+    get '/photos/:id' do
+      return 404 unless BSON::ObjectId.legal?(params[:id])
+
+      id = BSON::ObjectId.from_string(params[:id])
+      if record = env['useless.mongo']['museum.photos'].find_one(id)
+        photo_json(record)
+      else
+        404
+      end
+    end
+
+    doc.post '/photos' do
+      description 'Create a new photo.'
+      authentication_required true
+
+      body do
+        content_type 'multipart/form-data'
+        attribute 'photo', 'The actual file for the photo.', type: 'file'
+        attribute 'latitude',
+          ['The latitude where the photo was taken. Only required if it cannot be',
+           'extracted from the photo itself. If the information can be extracted,',
+           'this will be ignored.'].join("\n"),
+          required: false, type: 'number', default: 'value extracted from photo'
+        attribute 'longitude', 'The longitude where the photo was taken. Follows the same rules as latitude.',
+          required: false, type: 'number', default: 'value extracted from photo'
+        attribute 'shot_at', 'The time that the photo was taken. Follows the same rules as latitude and longitude.',
+          required: false, default: 'value extracted from photo'
+        attribute 'description', 'The description of the photo.', required: false, default: nil
+      end
+
+      response 201, 'The photo was created successfully.' do
+        header 'Location', 'The URL of the new photo.'
+      end
+      response 401, 'The request could not be authenticated.'
+      response 422, 'latitude, longitude or shot_at could not be extracted from the photo. ' +
+                    'Retry with the latitude, longitude and shot_at attributes specified.'
+      response 422, 'Invalid image format. Format must be one of JPEG, TIFF, PNG or GIF.'
+    end
+
+    post '/photos' do
+      unless env['useless.user']
+        halt 401, 'The request could not be authenticated.'
+      end
+
+      unless params[:file]
+        halt 422, 'File is a required parameter.'
+      end
+
+      file = params[:file][:tempfile]
+      image = Image.new(file)
+
+      unless image.valid?
+        halt 422, 'Invalid image format. Format must be one of JPEG, TIFF, PNG or GIF.'
+      end
+
+      document = {}
+      document['latitude'] = image.latitude || params[:latitude]
+      document['longitude'] = image.longitude || params[:longitude]
+      document['shot_at'] = image.shot_at || (params[:shot_at] && Time.parse(params[:shot_at]))
+
+      unless document['latitude'] and document['longitude'] and document['shot_at']
+        halt 422, 'latitude, longitude or shot_at could not be extracted from the photo. ' +
+                  'Retry with the latitude, longitude and shot_at attributes specified.'
+      end
+
+      document['file_url'] = {
+        'small' =>  create_image_url(image.small),
+        'medium' => create_image_url(image.medium),
+        'large' =>  create_image_url(image.large)
+      }
+      document['description'] = params[:description]
+      document['created_by_id'] = env['useless.user']['_id']
+      document['created_at'] = document['updated_at'] = Time.now
+      photo_id = env['useless.mongo']['museum.photos'] << document
+
+      status 201
+      headers 'Location' => "http://museum.useless.io/photos/#{photo_id}"
+      content_type 'application/json'
+      photo_json(document)
+    end
+
+    def photo_json(raw_record)
+      record = raw_record.dup
+
+      record['id'] = record.delete('_id').to_s
+
+      record['shot_at'] = raw_record['shot_at'].iso8601
+      record['created_at'] = raw_record['created_at'].iso8601
+      record['updated_at'] = raw_record['updated_at'].iso8601
+
+      created_by_id = record.delete('created_by_id')
+      created_by = env['useless.mongo']['users'].find_one(created_by_id)
+      record['created_by'] = {'id' => created_by_id.to_s, 'handle' => created_by['handle']}
+
+      record.to_json
+    end
+
+    def create_image_url(image)
+      id = env['useless.fs'].put(image.to_blob, content_type: image.mime_type)
+      "http://museum.useless.io/files/#{id}"
+    end
+  end
+end

data/spec/documentation_spec.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'useless'
+require 'oj'
+
+describe 'museum.useless.io Documentation' do
+  include Rack::Test::Methods
+
+  def app
+    Useless::Rack.new do
+      map 'museum' => Useless::Museum
+    end
+  end
+
+  describe 'OPTIONS /' do
+    it 'should return JSON for the full API documentation' do
+      options 'http://museum.useless.io/'
+      last_response.status.should == 200
+      doc = Oj.load(last_response.body)
+      doc['name'].should == 'Museum'
+      doc['url'].should == 'http://museum.useless.io'
+      doc['resources'].length.should == 2
+    end
+  end
+
+  describe 'OPTIONS /photos/:id' do
+    it 'should return JSON for the resource documentation' do
+      options 'http://museum.useless.io/photos/:id'
+      last_response.status.should == 200
+      doc = Oj.load(last_response.body)
+      doc['path'].should == '/photos/:id'
+    end
+  end
+
+  describe 'OPTIONS /photos' do
+    it 'should return JSON for the resource documentation' do
+      options 'http://museum.useless.io/photos'
+      last_response.status.should == 200
+      doc = Oj.load(last_response.body)
+      doc['path'].should == '/photos'
+    end
+  end
+end

data/spec/museum/image_spec.rb

@@ -0,0 +1,95 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Useless::Museum::Image do
+  def image(path = nil)
+    @instance ||= begin
+      file = File.open asset_path(path || 'muffin-milk.jpg')
+      Useless::Museum::Image.new(file)
+    end
+  end
+
+  def assert_image_resize(image, length)
+    if image[:width] > image[:height]
+      image[:width].should == length
+    elsif image[:height] > image[:width]
+      image[:height].should == length
+    else
+      image[:width].should == length and image[:height].should == length
+    end
+  end
+
+  describe '#small' do
+    it 'should return a MiniMagick::Image object whose longest dimension is 100 pixels' do
+      small_image = image.small
+      small_image.should be_a(MiniMagick::Image)
+      assert_image_resize small_image, 100
+    end
+  end
+
+  describe '#medium' do
+    it 'should return a MiniMagick::Image object whose longest dimension is 500 pixels' do
+      medium_image = image.medium
+      medium_image.should be_a(MiniMagick::Image)
+      assert_image_resize medium_image, 500
+    end
+  end
+
+  describe '#large' do
+    it 'should return a MiniMagick::Image object whose longest dimension is 1024 pixels' do
+      large_image = image.large
+      large_image.should be_a(MiniMagick::Image)
+      assert_image_resize large_image, 1024
+    end
+  end
+
+  # These specs aren't particularly useful as you have to go on faith that
+  # muffin-milk.jpg actually has these values embedded - I guess these can act
+  # as a sanity check
+  describe '#latitude' do
+    it 'should return the latitude value exracted from the image' do
+      image.latitude.to_i.should == 40
+    end
+
+    it 'should return nil if the image has no metadata' do
+      image('muffin-milk-stripped.jpg').latitude.should be_nil
+    end
+  end
+
+  describe '#longitude' do
+    it 'should return the latitude value exracted from the image' do
+      image.longitude.to_i.should == -73
+    end
+
+    it 'should return nil if the image has no metadata' do
+      image('muffin-milk-stripped.jpg').longitude.should be_nil
+    end
+  end
+
+  describe '#shot_at' do
+    it 'shoulr return the time that the image was taken' do
+      image.shot_at.should == Time.parse('2011-11-14T02:23:42Z')
+    end
+
+    it 'should return nil if the image has no metadata' do
+      image('muffin-milk-stripped.jpg').shot_at.should be_nil
+    end
+  end
+
+  describe '#valid?' do
+    it 'should return true if the image is a JPEG' do
+      image('muffin-milk.jpg').should be_valid
+    end
+
+    it 'should return true if the image is a PNG' do
+      image('muffin-milk.png').should be_valid
+    end
+
+    it 'should return true if the image is a TIFF' do
+      image('muffin-milk.tiff').should be_valid
+    end
+
+    it 'should return true if the image is a GIF' do
+      image('muffin-milk.gif').should be_valid
+    end
+  end
+end

data/spec/museum_spec.rb

@@ -0,0 +1,150 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'useless'
+
+describe 'museum.useless.io' do
+  include Rack::Test::Methods
+
+  def app
+    Useless::Rack.new do
+      map 'museum' => Useless::Museum
+    end
+  end
+
+  describe 'GET /photos/:id' do
+    it 'should return the record corresponding to the specified ID' do
+      shot_at = Time.now - (24 * 60 * 60)
+      created_at = Time.now
+      user_id = Useless.mongo['users'] << {handle: 'khy'}
+      photo_id = Useless.mongo['museum.photos'] << {
+        file_url: {
+          small: 'http://museum.useless.io/files/abc123',
+          medium: 'http://museum.useless.io/files/def456',
+          large: 'http://museum.useless.io/files/ghi789'
+        },
+        latitude: 71.567,
+        longitude: 48.987,
+        shot_at: shot_at,
+        description: 'An image of the Scientology headquarters',
+        created_by_id: user_id,
+        created_at: created_at,
+        updated_at: created_at
+      }
+
+      get "http://museum.useless.io/photos/#{photo_id}"
+      last_response.should be_ok
+
+      body = JSON.parse(last_response.body)
+      body['id'].should == photo_id.to_s
+      body['file_url']['small'].should == 'http://museum.useless.io/files/abc123'
+      body['file_url']['medium'].should == 'http://museum.useless.io/files/def456'
+      body['file_url']['large'].should == 'http://museum.useless.io/files/ghi789'
+      body['latitude'].should == 71.567
+      body['longitude'].should == 48.987
+      body['shot_at'].should == shot_at.utc.iso8601
+      body['description'].should == 'An image of the Scientology headquarters'
+      body['created_by']['id'].should == user_id.to_s
+      body['created_by']['handle'].should == 'khy'
+      body['created_at'].should == created_at.utc.iso8601
+      body['updated_at'].should == created_at.utc.iso8601
+    end
+
+    it 'should return a 404 Not Found if there is no record corresponding to the specified ID' do
+      get "http://museum.useless.io/photos/#{BSON::ObjectId.new.to_s}"
+      last_response.should be_not_found
+    end
+
+    it 'should return a 404 Not Found if the specified ID is not a valid BSON::ObjectId' do
+      get "http://museum.useless.io/photos/invalid-bson-object-id"
+      last_response.should be_not_found
+    end
+  end
+
+  describe 'POST /photos' do
+    it 'should create a new photo record if latitude, longitude and shot_at are not specified,
+        but can be extracted from the file and the request is authenticated' do
+      user_id = Useless.mongo['users'] << {handle: 'khy', access_token: 'abc123'}
+
+      header 'Authorization', 'abc123'
+      post 'http://museum.useless.io/photos',
+        file: upload_file('muffin-milk.jpg', 'image/jpeg'),
+        description: 'The Muffin Milk Man!'
+
+      last_response.status.should == 201
+      get last_response.header['Location']
+      last_response.should be_ok
+
+      body = JSON.parse(last_response.body)
+      body['latitude'].to_i.should == 40
+      body['longitude'].to_i.should == -73
+      body['shot_at'].should == '2011-11-14T02:23:42Z'
+      body['description'].should == 'The Muffin Milk Man!'
+      body['created_by']['id'].should == user_id.to_s
+      body['created_by']['handle'].should == 'khy'
+      Time.parse(body['created_at']).should be_within(2).of(Time.now)
+      Time.parse(body['updated_at']).should be_within(2).of(Time.now)
+
+      get body['file_url']['small']
+      image = MiniMagick::Image.read(last_response.body)
+      [image[:width], image[:height]].should include(100)
+
+      get body['file_url']['medium']
+      image = MiniMagick::Image.read(last_response.body)
+      [image[:width], image[:height]].should include(500)
+
+      get body['file_url']['large']
+      image = MiniMagick::Image.read(last_response.body)
+      [image[:width], image[:height]].should include(1024)
+    end
+
+    it 'should respond with a 401 Unauthorized if no access code is specified' do
+      post 'http://museum.useless.io/photos',
+        file: upload_file('muffin-milk.jpg', 'image/jpeg'),
+        description: 'The Muffin Milk Man!'
+      last_response.status.should == 401
+      last_response.body.should == 'The request could not be authenticated.'
+    end
+
+    it 'should respond with a 422 Unprocessible Entry if the latitude, longitude and shot at are
+        not specified and cannot be extracted' do
+      user_id = Useless.mongo['users'] << {handle: 'khy', access_token: 'abc123'}
+
+      header 'Authorization', 'abc123'
+      post 'http://museum.useless.io/photos',
+        file: upload_file('muffin-milk-stripped.jpg', 'image/jpeg'),
+        description: 'The Muffin Milk Man!'
+      last_response.status.should == 422
+      last_response.body.should == 'latitude, longitude or shot_at could not be extracted from the photo. Retry with the latitude, longitude and shot_at attributes specified.'
+    end
+
+    it 'should respond with 201 if latitude, longitude and shot_at cannot be extracted but are specified' do
+      user_id = Useless.mongo['users'] << {handle: 'khy', access_token: 'abc123'}
+
+      header 'Authorization', 'abc123'
+      post 'http://museum.useless.io/photos',
+        file: upload_file('muffin-milk-stripped.jpg', 'image/jpeg'),
+        description: 'The Muffin Milk Man!',
+        latitude: 71.567,
+        longitude: 48.987,
+        shot_at: (Time.now - (24 * 60 * 60)).utc.iso8601
+
+      last_response.status.should == 201
+      get last_response.header['Location']
+      last_response.should be_ok
+    end
+
+    it 'should respond with a 422 if the file type is invalid, even if latitude, longitude and shot at are specified' do
+      user_id = Useless.mongo['users'] << {handle: 'khy', access_token: 'abc123'}
+
+      header 'Authorization', 'abc123'
+      post 'http://museum.useless.io/photos',
+        file: upload_file('muffin-milk.txt', 'text/plain'),
+        latitude: 71.567,
+        longitude: 48.987,
+        shot_at: (Time.now - (24 * 60 * 60)).utc.iso8601
+
+      last_response.status.should == 422
+      last_response.body.should == 'Invalid image format. Format must be one of JPEG, TIFF, PNG or GIF.'
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,38 @@
+ENV['RACK_ENV'] = 'test'
+require File.dirname(__FILE__) + '/../lib/useless/museum'
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'rack/test'
+require 'useless/rack'
+
+RSpec.configure do |config|
+  config.order = :rand
+
+  def clean_database
+    Useless.mongo.db.collections.each do |collection|
+      if !(collection.name =~ /^system\./)
+        collection.drop
+      end
+    end
+  end
+
+  config.before(:suite){ clean_database }
+
+  config.after(:each) do
+    clean_database
+
+    # After dropping collections, we need to force a new connection on the
+    # next request.
+    Useless.mongo.reset_connection!
+  end
+
+  def upload_file(path, content_type = nil)
+    Rack::Test::UploadedFile.new(asset_path(path), content_type)
+  end
+
+  def asset_path(path)
+    File.dirname(__FILE__) + '/support/assets/' + path
+  end
+end

data/spec/support/assets/muffin-milk.txt

@@ -0,0 +1 @@
+MUFFIN MILK!

data/useless-museum.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.unshift(File.expand_path('../lib', __FILE__))
+require 'useless/museum'
+
+Gem::Specification.new do |spec|
+  spec.name           = 'useless-museum'
+  spec.version        = Useless::Museum::VERSION
+  spec.authors        = ['Kevin Hyland']
+  spec.email          = ['khy@me.com']
+  spec.summary        = 'The Museum of Whatever'
+  spec.description    = 'The Museum of Whatever'
+  spec.homepage       = 'http://museum.useless.io'
+  spec.license        = 'MIT'
+
+  spec.files          = `git ls-files`.split("\n")
+  spec.test_files     = spec.files.grep(%r{^spec/})
+  spec.require_paths  = ['lib']
+
+  spec.add_runtime_dependency 'sinatra', '~> 1.4.2'
+  spec.add_runtime_dependency 'mini_magick', '~> 3.5.0'
+  spec.add_runtime_dependency 'exifr', '~> 1.1.3'
+  spec.add_runtime_dependency 'useless', '~> 0.2.0'
+  spec.add_runtime_dependency 'useless-doc', '~> 0.6.1'
+
+  spec.add_development_dependency 'rspec', '~> 2.13.0'
+  spec.add_development_dependency 'rack-test', '~> 0.6.2'
+  spec.add_development_dependency 'oj', '~> 2.0.10'
+end

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification
+name: useless-museum
+version: !ruby/object:Gem::Version
+  version: 1.2.3
+platform: ruby
+authors:
+- Kevin Hyland
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+- !ruby/object:Gem::Dependency
+  name: mini_magick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+- !ruby/object:Gem::Dependency
+  name: exifr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.1.3
+- !ruby/object:Gem::Dependency
+  name: useless
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: useless-doc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.2
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.10
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.10
+description: The Museum of Whatever
+email:
+- khy@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rbenv-version
+- Gemfile
+- RESEARCH.md
+- Rakefile
+- lib/useless/museum.rb
+- lib/useless/museum/image.rb
+- lib/useless/museum/version.rb
+- spec/documentation_spec.rb
+- spec/museum/image_spec.rb
+- spec/museum_spec.rb
+- spec/spec_helper.rb
+- spec/support/assets/muffin-milk-stripped.jpg
+- spec/support/assets/muffin-milk.gif
+- spec/support/assets/muffin-milk.jpg
+- spec/support/assets/muffin-milk.png
+- spec/support/assets/muffin-milk.tiff
+- spec/support/assets/muffin-milk.txt
+- useless-museum.gemspec
+homepage: http://museum.useless.io
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: The Museum of Whatever
+test_files:
+- spec/documentation_spec.rb
+- spec/museum/image_spec.rb
+- spec/museum_spec.rb
+- spec/spec_helper.rb
+- spec/support/assets/muffin-milk-stripped.jpg
+- spec/support/assets/muffin-milk.gif
+- spec/support/assets/muffin-milk.jpg
+- spec/support/assets/muffin-milk.png
+- spec/support/assets/muffin-milk.tiff
+- spec/support/assets/muffin-milk.txt