minidoc 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bab3513e3711be6f000b2087acd5df2c327ed60f
+  data.tar.gz: 7cc05456284d80bbdba422cf58c93a829c45592b
+SHA512:
+  metadata.gz: 4d4c5d33c49a995a7d65186a9da8390aac2a0ae87340ad58c38452288bea0c424ac9e7c1d58c77fc171937ae6e1c14a36620df188586b1d5b8ff8dbad5b0638e
+  data.tar.gz: 8fbe9a2e11e6c9c37a773f41ec0c832bbe99584170fff167aa423488e01522d8d0ef619798a6185272e763abfb4840dd89f240ed4fc1c5fb44b4b6f0a192a06e

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3-p545

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.1
+services: mongodb
+before_install:
+  - gem update bundler

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Bryan Helmkamp
+
+MIT License
+
+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,76 @@
+[![Code Climate](https://codeclimate.com/github/brynary/minidoc.svg)](https://codeclimate.com/github/brynary/minidoc)
+[![Build Status](https://travis-ci.org/brynary/minidoc.svg)](https://travis-ci.org/brynary/minidoc)
+
+# Minidoc
+
+Minidoc is an extremely lightweight layer on top of the MongoDB client to
+make interacting with documents from Ruby more convenient.
+
+We rely heavily on the MongoDB client, Virtus and ActiveModel to keep
+things as simple as possible.
+
+## Features
+
+* Interact with Ruby objects instead of hashes
+* Full access to the powerful MongoDB client
+* Thread safe. (Hopefully)
+* Simple and easily extensible (Less than 500 lines of code.)
+* ActiveModel-compatible
+* Validations
+* Timestamp tracking (created_at/updated_at)
+* Very basic associations (for reads)
+* Conversion into immutable value objects
+* Read-only records
+
+## Anti-Features
+
+* Custom query API (just use Mongo)
+* Callbacks (just define a method like save and call super)
+
+## Usage
+
+    gem "minidoc", "~> 0.0.1"
+
+### Basics
+
+```ruby
+class User < Minidoc
+  attribute :name, String
+  attribute :language, String
+  timestamps!
+end
+
+user = User.create!(name: "Bryan", language: "Cobol")
+User.count # => 1
+
+user.language = "Lisp"
+user.save!
+
+user.set(language: "Fortran")
+
+user.destroy
+User.count # => 0
+```
+
+### Validations
+
+Just uses [`ActiveModel::Validations`](http://api.rubyonrails.org/classes/ActiveModel/Validations.html):
+
+```ruby
+class User < Minidoc
+  attribute :name, String
+
+  validates :name, presence: true
+end
+
+user = User.new
+user.valid? # => false
+user.name = "Bryan"
+user.valid? # => true
+```
+
+### Value Objects
+
+### Associations
+
+### Read-only records

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs.push "lib"
+  t.ruby_opts = %w[-W0]
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/lib/minidoc/associations.rb

@@ -0,0 +1,60 @@
+require "active_support/concern"
+
+module Minidoc::Associations
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def associations
+      @associations ||= {}
+    end
+
+    def belongs_to(association_name, options = {})
+      association_name = association_name.to_sym
+      associations[association_name] = options
+
+      attribute "#{association_name}_id", BSON::ObjectId
+
+      define_method("#{association_name}=") do |value|
+        write_association(association_name, value)
+      end
+
+      define_method("#{association_name}_id=") do |value|
+        instance_variable_set("@#{association_name}", nil)
+        super(value)
+      end
+
+      define_method(association_name) do
+        read_association(association_name)
+      end
+    end
+  end
+
+  def reload
+    clear_association_caches
+    super
+  end
+
+private
+
+  def write_association(name, value)
+    send("#{name}_id=", value ? value.id : nil)
+  end
+
+  def read_association(name)
+    return instance_variable_get("@#{name}") if instance_variable_get("@#{name}")
+
+    options = self.class.associations[name]
+
+    if (foreign_id = self["#{name}_id"])
+      record = options[:class_name].constantize.find(foreign_id)
+      instance_variable_set("@#{name}", record)
+      record
+    end
+  end
+
+  def clear_association_caches
+    self.class.associations.each do |name, options|
+      instance_variable_set("@#{name}", nil)
+    end
+  end
+end

data/lib/minidoc/autoload.rb

@@ -0,0 +1 @@
+autoload :Minidoc, "minidoc"

data/lib/minidoc/connection.rb

@@ -0,0 +1,28 @@
+require "active_support/concern"
+
+module Minidoc::Connection
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :connection
+    class_attribute :database_name
+  end
+
+  module ClassMethods
+    def collection
+      database[collection_name]
+    end
+
+    def database
+      connection[database_name]
+    end
+
+    def collection_name=(name)
+      @collection_name = name
+    end
+
+    def collection_name
+      @collection_name ||= name.demodulize.underscore.pluralize
+    end
+  end
+end

data/lib/minidoc/counters.rb

@@ -0,0 +1,44 @@
+class Minidoc
+  module Counters
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def counter(field, options = {})
+        start = options.fetch(:start, 0)
+        step_size = options.fetch(:step_size, 1)
+
+        attribute field, Integer, default: start
+
+        class_eval(<<-EOM)
+          def increment_#{field}
+            Minidoc::Counters::Incrementor.
+              new(self, :#{field}).increment(#{step_size})
+          end
+        EOM
+      end
+    end
+
+    class Incrementor
+      def initialize(record, field)
+        @record = record
+        @field = field
+      end
+
+      def increment(step_size = 1)
+        result = record.class.collection.find_and_modify(
+          query: { _id: record.id },
+          update: { "$inc" => { field => step_size } },
+          new: true,
+        )
+
+        result[field.to_s]
+      end
+
+      private
+
+      attr_reader :record, :field
+    end
+  end
+end

data/lib/minidoc/duplicate_key.rb

@@ -0,0 +1,12 @@
+class Minidoc::DuplicateKey < Mongo::OperationFailure
+  DUPLICATE_KEY_ERROR_CODE = 11000
+
+  def self.duplicate_key_exception(exception)
+    if exception.respond_to?(:error_code) && exception.error_code == DUPLICATE_KEY_ERROR_CODE
+      new(exception.message, exception.error_code, exception.result)
+    else
+      nil
+    end
+  end
+
+end

data/lib/minidoc/finders.rb

@@ -0,0 +1,50 @@
+require "active_support/concern"
+
+module Minidoc::Finders
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def first
+      find_one({})
+    end
+
+    def count(selector = {})
+      collection.count(query: selector)
+    end
+
+    def exists?(selector = {})
+      count(selector) > 0
+    end
+
+    def find(id_or_selector, options = {})
+      if id_or_selector.is_a?(Hash)
+        options.merge!(transformer: method(:wrap))
+        collection.find(id_or_selector, options)
+      else
+        raise ArgumentError unless options.empty?
+        id = BSON::ObjectId(id_or_selector.to_s)
+        wrap(collection.find_one(_id: id))
+      end
+    end
+
+    def find_one(selector, options = {})
+      wrap(collection.find_one(selector, options))
+    end
+
+    def from_db(attrs)
+      doc = new(attrs)
+      doc.instance_variable_set("@new_record", false)
+      doc
+    end
+
+    def wrap(doc)
+      return nil unless doc
+
+      if doc.is_a?(Array) || doc.is_a?(Mongo::Cursor)
+        doc.map { |d| from_db(d) }
+      else
+        from_db(doc)
+      end
+    end
+  end
+end

data/lib/minidoc/grid.rb

@@ -0,0 +1,16 @@
+class Minidoc::Grid < Mongo::Grid
+  def get(id)
+    id = BSON::ObjectId(id.to_s)
+    super(id)
+  end
+
+  def get_json(id)
+    raw_data = get(id).read
+    JSON.parse(raw_data)
+  end
+
+  def delete(id)
+    id = BSON::ObjectId(id.to_s)
+    super(id)
+  end
+end

data/lib/minidoc/indexes.rb

@@ -0,0 +1,31 @@
+require "active_support/concern"
+
+module Minidoc::Indexes
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    MONGO_DUPLICATE_KEY_ERROR_CODE = 11000
+
+    def ensure_index(key_or_keys, options = {})
+      indexes = Array(key_or_keys).map { |key| { key => 1 } }.reduce(:merge)
+
+      collection.ensure_index(indexes, options)
+    end
+
+    # Rescue a <tt>Mongo::OperationFailure</tt> exception which originated from
+    # duplicate key error (error code 11000) in the given block.
+    #
+    # Returns the status of the operation in the given block, or +false+ if the
+    # exception was raised.
+    def rescue_duplicate_key_errors
+      yield
+    rescue Mongo::OperationFailure => exception
+      if exception.respond_to?(:error_code) &&
+        exception.error_code == MONGO_DUPLICATE_KEY_ERROR_CODE
+        return false
+      else
+        raise
+      end
+    end
+  end
+end

data/lib/minidoc/read_only.rb

@@ -0,0 +1,11 @@
+require "minidoc"
+require "minidoc/value"
+
+class Minidoc::ReadOnly < Minidoc::Value
+  include Minidoc::Connection
+  include Minidoc::Finders
+
+  def self.database
+    Minidoc.database
+  end
+end

data/lib/minidoc/record_invalid.rb

@@ -0,0 +1,9 @@
+class Minidoc::RecordInvalid < StandardError
+  attr_reader :record
+
+  def initialize(record)
+    @record = record
+    errors = @record.errors.full_messages.join(", ")
+    super("Record invalid: #{errors}")
+  end
+end

data/lib/minidoc/test_helpers.rb

@@ -0,0 +1,24 @@
+class Minidoc
+  module TestHelpers
+    extend self
+
+    def clear_database
+      clear_collections
+      clear_indexes
+    end
+
+    def clear_collections
+      each_collection { |c| c.remove({}) }
+    end
+
+    def clear_indexes
+      each_collection(&:drop_indexes)
+    end
+
+    def each_collection(&block)
+      Minidoc.database.collections.
+        reject { |c| c.name.include?("system") }.
+        each(&block)
+    end
+  end
+end

data/lib/minidoc/timestamps.rb

@@ -0,0 +1,37 @@
+require "active_support/concern"
+
+module Minidoc::Timestamps
+  extend ActiveSupport::Concern
+
+  included do
+    class_attribute :record_timestamps
+  end
+
+  module ClassMethods
+    def timestamps!
+      self.record_timestamps = true
+      attribute :created_at, Time
+      attribute :updated_at, Time
+    end
+  end
+
+private
+
+  def create
+    if self.class.record_timestamps
+      current_time = Time.now.utc
+      self.created_at = current_time
+      self.updated_at = current_time
+    end
+
+    super
+  end
+
+  def update
+    if self.class.record_timestamps
+      self.updated_at = Time.now.utc
+    end
+
+    super
+  end
+end

data/lib/minidoc/validations.rb

@@ -0,0 +1,40 @@
+module Minidoc::Validations
+  class UniquenessValidator < ::ActiveModel::EachValidator
+    def initialize(options)
+      super(options.reverse_merge(case_sensitive: true))
+    end
+
+    def validate_each(record, attribute, value)
+      conditions = scope_conditions(record)
+
+      if options[:case_sensitive]
+        conditions[attribute] = value
+      else
+        conditions[attribute] = /^#{Regexp.escape(value.to_s)}$/i
+      end
+
+      # Make sure we're not including the current document in the query
+      if record._id
+        conditions[:_id] = { "$ne" => record.id }
+      end
+
+      if record.class.exists?(conditions)
+        record.errors.add(
+          attribute,
+          :taken,
+          options.except(:case_sensitive, :scope).merge(value: value)
+        )
+      end
+    end
+
+    def message(instance)
+      super || "has already been taken"
+    end
+
+    def scope_conditions(instance)
+      Array(options[:scope]).inject({}) do |conditions, key|
+        conditions.merge(key => instance[key])
+      end
+    end
+  end
+end

data/lib/minidoc/value.rb

@@ -0,0 +1,21 @@
+require "minidoc"
+
+class Minidoc::Value
+  include Virtus.value_object
+  extend ActiveModel::Naming
+
+  attribute :_id, BSON::ObjectId
+  alias_method :id, :_id
+
+  def to_key
+    [id.to_s]
+  end
+
+  def to_param
+    id.to_s
+  end
+
+  def as_value
+    self
+  end
+end