carrierwave-postgresql 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1,2 @@
+--format d
+--colour

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+gem 'carrierwave', "~> 0.6.2"
+
+group :development do
+  gem "activerecord", "~> 3.2.8"
+  gem "pg"
+  gem "rspec", "~> 2.11.0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.2.1"
+  gem "jeweler", "~> 1.8.4"
+end

data/Gemfile.lock

@@ -0,0 +1,54 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.2.8)
+      activesupport (= 3.2.8)
+      builder (~> 3.0.0)
+    activerecord (3.2.8)
+      activemodel (= 3.2.8)
+      activesupport (= 3.2.8)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activesupport (3.2.8)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    arel (3.0.2)
+    builder (3.0.0)
+    carrierwave (0.6.2)
+      activemodel (>= 3.2.0)
+      activesupport (>= 3.2.0)
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    i18n (0.6.1)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.5)
+    multi_json (1.3.6)
+    pg (0.14.0)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.3)
+    tzinfo (0.3.33)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 3.2.8)
+  bundler (~> 1.2.1)
+  carrierwave (~> 0.6.2)
+  jeweler (~> 1.8.4)
+  pg
+  rdoc (~> 3.12)
+  rspec (~> 2.11.0)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Diogo Biazus
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,117 @@
+# carrierwave-postgresql
+
+This gem adds to [CarrierWave](https://github.com/jnicklas/carrierwave/) a storage facility which will use the PostgreSQL's oid datatype to reference a large object residing in the databse. It supports up to 2GB files, though it's better suited for smaller ones. Makes life easier for fast prototyping and put all your data in the same place, allows one backup for all your data and file storage in heroku servers.
+
+For more information on PostgreSQL Large Objects you can take a look at the [oficial docs](http://www.postgresql.org/docs/9.2/static/largeobjects.html)
+
+## Installation
+
+Install the latest release:
+
+    gem install carrierwave-postgresql
+
+Require it in your code:
+
+    require 'carrierwave/postgresql'
+
+Or, in Rails you can add it to your Gemfile:
+
+    gem 'carrierwave-postgresql'
+
+## Getting Started
+
+First, this extension assumes 2 important things:
+
+ * You are using CarrierWave with ActiveRecord
+ * Your database is PostgreSQL
+
+If you fill the above requirements then you can proceed to the wonderful land of database stored files!
+
+Start off by generating an uploader:
+
+	rails generate uploader Avatar
+
+this should give you a file in:
+
+	app/uploaders/avatar_uploader.rb
+
+You can configure Carrierwave to use PostgreSQL Large Objects instead of the filesystem.
+Just change your uploader storage to `:postgresql_lo` as in:
+
+```ruby
+class AvatarUploader < CarrierWave::Uploader::Base
+  storage :postgresql_lo
+end
+```
+
+Add an oid column to the model you want to mount the uploader on:
+
+```ruby
+add_column :users, :avatar, :oid
+```
+
+*IMPORTANT:* The table contains only an oid, which is a number referencing the large object. The file content is stored in a separate table. This is nice because it does not genrate any problem with SELECT * statements and it gives us a nice file-like interface to the large object.
+
+Open your model file and mount the uploader:
+
+```ruby
+class User < ActiveRecord::Base
+  mount_uploader :avatar, AvatarUploader
+end
+```
+
+Now you can cache files by assigning them to the attribute, they will
+automatically be stored sinside the database using the Large Object facility when the record is saved.
+
+```ruby
+u = User.new
+u.avatar = params[:file]
+u.avatar = File.open('somewhere')
+u.save!
+u.avatar.url # => '/url/to/file.png'
+u.avatar.current_path # => 'path/to/file.png'
+u.avatar.identifier # => 'file.png'
+```
+
+For more info on CarrierWave take a look at the main [Carrierwave repository](https://raw.github.com/jnicklas/carrierwave/).
+
+
+## How to stream the files from the web server
+
+Since carrierwave-postgresql doesn't make the files available via HTTP, you'll need to stream
+them yourself. In Rails for example, you could use the `send_data` method.
+
+The url that will be available from the field where you mounted the uploader will be the model name followed by the attribute name and with the oid as the resource id.
+
+For instance, in the user's avatar example the url for an image with 1 as it's oid would be `/user_avatar/1`
+
+You can retrieve the file contents using the following code:
+
+```ruby
+u = User.new
+u.avatar = params[:file]
+u.avatar = File.open('somewhere')
+u.save!
+u.avatar.file.read
+```
+
+## Contributing to carrierwave-postgresql
+ 
+ * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+ * Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+ * Fork the project.
+ * Start a feature/bugfix branch.
+ * Commit and push until you are happy with your contribution.
+ * Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+ * Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+## Acknowledgments
+
+This code is largely based on [carrierwave-mongoid](https://github.com/jnicklas/carrierwave-mongoid)
+I wanted to thank (jnicklas)[https://github.com/jnicklas] for all the open source code and for the great (and extensible) architecture of CarrierWave.
+
+## Copyright
+
+Copyright (c) 2012 Diogo Biazus. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "carrierwave-postgresql"
+  gem.homepage = "http://diogob.github.com/carrierwave-postgresql/"
+
+  gem.license = "MIT"
+  gem.summary = %Q{Use PostgreSQL large objects (AKA BLOBs) to store your files inside the database}
+  gem.description = %Q{This gem adds to carrierwave a storage facility which will use the PostgreSQL's oid datatype to reference a large object residing in the databse. It supports up to 2GB files, though it's better suited for smaller ones. Makes life easier for fast prototyping and put all your data in the same place, allows one backup for all your data and file storage in heroku servers.}
+  gem.email = "diogo@biazus.me"
+  gem.authors = ["Diogo Biazus"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "carrierwave-postgresql #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/carrierwave-postgresql.gemspec

@@ -0,0 +1,75 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "carrierwave-postgresql"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Diogo Biazus"]
+  s.date = "2012-09-28"
+  s.description = "This gem adds to carrierwave a storage facility which will use the PostgreSQL's oid datatype to reference a large object residing in the databse. It supports up to 2GB files, though it's better suited for smaller ones. Makes life easier for fast prototyping and put all your data in the same place, allows one backup for all your data and file storage in heroku servers."
+  s.email = "diogo@biazus.me"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "carrierwave-postgresql.gemspec",
+    "lib/carrierwave-postgresql.rb",
+    "lib/carrierwave/postgresql.rb",
+    "lib/carrierwave/storage/postgresql_lo.rb",
+    "spec/fixtures/test.jpg",
+    "spec/spec_helper.rb",
+    "spec/storage/file_spec.rb",
+    "spec/storage/postgresql_lo_spec.rb",
+    "spec/support/active_record.rb",
+    "spec/support/mock_files.rb"
+  ]
+  s.homepage = "http://diogob.github.com/carrierwave-postgresql/"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.24"
+  s.summary = "Use PostgreSQL large objects (AKA BLOBs) to store your files inside the database"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<carrierwave>, ["~> 0.6.2"])
+      s.add_development_dependency(%q<activerecord>, ["~> 3.2.8"])
+      s.add_development_dependency(%q<pg>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.11.0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.2.1"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.4"])
+    else
+      s.add_dependency(%q<carrierwave>, ["~> 0.6.2"])
+      s.add_dependency(%q<activerecord>, ["~> 3.2.8"])
+      s.add_dependency(%q<pg>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.11.0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["~> 1.2.1"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+    end
+  else
+    s.add_dependency(%q<carrierwave>, ["~> 0.6.2"])
+    s.add_dependency(%q<activerecord>, ["~> 3.2.8"])
+    s.add_dependency(%q<pg>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.11.0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["~> 1.2.1"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.4"])
+  end
+end
+

data/lib/carrierwave-postgresql.rb

@@ -0,0 +1,3 @@
+# encoding: utf-8
+
+require 'carrierwave/postgresql'

data/lib/carrierwave/postgresql.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'carrierwave'
+require 'carrierwave/storage/postgresql_lo'
+
+module CarrierWave
+  module Postgresql
+  end
+end
+
+CarrierWave::Storage.autoload :PostgresqlLo, 'carrierwave/storage/postgresql_lo'
+CarrierWave::Uploader::Base.storage_engines[:postgresql_lo] = "CarrierWave::Storage::PostgresqlLo"

data/lib/carrierwave/storage/postgresql_lo.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+module CarrierWave
+  module Storage
+    class PostgresqlLo < Abstract
+      class File
+        def initialize(uploader)
+          @uploader = uploader
+        end
+
+        def url
+          "/#{@uploader.model.class.name.downcase}_#{@uploader.mounted_as.downcase}/#{identifier}"
+        end
+
+        def read
+          @uploader.model.transaction do
+            lo = connection.lo_open(identifier)
+            content = connection.lo_read(lo, file_length)
+            connection.lo_close(lo)
+            content
+          end
+        end
+
+        def write(file)
+          @uploader.model.transaction do
+            lo = connection.lo_open(identifier, ::PG::INV_WRITE)
+            size = connection.lo_write(lo, file.read)
+            connection.lo_close(lo)
+            size
+          end
+        end
+
+        def delete
+          connection.lo_unlink(identifier)
+        end
+
+        def content_type
+        end
+
+        def file_length
+          @uploader.model.transaction do
+            lo = connection.lo_open(identifier)
+            size = connection.lo_lseek(lo, 0, 2)
+            connection.lo_close(lo)
+            size
+          end
+        end
+
+        alias :size :file_length
+
+        def connection
+          @connection ||= @uploader.model.connection.raw_connection
+        end
+
+        def identifier
+          @oid ||= @uploader.identifier
+        end
+
+      end
+
+      def store!(file)
+        raise "This uploader must be mounted in an ActiveRecord model to work" unless uploader.model
+        stored = CarrierWave::Storage::PostgresqlLo::File.new(uploader)
+        stored.write(file)
+        stored
+      end
+
+      def retrieve!(identifier)
+        raise "This uploader must be mounted in an ActiveRecord model to work" unless uploader.model
+        CarrierWave::Storage::PostgresqlLo::File.new(uploader)
+      end
+
+      def identifier
+        @oid ||= uploader.model.read_attribute(uploader.mounted_as) || connection.lo_creat
+      end
+
+      def connection
+        @connection ||= uploader.model.connection.raw_connection
+      end
+    end
+  end
+end

data/spec/fixtures/test.jpg

@@ -0,0 +1 @@
+this is stuff

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'carrierwave-postgresql'
+require 'tempfile'
+
+require 'carrierwave'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+

data/spec/storage/file_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe CarrierWave::Storage::PostgresqlLo::File do
+  let(:test_model){ Test.new }
+  let(:uploader){ mock('an uploader', :model => test_model, :identifier => 0, :mounted_as => :file) }
+  let(:file){ CarrierWave::Storage::PostgresqlLo::File.new(uploader) }
+  let(:tempfile){ stub_tempfile('test.jpg', 'application/xml') }
+
+  describe "#delete" do
+    before do
+      file.connection.should_receive(:lo_unlink).with(0)
+    end
+    it("should delete the file using the lo interface"){ file.delete }
+  end
+
+  describe "#url" do
+    subject{ file.url }
+    it{ should == "/test_file/0" }
+  end
+
+  describe "#write" do
+    before do
+      file.connection.should_receive(:lo_open).with(0, ::PG::INV_WRITE).and_return(2)
+      file.connection.should_receive(:lo_close).with(2)
+      file.connection.should_receive(:lo_write).with(2, "this is stuff").and_return(42)
+    end
+    it("should write the file using the lo interface"){ file.write(tempfile).should == 42 }
+  end
+
+  describe "#file_length" do
+    before do
+      file.connection.should_receive(:lo_open).with(0).and_return(1)
+      file.connection.should_receive(:lo_close).with(1)
+      file.connection.should_receive(:lo_lseek).with(1, 0, 2).and_return(42)
+    end
+    it("should return the file size"){ file.file_length.should == 42 }
+  end
+
+  describe "#read" do
+    before do
+      file.connection.should_receive(:lo_open).with(0).and_return(1)
+      file.connection.should_receive(:lo_close).with(1)
+      file.should_receive(:file_length).and_return(42)
+      file.connection.should_receive(:lo_read).with(1, 42).and_return('file content')
+    end
+
+    it("should read the file using the lo interface"){ file.read.should == 'file content' }
+  end
+end

data/spec/storage/postgresql_lo_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe CarrierWave::Storage::PostgresqlLo do
+  let(:storage){ CarrierWave::Storage::PostgresqlLo.new(uploader) }
+  let(:file){ stub_tempfile('test.jpg', 'application/xml') }
+  let(:test_model){ Test.new }
+
+  describe "#retrieve!" do
+    context "when we do not have it mounted" do
+      let(:uploader){ mock('an uploader', :model => nil) }
+      it("should raise error if not mounted"){ ->{ storage.store!(file) }.should raise_error("This uploader must be mounted in an ActiveRecord model to work") }
+    end
+
+    context "when we have it mounted" do
+      let(:uploader){ mock('an uploader', :model => test_model, :mounted_as => :file) }
+      let(:lo){ storage.store!(file) }
+      before do
+        uploader.stub(:identifier) do
+          storage.identifier
+        end
+      end
+      subject{ storage.retrieve! lo.identifier }
+      its(:read){ should == "this is stuff" }
+    end
+  end
+
+  describe "#store!" do
+    context "when we do not have it mounted" do
+      let(:uploader){ mock('an uploader', :model => nil) }
+      it("should raise error if not mounted"){ ->{ storage.store!(file) }.should raise_error("This uploader must be mounted in an ActiveRecord model to work") }
+    end
+
+    context "when we have it mounted" do
+      let(:uploader){ mock('an uploader', :model => test_model, :mounted_as => :file) }
+      let(:lo){ storage.store!(file) }
+      before do
+        uploader.stub(:identifier) do
+          storage.identifier
+        end
+      end
+      subject{ lo }
+      its(:read){ should == "this is stuff" }
+    end
+  end
+end

data/spec/support/active_record.rb

@@ -0,0 +1,18 @@
+require 'active_record'
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    ActiveRecord::Base.establish_connection(
+      :adapter  => 'postgresql',
+      :database => 'carrierwave_test',
+      :username => 'postgres',
+      :password => 'password',
+      :host     => 'localhost')
+    ActiveRecord::Base.connection.execute "DROP TABLE IF EXISTS tests;"
+    ActiveRecord::Base.connection.execute "CREATE TABLE tests (file oid);"
+  end
+end
+
+class Test < ActiveRecord::Base
+end
+

data/spec/support/mock_files.rb

@@ -0,0 +1,32 @@
+module CarrierWave
+  module Test
+    module MockFiles
+      def file_path( *paths )
+        File.expand_path(File.join(File.dirname(__FILE__), '../fixtures', *paths))
+      end
+
+      def stub_file(filename, mime_type=nil, fake_name=nil)
+        f = File.open(file_path(filename))
+        return f
+      end
+
+      def stub_tempfile(filename, mime_type=nil, fake_name=nil)
+        raise "#{file_path(filename)} file does not exist" unless File.exist?(file_path(filename))
+
+        t = Tempfile.new(filename)
+        FileUtils.copy_file(file_path(filename), t.path)
+
+        t.stub!(:local_path => "",
+                :original_filename => filename || fake_name,
+                :content_type => mime_type)
+
+        return t
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include CarrierWave::Test::MockFiles
+end
+

metadata

@@ -0,0 +1,184 @@
+--- !ruby/object:Gem::Specification
+name: carrierwave-postgresql
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Diogo Biazus
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: carrierwave
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.2
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.8
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.8
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.4
+description: This gem adds to carrierwave a storage facility which will use the PostgreSQL's
+  oid datatype to reference a large object residing in the databse. It supports up
+  to 2GB files, though it's better suited for smaller ones. Makes life easier for
+  fast prototyping and put all your data in the same place, allows one backup for
+  all your data and file storage in heroku servers.
+email: diogo@biazus.me
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- carrierwave-postgresql.gemspec
+- lib/carrierwave-postgresql.rb
+- lib/carrierwave/postgresql.rb
+- lib/carrierwave/storage/postgresql_lo.rb
+- spec/fixtures/test.jpg
+- spec/spec_helper.rb
+- spec/storage/file_spec.rb
+- spec/storage/postgresql_lo_spec.rb
+- spec/support/active_record.rb
+- spec/support/mock_files.rb
+homepage: http://diogob.github.com/carrierwave-postgresql/
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2991919450044557960
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Use PostgreSQL large objects (AKA BLOBs) to store your files inside the database
+test_files: []