moped-gridfs 1.0.0

data/lib/moped/gridfs/files.rb

@@ -0,0 +1,29 @@
+require "moped/gridfs/bucketable"
+require "moped/gridfs/file"
+
+module Moped
+  module GridFS
+    class Files
+      include Enumerable
+      include Bucketable
+
+      attr_reader :bucket
+
+      def initialize(bucket)
+        @bucket = bucket
+      end
+
+      def [](id)
+        bucket.open(id, 'r')
+      end
+
+      def count
+        files_collection.find.count
+      end
+
+      def each(&block)
+        files_collection.find.each { |document| yield(self[document['_id']]) }
+      end
+    end
+  end
+end

data/lib/moped/gridfs/inspectable.rb

@@ -0,0 +1,15 @@
+module Moped
+  module GridFS
+    module Inspectable
+
+      private
+
+      def build_inspect_string(hash)
+        memaddr = (__send__(:object_id) << 1).to_s(16)
+        string = "#<#{self.class.name}:#{memaddr}"
+        hash.each { |k, v| string << " #{k}=#{v}" }
+        string << ">"
+      end
+    end
+  end
+end

data/lib/moped/gridfs/version.rb

@@ -0,0 +1,5 @@
+module Moped
+  module GridFS
+    VERSION = "1.0.0"
+  end
+end

data/moped-gridfs.gemspec

@@ -0,0 +1,26 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'moped/gridfs/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "moped-gridfs"
+  spec.version       = Moped::GridFS::VERSION
+  spec.authors       = ["topac"]
+  spec.email         = ["dani.m.mobile@gmail.com"]
+  spec.summary       = %q{mongoDB GridFS implementation for Moped}
+  spec.description   = %q{mongoDB GridFS implementation for Moped}
+  spec.homepage      = "https://www.github.com/topac/moped-gridfs"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency("moped")
+
+  spec.add_development_dependency("bundler", "~> 1.6")
+  spec.add_development_dependency("rake")
+  spec.add_development_dependency("rspec")
+  spec.add_development_dependency("pry")
+end

data/perf/compare.rb

@@ -0,0 +1,143 @@
+# Compare with mongo-ruby-driver
+# $ gem install mongo
+# $ gem install bson_ext
+
+$INCLUDE_MONGO = true
+
+require_relative 'perf_helper'
+
+def reset
+  purge
+
+  @bucket = moped_session.bucket
+  @grid = Mongo::GridFileSystem.new(mongo_connection)
+end
+
+def content(size = 0.5) # 0.5 mb
+  "\xDF\x00\xAB\xFA" * (1024 * 1024 * size)
+end
+
+profile("Create an empty file", n: [1000, 5_000]) do |bm, n|
+  reset
+
+  bm.report do
+    n.times { |i| @bucket.open("file#{i}", 'w') }
+  end
+
+  reset
+
+  bm.report do
+    n.times { |i| @grid.open( "file#{i}", 'w').close }
+  end
+end
+
+profile("Create and write a file", n: [10, 100]) do |bm, n|
+  reset
+
+  bm.report do
+    n.times { |i| @bucket.open("file#{i}", 'w').write(content) }
+  end
+
+  reset
+
+  bm.report do
+    n.times do |i|
+      file = @grid.open("file", "w")
+      file.write(content)
+      file.close
+    end
+  end
+end
+
+profile("Sequentially write on a file", n: [1000, 5_000]) do |bm, n|
+  reset
+  file = @bucket.open("file", 'w')
+
+  bm.report do
+    n.times { |i| file.write("foobar") }
+  end
+
+  reset
+  file = @grid.open("file", "w")
+
+  bm.report do
+    (n-1).times { |i| file.write("foobar") }
+    file.close
+  end
+end
+
+profile("Open a file in r mode", n: [1000, 5_000]) do |bm, n|
+  reset
+  @bucket.open("file", 'w')
+
+  bm.report do
+    n.times { |i| @bucket.open("file", "r") }
+  end
+
+  reset
+  @grid.open("file", 'w').close
+
+  bm.report do
+    n.times { |i| @grid.open("file", "r") }
+  end
+end
+
+profile("Open a file in w mode", n: [1000, 5_000]) do |bm, n|
+  reset
+
+  bm.report do
+    n.times { |i| @bucket.open("file", "w") }
+  end
+
+  reset
+
+  bm.report do
+    n.times { |i| @grid.open("file", "w") }
+  end
+end
+
+def write_sample_file(klass)
+  file = klass.open("file", 'w')
+  file.write(content)
+  file.close if file.respond_to?(:close)
+
+  klass.open("file", "r")
+end
+
+profile("Read a whole file from the beginning", n: 100) do |bm, n|
+  reset
+  file = write_sample_file(@bucket)
+
+  bm.report do
+    n.times { |i| file.seek(0); file.read }
+  end
+
+  reset
+  file = write_sample_file(@grid)
+
+  bm.report do
+    n.times { |i| file.seek(0); file.read }
+  end
+end
+
+profile("Read 100 bytes a time till the end", n: [10, 100]) do |bm, n|
+  reset
+  file = write_sample_file(@bucket)
+
+  bm.report do
+    n.times do |i|
+      file.seek(0)
+      while !file.eof?; file.read(100); end
+    end
+  end
+
+  reset
+  file = write_sample_file(@grid)
+
+  bm.report do
+    n.times do |i|
+      file.seek(0)
+      while !file.eof?; file.read(100); end
+    end
+  end
+end

data/perf/perf_helper.rb

@@ -0,0 +1,33 @@
+require 'benchmark'
+require_relative '../spec/spec_helper'
+
+if $INCLUDE_MONGO
+  require 'mongo'
+
+  def mongo_connection
+    client = Mongo::MongoClient.new(ENV["MOPED-GRIDFS_SPEC_HOST"], ENV["MOPED-GRIDFS_SPEC_PORT"])
+    client[ENV["MOPED-GRIDFS_SPEC_DB"]]
+  end
+
+  module Mongo
+    class GridIO
+      def warn(*args); end
+    end
+  end
+end
+
+def purge
+  drop_all_collections
+end
+
+def profile(message, options = {})
+  ary = [options[:n] || 1].flatten
+
+  ary.each do |n|
+    puts message+" (#{n} times)"
+
+    Benchmark.bm do |bm|
+      yield(bm, n)
+    end
+  end
+end

data/spec/lib/moped/gridfs/bucket_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+require 'moped/gridfs/bucket'
+
+describe Moped::GridFS::Bucket do
+
+  let(:session) { moped_session }
+
+  describe '#initialize' do
+
+    context 'when the given name is empty' do
+
+      it 'raises an error' do
+        expect { described_class.new(session, '') }.to raise_error
+      end
+    end
+
+    context 'when the given name is nil' do
+
+      it 'raises an error' do
+        expect { described_class.new(session, nil) }.to raise_error
+      end
+    end
+
+    context 'when the given name is not empty nor nil' do
+
+      it 'does not raise any error' do
+        expect { described_class.new(session, 'foo') }.not_to raise_error
+      end
+    end
+  end
+
+  let(:subject) { described_class.new(session, 'bar') }
+
+  describe '#files' do
+
+    it 'returns an enumerable' do
+      expect(subject.files).to respond_to(:each)
+    end
+  end
+
+  describe '#drop' do
+
+    before do
+      subject.files_collection.insert(foo: 'bar')
+      subject.chunks_collection.insert(foo: 'bar')
+    end
+
+    it 'drops the two collections' do
+      subject.drop
+
+      expect(subject.files_collection.find.count).to eq(0)
+      expect(subject.chunks_collection.find.count).to eq(0)
+    end
+  end
+
+  describe '#delete' do
+
+    context 'when a file is missing' do
+
+      it 'returns nil' do
+        expect(subject.delete("file")).to be_nil
+      end
+    end
+
+    context 'when a file exists' do
+
+      before do
+        subject.open("file", "w").write("buffer")
+      end
+
+      it 'not to returns nil' do
+        expect(subject.delete("file")).not_to be_nil
+      end
+
+      it 'deletes the file' do
+        subject.delete("file")
+        expect { subject.open("foo", "r") }.to raise_error
+      end
+    end
+  end
+
+  describe '#open' do
+
+    context 'when the mode is w' do
+
+      it 'returns a writable file' do
+        expect(subject.open("foo", "w")).to be_writable
+      end
+    end
+
+    context 'when the mode is r' do
+
+      context 'and the file is missing' do
+
+        it 'raises an error' do
+          expect { subject.open("foo", "r") }.to raise_error
+        end
+      end
+
+      context 'and the file exists' do
+
+        before do
+          subject.open("bar", "w").write("buffer")
+        end
+
+        it 'returns a readable file' do
+          expect(subject.open("bar", "r")).to be_readable
+        end
+      end
+    end
+
+    context 'when the mode is a' do
+
+      it 'returns a writable file' do
+        expect(subject.open("foo", "a")).to be_writable
+      end
+    end
+  end
+end

data/spec/lib/moped/gridfs/buckets_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'moped/gridfs/buckets'
+
+describe Moped::GridFS::Buckets do
+
+  let(:session) { moped_session }
+
+  let(:subject) { described_class.new(session) }
+
+  before do
+    Moped::GridFS::Bucket.new(session, "bar").open("file", "w")
+    Moped::GridFS::Bucket.new(session, "foo").open("file", "w")
+  end
+
+  describe '#names' do
+
+    it 'returns the bucket names' do
+      expect(subject.names.sort).to eq(%w[bar foo])
+    end
+  end
+
+  describe '#count' do
+
+    it 'returns the buckets count' do
+      expect(subject.count).to eq(2)
+    end
+  end
+
+  describe '#[]' do
+
+    it 'returns a bucket with the given name' do
+      bucket = subject['test']
+      expect(bucket.name).to eq('test')
+    end
+  end
+
+  describe '#each' do
+
+    it 'iterates over the buckets' do
+      names = []
+      subject.each { |bucket| names << bucket.name }
+      expect(names.sort).to eq(%w[bar foo])
+    end
+  end
+end

data/spec/lib/moped/gridfs/file_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+require 'moped/gridfs/file'
+
+require_relative 'write'
+require_relative 'read'
+require_relative 'getters'
+require_relative 'setters'
+
+describe Moped::GridFS::File do
+
+  $chunk_size = 5
+
+  before do
+    described_class.any_instance.stub(:default_chunk_size).and_return($chunk_size)
+  end
+
+  let(:session) { moped_session }
+
+  let(:bucket) { session.bucket }
+
+  context 'when mode is r' do
+
+    let(:access_mode) { 'r' }
+
+    include_examples :read, :getters
+
+    let(:file) do
+      bucket.open("file", "w").write("foobar")
+      bucket.open("file", access_mode)
+    end
+
+    it 'cannot be written' do
+      expect { file.write("foo") }.to raise_error
+    end
+
+    it 'does not have setters' do
+      %w[content_type metadata aliases filename upload_date].each do |name|
+        expect(file).not_to respond_to(:"#{name}=")
+      end
+    end
+  end
+
+  context 'when mode is r+' do
+
+    let(:access_mode) { 'r+' }
+
+    include_examples :read, :getters, :setters
+  end
+
+  context 'when mode is w' do
+
+    let(:access_mode) { 'w' }
+
+    include_examples :write, :getters, :setters
+
+    it 'cannot be readed' do
+      bucket.open("file", "w").write("foobar")
+      file = bucket.open("file", access_mode)
+      expect { file.read }.to raise_error
+    end
+  end
+
+  context 'when mode is w+' do
+
+    let(:access_mode) { 'w+' }
+
+    include_examples :write, :getters, :setters
+  end
+
+  context 'when mode is a' do
+
+    let(:access_mode) { 'a' }
+
+    include_examples :write, :getters, :setters
+  end
+
+  context 'when mode is a+' do
+
+    let(:access_mode) { 'a+' }
+
+    include_examples :write, :read, :getters, :setters
+  end
+end