mongoid-grid_fs 2.3.0 → 2.4.0

data/lib/mongoid/grid_fs/version.rb

@@ -1,5 +1,5 @@
 module Mongoid
   class GridFs
-    VERSION = "2.3.0"
+    VERSION = '2.4.0'.freeze
   end
 end

data/test/mongoid-grid_fs_test.rb

@@ -1,8 +1,8 @@
 require_relative 'helper'
 
 Testing Mongoid::GridFs do
-##
-#
+  ##
+  #
   GridFs = Mongoid::GridFs
 
   prepare do
@@ -10,239 +10,228 @@ Testing Mongoid::GridFs do
     GridFs::Chunk.delete_all
   end
 
-##
-#
+  ##
+  #
   context '#put' do
-
     test 'default' do
       filename = __FILE__
       basename = File.basename(filename)
 
-      g = assert{ GridFs.put(filename) }
+      g = assert { GridFs.put(filename) }
 
-      assert{ g.filename =~ %r| #{ object_id_re } / #{ basename } \Z|imox }
-      assert{ g.content_type == "application/x-ruby" }
-      assert{ g.data == IO.read(filename) }
+      assert { g.filename =~ %r{ #{ object_id_re } / #{ basename } \Z}imox }
+      assert { g.content_type == 'application/x-ruby' }
+      assert { g.data == IO.read(filename) }
     end
 
     test 'with a :filename' do
       filename = 'path/info/a.rb'
 
-      g = assert{ GridFs.put(__FILE__, :filename => filename) }
+      g = assert { GridFs.put(__FILE__, filename: filename) }
 
-      assert{ g.filename == filename }
+      assert { g.filename == filename }
     end
 
     test 'with your own attributes' do
-      my_value = "my_value"
+      my_value = 'my_value'
 
-      g = assert{ GridFs.put(__FILE__, :my_value => my_value) }
+      g = assert { GridFs.put(__FILE__, my_value: my_value) }
 
-      assert{ g.my_value == my_value }
+      assert { g.my_value == my_value }
     end
 
     test 'when error occurs (eg. missing file)' do
       file = '/path/to/missing'
 
-      assert_raises(Errno::ENOENT){ GridFs.put(file) }
+      assert_raises(Errno::ENOENT) { GridFs.put(file) }
     end
-
   end
 
-
-##
-#
+  ##
+  #
   context '#get' do
-
     test 'default' do
-      id = assert{ GridFs::File.last.id }
-      g = assert{ GridFs.get(id) }
+      id = assert { GridFs::File.last.id }
+      g = assert { GridFs.get(id) }
     end
-
   end
 
-##
-#
+  ##
+  #
   context '#delete' do
-
     test 'default' do
-      id = assert{ GridFs::File.last.id }
-      g = assert{ GridFs.get(id) }
-      assert{ GridFs.delete(id) }
-      assert_raises(Mongoid::Errors::DocumentNotFound){ GridFs.get(id) }
+      id = assert { GridFs::File.last.id }
+      g = assert { GridFs.get(id) }
+      assert { GridFs.delete(id) }
+      assert_raises(Mongoid::Errors::DocumentNotFound) { GridFs.get(id) }
     end
-
   end
 
-##
-#
+  ##
+  #
   context '[] and []=' do
-
     test 'default' do
       path = 'a.rb'
       data = IO.read(__FILE__)
 
       sio = SIO.new(path, data)
 
-      g = assert{ GridFs[path] = sio and GridFs[path] }
+      g = assert { (GridFs[path] = sio) && GridFs[path] }
 
-      assert{ g.data == data }
-      assert{ g.content_type == "application/x-ruby" }
+      assert { g.data == data }
+      assert { g.content_type == 'application/x-ruby' }
 
       before = GridFs::File.count
 
-      data = "#{ Time.now.to_f }-#{ rand }"
+      data = "#{Time.now.to_f}-#{rand}"
 
-      assert{ GridFs[path] = SIO.new(path, data) }
-      assert{ GridFs[path].data == data }
+      assert { GridFs[path] = SIO.new(path, data) }
+      assert { GridFs[path].data == data }
 
       after = GridFs::File.count
 
       created = after - before
 
-      assert{ created == 1 }
+      assert { created == 1 }
     end
 
-##
-#
-  context 'data uris' do
+    ##
+    #
+    context 'data uris' do
+      test 'default' do
+        id = assert { GridFs::File.last.id }
+        g = assert { GridFs.get(id) }
 
-    test 'default' do
-      id = assert{ GridFs::File.last.id }
-      g = assert{ GridFs.get(id) }
+        content_type = g.content_type
+        base64 = [g.to_s].pack('m').chomp
 
-      content_type = g.content_type
-      base64 = [g.to_s].pack('m').chomp
+        data_uri = "data:#{content_type};base64,".concat(base64)
 
-      data_uri = "data:#{ content_type };base64,".concat(base64)
-
-      assert{ g.data_uri == data_uri }
+        assert { g.data_uri == data_uri }
+      end
     end
 
-  end
-
-##
-#
-  context 'slicing and dicing' do
-
-    test 'range' do
-      id = assert { GridFs::File.last.id }
-      g = assert { GridFs.get(id) }
-      assert { g.data[1..3] == g.slice(1..3) }
-    end
+    ##
+    #
+    context 'slicing and dicing' do
+      test 'range' do
+        id = assert { GridFs::File.last.id }
+        g = assert { GridFs.get(id) }
+        assert { g.data[1..3] == g.slice(1..3) }
+      end
 
-    test 'start and length' do
-      id = assert { GridFs::File.last.id }
-      g = assert { GridFs.get(id) }
-      assert { g.data[1, 3] == g.slice(1, 3) }
-    end
+      test 'start and length' do
+        id = assert { GridFs::File.last.id }
+        g = assert { GridFs.get(id) }
+        assert { g.data[1, 3] == g.slice(1, 3) }
+      end
 
-    test 'just a single param' do
-      id = assert { GridFs::File.last.id }
-      g = assert {GridFs.get(id) }
+      test 'just a single param' do
+        id = assert { GridFs::File.last.id }
+        g = assert { GridFs.get(id) }
 
-      assert {g.data[1] == g.slice(1) }
-    end
+        assert { g.data[1] == g.slice(1) }
+      end
 
-    test 'getting the last index' do
-      id = assert { GridFs::File.last.id }
-      g = assert {GridFs.get(id) }
-      assert {g.data[-1] == g.slice(-1) }
-    end
+      test 'getting the last index' do
+        id = assert { GridFs::File.last.id }
+        g = assert { GridFs.get(id) }
+        assert { g.data[-1] == g.slice(-1) }
+      end
 
-    test 'yanking from the end of the data' do
-      id = assert { GridFs::File.last.id }
-      g = assert {GridFs.get(id) }
-      assert {g.data[-3, 2] == g.slice(-3, 2) }
-    end
+      test 'yanking from the end of the data' do
+        id = assert { GridFs::File.last.id }
+        g = assert { GridFs.get(id) }
+        assert { g.data[-3, 2] == g.slice(-3, 2) }
+      end
 
-    test 'multiple chunks...' do
-      path = 'slice_and_dice.txt'
+      test 'multiple chunks...' do
+        path = 'slice_and_dice.txt'
 
-      assert { GridFs[path] = SIO.new(path, "foobar" * 256 * 1024) }
+        assert { GridFs[path] = SIO.new(path, 'foobar' * 256 * 1024) }
 
-      g = GridFs[path]
+        g = GridFs[path]
 
-      assert { g.chunks.count > 0 }
-      assert { g.data[10, (256 * 1024 * 2)] == g.slice(10, (256 * 1024 * 2)) }
+        assert { g.chunks.count > 0 }
+        assert { g.data[10, (256 * 1024 * 2)] == g.slice(10, (256 * 1024 * 2)) }
+      end
     end
-  end
 
-##
-#
-  context 'iterating each chunk' do
-    test 'having file size more than 42mb' do
-      require 'tempfile'
+    ##
+    #
+    context 'iterating each chunk' do
+      test 'having file size more than 42mb' do
+        require 'tempfile'
 
-      orig, copy = %w{orig copy}.map do |suffix|
-        Tempfile.new("mongoid-grid_fs~43mb.#{suffix}")
-      end
+        orig, copy = %w(orig copy).map do |suffix|
+          Tempfile.new("mongoid-grid_fs~43mb.#{suffix}")
+        end
 
-      kilobyte = "x" * 1024
-      (43*1024).times { orig.write(kilobyte) }
+        kilobyte = 'x' * 1024
+        (43 * 1024).times { orig.write(kilobyte) }
 
-      GridFs.get(GridFs.put(orig.path).id).each do |chunk|
-        copy.print(chunk.to_s)
-      end
+        GridFs.get(GridFs.put(orig.path).id).each do |chunk|
+          copy.print(chunk.to_s)
+        end
 
-      assert { File.size(orig.path) == File.size(copy.path) }
+        assert { File.size(orig.path) == File.size(copy.path) }
+      end
     end
-  end
 
-##
-#
-  context 'namespaces' do
-    test 'default' do
-      assert{ GridFs.namespace.prefix == 'fs' }
-      assert{ GridFs.file_model.collection_name.to_s == 'fs.files' }
-      assert{ GridFs.chunk_model.collection_name.to_s == 'fs.chunks' }
-    end
+    ##
+    #
+    context 'namespaces' do
+      test 'default' do
+        assert { GridFs.namespace.prefix == 'fs' }
+        assert { GridFs.file_model.collection_name.to_s == 'fs.files' }
+        assert { GridFs.chunk_model.collection_name.to_s == 'fs.chunks' }
+      end
 
-    test 'new' do
-      ns = GridFs.namespace_for(:ns)
+      test 'new' do
+        ns = GridFs.namespace_for(:ns)
 
-      assert{ ns.prefix == 'ns' }
+        assert { ns.prefix == 'ns' }
 
-      assert{ ns.file_model < Mongoid::Document }
-      assert{ ns.file_model.collection_name.to_s == 'ns.files' }
+        assert { ns.file_model < Mongoid::Document }
+        assert { ns.file_model.collection_name.to_s == 'ns.files' }
 
-      assert{ ns.chunk_model < Mongoid::Document }
-      assert{ ns.chunk_model.collection_name.to_s == 'ns.chunks' }
+        assert { ns.chunk_model < Mongoid::Document }
+        assert { ns.chunk_model.collection_name.to_s == 'ns.chunks' }
 
-      assert{ ns.file_model.destroy_all }
+        assert { ns.file_model.destroy_all }
 
-      count = GridFs::File.count
+        count = GridFs::File.count
 
-      assert{ ns.file_model.count == 0}
-      assert{ ns.put __FILE__ }
-      assert{ ns.file_model.count == 1}
+        assert { ns.file_model.count == 0 }
+        assert { ns.put __FILE__ }
+        assert { ns.file_model.count == 1 }
 
-      assert{ count == GridFs::File.count }
+        assert { count == GridFs::File.count }
+      end
     end
   end
 
-  end
-
-##
-#
+  ##
+  #
   context 'rails' do
     test 'paths' do
       testdir = File.dirname(__FILE__)
       gemdir = File.dirname(testdir)
       libdir = File.join(gemdir, 'lib')
 
-      expanded = proc{|paths| Array(paths).map{|path| File.expand_path(path)}}
+      expanded = proc { |paths| Array(paths).map { |path| File.expand_path(path) } }
 
-      assert{
-        expanded[ Mongoid::GridFs::Engine.paths['app/models'] ] == expanded[ libdir ]
-      }
+      assert do
+        expanded[Mongoid::GridFs::Engine.paths['app/models']] == expanded[libdir]
+      end
     end
   end
 
 protected
+
   def object_id_re
     object_id = defined?(Moped::BSON) ? Moped::BSON::ObjectId.new : BSON::ObjectId.new
 
-    %r| \w{#{ object_id.to_s.size }} |iomx
+    / \w{#{ object_id.to_s.size }} /iomx
   end
 end

data/test/testing.rb

@@ -7,17 +7,17 @@ libdir = File.join(rootdir, 'lib')
 
 STDOUT.sync = true
 
-$:.unshift(testdir) unless $:.include?(testdir)
-$:.unshift(libdir) unless $:.include?(libdir)
-$:.unshift(rootdir) unless $:.include?(rootdir)
+$LOAD_PATH.unshift(testdir) unless $LOAD_PATH.include?(testdir)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+$LOAD_PATH.unshift(rootdir) unless $LOAD_PATH.include?(rootdir)
 
 class Testing
   class Slug < ::String
-    def Slug.for(*args)
+    def self.for(*args)
       string = args.flatten.compact.join('-')
-      words = string.to_s.scan(%r/\w+/)
-      words.map!{|word| word.gsub %r/[^0-9a-zA-Z_-]/, ''}
-      words.delete_if{|word| word.nil? or word.strip.empty?}
+      words = string.to_s.scan(/\w+/)
+      words.map! { |word| word.gsub /[^0-9a-zA-Z_-]/, '' }
+      words.delete_if { |word| word.nil? || word.strip.empty? }
       new(words.join('-').downcase)
     end
   end
@@ -25,7 +25,7 @@ class Testing
   class Context
     attr_accessor :name
 
-    def initialize(name, *args)
+    def initialize(name, *_args)
       @name = name
     end
 
@@ -39,21 +39,21 @@ def Testing(*args, &block)
   Class.new(::Minitest::Test) do
     i_suck_and_my_tests_are_order_dependent!
 
-  ## class methods
-  #
+    ## class methods
+    #
     class << self
       def contexts
         @contexts ||= []
       end
 
       def context(*args, &block)
-        return contexts.last if(args.empty? and block.nil?)
+        return contexts.last if args.empty? && block.nil?
 
         context = Testing::Context.new(*args)
         contexts.push(context)
 
         begin
-          block.call(context)
+          yield(context)
         ensure
           contexts.pop
         end
@@ -61,22 +61,24 @@ def Testing(*args, &block)
 
       def slug_for(*args)
         string = [context, args].flatten.compact.join('-')
-        words = string.to_s.scan(%r/\w+/)
-        words.map!{|word| word.gsub %r/[^0-9a-zA-Z_-]/, ''}
-        words.delete_if{|word| word.nil? or word.strip.empty?}
+        words = string.to_s.scan(/\w+/)
+        words.map! { |word| word.gsub /[^0-9a-zA-Z_-]/, '' }
+        words.delete_if { |word| word.nil? || word.strip.empty? }
         words.join('-').downcase.sub(/_$/, '')
       end
 
-      def name() const_get(:Name) end
+      def name
+        const_get(:Name)
+      end
 
-      def testno()
+      def testno
         '%05d' % (@testno ||= 0)
       ensure
         @testno += 1
       end
 
       def testing(*args, &block)
-        method = ["test", testno, slug_for(*args)].delete_if{|part| part.empty?}.join('_')
+        method = ['test', testno, slug_for(*args)].delete_if(&:empty?).join('_')
         define_method(method, &block)
       end
 
@@ -105,43 +107,43 @@ def Testing(*args, &block)
       end
     end
 
-  ## configure the subclass!
-  #
+    ## configure the subclass!
+    #
     const_set(:Testno, '0')
-    slug = slug_for(*args).gsub(%r/-/,'_')
-    name = ['TESTING', '%03d' % const_get(:Testno), slug].delete_if{|part| part.empty?}.join('_')
+    slug = slug_for(*args).tr('-', '_')
+    name = ['TESTING', '%03d' % const_get(:Testno), slug].delete_if(&:empty?).join('_')
     name = name.upcase!
     const_set(:Name, name)
     const_set(:Missing, Object.new.freeze)
 
-  ## instance methods
-  #
+    ## instance methods
+    #
     alias_method('__assert__', 'assert')
 
     def assert(*args, &block)
-      if args.size == 1 and args.first.is_a?(Hash)
+      if (args.size == 1) && args.first.is_a?(Hash)
         options = args.first
-        expected = getopt(:expected, options){ missing }
-        actual = getopt(:actual, options){ missing }
-        if expected == missing and actual == missing
+        expected = getopt(:expected, options) { missing }
+        actual = getopt(:actual, options) { missing }
+        if (expected == missing) && (actual == missing)
           actual, expected, *ignored = options.to_a.flatten
         end
-        expected = expected.call() if expected.respond_to?(:call)
-        actual = actual.call() if actual.respond_to?(:call)
+        expected = expected.call if expected.respond_to?(:call)
+        actual = actual.call if actual.respond_to?(:call)
         assert_equal(expected, actual)
       end
 
-      if block
-        label = "assert(#{ args.join(' ') })"
-        result = nil
-        result = block.call
-        __assert__(result, label)
-        result
-      else
-        result = args.shift
-        label = "assert(#{ args.join(' ') })"
-        __assert__(result, label)
-        result
+      result = if block
+                 label = "assert(#{args.join(' ')})"
+                 result = nil
+                 result = yield
+                 __assert__(result, label)
+                 result
+               else
+                 result = args.shift
+                 label = "assert(#{args.join(' ')})"
+                 __assert__(result, label)
+                 result
       end
     end
 
@@ -151,46 +153,47 @@ def Testing(*args, &block)
 
     def getopt(opt, hash, options = nil, &block)
       [opt.to_s, opt.to_s.to_sym].each do |key|
-        return hash[key] if hash.has_key?(key)
+        return hash[key] if hash.key?(key)
       end
       default =
         if block
-          block.call
+          yield
         else
           options.is_a?(Hash) ? options[:default] : nil
         end
-      return default
+      default
     end
 
-    def subclass_of exception
+    def subclass_of(exception)
       class << exception
-        def ==(other) super or self > other end
+        def ==(other)
+          super || self > other
+        end
       end
       exception
     end
 
-  ##
-  #
+    ##
+    #
     module_eval(&block)
 
-    self.setup()
-    self.prepare.each{|b| b.call()}
+    setup
+    prepare.each(&:call)
 
-    at_exit{
-      self.teardown()
-      self.cleanup.each{|b| b.call()}
-    }
+    at_exit do
+      teardown
+      cleanup.each(&:call)
+    end
 
     self
   end
 end
 
-
-if $0 == __FILE__
+if $PROGRAM_NAME == __FILE__
 
   Testing 'Testing' do
-    testing('foo'){ assert true }
-    test{ assert true }
+    testing('foo') { assert true }
+    test { assert true }
     p instance_methods.grep(/test/)
   end