mordor 0.3.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c0c2388e8d060d289571c40264cadf1d531c4efc
+  data.tar.gz: 2d660783cf567837d0936d10e6e66886ad47e14d
+SHA512:
+  metadata.gz: 0f8ddbdd70ec496a7a02df49b61425e7ad2064b5e88d3bd986d50f072d87addcb328acc14cc34c097dfdcfb633eb24cc4838e0df0e3f156318757ccb12fa925a
+  data.tar.gz: f4c0113fbbc300bd213b568f4df16307f6bcea8e51831d060f067924066fbb098848a6117e7eed840f72d84f960c1ef2e119e75490a2b988bb23e0e4ce910b73

data/.gitignore

@@ -0,0 +1,5 @@
+pkg/*
+.rvmrc
+.ruby-*
+Gemfile.lock
+.bundle

data/.travis.yml

@@ -0,0 +1,22 @@
+language: ruby
+cache: bundler
+bundler_args: --without optional
+
+jdk:
+  - oraclejdk7
+
+services:
+  - mongodb
+
+rvm:
+  - 1.9.3
+  - 2.1.6
+  - 2.2.2
+  - jruby-19mode
+  - rbx-19mode
+  - rbx-2.5.3
+
+matrix:
+  allow_failures:
+    - rvm: rbx-19mode
+    - rvm: rbx-2.5.3

data/CHANGES.md

@@ -0,0 +1,9 @@
+0.3.0
+-----------
+- Adds connection pool support
+- Sets explicit mongo gem dependency to version < 2.0
+- Deprecates support for MRI 1.8.7, 1.9.2 and JRuby 1.8
+
+0.2.20
+-----------
+- First stable release

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :optional do
+  gem 'guard-rspec'
+end

data/Guardfile

@@ -0,0 +1,39 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features)
+
+## Uncomment to clear the screen before every task
+# clearing :on
+
+## Guard internally checks for changes in the Guardfile and exits.
+## If you want Guard to automatically start up again, run guard in a
+## shell loop, e.g.:
+##
+##  $ while bundle exec guard; do echo "Restarting Guard..."; done
+##
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rsspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separetly)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 J.W. Koelewijn
+
+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,27 @@
+[![Build Status](https://secure.travis-ci.org/jwkoelewijn/mordor.png?branch=master)](http://travis-ci.org/jwkoelewijn/mordor)
+
+## Introduction
+Small library to add DataMapper style resources for MongoDB.
+
+```ruby
+class ExampleResource
+  include Mordor::Resource
+
+  attribute :first, :index => true
+  attribute :second
+  attribute :third, :finder_method => :find_by_third_attribute
+  attribute :at,    :timestamp => true
+end
+```
+
+This adds attr_accessors to the ExampleResource for each attribute, plus adds finder methods of the form 
+`find_by_{attribute}`. The naming convention can be overridden by using the optional `:finder_method` option,
+as can be seen with the third attribute.
+
+When the `:index => true` option is set, indices are ensured before each query on 
+the collection. Indices are descending by default, but this can be changed by also supplying a `:index_type => Mongo::ASCENDING` option.
+
+At most one attribute per Resource can have the option `:timestamp => true` set. This means that the attribute will be saved as one of the two first 
+attributes (the other one being the `_id` attribute. When no value is given for the timestamped attribute, a timestamp with value 0 will be inserted,
+which results in a timestamp being assigned to it by the MongoDB.
+An exception is raised when more than one attribute is given the timestamp option

data/Rakefile

@@ -0,0 +1,24 @@
+require "rubygems"
+require "bundler"
+
+Bundler.setup
+
+load('./tasks/github-gem.rake')
+
+task :default  => :spec
+
+# Register the gem release tasks in the gem namespace
+GithubGem::RakeTasks.new(:gem) do |config|
+
+  # Note that the following values are all default values and can
+  # therefore be omitted if they are not changed.
+
+  config.gemspec_file   = GithubGem.detect_gemspec_file
+  config.main_include   = GithubGem.detect_main_include
+  config.root_dir       = Dir.pwd
+  config.test_pattern   = 'test/**/*_test.rb'
+  config.spec_pattern   = 'spec/**/*_spec.rb'
+  config.local_branch   = 'master'
+  config.remote         = 'origin'
+  config.remote_branch  = 'master'
+end

data/ext/mkrf_conf.rb

@@ -0,0 +1,21 @@
+require 'rubygems/dependency_installer'
+
+gdi = Gem::DependencyInstaller.new
+
+begin
+  if RUBY_PLATFORM == 'java'
+    puts "Not installing bson_ext gem, because we're running on JRuby"
+  else
+    puts "Installing bson_ext"
+    gdi.install "bson_ext"
+  end
+rescue => e
+  warn "#{$0}: #{e}"
+
+  exit!
+end
+
+# Write fake Rakefile for rake since Makefile isn't used
+File.open(File.join(File.dirname(__FILE__), 'Rakefile'), 'w') do |f|
+  f.write("task :default" + $/)
+end

data/lib/mordor.rb

@@ -0,0 +1,84 @@
+require 'rubygems'
+require 'rational'
+require 'mongo'
+require 'extlib'
+require 'json'
+require 'mordor/version'
+require 'mordor/config'
+require 'mordor/collection'
+require 'mordor/resource'
+
+unless Object.const_defined?('BigDecimal')
+  BigDecimal = Float
+end
+
+class Date
+  def to_time(form = :utc)
+    Time.send("#{form}", year, month, day)
+  end
+
+  def to_gm
+    Time.gm(year, month, day).to_datetime
+  end
+
+  def to_local
+    Time.local(year, month, day).to_datetime
+  end
+
+  def to_datetime
+    DateTime.civil(self.year, self.mon, self.day)
+  end
+
+  def show(format = nil)
+    case format
+    when :human
+      strftime("%d-%m-%Y")
+    else
+      to_s
+    end
+  end
+
+  def full_string
+    strftime("%A %d %B %Y")
+  end
+end
+
+class DateTime
+  def to_datetime
+    self
+  end
+
+  def to_date
+    Date.civil(self.year, self.mon, self.day)
+  end
+
+  def show(format = nil)
+    case format
+    when :human
+      strftime("%d-%m-%Y %H:%M")
+    when :full
+      strftime("%d-%m-%Y %H:%M:%S")
+    else
+      to_s
+    end
+  end
+end
+
+class Time
+
+  def to_date
+    Date.civil(year, month, day)
+  end if RUBY_VERSION < '1.8.6'
+
+  def show(format = nil)
+    return self.to_date.show(format) if [hour,min] == [0,0]
+    case format
+    when :human
+      strftime("%d-%m-%Y %H:%m")
+    when :full
+      strftime("%d-%m-%Y %H:%M:%S")
+    else
+      to_s
+    end
+  end
+end

data/lib/mordor/collection.rb

@@ -0,0 +1,50 @@
+module Mordor
+  class Collection
+    include Enumerable
+
+    def initialize(klass, cursor)
+      @klass = klass
+      @cursor = cursor
+    end
+
+    def each
+      @cursor.each do |element|
+        if element.is_a? @klass
+          yield element
+        else
+          yield @klass.new(element)
+        end
+      end
+      @cursor.rewind! unless @cursor.is_a? Array
+    end
+
+    def size(regard_limits_and_offsets = true)
+      @cursor.is_a?(Array) ? @cursor.count : @cursor.count(regard_limits_and_offsets)
+    end
+    alias :count :size
+
+    def method_missing(method, *args, &block)
+      if @cursor.respond_to?(method)
+        self.class.new(@klass, @cursor.__send__(method, *args, &block))
+      else
+        super
+      end
+    end
+
+    def to_json(*args)
+      to_a.to_json(*args)
+    end
+
+    def merge(other_collection)
+      Collection.new(@klass, (self.to_a + other_collection.to_a))
+    end
+    alias_method :+, :merge
+
+    def merge!(other_collection)
+      unless @cursor.is_a? Array
+        @cursor = @cursor.to_a
+      end
+      @cursor += other_collection.to_a
+    end
+  end
+end

data/lib/mordor/config.rb

@@ -0,0 +1,91 @@
+module Mordor
+  class Config
+    class << self
+
+      # Yields the configuration.
+      #
+      # ==== Block parameters
+      # c<Hash>:: The configuration parameters.
+      #
+      # ==== Examples
+      #   Merb::Config.use do |config|
+      #     config[:exception_details] = false
+      #     config[:log_stream]        = STDOUT
+      #   end
+      #
+      # ==== Returns
+      # nil
+      #
+      # :api: publicdef use
+      def use
+        @configuration ||= defaults
+        yield @configuration
+        nil
+      end
+
+      # Resets the configuration to its default state
+      #
+      def reset
+        setup
+      end
+
+      # Retrieve the value of a config entry.
+      #
+      # ==== Parameters
+      # key<Object>:: The key to retrieve the parameter for.
+      #
+      # ==== Returns
+      # Object:: The value of the configuration parameter.
+      #
+      # :api: public
+      def [](key)
+        (@configuration ||= setup)[key]
+      end
+
+      # Set the value of a config entry.
+      #
+      # ==== Parameters
+      # key<Object>:: The key to set the parameter for.
+      # val<Object>:: The value of the parameter.
+      #
+      # :api: public
+      def []=(key, val)
+        (@configuration ||= setup)[key] = val
+      end
+
+      private
+
+      # Returns the hash of default config values for Merb.
+      #
+      # ==== Returns
+      # Hash:: The defaults for the config.
+      #
+      # :api: private
+      def defaults
+        @defaults ||= {
+          :hostname => 'localhost',
+          :port     => 27017,
+          :database => 'development',
+          :pool_size => nil,
+          :pool_timeout => nil,
+          :rs_refresh_mode => :sync,
+        }
+      end
+
+      # Sets up the configuration by storing the given settings.
+      #
+      # ==== Parameters
+      # settings<Hash>::
+      #   Configuration settings to use. These are merged with the defaults.
+      #
+      # ==== Returns
+      # The configuration as a hash.
+      #
+      # :api: private
+      def setup(settings = {})
+        @configuration = defaults.merge(settings)
+      end
+    end
+
+  end
+end

data/lib/mordor/resource.rb

@@ -0,0 +1,385 @@
+module Mordor
+  module Resource
+    attr_accessor :_id
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def initialize(attributes = {})
+      attributes.each do |k,v|
+        self.send("#{k}=", v)
+      end
+    end
+
+    def replace_params(params = {})
+      result = {}
+      return result if params.nil? or params.empty?
+      params.each do |key, value|
+        value = replace_type(value)
+        key = key.to_s.gsub(/\W|\./, "_")
+        result[key] = value
+      end
+      result
+    end
+
+    def replace_type(value)
+      case value
+      when Hash
+        value = replace_params(value)
+      when Date, DateTime
+        value = value.to_time.getlocal
+      when Time
+        value = value.getlocal
+      when BigDecimal
+        value = value.to_f
+      when Array
+        value = value.map do |val|
+          replace_type(val)
+        end
+      when BSON::Timestamp
+        value = replace_params({:seconds => value ? value.seconds : 0, :increment => value ? value.increment : 0})
+      when Integer
+      else
+        value = value.to_s
+      end
+      value
+    end
+
+    def new?
+      return self._id == nil
+    end
+
+    def saved?
+      return !new?
+    end
+
+    def reload
+      return unless _id
+      res = self.class.get(_id).to_hash.each do |k, v|
+        self.send("#{k}=".to_sym, v)
+      end
+      self
+    end
+
+    def save
+      unless self._id
+        self_hash = self.to_hash
+        if timestamp_attribute = self.class.timestamped_attribute
+          timestamp_value = self_hash.delete(timestamp_attribute)
+          if timestamp_value.is_a?(Hash)
+            timestamp_value = BSON::Timestamp.new(timestamp_value["seconds"], timestamp_value["increment"])
+          end
+          ordered_self_hash = BSON::OrderedHash.new
+          if timestamp_value.nil? || (timestamp_value.is_a?(String) && timestamp_value.empty?)
+            ordered_self_hash[timestamp_attribute] = BSON::Timestamp.new(0, 0)
+          else
+            ordered_self_hash[timestamp_attribute] = timestamp_value
+          end
+          self_hash.each do |key, value|
+            ordered_self_hash[key] = value
+          end
+          self_hash = ordered_self_hash
+        end
+        with_collection do |collection|
+          insert_id = collection.insert(self_hash)
+          self._id = insert_id
+        end
+      else
+        insert_id = self.update
+      end
+      saved?
+    end
+
+    alias_method :save!, :save
+
+    def with_collection
+      self.class.with_collection do |collection|
+        yield collection
+      end
+    end
+
+    def update
+      insert_id = nil
+      with_collection do |collection|
+        insert_id = collection.update({:_id => self._id}, self.to_hash)
+      end
+      insert_id
+    end
+
+    def collection
+      self.class.collection
+    end
+
+    def to_hash
+      attributes = self.class.instance_variable_get(:@attributes)
+      result = {}
+      return result unless attributes
+      attributes.each do |attribute_name|
+        result[attribute_name] = replace_type(self.send(attribute_name))
+      end
+      result
+    end
+
+    def to_json(*args)
+      to_hash.merge(:_id => _id).to_json(*args)
+    end
+
+    def destroyed?
+      @destroyed ||= false
+    end
+
+    def destroy
+      collection.remove({:_id => _id})
+      self.class.send(:ensure_indices)
+      @destroyed = true
+    end
+
+    module ClassMethods
+      def create(attributes = {})
+        resource = self.new(attributes)
+        resource.save
+        resource
+      end
+
+      def all(options = {})
+        Collection.new(self, perform_collection_find({}, options))
+      end
+
+      def collection
+        collection = nil
+        with_database do |database|
+          collection = database.collection(self.collection_name)
+        end
+        collection
+      end
+
+      def collection_name
+        klassname = self.to_s.downcase.gsub(/[\/|.|::]/, '_')
+        "#{klassname}s"
+      end
+
+      def get(id)
+        if id.is_a?(String)
+          id = BSON::ObjectId.from_string(id)
+        end
+        if attributes = perform_collection_find_one(:_id => id)
+          new(attributes)
+        else
+          nil
+        end
+      end
+
+      def database
+        unless @db
+          if connecting_to_replica_set?
+            client = new_replica_set_client
+          else
+            client = new_mongo_connection
+          end
+          @db = database_connection(client)
+        end
+
+        @db
+      end
+
+      def with_database(max_retries=60)
+        retries = 0
+        begin
+          yield self.database
+        rescue Mongo::ConnectionFailure => ex
+          retries += 1
+          raise ex if retries > max_retries
+          sleep(0.5)
+          retry
+        end
+      end
+
+      def with_collection
+        with_database do |database|
+          yield database.collection(self.collection_name)
+        end
+      end
+
+      def find_by_id(id)
+        get(id)
+      end
+
+      def find(query, options = {})
+        Collection.new(self, perform_collection_find(query, options))
+      end
+
+      def find_by_day(value, options = {})
+        if value.is_a?(Hash)
+          raise ArgumentError.new(":value missing from complex query hash") unless value.keys.include?(:value)
+          day = value.delete(:value)
+          query = value.merge(day_to_query(day))
+        else
+          query = day_to_query(value)
+        end
+
+        cursor = perform_collection_find(query, options)
+        Collection.new(self, cursor)
+      end
+
+      def timestamped_attribute
+        @timestamped_attribute
+      end
+
+      def attribute(name, options = {})
+        @attributes  ||= []
+        @indices     ||= []
+        @index_types ||= {}
+
+        @attributes << name unless @attributes.include?(name)
+        if options[:index]
+          @indices    << name unless @indices.include?(name)
+          @index_types[name] = options[:index_type] ? options[:index_type] : Mongo::DESCENDING
+          ensure_index(name)
+        end
+
+        if options[:timestamp]
+          raise ArgumentError.new("Only one timestamped attribute is allowed, '#{@timestamped_attribute}' is already timestamped") unless @timestamped_attribute.nil?
+          @timestamped_attribute = name
+        end
+
+        method_name = options.key?(:finder_method) ? options[:finder_method] : "find_by_#{name}"
+
+        class_eval <<-EOS, __FILE__, __LINE__
+          attr_accessor name
+
+          def self.#{method_name}(value, options = {})
+            if value.is_a?(Hash)
+              raise ArgumentError.new(":value missing from complex query hash") unless value.keys.include?(:value)
+              query = {:#{name} => value.delete(:value)}
+              query = query.merge(value)
+            else
+              query = {:#{name} => value}
+            end
+            col = perform_collection_find(query, options)
+            Collection.new(self, col)
+          end
+        EOS
+      end
+
+    private
+
+      def perform_collection_find(query, options = {})
+        ensure_indices
+        collection.find(query, options)
+      end
+
+      def perform_collection_find_one(query, options = {})
+        ensure_indices
+        collection.find_one(query, options)
+      end
+
+      def ensure_indices
+        indices.each do |index|
+          ensure_index(index)
+        end
+      end
+
+      def ensure_index(attribute)
+        with_collection do |collection|
+          collection.ensure_index( [ [attribute.to_s, index_types[attribute] ]] )
+        end
+      end
+
+      def indices
+        @indices ||= []
+      end
+
+      def index_types
+        @index_types ||= {}
+      end
+
+      def day_to_range(day)
+        case day
+        when DateTime
+          start = day.to_date.to_time
+          end_of_day = (day.to_date + 1).to_time
+        when Date
+          start = day.to_time
+          end_of_day = (day + 1).to_time
+        when Time
+          start = day.to_datetime.to_date.to_time
+          end_of_day = (day.to_datetime + 1).to_date.to_time
+        end
+        [start, end_of_day]
+      end
+
+      def date_range_to_query(range)
+        {:at => {:$gte => range.first, :$lt => range.last}}
+      end
+
+      def day_to_query(day)
+        date_range_to_query( day_to_range(day) )
+      end
+
+      # Connection setup
+
+      def new_mongo_connection
+        Mongo::Connection.new(*mongo_connection_args)
+      end
+
+      def new_replica_set_client
+        Mongo::MongoReplicaSetClient.new(*replica_set_client_args)
+      end
+
+      def database_connection(client)
+        client.db(Mordor::Config[:database]).tap do |db|
+          db.authenticate(*authentication_args) if authentication_args.any?
+        end
+      end
+
+      # Connection arguments
+
+      def mongo_connection_args
+        args = [ Mordor::Config[:hostname], Mordor::Config[:port] ]
+        args << connection_pool_options if connection_pool_options.any?
+        args
+      end
+
+      def replica_set_client_args
+        [ replica_set_host_list, replica_set_options ]
+      end
+
+      def authentication_args
+        args = []
+        if user_name = Mordor::Config[:username]
+          args << user_name
+          args << Mordor::Config[:password] if Mordor::Config[:password]
+        end
+        args
+      end
+
+      # Connection options
+
+      def connection_pool_options
+        @connection_pool_options ||= Hash.new.tap do |hash|
+          hash[:pool_size]    = Mordor::Config[:pool_size]    if Mordor::Config[:pool_size]
+          hash[:pool_timeout] = Mordor::Config[:pool_timeout] if Mordor::Config[:pool_timeout]
+        end
+      end
+
+      def replica_set_options
+        @replica_set_options ||= connection_pool_options.tap do |hash|
+          hash[:refresh_mode] = Mordor::Config[:rs_refresh_mode]
+          hash[:rs_name]      = Mordor::Config[:replica_set] if Mordor::Config[:replica_set]
+        end
+      end
+
+      # Replica set helpers
+
+      def replica_set_host_list
+        @replica_set_hosts ||= Mordor::Config[:hostname].split(',').map(&:strip).compact
+      end
+
+      def connecting_to_replica_set?
+        replica_set_host_list.size > 1
+      end
+
+    end
+  end
+end