mongrep 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 69914b4493a7de6bb8566f431244fc57f17a8a20
+  data.tar.gz: 5f24300241239d49e2bacbbcf6d3ce99d8c12327
+SHA512:
+  metadata.gz: 96db1d696abc053ea35d709f4cb7694bf555fbdd1d969265a19cac103eefb2f889174c63f8e79158d699abe474a3b94ee3601ad06e1d76a16bc88a1ac5f5ae99
+  data.tar.gz: d695e3946bed16a8caa294fa96971a51073226ae44f78a2f5afecd95cb06296f8b423e856ca696e65513f9f9f5c3466b37d39b7d14d7a3e9ffb98d2751642d6b

data/.editorconfig

@@ -0,0 +1,15 @@
+root = true
+
+[*]
+end_of_line = lf
+trim_trailing_whitespace = true
+insert_final_newline = true
+charset = utf-8
+indent_style = space
+
+[{Gemfile,*.{rb,gemspec}}]
+indent_size = 2
+
+[*.md]
+trim_trailing_whitespace = false
+indent_size = 2

data/.gitignore

@@ -0,0 +1,22 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/*
+!/coverage/.last_run.json
+/pkg/
+/spec/reports/
+/tmp/
+/vendor/bundle/
+
+# for example coverage
+tmp
+
+# exuberant ctags
+tags
+
+# yardoc
+.yardoc/
+doc/yardoc
+
+log

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,6 @@
+require: rubocop-rspec
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*.rb'
+    - '*.gemspec'

data/.ruby-version

@@ -0,0 +1 @@
+2.3.1

data/.simplecov

@@ -0,0 +1,9 @@
+unless ARGV.any? { |e| e =~ /guard-rspec/ }
+  SimpleCov.start do
+    coverage_dir 'log/coverage'
+    formatter SimpleCov::Formatter::HTMLFormatter
+
+    command_name 'rspec'
+    maximum_coverage_drop 1
+  end
+end

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.12.5

data/.yardopts

@@ -0,0 +1,6 @@
+--plugin classmethods
+--charset utf-8
+--markup markdown
+--list-undoc compact
+--output-dir doc/yardoc
+lib/**/*.rb

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mongrep.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+guard :rspec, cmd: 'bundle exec rspec' do
+  require 'guard/rspec/dsl'
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  watch(ruby.lib_files) do |m|
+    spec_path = m[1][%r{(?<=lib/).*}]
+    [
+      rspec.spec.call("unit/#{spec_path}"),
+      rspec.spec.call("integration/#{spec_path}")
+    ]
+  end
+
+  # Shared examples
+  watch(%r{(spec/.+)/shared_examples/.*\.rb}) { |m| m[1] }
+end
+
+guard 'yard' do
+  watch(%r{app/.+\.rb})
+  watch(%r{lib/.+\.rb})
+  watch(%r{ext/.+\.c})
+end

data/README.md

@@ -0,0 +1,31 @@
+# Mongrep
+
+This gem provides classes and modules for implementing persistance layers using
+the repository pattern
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mongrep', '~> 0.2'
+```
+
+And then execute:
+
+    $ bundle
+
+## Documentation
+
+API docs are available at https://rubydocs.info/mongrep
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`rake test` to run the tests. You can also run `bin/console` for an interactive
+prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To
+release a new version, update the version number in `version.rb`, and then run
+`bundle exec rake release`, which will create a git tag for the version, push
+git commits and tags and push the gem to rubygems.org.

data/README.md.erb

@@ -0,0 +1,31 @@
+# Mongrep
+
+This gem provides classes and modules for implementing persistance layers using
+the repository pattern
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mongrep', '~> <%= Mongrep::VERSION.split('.').first(2).join('.') %>'
+```
+
+And then execute:
+
+    $ bundle
+
+## Documentation
+
+API docs are available at https://rubydocs.info/mongrep
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`rake test` to run the tests. You can also run `bin/console` for an interactive
+prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To
+release a new version, update the version number in `version.rb`, and then run
+`bundle exec rake release`, which will create a git tag for the version, push
+git commits and tags and push the gem to rubygems.org.

data/Rakefile

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+require 'erb'
+require 'yard'
+require 'json'
+
+require 'mongrep/version'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :test
+
+task test: [:spec, :rubocop]
+
+RuboCop::RakeTask.new
+
+Rake::Task['release:guard_clean'].enhance do
+  begin
+    system('git stash')
+    erb = ERB.new(File.read(File.expand_path('../README.md.erb', __FILE__)))
+    File.write(File.expand_path('../README.md', __FILE__), erb.result)
+    system('git add README.md')
+    system('git commit -m "Update gem version in readme"')
+  ensure
+    system('git stash pop')
+  end
+end

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'mongrep'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require 'pry'
+# Pry.start
+
+require 'pry'
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/mongrep/core_ext/hash.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require 'active_support/core_ext/hash/indifferent_access'
+
+module Mongrep
+  # Top level namespace for all core extensions
+  module CoreExt
+    # Core extensions to Hash class
+    module Hash
+      # Produces a hash containing only given keys which can be in dot
+      # notation
+      # @param keys [<String, Symbol>] the keys to include in the resulting
+      #   hash. Note that they are stringified and self will be accessed
+      #   with indifferent access.
+      # @return [{String => Object}] the hash including only the selected
+      #   stringified keys
+      # @example
+      #   hash = { foo: { bar: 'foobar' }, bar: 'foo' }
+      #   hash.slice_with_dot_notation('foo.bar')
+      #   #=> { 'foo.bar' => 'foobar' }
+      def slice_with_dot_notation(*keys)
+        keys.map(&:to_s).each_with_object(self.class.new) do |key, hash|
+          path = key.to_s.split('.')
+
+          catch :missing_key do
+            hash[key] = path.reduce(with_indifferent_access) do |level, part|
+              throw :missing_key unless level.key?(part)
+              level[part]
+            end
+          end
+        end
+      end
+
+      ::Hash.include(self)
+    end
+  end
+end

data/lib/mongrep/core_ext/mongo/error/operation_failure.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+require 'mongo'
+
+module Mongrep
+  module CoreExt
+    # Core extensions to Mongo
+    module Mongo
+      # Core extensions to Mongo::Error
+      module Error
+        # Core extensions to Mongo::Error::OperationFailure
+        module OperationFailure
+          def duplicate_key_error?
+            message.start_with?('E11000')
+          end
+
+          ::Mongo::Error::OperationFailure.include(self)
+        end
+      end
+    end
+  end
+end

data/lib/mongrep/model.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+require 'virtus'
+
+module Mongrep
+  # A mixin providing Virtus.model functionality and a recursive to_h method
+  module Model
+    class << self
+      private
+
+      # The included method is used here to ensure correct order
+      # of inclusion and method overrides
+      def included(base)
+        base.include(Virtus.model(strict: true))
+        base.include(VirtusExtensions)
+        base.extend(ClassMethods)
+      end
+    end
+
+    # Static methods of Shells
+    module Shell
+      # @return [String] A human readable string representation of the
+      #   instance
+      def inspect
+        instance_vars = instance_variables.map do |var|
+          "#{var}=#{instance_variable_get(var).inspect}"
+        end
+        "#<#{self.class.inspect}:#{object_id} #{instance_vars.join(' ')}>"
+      end
+
+      # Static class methods for Shells
+      module ClassMethods
+        # @return [String] A human readable string representation of the
+        #   class instance
+        def inspect
+          name
+        end
+      end
+    end
+
+    # Class methods for models
+    # TODO: Clean this up
+    # @!classmethods
+    module ClassMethods
+      # Returns a new model that includes just the provided subset of fields
+      # from the original model
+      # @overload partial(*field_names)
+      #   @param field_names [Array(Symbol)] a list of fields to include in the
+      #     resulting model
+      # @overload partial(*field_names, nested_fields)
+      #   @param field_names [Array(Symbol)] a list of fields to include in the
+      #     resulting model
+      #   @param nested_fields [Hash(Symbol => Array(Symbol, Hash))]
+      #     nested fields to include in the resulting model
+      # @return [Model] the generated model class
+      # @example
+      #   MyModel.partial(:foo, :bar)
+      # @example With nested fields
+      #   MyModel.partial(:foo, :bar, nested: [:foo, { deep: [:bar] }])
+      def partial(*fields)
+        class_name = "#{name}::Partial[#{fields.map(&:inspect).join(', ')}]"
+        attributes = partial_attributes(*fields)
+        Class.new do
+          include Model
+          include Shell
+          extend Shell::ClassMethods
+
+          define_singleton_method(:name) { class_name }
+          attributes.each { |attribute| attribute_set << attribute }
+        end
+      end
+
+      private
+
+      def partial_attributes(*fields)
+        field_hash = fields.last.is_a?(Hash) ? fields.pop : {}
+
+        (fields + field_hash.keys).map do |name|
+          attribute = attribute_set[name]
+          nested_fields = field_hash[name]
+          if nested_fields
+            nested_partial_attribute(attribute, *nested_fields)
+          else
+            attribute
+          end
+        end
+      end
+
+      def nested_partial_attribute(attribute, *fields)
+        type = nested_partial(attribute.type, *fields)
+        options = attribute.options.slice(
+          :primitive, :default, :strict, :required, :finalize,
+          :nullify_blank, :reader, :writer, :name, :coerce
+        )
+        Virtus::Attribute.build(type, options)
+      end
+
+      def nested_partial(type, *fields)
+        case type
+        when Virtus::Attribute::Collection::Type
+          type.primitive[type.member_type.partial(*fields)]
+        when Virtus::Attribute::Hash::Type
+          Hash[type.key_type.primitive => type.value_type.partial(*fields)]
+        else type.primitive.partial(*fields)
+        end
+      end
+    end
+
+    # @!parse include VirtusExtensions
+
+    # Extensions to Virtus models
+    module VirtusExtensions
+      # Converts the model into a hash. This supports nested models.
+      # @return [Hash] A Hash representation of the models attributes
+      def to_h
+        result = {}
+        super.each { |key, value| result[key] = hashify_value(value) }
+        result
+      end
+
+      # Checks for equality between self and other
+      # @param other [Model] Another Model
+      # @return [true] If other has equal attributes
+      # @return [false] otherwise
+      def ==(other)
+        return false unless other.is_a?(self.class)
+        to_h == other.to_h
+      end
+
+      private
+
+      def hashify_value(value)
+        case value
+        when Array then value.map(&method(:hashify_value))
+        when Hash
+          result = {}
+          value.each { |k, v| result[k] = hashify_value(v) }
+          result
+        when Model then value.to_h
+        else value
+        end
+      end
+    end
+  end
+end

data/lib/mongrep/mongo_model.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+require 'abstractize'
+require 'active_support/core_ext/hash/indifferent_access'
+
+require 'mongrep/model'
+
+module Mongrep
+  # @abstract The base class for all models
+  class MongoModel
+    include Abstractize
+    include Model
+
+    define_abstract_method :_id
+
+    # An alias for #_id
+    def id
+      _id
+    end
+
+    # Used by Mongo to convert the model into BSON
+    # @api private
+    def bson_type
+      Hash::BSON_TYPE
+    end
+
+    # Used by Mongo to convert the model into BSON
+    # @api private
+    def to_bson(*args)
+      to_h.to_bson(*args)
+    end
+  end
+end

data/lib/mongrep/query.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+module Mongrep
+  # A mongodb query object
+  class Query
+    # @param query_hash [Hash] A hash representing the query
+    # @example
+    #   Query.new(name: 'test')
+    def initialize(query_hash = {})
+      @query_hash = query_hash.to_h
+    end
+
+    # Combines two queries by merging their underlying query hashes
+    # @param other [Query] The query to combine self with
+    # @return [Query] A new Query instance resulting in the combination of
+    #   self and other
+    # @example
+    #   first = Query.new(name: 'test', value: 5)
+    #   second = Query.new(value: 6)
+    #   (first & second).to_h #=> { name: 'test', value: 6 }
+    def &(other)
+      self.class.new(@query_hash.merge(other.to_h))
+    end
+
+    # Combines two queries by using the MongoDB $or operator
+    # @param other [Query] The query to combine self with
+    # @return [Query] A new Query instance resulting in the combination of
+    #   self and other
+    # @example
+    #   first = Query.new(name: 'foo')
+    #   second = Query.new(name: 'bar')
+    #   (first | second).to_h
+    #   #=> { :$or => [{ name: 'foo' }, { name: 'bar' }] }
+    def |(other)
+      self.class.new(:$or => [@query_hash, other.to_h])
+    end
+
+    # Combines self with the given query hash by merging it to the
+    # existing one
+    # @param query_hash [Hash] The query hash to merge into the query
+    # @return [Query] A new Query resulting in the combination of the
+    #   given query hash and the existing one
+    # @example
+    #   query.where(name: 'test')
+    # @note This is mainly for usage in Repository#find using a block
+    # @see #&
+    # @see Repository Repository#find
+    def where(query_hash)
+      self & self.class.new(query_hash)
+    end
+
+    # Combines self with the given query hash by using the MongoDB $or
+    # operator
+    # @param query_hash [Hash] The query hash to combine with the query
+    # @return [Query] A new Query resulting in the combination of the
+    #   given query hash and the existing one
+    # @see #|
+    # @example
+    #   query.where(name: 'foo').or(name: 'bar')
+    def or(query_hash)
+      self | self.class.new(query_hash)
+    end
+
+    alias and where
+
+    # @return [Hash] The underlying query hash
+    def to_h
+      @query_hash
+    end
+  end
+end

data/lib/mongrep/query_result.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+module Mongrep
+  # A wrapper around mongo cursors
+  class QueryResult
+    include Enumerable
+
+    # The methods to be delegated to the underlying mongo cursor
+    # @api private
+    DELEGATED_METHODS = %i(limit projection skip sort).freeze
+
+    attr_reader :model_class
+    # @api private
+    def initialize(collection_view, model_class)
+      @model_class = model_class
+      @collection_view = collection_view
+    end
+
+    DELEGATED_METHODS.each do |method|
+      aggregation_stage = method == :projection ? :project : method
+
+      define_method(method) do |param|
+        if @collection_view.is_a?(Mongo::Collection::View::Aggregation)
+          @collection_view.pipeline << { :"$#{aggregation_stage}" => param }
+        else
+          @collection_view = @collection_view.public_send(method, param)
+        end
+
+        self
+      end
+    end
+
+    # Iterates over the query result
+    # @yieldparam item [Model] A model representing a document from the
+    #   query result
+    # @return [void]
+    def each
+      return enum_for(:each) unless block_given?
+
+      @collection_view.each do |document|
+        yield @model_class.new(document)
+      end
+    end
+  end
+end

data/lib/mongrep/read_only_repository.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'mongrep/repository'
+module Mongrep
+  # A mixin providing overwrites for write methods in read-only repositories
+  module ReadOnlyRepository
+    # An error signaling that the write operation isn't possible
+    class WriteError < ArgumentError; end
+
+    # @!method insert(*)
+    #   @raise [WriteError] - Always raises
+    # @!method update(*)
+    #   @raise [WriteError] - Always raises
+    # @!method delete(*)
+    #   @raise [WriteError] - Always raises
+    %i(insert update delete).each do |method|
+      define_method(method) do |*|
+        raise WriteError, 'this repository is read-only'
+      end
+    end
+  end
+end

data/lib/mongrep/repository.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+require 'active_support/inflector'
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/hash/slice'
+require 'mongrep/core_ext/hash'
+require 'abstractize'
+require 'mongrep/query'
+require 'mongrep/query_result'
+require 'mongrep/core_ext/mongo/error/operation_failure'
+
+module Mongrep
+  # @abstract The base class for all repositories
+  class Repository
+    include Abstractize
+
+    # An error signaling that a document could not be found
+    class DocumentNotFoundError < RuntimeError; end
+    # An error signaling that a model has not been persisted
+    class UnpersistedModelError < ArgumentError; end
+    # An error signaling that a document already exists
+    class DocumentExistsError < ArgumentError; end
+
+    attr_reader :collection
+
+    # @param mongo_client [Mongo::Client] The mongodb client to use
+    # @param collection_name [String] The name of the collection to use
+    #   defaults to the demodulized and underscored class name
+    def initialize(
+      mongo_client,
+      collection_name = self.class.name.demodulize.underscore
+    )
+      @collection = mongo_client[collection_name]
+    end
+
+    # Derives the model class from the class name, requires and returns it
+    # @return [Model.class] The model class for this repository
+    # @example
+    #   repository = Shop::ShoppingCarts.new(mongo_client)
+    #   repository.model_class #=> Shop::Models::ShoppingCart
+    def model_class
+      model_name = self.class.name.demodulize.singularize
+      Mongrep.models_namespace.const_get(model_name)
+    end
+
+    # Finds documents matching the given query
+    # @overload find(query)
+    #   @param query [Hash, Query] The mongodb query to perform
+    # @overload find(query, options)
+    #   @param query [Hash, Query] The mongodb query to perform
+    #   @param options [Hash] Options to pass to the query
+    # @overload find
+    #   @yieldparam query [Query] A new query
+    #   @yieldreturn [Query] The query to be used
+    # @overload find(query)
+    #   @param query [Hash, Query] The initial query
+    #   @yieldparam query [Query] The query object
+    #   @yieldreturn [Query] The final query to be used
+    # @overload find(query, options)
+    #   @param query [Hash, Query] The initial query
+    #   @param options [Hash] Options to pass to the query
+    #   @yieldparam query [Query] The query object
+    #   @yieldreturn [Query] The final query to be used
+    # @return [QueryResult<Model>] An enumerable query result
+    # @example With query hash
+    #   result = repository.find(name: 'test')
+    # @example With Query object
+    #   repeating_query = Query.new(name: 'test')
+    #   result = repository.find(repeating_query)
+    # @example With code block
+    #   result = repository.find do |query|
+    #     query.where(name: 'test 1').or(name: 'test 2')
+    #   end
+    # @example With query hash and options
+    #   result = repository.find({ name: 'test' }, limit: 1)
+    # @see Query
+    # @see QueryResult
+    def find(query = {}, options = {})
+      query_object = query.is_a?(Hash) ? Query.new(query) : query
+      query_object = yield(query_object) if block_given?
+      execute_query(query_object, options)
+    end
+
+    # Finds a single document matching the given query
+    # @overload find_one(query)
+    #   @param query [Hash, Query] The mongodb query to perform
+    # @overload find_one(query, options)
+    #   @param query [Hash, Query] The mongodb query to perform
+    #   @param options [Hash] Options to pass to the query
+    # @overload find_one
+    #   @yieldparam query [Query] A new query
+    #   @yieldreturn [Query] The query to be used
+    # @overload find_one(query)
+    #   @param query [Hash, Query] The initial query
+    #   @yieldparam query [Query] The query object
+    #   @yieldreturn [Query] The final query to be used
+    # @overload find_one(query, options)
+    #   @param query [Hash, Query] The initial query
+    #   @param options [Hash] Options to pass to the query
+    #   @yieldparam query [Query] The query object
+    #   @yieldreturn [Query] The final query to be used
+    # @raise [DocumentNotFoundError] if no matching document could be found
+    # @return [Model] The single model instance representing the document
+    #   matching the query
+    def find_one(query = {}, options = {}, &block)
+      # TODO: Pass some context to DocumentNotFoundError
+      find(query, options, &block).first || raise(DocumentNotFoundError)
+    end
+
+    # Inserts a document into the database
+    # @param model [Model] The model representing the document to be inserted
+    # @return [Mongo::Operation::Write::Insert::Result] The result of the
+    #   insert operation
+    def insert(model)
+      collection.insert_one(model.to_h)
+    rescue Mongo::Error::OperationFailure => error
+      # TODO: Pass relevant info to DocumentExistsError message
+      raise(error.duplicate_key_error? ? DocumentExistsError : error)
+    end
+
+    # Update an existing document in the database
+    # @param model [Model] The model representing the document to be updated
+    # @option options [Array<String>] :fields The specific fields to update.
+    #   If this option is omitted the whole document is updated
+    # @raise [UnpersistedModelError] if the model is not persisted
+    #   (has no value for _id)
+    # @raise [DocumentNotFoundError] if nothing was updated
+    #   (no document found for _id)
+    # @return [Mongo::Operation::Write::Update::Result] The result of the
+    #   update operation
+    def update(model, options = {})
+      check_persistence!(model)
+      result = collection.update_one(
+        id_query(model),
+        update_hash(model, options[:fields])
+      )
+      # TODO: Pass some context to DocumentNotFoundError
+      raise(DocumentNotFoundError) if result.documents.first['n'].zero?
+      result
+    end
+
+    # TODO: implement upsert
+
+    # Delete an existing document from the database
+    # @param model [Model] The model representing the document to be updated
+    # @raise [UnpersistedModelError] if the model is not persisted
+    #   (has no value for _id)
+    # @raise [DocumentNotFoundError] if nothing was deleted
+    #   (no document found for _id)
+    # @return [Mongo::Operation::Write::Delete::Result] The result of the
+    #   delete operation
+    def delete(model)
+      check_persistence!(model)
+      result = collection.delete_one(id_query(model))
+      # TODO: Pass some context to DocumentNotFoundError
+      raise(DocumentNotFoundError) if result.documents.first['n'].zero?
+      result
+    end
+
+    # Get a distinct list of values for the given field over all documents
+    # in the collection.
+    # @param field [Symbol, String] The field or dot notated path to the
+    #   field
+    # @return [Array] An array with the distinct values
+    def distinct(field)
+      collection.distinct(field)
+    end
+
+    private
+
+    def update_hash(model, fields_to_set = nil)
+      model_fields = model.to_h.except(:_id)
+      return model_fields unless fields_to_set
+      { :$set => model_fields.slice_with_dot_notation(*fields_to_set) }
+    end
+
+    def id_query(model)
+      { _id: model._id }
+    end
+
+    def execute_query(query_object, options)
+      check_query_type!(query_object)
+      QueryResult.new(collection.find(query_object.to_h, options), model_class)
+    end
+
+    def check_persistence!(model)
+      return if model._id
+      raise UnpersistedModelError, 'model is not yet persisted'
+    end
+
+    protected
+
+    def check_query_type!(query_object)
+      return if query_object.is_a?(Query)
+      raise ArgumentError, 'Invalid type for query ' \
+                           "(#{query_object.class.name})"
+    end
+  end
+end

data/lib/mongrep/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+module Mongrep
+  # The current version of this gem
+  VERSION = '0.2.0'
+end

data/lib/mongrep.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+require 'mongrep/version'
+
+# The top level namespace
+module Mongrep
+  # An error signaling an error with the configuration of the gem
+  class ConfigurationError < RuntimeError; end
+
+  module_function
+
+  # @overload models_namespace
+  #   Get the namespace where models are defined
+  # @overload models_namespace(namespace)
+  #   Set the namespace where models are defined
+  #   @param namespace [Module] The namespace module to be set
+  # @return [Module] the models namespace
+  def models_namespace(namespace = nil)
+    unless namespace || @models_namespace
+      raise ConfigurationError, 'models namespace is unset'
+    end
+
+    namespace ? @models_namespace = namespace : @models_namespace
+  end
+end

data/mongrep.gemspec

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mongrep/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'mongrep'
+  spec.version       = Mongrep::VERSION
+  spec.authors       = ['Joakim Reinert']
+  spec.email         = ['reinert@meso.net']
+
+  spec.summary       =
+    'A library for utilizing the repository pattern for MongoDB'
+  spec.description   =
+    'Mongrep provides base classes and modules for implementing persistance ' \
+    'layers for MongoDB using the repository pattern'
+  spec.homepage      = 'https://github.com/meso-unimpressed/mongrep'
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.1'
+  spec.add_development_dependency 'rake', '~> 11.2'
+  spec.add_development_dependency 'rspec', '~> 3.5'
+  spec.add_development_dependency 'rubocop', '~> 0.4'
+  spec.add_development_dependency 'rubocop-rspec', '~> 1.7'
+  spec.add_development_dependency 'pry', '~> 0.1'
+  spec.add_development_dependency 'pry-byebug', '~> 3.4'
+  spec.add_development_dependency 'simplecov', '~> 0.1'
+  spec.add_development_dependency 'guard', '~> 2.1'
+  spec.add_development_dependency 'guard-rspec', '~> 4.7'
+  spec.add_development_dependency 'guard-yard', '~> 2.1'
+  spec.add_development_dependency 'libnotify', '~> 0.9'
+  spec.add_development_dependency 'yard', '~> 0.9'
+  spec.add_development_dependency 'yard-classmethods', '~> 1.0'
+  spec.add_development_dependency 'factory_girl', '~> 4.7'
+
+  spec.add_dependency 'abstractize', '~> 0.1'
+  spec.add_dependency 'mongo', '~> 2.3'
+  spec.add_dependency 'virtus', '~> 1.0'
+  spec.add_dependency 'activesupport', '~> 5.0'
+end

metadata

@@ -0,0 +1,336 @@
+--- !ruby/object:Gem::Specification
+name: mongrep
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Joakim Reinert
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-11-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+- !ruby/object:Gem::Dependency
+  name: guard-yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: libnotify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: yard-classmethods
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+- !ruby/object:Gem::Dependency
+  name: abstractize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: mongo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Mongrep provides base classes and modules for implementing persistance
+  layers for MongoDB using the repository pattern
+email:
+- reinert@meso.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- ".simplecov"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- Guardfile
+- README.md
+- README.md.erb
+- Rakefile
+- bin/console
+- bin/setup
+- lib/mongrep.rb
+- lib/mongrep/core_ext/hash.rb
+- lib/mongrep/core_ext/mongo/error/operation_failure.rb
+- lib/mongrep/model.rb
+- lib/mongrep/mongo_model.rb
+- lib/mongrep/query.rb
+- lib/mongrep/query_result.rb
+- lib/mongrep/read_only_repository.rb
+- lib/mongrep/repository.rb
+- lib/mongrep/version.rb
+- mongrep.gemspec
+homepage: https://github.com/meso-unimpressed/mongrep
+licenses: []
+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.5.1
+signing_key: 
+specification_version: 4
+summary: A library for utilizing the repository pattern for MongoDB
+test_files: []