moped_mapping 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NTEwYmI1N2E2MGM0MjJkYTk3YTY0MjQ3YWNiNmNlYTRjMTAxNzA4MA==
+  data.tar.gz: !binary |-
+    NmI3OWU0N2E5YTM3ZDhhZTY2ZDExNmMzMDI2ZDg5NzA5ZTBjNzg5Mw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    NGU5MTRhZGUzZjQwZGQ3NzUxYmE3Yjk1MTgwYzU0MTVhM2RkYmY3YjljYzdm
+    NDUwYzdmNWVmZTZlYjNjMGVhZjA2ODY4MDgyMzQyMDAwZGNmNjI5NWVhMzhm
+    YzRmZjAxNDc3MDQxMDhmODg3M2E2MTEzYTAxNGM1NGE1OTM4NDA=
+  data.tar.gz: !binary |-
+    NmE3OTk4MzZiOWMzZGU5YTdlZGI1ZDkwN2M1NDQwMGNiOTZhYWIxN2ZhMTU3
+    MmYwZDYzYzBjYzQ1MjU5ZmE5NDczNDViNDQ2YjkyYWJhODE3NTdiMTQxMzU0
+    ZDRlMWUwODRhYzY0NWY0NmIzZWE2ZTQ4MzU2ODY3ZjgxZmI5ZjM=

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/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in moped_mapping.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,14 @@
+Copyright (C) 2013  Groovenauts, inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>

data/README.md

@@ -0,0 +1,51 @@
+# MopedMapping
+
+moped extension library to switch collection.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'moped_mapping'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install moped_mapping
+
+## Usage
+
+### Global switch
+
+#### configuration
+
+```
+MopedMapping.enable
+```
+
+#### each action
+
+```
+MopedMapping.collection_map(@database_name,{"items" => "items@3" }) do
+  # actually this document will be inserted into items@3
+  session["items"].insert({some: "document"})
+end
+```
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+GPLv3
+
+Copyright (C) 2013  Groovenauts, inc.

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)

data/lib/moped_mapping/indexes_ext.rb

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+require 'moped_mapping'
+
+module MopedMapping
+  module IndexesExt
+    def self.included(klass)
+      klass.module_eval do
+        alias_method :namespace_without_mapping, :namespace
+        alias_method :namespace, :namespace_with_mapping
+      end
+    end
+
+    def namespace_with_mapping
+      return @namespace unless MopedMapping.enabled
+      col_name = MopedMapping.mapped_name(database.name, collection_name)
+      "#{database.name}.#{col_name}"
+    end
+  end
+end

data/lib/moped_mapping/node_ext.rb

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+require 'moped_mapping'
+
+module MopedMapping
+  module NodeExt
+    def self.included(klass)
+      klass.module_eval do
+        alias_method :query_without_mapping, :query
+        alias_method :query, :query_with_mapping
+      end
+    end
+
+    def query_with_mapping(database, collection, selector, options = {}, &block)
+      collection = MopedMapping.mapped_name(database, collection)
+      return query_without_mapping(database, collection, selector, options, &block)
+    end
+  end
+end

data/lib/moped_mapping/session_context_ext.rb

@@ -0,0 +1,104 @@
+# -*- coding: utf-8 -*-
+require 'moped_mapping'
+
+module MopedMapping
+  module SessionContextExt
+    def self.included(klass)
+      klass.module_eval do
+        %w[query insert update remove command].each do |m|
+          alias_method :"#{m}_without_mapping", m.to_sym
+          alias_method m.to_sym, :"#{m}_with_mapping"
+        end
+      end
+    end
+
+    def query_with_mapping(database, collection, selector, options = {}, &block)
+      collection = MopedMapping.mapped_name(database, collection)
+      return query_without_mapping(database, collection, selector, options, &block)
+    end
+
+    def insert_with_mapping(database, collection, documents, options = {}, &block)
+      collection = MopedMapping.mapped_name(database, collection)
+      return insert_without_mapping(database, collection, documents, options, &block)
+    end
+
+    def update_with_mapping(database, collection, selector, change, options = {}, &block)
+      collection = MopedMapping.mapped_name(database, collection)
+      return update_without_mapping(database, collection, selector, change, options, &block)
+    end
+
+    def remove_with_mapping(database, collection, selector, options = {}, &block)
+      collection = MopedMapping.mapped_name(database, collection)
+      return remove_without_mapping(database, collection, selector, options, &block)
+    end
+
+    # MongoDBのコマンド一覧
+    # http://docs.mongodb.org/manual/reference/command/
+
+    # MongoDBのコマンドのうち、コレクションを対象としたコマンド名
+    collection_command_names = [
+      # #aggregation-commands
+      :count, :aggregate, :distinct, # group # mapReduce
+      # #geospatial-commands
+      :geoNear, :geoSearch, # :geoWalk,
+      # #query-and-write-operation-commands
+      :findAndModify, # text
+      # #replication-commands
+      # #sharding-commands
+      :shardCollection,
+      # #instance-administration-commands
+      :drop, :create, # :convertToCapped,
+      :dropIndexes, :compact, :collMod, :reIndex,
+      :deleteIndexes,
+
+      # #diagnostic-commands
+      :collStats, :validate
+    ].freeze
+
+    COLLECTION_COMMAND_NAMES = (collection_command_names + collection_command_names.map(&:to_s).map(&:freeze)).freeze
+
+    command_args_array = [
+      # [:cloneCollection, :from], # このfromはホスト名を指定するので、対象外
+      [:cloneCollectionAsCapped, :toCollection],
+    ].map(&:freeze).freeze
+
+    COMMAND_ARGS_ARRAY = (
+      command_args_array +
+      command_args_array.map{|args| args.map(&:to_s).map(&:freeze).freeze }
+    ).freeze
+
+    full_name_command_names = [
+      :renameCollection, :to
+    ].freeze
+
+    FULL_NAME_COMMAND_NAMES = (full_name_command_names + full_name_command_names.map(&:to_s).map(&:freeze)).freeze
+
+    def command_with_mapping(database, command, &block)
+      done = false
+      COLLECTION_COMMAND_NAMES.each do |name|
+        next unless command.key?(name)
+        command[name] = MopedMapping.mapped_name(database, command[name])
+        done = true
+        break
+      end
+      unless done
+        COMMAND_ARGS_ARRAY.each do |args|
+          next unless command.key?(args.first)
+          args.each do |arg|
+            command[arg] = MopedMapping.mapped_name(database, command[arg])
+          end
+          done = true
+          break
+        end
+      end
+      unless done
+        FULL_NAME_COMMAND_NAMES.each do |name|
+          next unless command.key?(name)
+          command[name] = MopedMapping.mapped_full_name(database, command[name])
+        end
+      end
+      return command_without_mapping(database, command, &block)
+    end
+
+  end
+end

data/lib/moped_mapping/version.rb

@@ -0,0 +1,3 @@
+module MopedMapping
+  VERSION = "0.0.1"
+end

data/lib/moped_mapping.rb

@@ -0,0 +1,80 @@
+require "moped_mapping/version"
+
+require 'moped'
+
+module MopedMapping
+  extend self
+
+  attr_reader :enabled
+
+  def enable(&block) ; set_enabled(true , &block); end
+  def disable(&block); set_enabled(false, &block); end
+
+  def set_enabled(value)
+    if block_given?
+      bak, @enabled = @enabled, value
+      begin
+        yield
+      ensure
+        @enabled = bak
+      end
+    else
+      @enabled = value
+    end
+  end
+  private :set_enabled
+
+
+  def db_collection_map
+    t = Thread.current
+    result = t[:MopedMapping_db_collection_map]
+    unless result
+      result = nil
+      result = Thread.main[:MopedMapping_db_collection_map] unless t == Thread.main
+      result = result.dup if result
+      result ||= {}
+      t[:MopedMapping_db_collection_map] = result
+    end
+    result
+  end
+
+  def mapped_name(database, collection)
+    return collection unless MopedMapping.enabled
+    mapping = db_collection_map[database]
+    return collection unless mapping
+    return mapping[collection] || collection
+  end
+
+  def mapped_full_name(database, collection)
+    return collection unless MopedMapping.enabled
+    db, col = collection.split(/\./, 2)
+    return collection unless col
+    mapping = db_collection_map[db]
+    return collection unless mapping
+    mapped = mapping[col]
+    mapped ? "#{db}.#{mapped}" : collection
+  end
+
+  def collection_map(db_name, mapping)
+    if block_given?
+      bak, db_collection_map[db_name] = db_collection_map[db_name], mapping
+      begin
+        yield
+      ensure
+        db_collection_map[db_name] = bak
+      end
+    else
+      db_collection_map[db_name] = mapping
+    end
+  end
+
+end
+
+
+require "moped_mapping/session_context_ext"
+require "moped_mapping/indexes_ext"
+require "moped_mapping/node_ext"
+
+Moped::Session::Context.send(:include, MopedMapping::SessionContextExt)
+Moped::Indexes.send(:include, MopedMapping::IndexesExt)
+Moped::Node.send(:include, MopedMapping::NodeExt)

data/moped_mapping.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'moped_mapping/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "moped_mapping"
+  spec.version       = MopedMapping::VERSION
+  spec.authors       = ["akima"]
+  spec.email         = ["akm2000@gmail.com"]
+  spec.description   = %q{make mapping from moped collection object to MongoDB actual collection by using Hash}
+  spec.summary       = %q{make mapping from moped collection object to MongoDB actual collection by using Hash}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.add_dependency "moped", "~> 1.5.0"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "tengine_support"
+end

data/spec/moped.config.yml

@@ -0,0 +1,6 @@
+test:
+  sessions:
+    default:
+      database: moped_mapping_test
+      hosts:
+        - localhost:27017

data/spec/moped_mapping/geospatial_spec.rb

@@ -0,0 +1,136 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+require 'tengine/support/yaml_with_erb'
+require 'active_support/core_ext/hash/indifferent_access'
+
+describe MopedMapping do
+
+  let(:config) do
+    YAML.load_file(File.expand_path("../../moped.config.yml", __FILE__))["test"].with_indifferent_access
+  end
+
+  describe "2d" do
+
+    before do
+      MopedMapping.disable
+      @session = Moped::Session.new(config[:sessions][:default][:hosts])
+      @database_name = config[:sessions][:default][:database]
+      @session.use(@database_name)
+      @session.tap do |s|
+        # コレクションの削除
+        s.collection_names.each{|col| s[col].drop }
+        # テスト用のデータの追加
+        s["points@1"].tap do |c|
+          c.insert(num: 1, loc: [ 0,  0])
+          c.insert(num: 2, loc: [10, 10])
+          c.insert(num: 3, loc: [20, 10])
+          c.insert(num: 4, loc: [10, 30])
+          c.indexes.create({loc: "2d"})
+        end
+        s["points@2"].tap do |c|
+          c.insert(num: 1, loc: [ 0,  0])
+          c.insert(num: 2, loc: [10, 10])
+          c.insert(num: 3, loc: [15,  5])
+          c.insert(num: 4, loc: [10, 20])
+          c.indexes.create({loc: "2d"})
+        end
+      end
+    end
+
+    describe "geoNear" do
+      it do
+        MopedMapping.collection_map(@database_name,{"points" => "points@1" })
+        MopedMapping.enable
+        # {
+        #   "ns"=>"moped_mapping_test.points@1", "near"=>"1100000010010011010011111010100010010011010011111010",
+        #   "results"=>[
+        #     {"dis"=>3.605551275463989 , "obj"=>{"_id"=>"51ebfa5a73b7f70994b28e99", "num"=>2, "loc"=>[10, 10] } },
+        #     {"dis"=>7.280109889280518 , "obj"=>{"_id"=>"51ebfa5a73b7f70994b28e9a", "num"=>3, "loc"=>[20, 10] } },
+        #     {"dis"=>15.264337522473747, "obj"=>{"_id"=>"51ebfa5a73b7f70994b28e98", "num"=>1, "loc"=>[ 0,  0] } },
+        #     {"dis"=>22.20360331117452 , "obj"=>{"_id"=>"51ebfa5a73b7f70994b28e9b", "num"=>4, "loc"=>[10, 30] } }
+        #   ],
+        #   "stats"=>{"time"=>2, "btreelocs"=>0, "nscanned"=>4, "objectsLoaded"=>4, "avgDistance"=>12.088400499598194, "maxDistance"=>22.203616792998975},
+        #   "ok"=>1.0
+        # }
+        target = [14, 8]
+        r = @session.command("geoNear" => "points", "near" => target)
+        r["ok"].should == 1
+        r["results"].map{|d| d["obj"]["num"]}.should == [2,3,1,4]
+        MopedMapping.collection_map(@database_name,{"points" => "points@2" }) do
+          r = @session.command("geoNear" => "points", "near" => target)
+          r["ok"].should == 1
+          r["results"].map{|d| d["obj"]["num"]}.should == [3,2,4,1]
+        end
+        r = @session.command("geoNear" => "points", "near" => target)
+        r["ok"].should == 1
+        r["results"].map{|d| d["obj"]["num"]}.should == [2,3,1,4]
+      end
+    end
+  end
+
+  describe "Haystack index" do
+
+    # see http://docs.mongodb.org/manual/core/geohaystack/
+    before do
+      MopedMapping.disable
+      @session = Moped::Session.new(config[:sessions][:default][:hosts])
+      @database_name = config[:sessions][:default][:database]
+      @session.use(@database_name)
+      @session.tap do |s|
+        # コレクションの削除
+        s.collection_names.each{|col| s[col].drop }
+        # テスト用のデータの追加
+        s["places@1"].tap do |c|
+          c.insert({ _id: 100, pos: { lng: 126.9, lat: 35.2 } , type: "restaurant"})
+          c.insert({ _id: 200, pos: { lng: 127.5, lat: 36.1 } , type: "restaurant"})
+          c.insert({ _id: 300, pos: { lng: 128.0, lat: 36.7 } , type: "national park"})
+          c.indexes.create({pos: "geoHaystack", type: 1}, { bucketSize: 1 } )
+        end
+        s["places@2"].tap do |c|
+          c.insert({ _id: 100, pos: { lng: 106.9, lat: 25.2 } , type: "restaurant"})
+          c.insert({ _id: 200, pos: { lng: 127.5, lat: 36.1 } , type: "restaurant"})
+          c.insert({ _id: 300, pos: { lng: 128.0, lat: 36.7 } , type: "national park"})
+          c.indexes.create({pos: "geoHaystack", type: 1}, { bucketSize: 1 } )
+        end
+      end
+    end
+
+    describe :geoSearch do
+      it do
+        MopedMapping.collection_map(@database_name,{"places" => "places@1" })
+        MopedMapping.enable
+        target = [127.1, 35.6]
+        # {
+        #   "results"=>[
+        #     {"_id"=>100, "pos"=>{"lng"=>126.9, "lat"=>35.2}, "type"=>"restaurant"},
+        #     {"_id"=>200, "pos"=>{"lng"=>127.5, "lat"=>36.1}, "type"=>"restaurant"}
+        #   ],
+        #   "stats"=>{"time"=>3, "btreeMatches"=>2, "n"=>2},
+        #   "ok"=>1.0
+        # }
+        r = @session.command({geoSearch: "places",
+                     search: { type: "restaurant" },
+                     near: target,
+                     maxDistance: 10 })
+        r["ok"].should == 1
+        r["results"].map{|d| d["_id"]}.should == [100, 200]
+        MopedMapping.collection_map(@database_name,{"places" => "places@2" }) do
+          r = @session.command({geoSearch: "places",
+                       search: { type: "restaurant" },
+                       near: target,
+                       maxDistance: 10 })
+          r["ok"].should == 1
+          r["results"].map{|d| d["_id"]}.should == [200]
+        end
+        r = @session.command({geoSearch: "places",
+                     search: { type: "restaurant" },
+                     near: target,
+                     maxDistance: 10 })
+        r["ok"].should == 1
+        r["results"].map{|d| d["_id"]}.should == [100, 200]
+      end
+    end
+  end
+
+end

data/spec/moped_mapping/thread_safe_spec.rb

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+require 'tengine/support/yaml_with_erb'
+require 'active_support/core_ext/hash/indifferent_access'
+
+describe MopedMapping do
+
+  let(:config) do
+    YAML.load_file(File.expand_path("../../moped.config.yml", __FILE__))["test"].with_indifferent_access
+  end
+
+  describe "thread safe" do
+    before do
+      MopedMapping.disable
+      @session = Moped::Session.new(config[:sessions][:default][:hosts])
+      @database_name = config[:sessions][:default][:database]
+      @session.use(@database_name)
+      @session.tap do |s|
+        # コレクションの削除
+        s.collection_names.each{|col| s[col].drop }
+        # テスト用のデータの追加
+        s["test_logs@1"].tap do |c|
+          c.insert(num: 1)
+          c.insert(num: 2)
+          c.insert(num: 3)
+          c.insert(num: 4)
+        end
+        s["test_logs@2"].tap do |c|
+          c.insert(num: 1)
+        end
+      end
+    end
+
+    it "query@1 and insert@2 parallel" do
+      MopedMapping.enable
+      database_name = config[:sessions][:default][:database]
+      run_insert = true
+      query_thread = Thread.new do
+        MopedMapping.collection_map(@database_name,{"test_logs" => "test_logs@1" }) do
+          session1 = Moped::Session.new(config[:sessions][:default][:hosts])
+          session1.use(database_name)
+          1000.times do
+            Thread.pass
+            begin
+              col = session1["test_logs"]
+              r = col.find.count
+              r.should == 4
+            rescue
+              run_insert = false
+              raise
+            end
+          end
+        end
+      end
+
+      insert_thread = Thread.new do
+        MopedMapping.collection_map(@database_name,{"test_logs" => "test_logs@2" }) do
+          session2 = Moped::Session.new(config[:sessions][:default][:hosts])
+          session2.use(database_name)
+          1000.times do |idx|
+            Thread.pass
+            break unless run_insert
+            col = session2["test_logs"]
+            col.insert(num: idx + 2)
+          end
+        end
+      end
+      query_thread.join
+      insert_thread.join
+    end
+
+
+    it "query@1 and insert@2 parallel with default collection_map defined in main thread" do
+      MopedMapping.collection_map(@database_name,{"test_logs" => "test_logs@1" })
+      MopedMapping.enable
+      database_name = config[:sessions][:default][:database]
+      run_insert = true
+      query_thread = Thread.new do
+        session1 = Moped::Session.new(config[:sessions][:default][:hosts])
+        session1.use(database_name)
+        1000.times do
+          Thread.pass
+          begin
+            col = session1["test_logs"]
+            r = col.find.count
+            r.should == 4
+          rescue
+            run_insert = false
+            raise
+          end
+        end
+      end
+
+      insert_thread = Thread.new do
+        MopedMapping.collection_map(@database_name,{"test_logs" => "test_logs@2" }) do
+          session2 = Moped::Session.new(config[:sessions][:default][:hosts])
+          session2.use(database_name)
+          1000.times do |idx|
+            Thread.pass
+            break unless run_insert
+            col = session2["test_logs"]
+            col.insert(num: idx + 2)
+          end
+        end
+      end
+      query_thread.join
+      insert_thread.join
+    end
+  end
+
+end

data/spec/moped_mapping_spec.rb

@@ -0,0 +1,581 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+require 'tengine/support/yaml_with_erb'
+require 'active_support/core_ext/hash/indifferent_access'
+
+describe MopedMapping do
+
+  let(:config) do
+    YAML.load_file(File.expand_path("../moped.config.yml", __FILE__))["test"].with_indifferent_access
+  end
+
+  before do
+    MopedMapping.disable
+    @session = Moped::Session.new(config[:sessions][:default][:hosts])
+    @database_name = config[:sessions][:default][:database]
+    @session.use(@database_name)
+    @session.tap do |s|
+      # コレクションの削除
+      s.collection_names.each{|col| s[col].drop }
+      # テスト用のデータの追加
+      s["items"].tap do |c|
+        c.insert(name: "foo", price: 100)
+      end
+      s["items@1"].tap do |c|
+        c.insert(name: "foo", price:  90)
+        c.insert(name: "bar", price: 200)
+        c.insert(name: "baz", price: 400)
+      end
+      s["items@2"].tap do |c|
+        c.insert(name: "foo", price:  80)
+        c.insert(name: "bar", price: 180)
+        c.insert(name: "baz", price: 350)
+        c.insert(name: "qux", price: 150)
+      end
+      s["items@3"].tap do |c|
+        c.insert(name: "bar", price: 180)
+        c.insert(name: "baz", price: 350)
+        c.insert(name: "qux", price: 400)
+      end
+    end
+  end
+
+  describe :enable do
+    it "with block" do
+      MopedMapping.collection_map(@database_name,{"items" => "items@1" })
+      col = @session["items"]
+      col.find.sort(price: -1).one["name"].should == "foo"
+      col.find.count.should == 1
+      MopedMapping.enable do
+        col.find.sort(price: -1).one["name"].should == "baz"
+        col.find.count.should == 3
+      end
+      col.find.sort(price: -1).one["name"].should == "foo"
+      col.find.count.should == 1
+    end
+
+    it "without block" do
+      MopedMapping.collection_map(@database_name,{"items" => "items@1" })
+      col = @session["items"]
+      col.find.sort(price: -1).one["name"].should == "foo"
+      col.find.count.should == 1
+      MopedMapping.enable
+      col.find.sort(price: -1).one["name"].should == "baz"
+      col.find.count.should == 3
+      MopedMapping.disable
+      col.find.sort(price: -1).one["name"].should == "foo"
+      col.find.count.should == 1
+    end
+  end
+
+
+  describe :collection_map do
+    it "actual usage" do
+      MopedMapping.collection_map(@database_name,{"items" => "items@2" })
+      MopedMapping.enable
+      col = @session["items"]
+      col.find.sort(price: -1).one["name"].should == "baz"
+      col.find.count.should == 4
+      MopedMapping.collection_map(@database_name,{"items" => "items@3" }) do
+        col.find.sort(price: -1).one["name"].should == "qux"
+        col.find.count.should == 3
+      end
+    end
+  end
+
+  describe :create do
+    it "actual usage" do
+      MopedMapping.collection_map(@database_name,{"items" => "items@4" })
+      MopedMapping.enable
+      @session.collection_names.should =~ %w[items items@1 items@2 items@3]
+      @session.command("create" => "items")
+      @session.collection_names.should =~ %w[items items@1 items@2 items@3 items@4]
+      MopedMapping.collection_map(@database_name,{"items" => "items@5" }) do
+        @session.command("create" => "items")
+        @session.collection_names.should =~ %w[items items@1 items@2 items@3 items@4 items@5]
+      end
+    end
+  end
+
+  describe :drop do
+    it "actual usage" do
+      MopedMapping.collection_map(@database_name,{"items" => "items@2" })
+      MopedMapping.enable
+      @session.collection_names.should =~ %w[items items@1 items@2 items@3]
+      col = @session["items"]
+      MopedMapping.collection_map(@database_name,{"items" => "items@3" }) do
+        col.drop
+        @session.collection_names.should =~ %w[items items@1 items@2]
+      end
+      col.drop
+      @session.collection_names.should =~ %w[items items@1]
+    end
+  end
+
+
+  describe :renameCollection do
+    it "actual usage" do
+      MopedMapping.collection_map(@database_name,{"items" => "items@2", "products" => "products@2" })
+      MopedMapping.enable
+      @session.collection_names.should =~ %w[items items@1 items@2 items@3]
+      # renameCollection では単なるコレクション名ではなく、 <ネームスペース名>.<コレクション名> を指定する必要があります
+      @session.with(database: :admin).command("renameCollection" => "#{@database_name}.items", "to" => "#{@database_name}.products")
+      @session.collection_names.should =~ %w[items items@1 products@2 items@3]
+      MopedMapping.collection_map(@database_name,{"items" => "items@3", "products" => "products@3" }) do
+        @session.with(database: :admin).command("renameCollection" => "#{@database_name}.items", "to" => "#{@database_name}.products")
+        @session.collection_names.should =~ %w[items items@1 products@2 products@3]
+      end
+      @session.collection_names.should =~ %w[items items@1 products@2 products@3]
+    end
+  end
+
+  describe :cloneCollectionAsCapped  do
+    it "actual usage" do
+      MopedMapping.collection_map(@database_name,{"items" => "items@2", "products" => "products@2" })
+      MopedMapping.enable
+      @session.collection_names.should =~ %w[items items@1 items@2 items@3]
+      @session.command("cloneCollectionAsCapped" => "items", "toCollection" => "products", "size" => 1024 * 1024)
+      @session.collection_names.should =~ %w[items items@1 items@2 items@3 products@2]
+      MopedMapping.collection_map(@database_name,{"items" => "items@3", "products" => "products@3" }) do
+        @session.command("cloneCollectionAsCapped" => "items", "toCollection" => "products", "size" => 1024 * 1024)
+        @session.collection_names.should =~ %w[items items@1 items@2 items@3 products@2 products@3]
+      end
+      @session.collection_names.should =~ %w[items items@1 items@2 items@3 products@2 products@3]
+    end
+  end
+
+
+  describe :distinct do
+    it "actual usage" do
+      MopedMapping.collection_map(@database_name,{"items" => "items@2" })
+      MopedMapping.enable
+      col = @session["items"]
+      col.find.distinct(:name).should =~ %w[foo bar baz qux]
+      MopedMapping.collection_map(@database_name,{"items" => "items@3" }) do
+        col.find.distinct(:name).should =~ %w[bar baz qux]
+      end
+      col.find.distinct(:name).should =~ %w[foo bar baz qux]
+    end
+  end
+
+  describe :findAndModify do
+    it "actual usage" do
+      MopedMapping.collection_map(@database_name,{"items" => "items@2" })
+      MopedMapping.enable
+      col = @session["items"]
+      col.find(name: "bar").modify({"$set" => {price: 190}})
+      col.find(name: "bar").one["price"].should == 190
+      MopedMapping.collection_map(@database_name,{"items" => "items@3" }) do
+        col.find(name: "bar").modify({"$set" => {price: 200}})
+        col.find(name: "bar").one["price"].should == 200
+      end
+      col.find(name: "bar").one["price"].should == 190
+    end
+  end
+
+
+
+
+  describe :create_index do
+    it "actual usage" do
+      MopedMapping.collection_map(@database_name,{"items" => "items@2" })
+      MopedMapping.enable
+      col = @session["items"]
+      col.indexes.create({name: 1}, {name: "items_2_name"})
+      %w[items items@2].each do |col_name|
+        col.indexes[{"name" => 1}]["name"].should == "items_2_name"
+      end
+
+      MopedMapping.collection_map(@database_name,{"items" => "items@3" }) do
+        col.indexes.create({"name" => 1}, {name: "items_3_name"})
+        %w[items items@2].each do |col_name|
+          col.indexes[{"name" => 1}]["name"].should == "items_3_name"
+        end
+      end
+
+      %w[items items@2].each do |col_name|
+        col.indexes[{"name" => 1}]["name"].should == "items_2_name"
+      end
+    end
+  end
+
+  describe :drop_index do
+    it "actual usage" do
+      %w[items items@1 items@2 items@3].each do |col_name|
+        col = @session[col_name]
+        col.indexes.create({name: 1}, {name: "#{col_name}_name"})
+        col.indexes.create({price: 1}, {name: "#{col_name}_price"})
+      end
+
+      MopedMapping.collection_map(@database_name,{"items" => "items@2" })
+      MopedMapping.enable
+      col = @session["items"]
+      col.indexes.drop({"name" => 1})
+      %w[items items@2].each do |col_name|
+        col.indexes.to_a.map{|idx| idx["name"]}.should =~ ["_id_", "items@2_price"]
+      end
+      MopedMapping.collection_map(@database_name,{"items" => "items@3" }) do
+        col = @session["items"]
+        col.indexes.drop({"price" => 1})
+        %w[items items@3].each do |col_name|
+          col.indexes.to_a.map{|idx| idx["name"]}.should =~ ["_id_", "items@3_name"]
+        end
+      end
+    end
+  end
+
+  describe :insert do
+    it do
+      MopedMapping.collection_map(@database_name,{"items" => "items@2" })
+      MopedMapping.disable do
+        @session["items"].find.count.should == 1
+        @session["items@2"].find.count.should == 4
+        @session["items@3"].find.count.should == 3
+      end
+      MopedMapping.enable
+      col = @session["items"]
+      col.find.count.should == 4
+      col.insert({name: "quux", price: 500})
+      col.find.count.should == 5
+      @session["items"].find.count.should == 5
+      MopedMapping.disable do
+        @session["items"].find.count.should == 1
+        @session["items@2"].find.count.should == 5
+        @session["items@3"].find.count.should == 3
+      end
+      MopedMapping.collection_map(@database_name,{"items" => "items@3" }) do
+        @session["items"].find.count.should == 3
+      end
+    end
+  end
+
+
+  describe :find_one do
+    it do
+      MopedMapping.disable do
+        @session["items"  ].find(name: "foo").one["price"].should == 100
+        @session["items@1"].find(name: "foo").one["price"].should == 90
+        @session["items@2"].find(name: "foo").one["price"].should == 80
+        @session["items@3"].find(name: "foo").one.should == nil
+      end
+      MopedMapping.enable
+      col = @session["items"]
+      MopedMapping.collection_map(@database_name,{"items" => "items@1" }) do
+        col.find(name: "foo").one["price"].should == 90
+      end
+      MopedMapping.collection_map(@database_name,{"items" => "items@2" }) do
+        col.find(name: "foo").one["price"].should == 80
+      end
+      MopedMapping.collection_map(@database_name,{"items" => "items@3" }) do
+        col.find(name: "foo").one.should == nil
+      end
+    end
+  end
+
+  def assert_item_prices(col, name_to_prices)
+    name_to_prices.each do  |k,v|
+      begin
+        @session[col].find(name: k).one["price"].should == v
+      rescue
+        puts "[#{col}] #{k} => #{v}"
+        raise
+      end
+    end
+  end
+
+  describe :find_with_cursor do
+    it do
+      MopedMapping.enable
+      col = @session["items"]
+      cond = { price: {"$gte" => 100, "$lte" => 350} }
+      MopedMapping.collection_map(@database_name,{"items" => "items@1" }) do
+        col.find(cond).sort(price: 1).map{|r| r["name"]}.should == %w[bar]
+      end
+      MopedMapping.collection_map(@database_name,{"items" => "items@2" }) do
+        col.find(cond).sort(price: 1).map{|r| r["name"]}.should == %w[qux bar baz]
+      end
+      MopedMapping.collection_map(@database_name,{"items" => "items@3" }) do
+        col.find(cond).sort(price: 1).map{|r| r["name"]}.should == %w[bar baz]
+      end
+    end
+  end
+
+
+  describe :update do
+    it "match just one" do
+      MopedMapping.enable
+      col = @session["items"]
+      change = {"$inc" => {price: 30}}
+      MopedMapping.collection_map(@database_name,{"items" => "items@1" }) do
+        col.find(name: "foo").update(change)
+      end
+      MopedMapping.disable do
+        @session["items"  ].find(name: "foo").one["price"].should == 100
+        @session["items@1"].find(name: "foo").one["price"].should == 120
+        @session["items@2"].find(name: "foo").one["price"].should == 80
+        @session["items@3"].find(name: "foo").one.should == nil
+      end
+      MopedMapping.collection_map(@database_name,{"items" => "items@2" }) do
+        col.find(name: "foo").update(change)
+      end
+      MopedMapping.disable do
+        @session["items"  ].find(name: "foo").one["price"].should == 100
+        @session["items@1"].find(name: "foo").one["price"].should == 120
+        @session["items@2"].find(name: "foo").one["price"].should == 110
+        @session["items@3"].find(name: "foo").one.should == nil
+      end
+      MopedMapping.collection_map(@database_name,{"items" => "items@3" }) do
+        col.find(name: "foo").update(change)
+      end
+      MopedMapping.disable do
+        @session["items"  ].find(name: "foo").one["price"].should == 100
+        @session["items@1"].find(name: "foo").one["price"].should == 120
+        @session["items@2"].find(name: "foo").one["price"].should == 110
+        @session["items@3"].find(name: "foo").one.should == nil
+      end
+    end
+
+    it "match some documents and does not use update_all but update" do
+      MopedMapping.disable do
+        {
+          "items@1" => {"foo" =>  90, "bar" => 200, "baz" => 400},
+          "items@2" => {"foo" =>  80, "bar" => 180, "baz" => 350, "qux" => 150},
+          "items@3" => {              "bar" => 180, "baz" => 350, "qux" => 400},
+        }.each do |col, hash|
+          hash.each do  |k,v|
+            @session[col].find(name: k).one["price"].should == v
+          end
+        end
+      end
+      MopedMapping.enable
+      col = @session["items"]
+      cond = { price: {"$gte" => 100, "$lte" => 350} }
+      change = {"$inc" => {price: 30}}
+      MopedMapping.collection_map(@database_name,{"items" => "items@1" }) do
+        col.find(cond).update(change)
+      end
+      MopedMapping.disable do
+        {
+          "items@1" => {"foo" =>  90, "bar" => 230, "baz" => 400},
+          "items@2" => {"foo" =>  80, "bar" => 180, "baz" => 350, "qux" => 150},
+          "items@3" => {              "bar" => 180, "baz" => 350, "qux" => 400},
+        }.each do |col, hash|
+          hash.each do  |k,v|
+            @session[col].find(name: k).one["price"].should == v
+          end
+        end
+      end
+      MopedMapping.collection_map(@database_name,{"items" => "items@2" }) do
+        col.find(cond).update(change)
+      end
+      MopedMapping.disable do
+        {
+          "items@1" => {"foo" =>  90, "bar" => 230, "baz" => 400},
+          "items@2" => {"foo" =>  80, "bar" => 210, "baz" => 350, "qux" => 150},
+          "items@3" => {              "bar" => 180, "baz" => 350, "qux" => 400},
+        }.each do |col, hash|
+          hash.each do  |k,v|
+            @session[col].find(name: k).one["price"].should == v
+          end
+        end
+      end
+      MopedMapping.collection_map(@database_name,{"items" => "items@3" }) do
+        col.find(cond).update(change)
+      end
+      MopedMapping.disable do
+        {
+          "items@1" => {"foo" =>  90, "bar" => 230, "baz" => 400},
+          "items@2" => {"foo" =>  80, "bar" => 210, "baz" => 350, "qux" => 150},
+          "items@3" => {              "bar" => 210, "baz" => 350, "qux" => 400},
+        }.each do |col, hash|
+          hash.each do  |k,v|
+            @session[col].find(name: k).one["price"].should == v
+          end
+        end
+      end
+    end
+
+    it "match some documents and use update_all" do
+      MopedMapping.disable do
+        assert_item_prices "items@1", {"foo" =>  90, "bar" => 200, "baz" => 400}
+        assert_item_prices "items@2", {"foo" =>  80, "bar" => 180, "baz" => 350, "qux" => 150}
+        assert_item_prices "items@3", {              "bar" => 180, "baz" => 350, "qux" => 400}
+      end
+      MopedMapping.enable
+      col = @session["items"]
+      cond = { price: {"$gte" => 100, "$lte" => 350} }
+      change = {"$inc" => {price: 30}}
+      MopedMapping.collection_map(@database_name,{"items" => "items@1" }) do
+        col.find(cond).update_all(change)
+      end
+      MopedMapping.disable do
+        assert_item_prices "items@1", {"foo" =>  90, "bar" => 230, "baz" => 400}
+        assert_item_prices "items@2", {"foo" =>  80, "bar" => 180, "baz" => 350, "qux" => 150}
+        assert_item_prices "items@3", {              "bar" => 180, "baz" => 350, "qux" => 400}
+      end
+      MopedMapping.collection_map(@database_name,{"items" => "items@2" }) do
+        col.find(cond).update_all(change)
+      end
+      MopedMapping.disable do
+        assert_item_prices "items@1", {"foo" =>  90, "bar" => 230, "baz" => 400}
+        assert_item_prices "items@2", {"foo" =>  80, "bar" => 210, "baz" => 380, "qux" => 180}
+        assert_item_prices "items@3", {              "bar" => 180, "baz" => 350, "qux" => 400}
+      end
+      MopedMapping.collection_map(@database_name,{"items" => "items@3" }) do
+        col.find(cond).update_all(change)
+      end
+      MopedMapping.disable do
+        assert_item_prices "items@1", {"foo" =>  90, "bar" => 230, "baz" => 400}
+        assert_item_prices "items@2", {"foo" =>  80, "bar" => 210, "baz" => 380, "qux" => 180}
+        assert_item_prices "items@3", {              "bar" => 210, "baz" => 380, "qux" => 400}
+      end
+    end
+
+    it "match just one and upsert" do
+      MopedMapping.enable
+      col = @session["items"]
+      change = {name: "foo", price: 60}
+      MopedMapping.collection_map(@database_name,{"items" => "items@1" }) do
+        col.find(name: "foo").upsert(change)
+      end
+      MopedMapping.disable do
+        assert_item_prices "items@1", {"foo" =>  60, "bar" => 200, "baz" => 400}
+        assert_item_prices "items@2", {"foo" =>  80, "bar" => 180, "baz" => 350, "qux" => 150}
+        assert_item_prices "items@3", {              "bar" => 180, "baz" => 350, "qux" => 400}
+      end
+      MopedMapping.collection_map(@database_name,{"items" => "items@2" }) do
+        col.find(name: "foo").upsert(change)
+      end
+      MopedMapping.disable do
+        assert_item_prices "items@1", {"foo" =>  60, "bar" => 200, "baz" => 400}
+        assert_item_prices "items@2", {"foo" =>  60, "bar" => 180, "baz" => 350, "qux" => 150}
+        assert_item_prices "items@3", {              "bar" => 180, "baz" => 350, "qux" => 400}
+      end
+      MopedMapping.collection_map(@database_name,{"items" => "items@3" }) do
+        col.find(name: "foo").upsert(change)
+      end
+      MopedMapping.disable do
+        assert_item_prices "items@1", {"foo" =>  60, "bar" => 200, "baz" => 400}
+        assert_item_prices "items@2", {"foo" =>  60, "bar" => 180, "baz" => 350, "qux" => 150}
+        assert_item_prices "items@3", {"foo" =>  60, "bar" => 180, "baz" => 350, "qux" => 400}
+      end
+    end
+
+  end
+
+
+  describe :remove do
+    it "match just one" do
+      MopedMapping.enable
+      col = @session["items"]
+      MopedMapping.collection_map(@database_name,{"items" => "items@1" }) do
+        col.find(name: "foo").remove
+      end
+      MopedMapping.disable do
+        @session["items"  ].find.count.should == 1
+        @session["items@1"].find.count.should == 2
+        @session["items@2"].find.count.should == 4
+        @session["items@3"].find.count.should == 3
+      end
+      MopedMapping.collection_map(@database_name,{"items" => "items@2" }) do
+        col.find(name: "foo").remove
+      end
+      MopedMapping.disable do
+        @session["items"  ].find.count.should == 1
+        @session["items@1"].find.count.should == 2
+        @session["items@2"].find.count.should == 3
+        @session["items@3"].find.count.should == 3
+      end
+      MopedMapping.collection_map(@database_name,{"items" => "items@3" }) do
+        col.find(name: "foo").remove
+      end
+      MopedMapping.disable do
+        @session["items"  ].find.count.should == 1
+        @session["items@1"].find.count.should == 2
+        @session["items@2"].find.count.should == 3
+        @session["items@3"].find.count.should == 3
+      end
+    end
+
+    it "match some documents and does not use remove_all but remove" do
+      MopedMapping.disable do
+        @session["items"  ].find.count.should == 1
+        @session["items@1"].find.count.should == 3
+        @session["items@2"].find.count.should == 4
+        @session["items@3"].find.count.should == 3
+      end
+      MopedMapping.enable
+      col = @session["items"]
+      cond = { price: {"$gte" => 100, "$lte" => 350} }
+      MopedMapping.collection_map(@database_name,{"items" => "items@1" }) do
+        col.find(cond).remove
+      end
+      MopedMapping.disable do
+        @session["items"  ].find.count.should == 1
+        @session["items@1"].find.count.should == 2
+        @session["items@2"].find.count.should == 4
+        @session["items@3"].find.count.should == 3
+      end
+      MopedMapping.collection_map(@database_name,{"items" => "items@2" }) do
+        col.find(cond).remove
+      end
+      MopedMapping.disable do
+        @session["items"  ].find.count.should == 1
+        @session["items@1"].find.count.should == 2
+        @session["items@2"].find.count.should == 3
+        @session["items@3"].find.count.should == 3
+      end
+      MopedMapping.collection_map(@database_name,{"items" => "items@3" }) do
+        col.find(cond).remove
+      end
+      MopedMapping.disable do
+        @session["items"  ].find.count.should == 1
+        @session["items@1"].find.count.should == 2
+        @session["items@2"].find.count.should == 3
+        @session["items@3"].find.count.should == 2
+      end
+    end
+
+    it "match some documents and use remove_all" do
+      MopedMapping.disable do
+        @session["items"  ].find.count.should == 1
+        @session["items@1"].find.count.should == 3
+        @session["items@2"].find.count.should == 4
+        @session["items@3"].find.count.should == 3
+      end
+      MopedMapping.enable
+      col = @session["items"]
+      cond = { price: {"$gte" => 100, "$lte" => 350} }
+      MopedMapping.collection_map(@database_name,{"items" => "items@1" }) do
+        col.find(cond).remove_all
+      end
+      MopedMapping.disable do
+        @session["items"  ].find.count.should == 1
+        @session["items@1"].find.count.should == 2
+        @session["items@2"].find.count.should == 4
+        @session["items@3"].find.count.should == 3
+      end
+      MopedMapping.collection_map(@database_name,{"items" => "items@2" }) do
+        col.find(cond).remove_all
+      end
+      MopedMapping.disable do
+        @session["items"  ].find.count.should == 1
+        @session["items@1"].find.count.should == 2
+        @session["items@2"].find.count.should == 1
+        @session["items@3"].find.count.should == 3
+      end
+      MopedMapping.collection_map(@database_name,{"items" => "items@3" }) do
+        col.find(cond).remove_all
+      end
+      MopedMapping.disable do
+        @session["items"  ].find.count.should == 1
+        @session["items@1"].find.count.should == 2
+        @session["items@2"].find.count.should == 1
+        @session["items@3"].find.count.should == 1
+      end
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'moped_mapping'
+
+Dir[File.expand_path("../support/**/*.rb", __FILE__)].each {|f| require f}
+
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: moped_mapping
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- akima
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: moped
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tengine_support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: make mapping from moped collection object to MongoDB actual collection
+  by using Hash
+email:
+- akm2000@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/moped_mapping.rb
+- lib/moped_mapping/indexes_ext.rb
+- lib/moped_mapping/node_ext.rb
+- lib/moped_mapping/session_context_ext.rb
+- lib/moped_mapping/version.rb
+- moped_mapping.gemspec
+- spec/moped.config.yml
+- spec/moped_mapping/geospatial_spec.rb
+- spec/moped_mapping/thread_safe_spec.rb
+- spec/moped_mapping_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+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.0.3
+signing_key: 
+specification_version: 4
+summary: make mapping from moped collection object to MongoDB actual collection by
+  using Hash
+test_files:
+- spec/moped.config.yml
+- spec/moped_mapping/geospatial_spec.rb
+- spec/moped_mapping/thread_safe_spec.rb
+- spec/moped_mapping_spec.rb
+- spec/spec_helper.rb
+has_rdoc: