mongoid-grid_fs 1.0.0 → 1.1.0

data/README.md

@@ -1,52 +1,56 @@
 NAME
 ----
-  mongoid_grid_fs
+  mongoid-grid_fs
+
+INSTALL
+-------
+  gem install mongoid-grid_fs
 
 SYNOPSIS
 --------
 
-  ````ruby
+````ruby
 
-    require 'mongoid-grid_fs'
+  require 'mongoid-grid_fs'
 
-    g = GridFs.put anthing_that_respons_to_read
+  g = GridFs.put readable
 
-    GridFS.get id
+  GridFS.get id
 
-    GridFS.delete id
+  GridFS.delete id
 
 
-  ````
+````
 
 DESCRIPTION
 -----------
-  mongoid_grid_fs is pure mongoid 3  / moped implementation of the mongodb
-  grid_fs specification
+mongoid_grid_fs is a pure mongoid 3  / moped implementation of the mongodb
+grid_fs specification
 
-   ref: http://www.mongodb.org/display/DOCS/GridFS+Specification
+ref: http://www.mongodb.org/display/DOCS/GridFS+Specification
 
-   it has the following features:
+it has the following features:
 
-    - implementation is on top of mongoid for portability.  moped (the drive)
-      is barely used
+- implementation is on top of mongoid for portability.  moped (the driver) is
+  barely used
 
-    - simple, REST-like api
+- simple, REST-like api
 
-    - support for custom namespaces (fs.files vs. image.files)
+- support for custom namespaces (fs.files vs. image.files)
 
-    - pathnames and io-like objects can be written to the grid
+- pathnames and io-like objects can be written to the grid
 
-    - auto-unique pathnames are generated (by default) to avoid collisions using #put
+- auto-unique pathnames are generated (by default) to avoid collisions using #put
 
-        'path/info/a.rb' -> '$object_id/a.rb'
+    'path/info/a.rb' -> '$object_id/a.rb'
 
-    - #[] and #[]= methods which allow the grid to be used like a giant file
-      hash in the sky
+- [] and []= methods which allow the grid to be used like a giant file
+  hash in the sky
 
-    - supprt for data_uris
+- supprt for data_uris
 
-      ````eruby
+  ````erb
 
-        <%= image_tag :src => file.data_url %>
+    <%= image_tag :src => file.data_uri %>
 
-      ````
+  ````

data/lib/mongoid-grid_fs.rb

@@ -1,419 +1,466 @@
-require "mongoid"
-require "mime/types"
-require "digest/md5"
-require "cgi"
-
-class GridFS
 ##
 #
-  class << GridFS
-    def version
-      "1.0.0"
-    end
+  class GridFS
+    const_set :Version, '1.1.0'
+
+    class << GridFS
+      def version
+        const_get :Version
+      end
+
+      def dependencies
+        {
+          'mongoid'         => [ 'mongoid'         , ' >= 3.0.1' ] ,
+          'mime/types'      => [ 'mime-types'      , ' >= 1.19'  ] ,
+        }
+      end
 
-    attr_accessor :namespace
-    attr_accessor :file_model
-    attr_accessor :chunk_model
-
-    def init!
-      GridFS.build_namespace_for(:Fs)
-
-      GridFS.namespace = Fs
-      GridFS.file_model = Fs.file_model
-      GridFS.chunk_model = Fs.chunk_model
-
-      const_set(:File, Fs.file_model)
-      const_set(:Chunk, Fs.chunk_model)
-
-      to_delegate = %w(
-        put
-        get
-        delete
-        find
-        []
-        []=
-      )
-      
-      to_delegate.each do |method|
-        class_eval <<-__
-          def GridFS.#{ method }(*args, &block)
-            ::GridFS::Fs::#{ method }(*args, &block)
+      def libdir(*args, &block)
+        @libdir ||= File.expand_path(__FILE__).sub(/\.rb$/,'')
+        args.empty? ? @libdir : File.join(@libdir, *args)
+      ensure
+        if block
+          begin
+            $LOAD_PATH.unshift(@libdir)
+            block.call()
+          ensure
+            $LOAD_PATH.shift()
           end
-        __
+        end
+      end
+
+      def load(*libs)
+        libs = libs.join(' ').scan(/[^\s+]+/)
+        libdir{ libs.each{|lib| Kernel.load(lib) } }
       end
     end
-  end
 
-##
-#
-  def GridFS.namespace_for(prefix)
-    prefix = prefix.to_s.downcase
-    const = "::GridFS::#{ prefix.to_s.camelize }"
-    namespace = const.split(/::/).last
-    const_defined?(namespace) ? const_get(namespace) : build_namespace_for(namespace)
+    begin
+      require 'rubygems'
+    rescue LoadError
+      nil
+    end
+
+    if defined?(gem)
+      dependencies.each do |lib, dependency|
+        gem(*dependency)
+        require(lib)
+      end
+    end
+
+    require "digest/md5"
+    require "cgi"
   end
 
 ##
 #
-  def GridFS.build_namespace_for(prefix)
-    prefix = prefix.to_s.downcase
-    const = prefix.camelize
-
-    namespace =
-      Module.new do
-        module_eval(&NamespaceMixin)
-        self
+  class GridFS
+    class << GridFS
+      attr_accessor :namespace
+      attr_accessor :file_model
+      attr_accessor :chunk_model
+
+      def init!
+        GridFS.build_namespace_for(:Fs)
+
+        GridFS.namespace = Fs
+        GridFS.file_model = Fs.file_model
+        GridFS.chunk_model = Fs.chunk_model
+
+        const_set(:File, Fs.file_model)
+        const_set(:Chunk, Fs.chunk_model)
+
+        to_delegate = %w(
+          put
+          get
+          delete
+          find
+          []
+          []=
+        )
+        
+        to_delegate.each do |method|
+          class_eval <<-__
+            def GridFS.#{ method }(*args, &block)
+              ::GridFS::Fs::#{ method }(*args, &block)
+            end
+          __
+        end
       end
+    end
 
-    const_set(const, namespace)
+  ##
+  #
+    def GridFS.namespace_for(prefix)
+      prefix = prefix.to_s.downcase
+      const = "::GridFS::#{ prefix.to_s.camelize }"
+      namespace = const.split(/::/).last
+      const_defined?(namespace) ? const_get(namespace) : build_namespace_for(namespace)
+    end
 
-    file_model = build_file_model_for(namespace)
-    chunk_model = build_chunk_model_for(namespace)
+  ##
+  #
+    def GridFS.build_namespace_for(prefix)
+      prefix = prefix.to_s.downcase
+      const = prefix.camelize
 
-    file_model.namespace = namespace
-    chunk_model.namespace = namespace
+      namespace =
+        Module.new do
+          module_eval(&NamespaceMixin)
+          self
+        end
 
-    file_model.chunk_model = chunk_model
-    chunk_model.file_model = file_model
+      const_set(const, namespace)
 
-    namespace.prefix = prefix
-    namespace.file_model = file_model
-    namespace.chunk_model = chunk_model
+      file_model = build_file_model_for(namespace)
+      chunk_model = build_chunk_model_for(namespace)
 
-    namespace.send(:const_set, :File, file_model)
-    namespace.send(:const_set, :Chunk, chunk_model)
+      file_model.namespace = namespace
+      chunk_model.namespace = namespace
 
-    #at_exit{ file_model.create_indexes rescue nil }
-    #at_exit{ chunk_model.create_indexes rescue nil }
+      file_model.chunk_model = chunk_model
+      chunk_model.file_model = file_model
 
-    const_get(const)
-  end
+      namespace.prefix = prefix
+      namespace.file_model = file_model
+      namespace.chunk_model = chunk_model
 
-  NamespaceMixin = proc do
-    class << self
-      attr_accessor :prefix
-      attr_accessor :file_model
-      attr_accessor :chunk_model
+      namespace.send(:const_set, :File, file_model)
+      namespace.send(:const_set, :Chunk, chunk_model)
 
-      def to_s
-        prefix
-      end
+      #at_exit{ file_model.create_indexes rescue nil }
+      #at_exit{ chunk_model.create_indexes rescue nil }
 
-      def namespace
-        prefix
-      end
+      const_get(const)
+    end
 
-      def put(readable, attributes = {})
-        chunks = []
-        file = file_model.new
-        attributes.to_options!
+    NamespaceMixin = proc do
+      class << self
+        attr_accessor :prefix
+        attr_accessor :file_model
+        attr_accessor :chunk_model
 
-        if attributes.has_key?(:id)
-          file.id = attributes.delete(:id)
+        def to_s
+          prefix
         end
 
-        if attributes.has_key?(:_id)
-          file.id = attributes.delete(:_id)
+        def namespace
+          prefix
         end
 
-        if attributes.has_key?(:content_type)
-          attributes[:contentType] = attributes.delete(:content_type)
-        end
+        def put(readable, attributes = {})
+          chunks = []
+          file = file_model.new
+          attributes.to_options!
 
-        if attributes.has_key?(:upload_date)
-          attributes[:uploadDate] = attributes.delete(:upload_date)
-        end
+          if attributes.has_key?(:id)
+            file.id = attributes.delete(:id)
+          end
 
-        md5 = Digest::MD5.new
-        length = 0
-        chunkSize = file.chunkSize
-        n = 0
+          if attributes.has_key?(:_id)
+            file.id = attributes.delete(:_id)
+          end
 
-        GridFS.reading(readable) do |io|
+          if attributes.has_key?(:content_type)
+            attributes[:contentType] = attributes.delete(:content_type)
+          end
 
-          filename =
-            attributes[:filename] ||=
-              [file.id.to_s, GridFS.extract_basename(io)].join('/').squeeze('/')
+          if attributes.has_key?(:upload_date)
+            attributes[:uploadDate] = attributes.delete(:upload_date)
+          end
 
-          content_type =
-            attributes[:contentType] ||=
-              GridFS.extract_content_type(filename) || file.contentType
+          md5 = Digest::MD5.new
+          length = 0
+          chunkSize = file.chunkSize
+          n = 0
 
-          while((buf = io.read(chunkSize)))
-            md5 << buf
-            length += buf.size
-            chunk = file.chunks.build
-            chunk.data = binary_for(buf)
-            chunk.n = n
-            n += 1
-            chunk.save!
-            chunks.push(chunk)
-          end
+          GridFS.reading(readable) do |io|
 
-        end
+            filename =
+              attributes[:filename] ||=
+                [file.id.to_s, GridFS.extract_basename(io)].join('/').squeeze('/')
 
-        attributes[:length] ||= length
-        attributes[:uploadDate] ||= Time.now.utc
-        attributes[:md5] ||= md5.hexdigest
+            content_type =
+              attributes[:contentType] ||=
+                GridFS.extract_content_type(filename) || file.contentType
 
-        file.update_attributes(attributes)
+            while((buf = io.read(chunkSize)))
+              md5 << buf
+              length += buf.size
+              chunk = file.chunks.build
+              chunk.data = binary_for(buf)
+              chunk.n = n
+              n += 1
+              chunk.save!
+              chunks.push(chunk)
+            end
 
-        file.save!
-        file
-      ensure
-        chunks.each{|chunk| chunk.destroy rescue nil} if $!
-      end
+          end
 
-      if defined?(Moped)
-        def binary_for(*buf)
-          Moped::BSON::Binary.new(:generic, buf.join)
+          attributes[:length] ||= length
+          attributes[:uploadDate] ||= Time.now.utc
+          attributes[:md5] ||= md5.hexdigest
+
+          file.update_attributes(attributes)
+
+          file.save!
+          file
+        ensure
+          chunks.each{|chunk| chunk.destroy rescue nil} if $!
         end
-      else
-        def binary_for(buf)
-          BSON::Binary.new(buf.bytes.to_a)
+
+        if defined?(Moped)
+          def binary_for(*buf)
+            Moped::BSON::Binary.new(:generic, buf.join)
+          end
+        else
+          def binary_for(buf)
+            BSON::Binary.new(buf.bytes.to_a)
+          end
         end
-      end
 
-      def get(id)
-        file_model.find(id)
-      end
+        def get(id)
+          file_model.find(id)
+        end
 
-      def delete(id)
-        file_model.find(id).destroy
-      rescue
-        nil
-      end
+        def delete(id)
+          file_model.find(id).destroy
+        rescue
+          nil
+        end
 
-      def where(conditions = {})
-        case conditions
-          when String
-            file_model.where(:filename => conditions)
-          else
-            file_model.where(conditions)
+        def where(conditions = {})
+          case conditions
+            when String
+              file_model.where(:filename => conditions)
+            else
+              file_model.where(conditions)
+          end
         end
-      end
 
-      def find(*args)
-        where(*args).first
-      end
+        def find(*args)
+          where(*args).first
+        end
 
-      def [](filename)
-        file_model.where(:filename => filename.to_s).first
-      end
+        def [](filename)
+          file_model.where(:filename => filename.to_s).first
+        end
 
-      def []=(filename, readable)
-        file = self[filename]
-        file.destroy if file
-        put(readable, :filename => filename.to_s)
-      end
+        def []=(filename, readable)
+          file = self[filename]
+          file.destroy if file
+          put(readable, :filename => filename.to_s)
+        end
 
-    # TODO - opening with a mode = 'w' should return a GridIO::IOProxy
-    # implementing a StringIO-like interface
-    #
-      def open(filename, mode = 'r', &block)
-        raise NotImplementedError
+      # TODO - opening with a mode = 'w' should return a GridIO::IOProxy
+      # implementing a StringIO-like interface
+      #
+        def open(filename, mode = 'r', &block)
+          raise NotImplementedError
+        end
       end
     end
-  end
 
-##
-#
-  def GridFS.build_file_model_for(namespace)
-    prefix = namespace.name.split(/::/).last.downcase
-    file_model_name = "#{ namespace.name }::File"
-    chunk_model_name = "#{ namespace.name }::Chunk"
+  ##
+  #
+    def GridFS.build_file_model_for(namespace)
+      prefix = namespace.name.split(/::/).last.downcase
+      file_model_name = "#{ namespace.name }::File"
+      chunk_model_name = "#{ namespace.name }::Chunk"
 
-    Class.new do
-      include Mongoid::Document
+      Class.new do
+        include Mongoid::Document
 
-      singleton_class = class << self; self; end
+        singleton_class = class << self; self; end
 
-      singleton_class.instance_eval do
-        define_method(:name){ file_model_name }
-        attr_accessor :chunk_model
-        attr_accessor :namespace
-      end
+        singleton_class.instance_eval do
+          define_method(:name){ file_model_name }
+          attr_accessor :chunk_model
+          attr_accessor :namespace
+        end
 
-      self.default_collection_name = "#{ prefix }.files"
+        self.default_collection_name = "#{ prefix }.files"
 
-      field(:filename, :type => String)
-      field(:contentType, :type => String, :default => 'application/octet-stream')
+        field(:filename, :type => String)
+        field(:contentType, :type => String, :default => 'application/octet-stream')
 
-      field(:length, :type => Integer, :default => 0)
-      field(:chunkSize, :type => Integer, :default => (256 * (2 ** 20)))
-      field(:uploadDate, :type => Date, :default => Time.now.utc)
-      field(:md5, :type => String, :default => Digest::MD5.hexdigest(''))
+        field(:length, :type => Integer, :default => 0)
+        field(:chunkSize, :type => Integer, :default => (256 * (2 ** 20)))
+        field(:uploadDate, :type => Date, :default => Time.now.utc)
+        field(:md5, :type => String, :default => Digest::MD5.hexdigest(''))
 
-      %w( filename contentType length chunkSize uploadDate md5 ).each do |f|
-        validates_presence_of(f)
-      end
-      validates_uniqueness_of(:filename)
+        %w( filename contentType length chunkSize uploadDate md5 ).each do |f|
+          validates_presence_of(f)
+        end
+        validates_uniqueness_of(:filename)
 
-      has_many(:chunks, :class_name => chunk_model_name, :inverse_of => :files, :dependent => :destroy, :order => [:n, :asc])
+        has_many(:chunks, :class_name => chunk_model_name, :inverse_of => :files, :dependent => :destroy, :order => [:n, :asc])
 
-      index({:filename => 1}, :unique => true) 
+        index({:filename => 1}, :unique => true) 
 
-      def path
-        filename
-      end
+        def path
+          filename
+        end
 
-      def basename
-        ::File.basename(filename)
-      end
+        def basename
+          ::File.basename(filename)
+        end
 
-      def prefix
-        self.class.namespace.prefix
-      end
+        def prefix
+          self.class.namespace.prefix
+        end
 
-      def each(&block)
-        chunks.all.order_by([:n, :asc]).each do |chunk|
-          block.call(chunk.to_s)
+        def each(&block)
+          chunks.all.order_by([:n, :asc]).each do |chunk|
+            block.call(chunk.to_s)
+          end
         end
-      end
 
-      def data
-        data = ''
-        each{|chunk| data << chunk}
-        data
-      end
+        def data
+          data = ''
+          each{|chunk| data << chunk}
+          data
+        end
 
-      def base64
-        Array(to_s).pack('m')
-      end
+        def base64
+          Array(to_s).pack('m')
+        end
 
-      def data_uri(options = {})
-        data = base64.chomp
-        "data:#{ content_type };base64,".concat(data)
-      end
+        def data_uri(options = {})
+          data = base64.chomp
+          "data:#{ content_type };base64,".concat(data)
+        end
 
-      def bytes(&block)
-        if block
-          each{|data| block.call(data)}
-          length
-        else
-          bytes = []
-          each{|data| bytes.push(*data)}
-          bytes
+        def bytes(&block)
+          if block
+            each{|data| block.call(data)}
+            length
+          else
+            bytes = []
+            each{|data| bytes.push(*data)}
+            bytes
+          end
         end
-      end
 
-      def close
-        self
-      end
+        def close
+          self
+        end
 
-      def content_type
-        contentType
-      end
+        def content_type
+          contentType
+        end
 
-      def update_date 
-        updateDate
-      end
+        def update_date 
+          updateDate
+        end
 
-      def created_at
-        updateDate
-      end
+        def created_at
+          updateDate
+        end
 
-      def namespace
-        self.class.namespace
+        def namespace
+          self.class.namespace
+        end
       end
     end
-  end
 
-##
-#
-  def GridFS.build_chunk_model_for(namespace)
-    prefix = namespace.name.split(/::/).last.downcase
-    file_model_name = "#{ namespace.name }::File"
-    chunk_model_name = "#{ namespace.name }::Chunk"
+  ##
+  #
+    def GridFS.build_chunk_model_for(namespace)
+      prefix = namespace.name.split(/::/).last.downcase
+      file_model_name = "#{ namespace.name }::File"
+      chunk_model_name = "#{ namespace.name }::Chunk"
 
-    Class.new do
-      include Mongoid::Document
+      Class.new do
+        include Mongoid::Document
 
-      singleton_class = class << self; self; end
+        singleton_class = class << self; self; end
 
-      singleton_class.instance_eval do
-        define_method(:name){ chunk_model_name }
-        attr_accessor :file_model
-        attr_accessor :namespace
-      end
+        singleton_class.instance_eval do
+          define_method(:name){ chunk_model_name }
+          attr_accessor :file_model
+          attr_accessor :namespace
+        end
 
-      self.default_collection_name = "#{ prefix }.chunks"
+        self.default_collection_name = "#{ prefix }.chunks"
 
-      field(:n, :type => Integer, :default => 0)
-      field(:data, :type => Moped::BSON::Binary)
+        field(:n, :type => Integer, :default => 0)
+        field(:data, :type => (defined?(Moped) ? Moped::BSON::Binary : BSON::Binary))
 
-      belongs_to(:file, :foreign_key => :files_id, :class_name => file_model_name)
+        belongs_to(:file, :foreign_key => :files_id, :class_name => file_model_name)
 
-      index({:files_id => 1, :n => -1}, :unique => true) 
+        index({:files_id => 1, :n => -1}, :unique => true) 
 
-      def namespace
-        self.class.namespace
-      end
-
-      def to_s
-        data.data
-      end
+        def namespace
+          self.class.namespace
+        end
 
-      alias_method 'to_str', 'to_s'
-    end
-  end
+        def to_s
+          data.data
+        end
 
-##
-#
-  def GridFS.reading(arg, &block)
-    if arg.respond_to?(:read)
-      rewind(arg) do |io|
-        block.call(io)
-      end
-    else
-      open(arg.to_s) do |io|
-        block.call(io)
+        alias_method 'to_str', 'to_s'
       end
     end
-  end
 
-  def GridFS.rewind(io, &block)
-    begin
-      pos = io.pos
-      io.flush
-      io.rewind
-    rescue
-      nil
+  ##
+  #
+    def GridFS.reading(arg, &block)
+      if arg.respond_to?(:read)
+        rewind(arg) do |io|
+          block.call(io)
+        end
+      else
+        open(arg.to_s) do |io|
+          block.call(io)
+        end
+      end
     end
 
-    begin
-      block.call(io)
-    ensure
+    def GridFS.rewind(io, &block)
       begin
-        io.pos = pos
+        pos = io.pos
+        io.flush
+        io.rewind
       rescue
         nil
       end
+
+      begin
+        block.call(io)
+      ensure
+        begin
+          io.pos = pos
+        rescue
+          nil
+        end
+      end
     end
-  end
 
-  def GridFS.extract_basename(object)
-    filename = nil
-    [:original_path, :original_filename, :path, :filename, :pathname].each do |msg|
-      if object.respond_to?(msg)
-        filename = object.send(msg)
-        break
+    def GridFS.extract_basename(object)
+      filename = nil
+      [:original_path, :original_filename, :path, :filename, :pathname].each do |msg|
+        if object.respond_to?(msg)
+          filename = object.send(msg)
+          break
+        end
       end
+      filename ? cleanname(filename) : nil
     end
-    filename ? cleanname(filename) : nil
-  end
 
-  def GridFS.extract_content_type(filename)
-    content_type = MIME::Types.type_for(::File.basename(filename.to_s)).first
-    content_type.to_s if content_type
-  end
+    def GridFS.extract_content_type(filename)
+      content_type = MIME::Types.type_for(::File.basename(filename.to_s)).first
+      content_type.to_s if content_type
+    end
 
-  def GridFS.cleanname(pathname)
-    basename = ::File.basename(pathname.to_s)
-    CGI.unescape(basename).gsub(%r/[^0-9a-zA-Z_@)(~.-]/, '_').gsub(%r/_+/,'_')
+    def GridFS.cleanname(pathname)
+      basename = ::File.basename(pathname.to_s)
+      CGI.unescape(basename).gsub(%r/[^0-9a-zA-Z_@)(~.-]/, '_').gsub(%r/_+/,'_')
+    end
   end
-end
 
-GridFs = GridFS
+##
+#
+  GridFs = GridFS
 
-GridFS.init!
+  GridFS.init!

data/mongoid-grid_fs.gemspec

@@ -3,7 +3,7 @@
 
 Gem::Specification::new do |spec|
   spec.name = "mongoid-grid_fs"
-  spec.version = "1.0.0"
+  spec.version = "1.1.0"
   spec.platform = Gem::Platform::RUBY
   spec.summary = "mongoid-grid_fs"
   spec.description = "a mongoid 3/moped compatible implementation of the grid_fs specification"
@@ -26,6 +26,10 @@ Gem::Specification::new do |spec|
   spec.test_files = nil
 
   
+    spec.add_dependency(*["mongoid", " >= 3.0.1"])
+  
+    spec.add_dependency(*["mime-types", " >= 1.19"])
+  
 
   spec.extensions.push(*[])
 

data/test/mongoid-grid_fs_test.rb

@@ -142,6 +142,8 @@ Testing GridFs do
 
 protected
   def object_id_re
-    %r| \w{#{ BSON::ObjectId.new.to_s.size }} |iomx
+    object_id = defined?(Moped) ? Moped::BSON::ObjectId.new : BSON::ObjectId.new
+
+    %r| \w{#{ object_id.to_s.size }} |iomx
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongoid-grid_fs
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,40 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-23 00:00:00.000000000 Z
-dependencies: []
+date: 2012-07-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.1
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.19'
 description: a mongoid 3/moped compatible implementation of the grid_fs specification
 email: ara.t.howard@gmail.com
 executables: []