clone 1.0.0.alpha → 1.0.0.beta

data/samples/grape/init/docs/grape/generate_rest_routes.rb

@@ -0,0 +1,37 @@
+require_relative File.join("..","..","boot.rb")
+write_out_array = Array.new
+write_out_array.push "REST::API ROUTES:\n"
+write_out_array.push "\nTable Of Contents\n================="
+
+array_of_hash = Array.new
+REST::API.routes.map do |route|
+  array_of_hash.push({:method => route.route_method.to_s, :path => route.route_path.to_s})
+end
+contents_array= Array.new
+array_of_hash.each do |hash|
+  separator_str= String.new
+  if hash[:method].to_s == "POST" || hash[:method].to_s == "DELETE"
+    separator_str= "\t\t   "
+  else
+    separator_str= "\t\t\t   "
+  end
+  contents_array.push "#{hash[:method]}#{separator_str}#{hash[:path]}"
+end
+write_out_array.push contents_array.join("\n")
+write_out_array.push "\nExplanations\n============"
+REST::API.routes.map do |route|
+  new_docs_element= Array.new
+  new_docs_element.push "Method:      #{route.route_method}"
+  new_docs_element.push "Path:        #{route.route_path}"
+  new_docs_element.push "description: #{route.route_description}"
+  if route.route_params.count == 0
+    new_docs_element.push "No specified or special params"
+  else
+    route.route_params.each do |key,value|
+      new_docs_element.push " -#{key}: #{value}"
+    end
+  end
+  new_docs_element.push "\n"
+  write_out_array.push new_docs_element.join("\n")
+end
+File.new("routes_docs.txt","w").write write_out_array.join("\n")

data/samples/grape/init/docs/grape/ls_routes.rb

@@ -0,0 +1,31 @@
+require_relative File.join("..","..","boot.rb")
+write_out_array = Array.new
+write_out_array.push "REST::API ROUTES:\n"
+write_out_array.push "\nTable Of Contents\n================="
+
+array_of_hash = Array.new
+REST::API.routes.map do |route|
+  array_of_hash.push({:method => route.route_method.to_s, :path => route.route_path.to_s})
+end
+contents_array= Array.new
+array_of_hash.sort_by!{|hash| hash[:method]}.each do |hash|
+  contents_array.push "#{hash[:method]} | #{hash[:path]}"
+end
+write_out_array.push contents_array.join("\n")
+write_out_array.push "\nExplanations\n============"
+REST::API.routes.map do |route|
+  new_docs_element= Array.new
+  new_docs_element.push "Method:      #{route.route_method}"
+  new_docs_element.push "Path:        #{route.route_path}"
+  new_docs_element.push "description: #{route.route_description}"
+  if route.route_params.count == 0
+    new_docs_element.push "No specified or special params"
+  else
+    route.route_params.each do |key,value|
+      new_docs_element.push " -#{key}: #{value}"
+    end
+  end
+  new_docs_element.push "\n"
+  write_out_array.push new_docs_element.join("\n")
+end
+puts write_out_array.join("\n")

data/samples/grape/init/lib/grape.rb

@@ -0,0 +1,4 @@
+
+### Load Grape API parts
+require_relative_directory File.join "grape","vendors"
+require_relative_directory File.join "grape","xpath"

data/samples/grape/init/lib/grape/meta/subclasses.rb

@@ -0,0 +1,20 @@
+module Grape
+  # The API class is the primary entry point for
+  # creating Grape APIs.Users should subclass this
+  # class in order to build an API.
+  class API
+
+    def self.inherited(subclass)
+      @classes ||= Array.new
+      @classes.push subclass.name.constantize
+
+      subclass.reset!
+      subclass.logger = logger.clone
+    end
+
+    def self.classes
+      @classes
+    end
+
+  end
+end

data/samples/grape/init/lib/grape/xpath/app.rb

@@ -0,0 +1,30 @@
+#encoding: UTF-8
+module REST
+  class API < Grape::API
+
+    ### defaults
+    begin
+      ### exclude array
+      exclude_list = [
+          self
+      ]
+    end
+
+    ### mount components
+    begin
+      Grape::API.classes.each do |component|
+        if !exclude_list.include? component
+          begin
+            if component.class == Class
+              mount component
+            else
+              mount component.constantize
+            end
+          end
+        end
+      end
+    end
+
+
+  end
+end

data/samples/grape/init/lib/grape/xpath/ruotes.rb

@@ -0,0 +1,6 @@
+if $DEBUG
+  puts "\n\nREST::API ROUTES:"
+  REST::API.routes.map do |route|
+    putsf 8,"\t#{route.route_method}","#{route.route_path}"
+  end
+end

data/samples/grape/init/readme

@@ -0,0 +1 @@
+generet Grape files and add new entry to the boot

data/samples/grape/readme

@@ -0,0 +1,29 @@
+REST module for making rest webserver methods!
+-Ezzel REST est aplikaciokat tudsz kesziteni webszerverrer egyutt
+-az aplikáció figyelni fogja a megadott routjain a beérkező kéréseket
+
+pl.: ha a 0.0.0.0:80 on fut a webservered akkor a
+GET /user .:format  ez az alábbin fog figyelni ott:
+0.0.0.0:80/user
+
+ezen az utvonalon ha bejön neki egy GET kérés válaszolni fog
+
+REST methods:
+    -GET     -add vissza
+    -POST    -rogzitsed
+    -PUT     -frissitsed a mar meglevot
+    -DELETE  -torold azt amirol beszelunk
+*ezek szimbolikus jelentesek, de ettől függetlenül a kód azt teszi
+amit bele írnak.
+
+
+Grape is a REST-like API micro-framework for Ruby.
+It's designed to run on Rack or complement
+existing web application frameworks such as Rails
+and Sinatra by providing a simple DSL to easily develop RESTful APIs.
+It has built-in support for common conventions,
+including multiple formats, subdomain/prefix restriction,
+content negotiation, versioning and much more.
+
+Grape APIs are Rack applications that are created by
+subclassing Grape::API.

data/samples/grape/vendor/lib/grape/vendors/v1/rest.rb

@@ -0,0 +1,57 @@
+#encoding: UTF-8
+module REST
+  class CLASS < Grape::API
+
+    version 'v1',
+            using: :header,
+            vendor: 'APP'
+
+    default_format :txt
+    format :txt
+    #format :xml
+    #format :json
+
+
+    resource :RESOURCE do
+
+      desc ""
+      params do
+        #requires :id, type: Integer
+        #optional :text, type: String, regexp: /^[a-z]+$/
+        #group :media do
+        #  requires :url
+        #end
+      end
+      get do
+
+      end
+
+
+      desc ""
+      post do
+
+      end
+
+
+      desc ""
+      put do
+
+      end
+
+
+      desc ""
+      delete do
+
+      end
+
+
+    end
+  end
+end
+
+
+
+
+
+
+

data/samples/mongoid/cmd.yml

@@ -0,0 +1 @@
+helper: init

data/samples/mongoid/init/Gemfile

@@ -0,0 +1,3 @@
+### Mongoid is an ODM (Object Document Mapper)
+## Framework for MongoDB, written in Ruby.
+gem "mongoid", "~> 3.1.4"

data/samples/mongoid/init/cmd.yml

@@ -0,0 +1,2 @@
+helper: init
+mongoid: model

data/samples/mongoid/init/docs/mongoid/ModelsRelations.rb

@@ -0,0 +1,11 @@
+require_relative File.join("..","..","boot.rb")
+
+
+begin
+  relations_array = Array.new
+  Mongoid::Document.classes.each do |class_name|
+    relations_array.push class_name.constantize.getPaths[0]
+  end
+  relations_array= relations_array.sort_by{ |hsh| hsh.values }
+end
+puts relations_array

data/samples/mongoid/init/docs/mongoid/generate_modelsToDocs.rb

@@ -0,0 +1,25 @@
+require_relative File.join("..","..","boot.rb")
+
+write_out_array= Array.new
+begin
+  puts "\n"
+  separator= "="*0#*99
+  Mongoid::Document.classes.each do |class_name|
+    puts separator
+    write_out_array.push separator
+    puts "the model name:#{class_name}"
+    write_out_array.push "the model name:#{class_name}"
+    begin
+    puts "the embeds model:"+(class_name.constantize.getPaths).inspect
+    write_out_array.push "the embeds model:"+(class_name.constantize.getPaths).inspect
+    rescue NoMethodError
+    end
+    class_name.constantize.properties.each do |key,value|
+      printf "%-78s %s\n", "The field name: #{key}", "field type: #{value}"
+      write_out_array.push("The field name: #{key},\t                       field type: #{value}")
+    end
+    puts separator
+    write_out_array.push separator
+  end
+end
+File.new("models_docs.txt","w").write write_out_array.join("\n")

data/samples/mongoid/init/docs/mongoid/modelsToDocs.rb

@@ -0,0 +1,25 @@
+require_relative File.join("..","..","boot.rb")
+
+write_out_array= Array.new
+begin
+  puts "\n"
+  separator= "="*0#*99
+  Mongoid::Document.classes.each do |class_name|
+    puts separator
+    write_out_array.push separator
+    puts "the model name:#{class_name}"
+    write_out_array.push "the model name:#{class_name}"
+    begin
+    puts "the embeds model:"+(class_name.constantize.getPaths).inspect
+    write_out_array.push "the embeds model:"+(class_name.constantize.getPaths).inspect
+    rescue NoMethodError
+    end
+    class_name.constantize.properties.each do |key,value|
+      printf "%-78s %s\n", "The field name: #{key}", "field type: #{value}"
+      write_out_array.push("The field name: #{key},\t                       field type: #{value}")
+    end
+    puts separator
+    write_out_array.push separator
+  end
+end
+File.new("models_docs.txt","w").write write_out_array.join("\n")

data/samples/mongoid/init/docs/mongoid/relations.txt

@@ -0,0 +1,1354 @@
+
+Common Behaviour
+
+Attributes
+
+All relations contain a target, which is the proxied document or documents, a base which is the document the relation hangs off, and metadata which provides information about the relation.
+
+
+class Person
+  include Mongoid::Document
+  embeds_many :addresses
+end
+
+person.addresses = [ address ]
+person.addresses.target # returns [ address ]
+person.addresses.base # returns person
+person.addresses.metadata # returns the metadata
+
+
+Extensions
+
+All relations can have extensions, which provides a way to add application specific functionality to the relation. They are defined by providing a block to the relation definition.
+
+
+class Person
+  include Mongoid::Document
+  embeds_many :addresses do
+    def find_by_country(country)
+      where(country: country).first
+    end
+    def chinese
+      @target.select { |address| address.country == "China"}
+    end
+  end
+end
+
+person.addresses.find_by_country("Mongolia") # returns address
+person.addresses.chinese # returns [ address ]
+
+
+Custom Relation Names
+
+You can name your relations whatever you like, but if the class cannot be inferred by Mongoid from the name, and neither can the opposite side you'll want to provide the macro with some additional options to tell Mongoid how to hook them up.
+
+
+class Lush
+  include Mongoid::Document
+  embeds_one :whiskey, class_name: "Drink", inverse_of: :alcoholic
+end
+
+class Drink
+  include Mongoid::Document
+  embedded_in :alcoholic, class_name: "Lush", inverse_of: :whiskey
+end
+
+
+Validations
+
+It is important to note that by default, Mongoid will validate the children of any relation that are loaded into memory via a validates_associated. The relations that this applies to are:
+•embeds_many
+•embeds_one
+•has_many
+•has_one
+•has_and_belongs_to_many
+
+
+If you do not want this behavior, you may turn it off when defining the relation.
+
+
+class Person
+  include Mongoid::Document
+
+  embeds_many :addresses, validate: false
+  has_many :posts, validate: false
+end
+
+
+Polymorphism
+
+When a child embedded document can belong to more than one type of parent document, you can tell Mongoid to support this by adding the as option to the definition on the parents, and the polymorphic option on the child. On the child object, an additional field will be stored that indicates the type of the parent.
+
+
+
+Polymorphic behavior is allowed on all relations with the exception of has_and_belongs_to_many.
+
+
+
+class Band
+  include Mongoid::Document
+  embeds_many :photos, as: :photographic
+  has_one :address, as: :addressable
+end
+
+class Photo
+  include Mongoid::Document
+  embedded_in :photographic, polymorphic: true
+end
+
+class Address
+  include Mongoid::Document
+  belongs_to :addressable, polymorphic: true
+end
+
+
+Cascading Callbacks
+
+If you want the embedded document callbacks to fire when calling a persistence operation on its parent, you will need to provide the cascade callbacks option to the relation.
+
+
+
+Cascading callbacks is only available on embeds_one and embeds_many relations.
+
+
+
+class Band
+  include Mongoid::Document
+  embeds_many :albums, cascade_callbacks: true
+  embeds_one :label, cascade_callbacks: true
+end
+
+band.save # Fires all save callbacks on the band, albums, and label.
+
+
+Dependent Behaviour
+
+You can provided dependent options to referenced associations to instruct Mongoid how to handle situations where one side of the relation is deleted, or is attempted to be deleted. The options are as follows:
+•:delete: Delete the child document.
+•:destroy: Destroy the child document.
+•:nullify: Orphan the child document.
+•:restrict: Raise an error if the child is not empty.
+
+
+
+Dependent options are only available on referenced relations.
+
+
+The default behavior of each association when no dependent option is provided is to nullify.
+
+
+class Band
+  include Mongoid::Document
+  has_many :albums, dependent: :delete
+  belongs_to :label, dependent: :nullify
+end
+
+class Album
+  include Mongoid::Document
+  belongs_to :band
+end
+
+class Label
+  include Mongoid::Document
+  has_many :bands, dependent: :restrict
+end
+
+label = Label.first
+label.bands.push(Band.first)
+label.delete # Raises an error since bands is not empty.
+
+Band.first.delete # Will delete all associated albums.
+
+
+Autosaving
+
+One core difference between Mongoid and Active Record from a behavior standpoint is that Mongoid does not automatically save child relations for relational associations. This is for performance reasons.
+
+To enable an autosave on a relational association (embedded associations do not need this since they are actually part of the parent in the database) add the autosave option to the relation.
+
+
+ Note that autosave functionality will automatically be added to a relation when using accepts_nested_attributes_for or validating presence of the relation.
+
+
+class Band
+  include Mongoid::Document
+  has_many :albums, autosave: true
+end
+
+band = Band.first
+band.albums.build(name: "101")
+band.save #=> Will save the album as well.
+
+
+Recursive Embedding
+
+A document can recursively embed itself using recursively_embeds_one or recursively_embeds_many, which provides accessors for the parent and children via parent_ and child_ methods.
+
+
+
+Recursive options are only available on embedded relations.
+
+
+
+class Tag
+  include Mongoid::Document
+  recursively_embeds_many
+end
+
+root = Tag.new(name: "programming")
+child_one = root.child_tags.build
+child_two = root.child_tags.build
+
+root.child_tags # [ child_one, child_two ]
+child_one.parent_tag # [ root ]
+child_two.parent_tag # [ root ]
+
+class Node
+  include Mongoid::Document
+  recursively_embeds_one
+end
+
+root = Node.new
+child = Node.new
+root.child_node = child
+
+root.child # child
+child.parent_node # root
+
+
+Existence Predicates
+
+All relations have existence predicates on them in the form of name? and has_name? to check if the relation is blank.
+
+
+class Band
+  include Mongoid::Document
+  embeds_one :label
+  embeds_many :albums
+end
+
+band.label?
+band.has_label?
+band.albums?
+band.has_albums?
+
+
+Autobuilding
+
+One to one relations (embeds_one, has_one) have an autobuild option which tells Mongoid to instantiate a new document when the relation is accessed and it is nil
+
+
+
+Existence predicates will not trigger an autobuild, so they will properly return false if the document is not present.
+
+
+
+class Band
+  include Mongoid::Document
+  embeds_one :label, autobuild: true
+  has_one :producer, autobuild: true
+end
+
+band = Band.new
+band.label # Returns a new empty label.
+band.producer # Returns a new empty producer.
+
+
+Touching
+
+Any belongs_to relation, no matter where it hangs off from, can take an optional :touch option which will call the touch method on it and any parent relations with the option defined when the base document calls #touch.
+
+
+class Band
+  include Mongoid::Document
+  belongs_to :label, touch: true
+end
+
+band = Band.first
+band.touch #=> Calls touch on the parent label.
+
+
+Metadata
+
+All relations in Mongoid contain metadata that holds information about the relation in question, and is a valuable tool for third party developers to use to extend Mongoid.
+
+You can access the metadata of the relation in a few different ways.
+
+
+# Get the metadata for a named relation from the class or document.
+Model.reflect_on_association(:relation_name)
+model.reflect_on_association(:relation_name)
+
+# Get the metadata that the current object has in its relation.
+model.metadata
+
+# Get the metadata with a specific relation itself on a specific
+# document.
+person.addresses.metadata
+
+
+The Metadata Object
+
+The metadata object itself contains more information than one might know what to do with, and is useful for developers of extensions to Mongoid.
+
+
+Method
+
+Description
+
+
+Metadata#as Returns the name of the parent to a polymorphic child.
+Metadata#as? Returns whether or not an as option exists.
+Metadata#autobuilding? Returns whether or not the relation is autobuilding.
+Metadata#autosaving? Returns whether or not the relation is autosaving.
+Metadata#cascading_callbacks? Returns whether the relation has callbacks cascaded down from the parent.
+Metadata#class_name Returns the class name of the proxied document.
+Metadata#cyclic? Returns whether the relation is a cyclic relation.
+Metadata#dependent Returns the relation's dependent option.
+Metadata#dependent? Returns whether the relation is a dependent relation.
+Metadata#destructive? Returns true if the relation has a dependent delete or destroy.
+Metadata#embedded? Returns whether the relation is embedded in another document.
+Metadata#forced_nil_inverse? Returns whether the relation has a nil inverse defined.
+Metadata#foreign_key Returns the name of the foreign key field.
+Metadata#foreign_key_check Returns the name of the foreign key field dirty check method.
+Metadata#foreign_key_setter Returns the name of the foreign key field setter.
+Metadata#indexed? Returns whether the foreign key is auto indexed.
+Metadata#inverses Returns the names of all inverse relation.
+Metadata#inverse Returns the name of a single inverse relation.
+Metadata#inverse_class_name Returns the class name of the relation on the inverse side.
+Metadata#inverse_foreign_key Returns the name of the foreign key field on the inverse side.
+Metadata#inverse_klass Returns the class of the relation on the inverse side.
+Metadata#inverse_metadata Returns the metadata of the relation on the inverse side.
+Metadata#inverse_of Returns the explicitly defined name of the inverse relation.
+Metadata#inverse_of? Returns whether an inverse_of option is defined.
+Metadata#inverse_setter Returns the name of the method used to set the inverse.
+Metadata#inverse_type Returns the name for the polymorphic type field of the inverse.
+Metadata#inverse_type_setter Returns the name for the polymorphic type field setter of the inverse.
+Metadata#key Returns the name of the field in the attributes hash to use to get the relation.
+Metadata#klass Returns the class of the proxied documents in the relation.
+Metadata#macro Returns the relation's macro.
+Metadata#name Returns the relation name.
+Metadata#options Returns self, for API compatibility with Active Record.
+Metadata#order Returns the custom sorting options on the relation.
+Metadata#order? Returns whether custom sorting options are set.
+Metadata#polymorphic? Returns whether the relation is polymorphic.
+Metadata#setter Returns the name of the field to set the relation.
+Metadata#store_as Returns the name of the attribute to store an embedded relation in.
+Metadata#touchable? Returns whether or not the relation has a touch option.
+Metadata#type Returns the name of the field to get the polymorphic type.
+Metadata#type_setter Returns the name of the field to set the polymorphic type.
+Metadata#validate? Returns whether the relation has an associated validation.
+Metadata#versioned? Returns whether the relation is an embedded version.
+
+Embedded 1-1
+
+One to one relationships where the children are embedded in the parent document are defined using Mongoid's embeds_one and embedded_in macros.
+
+Defining
+
+The parent document of the relation should use the embeds_one macro to indicate is has 1 embedded child, where the document that is embedded uses embedded_in.
+
+
+class Band
+  include Mongoid::Document
+  embeds_one :label
+end
+
+class Label
+  include Mongoid::Document
+  field :name, type: String
+  embedded_in :band
+end
+
+
+
+
+Definitions are required on both sides to the relation in order for it to work properly.
+
+
+Storage
+
+Documents that are embedded using the embeds_one macro are stored as a hash inside the parent in the parent's database collection.
+
+
+{
+  "_id" : ObjectId("4d3ed089fb60ab534684b7e9"),
+  "label" : {
+    "_id" : ObjectId("4d3ed089fb60ab534684b7e0"),
+    "name" : "Mute",
+  }
+}
+
+
+You can optionally tell Mongoid to store the embedded document in a different attribute other than the name, by providing a :store_as option.
+
+
+class Band
+  include Mongoid::Document
+  embeds_one :label, store_as: "lab"
+end
+
+
+Operations
+
+Once the relation is defined, the following operations are available, and the following table shows any database operations that are performed if applicable. The previously defined models will be used for example code.
+
+
+Operation
+
+Mongoid
+
+Moped
+
+
+Model#{name}
+Get the embedded document.
+
+
+band.label
+
+Model#{name}=
+ Set the embedded document. If the parent document is persisted, then the child will be atomically saved immediately. If setting to nil then the child will be deleted.
+
+
+band.label = Label.new(name: "Mute")
+
+band.label = nil
+
+
+collections[:bands].find(...).
+  update(
+    "$set" => { label: { name: "Mute" }}
+  )
+
+collections[:bands].find(...).
+  update("$unset" => { label: true })
+
+
+Model#{parent_name}
+ Get the parent document from the child.
+
+
+label.band
+
+Model#{parent_name}=
+ Set the parent document from the child.
+
+
+label.band = Band.new
+
+Model#build_{name}
+ Build a new document on the relation.
+
+
+band.build_label(name: "Mute")
+
+label.build_band(name: "Depeche Mode")
+
+Model#create_{name}
+ Create a new document from either side of the relation. This persists the child immediately if executing from the parent, and persists the entire tree if executed from the child.
+
+
+band.create_label(name: "Mute")
+
+label.create_band({
+  name: "Depeche Mode"
+})
+
+
+collections[:bands].find(...).
+  update(
+    "$set" => { label: { name: "Mute" }}
+  )
+
+collections[:bands].
+  insert({
+    name: "Depeche Mode",
+    label: { name: "Mute" }
+  })
+
+
+
+Embedded 1-n
+
+One to many relationships where the children are embedded in the parent document are defined using Mongoid's embeds_many and embedded_in macros.
+
+Defining
+
+The parent document of the relation should use the embeds_many macro to indicate it has n number of embedded children, where the document that is embedded uses embedded_in.
+
+
+class Band
+  include Mongoid::Document
+  embeds_many :albums
+end
+
+class Album
+  include Mongoid::Document
+  field :name, type: String
+  embedded_in :band
+end
+
+
+
+
+Definitions are required on both sides to the relation in order for it to work properly.
+
+
+Storage
+
+Documents that are embedded using the embeds_many macro are stored as an array of hashes inside the parent in the parent's database collection.
+
+
+{
+  "_id" : ObjectId("4d3ed089fb60ab534684b7e9"),
+  "albums" : [
+    {
+      "_id" : ObjectId("4d3ed089fb60ab534684b7e0"),
+      "name" : "Violator",
+    }
+  ]
+}
+
+
+You can optionally tell Mongoid to store the embedded document in a different attribute other than the name, by providing a :store_as option.
+
+
+class Band
+  include Mongoid::Document
+  embeds_many :albums, store_as: "albs"
+end
+
+
+Operations
+
+Once the relation is defined, the following operations are available, and the following table shows any database operations that are performed if applicable. The previously defined models will be used for example code.
+
+
+Operation
+
+Mongoid
+
+Moped
+
+
+Model#{name}
+Get the embedded documents.
+
+
+band.albums
+
+Model#{name}=
+ Set the embedded documents. If the parent document is persisted, then the child will be atomically saved immediately. If setting to nil or [] then the children will be deleted.
+
+
+band.albums = [ Album.new(name: "Violator") ]
+
+band.albums = nil
+band.albums = []
+
+
+collections[:bands].find(...).
+  update(
+    "$set" => { albums: [{ name: "Violator" }]}
+  )
+
+collections[:bands].find(...).
+  update("$unset" => { albums: true })
+
+
+Model#{parent_name}
+ Get the parent document from any child.
+
+
+album.band
+
+Model#{parent_name}=
+ Set the parent document from a child.
+
+
+album.band = Band.new
+
+Model#{name}.<<
+Model#{name}.push
+ Push a new document onto the relation. If the parent is persisted, then the child documents will be automatically saved.
+
+
+band.albums << Album.new(name: "Violator")
+band.albums.push(Album.new(name: "Violator"))
+
+
+collections[:bands].find(...).
+  update(
+    "$push" => { albums: { name: "Violator" }}
+  )
+
+Model#{name}.concat
+ Push multiple documents onto the relation. If the parent is persisted, then the child documents will be automatically saved. Note that while batch operations limit the number of database calls to a single one for the new documents, it is in fact at least 2x slower from the Ruby side. This is due to the fact that 2 iterations over all documents must occur to ensure that all the before callbacks run before the db hit, and that all after callbacks have to wait until after.
+
+
+band.albums.concat(
+  Album.new(name: "Violator"),
+  Album.new(name: "101")
+)
+
+
+collections[:bands].find(...).
+  update(
+    "$pushAll" => {
+      albums: [{ name: "Violator" }, { name: "101" }]
+    }
+  )
+
+Model#{name}.build
+Model#{name}.new
+ Build a new document in the relation with the provided attributes. Does not save the new document.
+
+
+band.albums.build(name: "Violator")
+band.albums.new(name: "Violator")
+
+Model#{name}.create
+Model#{name}.create!
+ Create a new document in the relation with the provided attributes and saves. With the bang version an error will be raised if validation fails.
+
+
+band.albums.create(name: "Violator")
+band.albums.create!(name: "Violator")
+
+
+collections[:bands].find(...).
+  update(
+    "$push" => { albums: { name: "Violator" }}
+  )
+
+Model#{name}.clear
+Model#{name}.delete_all
+ Deletes all documents from the relation, without running any callbacks.
+
+
+band.albums.clear
+band.albums.delete_all
+band.albums.delete_all(name: "Violator")
+band.albums.
+  where(name: "Violator").delete_all
+
+
+collections[:bands].find(...).
+  update(
+    "$pullAll" => { albums: [{ name: "Violator" }]}
+  )
+
+Model#{name}.destroy_all
+ Deletes all documents from the relation, while running the destroy callbacks.
+
+
+band.albums.destroy_all
+band.albums.destroy_all(name: "Violator")
+band.albums.
+  where(name: "Violator").destroy_all
+
+
+collections[:bands].find(...).
+  update(
+    "$pullAll" => { albums: [{ name: "Violator" }]}
+  )
+
+Model#{name}.delete
+ Deletes the matching document from the relation.
+
+
+band.albums.delete(album)
+
+
+collections[:bands].find(...).
+  update(
+    "$pull" => { albums: { name: "Violator" }}
+  )
+
+Model#{name}.pop
+ Deletes the provided number of documents, defaulting to 1.
+
+
+band.albums.pop
+band.albums.pop(1)
+
+
+collections[:bands].find(...).
+  update(
+    "$pullAll" => { albums: [{ name: "Violator" }]}
+  )
+
+Model#{name}.find
+ Return documents in the relation with matching ids. Will raise an error if all the ids are not found by default.
+
+
+band.albums.find(id)
+band.albums.find(id_one, id_two)
+
+Model#{name}.find_or_create_by
+ Search for the document in the relation, and if not found create a newly persisted one.
+
+
+band.albums.
+  find_or_create_by(name: "Violator")
+
+
+collections[:bands].find(...).
+  update(
+    "$push" => { albums: { name: "Violator" }}
+  )
+
+Model#{name}.find_or_initialize_by
+ Search for the document in the relation, and if not found add a new one.
+
+
+band.albums.
+  find_or_initialize_by(name: "Violator")
+
+Model#{name}.where
+ Find matching documents in the relation. This can be any criteria method, not just where.
+
+
+band.albums.where(name: "Violator")
+
+Model#{name}.exists?
+ Returns whether or not the relation has any documents.
+
+
+band.albums.exists?
+
+
+Referenced 1-1
+
+One to one relationships where the children are referenced in the parent document are defined using Mongoid's has_one and belongs_to macros.
+
+Defining
+
+The parent document of the relation should use the has_one macro to indicate is has 1 referenced child, where the document that is referenced in it uses belongs_to.
+
+
+class Band
+  include Mongoid::Document
+  has_one :studio
+end
+
+class Studio
+  include Mongoid::Document
+  field :name, type: String
+  belongs_to :band
+end
+
+
+Definitions are required on both sides to the relation in order for it to work properly, unless one of the models is embedded.
+
+Storage
+
+When defining a relation of this nature, each document is stored in its respective collection, but the child document contains a "foreign key" reference to the parent.
+
+
+# The parent band document.
+{ "_id" : ObjectId("4d3ed089fb60ab534684b7e9") }
+
+# The child studio document.
+{
+  "_id" : ObjectId("4d3ed089fb60ab534684b7f1"),
+  "band_id" : ObjectId("4d3ed089fb60ab534684b7e9")
+}
+
+
+Operations
+
+Once the relation is defined, the following operations are available, and the following table shows any database operations that are performed if applicable. The previously defined models will be used for example code.
+
+
+Operation
+
+Mongoid
+
+Moped
+
+
+Model#{name}
+Get the child document.
+
+
+band.studio
+
+Model#{name}=
+ Set the child document. If the parent document is persisted, then the child will be saved immediately. If setting to nil then the child will be deleted.
+
+
+band.studio = Studio.new(name: "Abbey Road")
+
+band.studio = nil
+
+
+collections[:studios].insert(
+  { name: "Abbey Road", band_id: ... }
+)
+
+collections[:studios].find(...).remove
+
+
+Model#{parent_name}
+ Get the parent document from the child.
+
+
+studio.band
+
+Model#{parent_name}=
+ Set the parent document from the child.
+
+
+studio.band = Band.new
+
+Model#build_{name}
+ Build a new document on the relation. This does not save the new document.
+
+
+band.build_studio(name: "Abbey Road")
+
+studio.build_band(name: "Depeche Mode")
+
+Model#create_{name}
+ Create a new document from either side of the relation. This persists the child immediately if executing from the parent, and persists the parent if executed from the child.
+
+
+band.create_studio(name: "Abbey Road")
+
+studio.create_band(name: "Depeche Mode")
+
+
+collections[:studios].insert(
+  { name: "Abbey Road", band_id: ... }
+)
+
+collections[:bands].insert(
+  { name: "Depeche Mode" }
+)
+
+
+
+Referenced 1-n
+
+One to many relationships where the children are stored in a separate collection from the parent document are defined using Mongoid's has_many and belongs_to macros. This exhibits similar behavior to Active Record.
+
+Defining
+
+The parent document of the relation should use the has_many macro to indicate is has n number of referenced children, where the document that is referenced uses belongs_to.
+
+
+class Band
+  include Mongoid::Document
+  has_many :members
+end
+
+class Member
+  include Mongoid::Document
+  field :name, type: String
+  belongs_to :band
+end
+
+
+Definitions are required on both sides to the relation in order for it to work properly, unless one of the models is embedded.
+
+Storage
+
+When defining a relation of this nature, each document is stored in its respective collection, but the child document contains a "foreign key" reference to the parent.
+
+
+# The parent band document.
+{ "_id" : ObjectId("4d3ed089fb60ab534684b7e9") }
+
+# The child member document.
+{
+  "_id" : ObjectId("4d3ed089fb60ab534684b7f1"),
+  "band_id" : ObjectId("4d3ed089fb60ab534684b7e9")
+}
+
+
+Operations
+
+Once the relation is defined, the following operations are available, and the following table shows any database operations that are performed if applicable. The previously defined models will be used for example code.
+
+
+Operation
+
+Mongoid
+
+Moped
+
+
+Model#{name}
+Get the related documents.
+
+
+band.members
+
+Model#{name}=
+ Set the related documents. If the parent document is persisted, then the child will be saved immediately. If setting to nil or [] then the children will be deleted.
+
+
+band.members = [ Member.new(name: "Fletch") ]
+
+band.members = nil
+band.members = []
+
+
+collections[:members].insert(
+  { name: "Fletch", band_id: ... }
+)
+
+collections[:members].find(...).remove
+
+Model#{name}_ids
+Get the related document ids.
+
+
+band.member_ids
+
+Model#{name}_ids=
+ Set the related document ids.
+
+
+band.member_ids = [ id ]
+
+Model#{parent_name}
+ Get the parent document from any child.
+
+
+member.band
+
+Model#{parent_name}=
+ Set the parent document from a child.
+
+
+member.band = Band.new
+
+Model#{name}.<<
+Model#{name}.push
+ Push a new document onto the relation. If the parent is persisted, then the child documents will be automatically saved.
+
+
+band.members << Member.new(name: "Fletch")
+band.members.push(Member.new(name: "Fletch"))
+
+
+collections[:members].insert(
+  { name: "Fletch", band_id: ... }
+)
+
+Model#{name}.concat
+ Push multiple documents onto the relation. If the parent is persisted, then the child documents will be automatically saved in a single batch. Note that while batch operations limit the number of database calls to a single one for the new documents, it is in fact at least 2x slower from the Ruby side. This is due to the fact that 2 iterations over all documents must occur to ensure that all the before callbacks run before the db hit, and that all after callbacks have to wait until after.
+
+
+band.members.concat(
+  Member.new(name: "Fletch"),
+  Member.new(name: "Martin")
+)
+
+
+collections[:members].insert([
+  { name: "Fletch", band_id: ... },
+  { name: "Martin", band_id: ... }
+])
+
+Model#{name}.build
+Model#{name}.new
+ Build a new document in the relation with the provided attributes. Does not save the new document.
+
+
+band.members.build(name: "Fletch")
+band.members.new(name: "Fletch")
+
+Model#{name}.create
+Model#{name}.create!
+ Create a new document in the relation with the provided attributes and saves. With the bang version an error will be raised if validation fails.
+
+
+band.members.create(name: "Fletch")
+band.members.create!(name: "Fletch")
+
+
+collections[:members].insert(
+  { name: "Fletch", band_id: ... }
+)
+
+Model#{name}.clear
+Model#{name}.delete_all
+ Deletes all documents from the relation, without running any callbacks.
+
+
+band.members.clear
+band.members.delete_all
+band.members.delete_all(name: "Fletch")
+band.members.
+  where(name: "Fletch").delete_all
+
+
+collections[:members].find(band_id: ...).remove_all
+
+collections[:members].
+  find(band_id: ..., name: "Fletch").remove_all
+
+Model#{name}.destroy_all
+ Deletes all documents from the relation, while running the destroy callbacks.
+
+
+band.members.destroy_all
+band.members.destroy_all(name: "Fletch")
+band.members.
+  where(name: "Fletch").destroy_all
+
+
+collections[:members].find(band_id: ...).remove_all
+
+collections[:members].
+  find(band_id: ..., name: "Fletch").remove_all
+
+Model#{name}.delete
+ Deletes the matching document from the relation.
+
+
+band.members.delete(member)
+
+
+collections[:members].
+  find(band_id: ..., name: "Fletch").remove
+
+Model#{name}.find
+ Return documents in the relation with matching ids. Will raise an error if all the ids are not found by default.
+
+
+band.members.find(id)
+
+band.members.find(id_one, id_two)
+
+
+collections[:members].find({
+  band_id: ..., _id: id
+})
+
+collections[:members].find({
+  band_id: ..., _id: { "$in" => [ id_one, id_two ] }
+})
+
+Model#{name}.find_or_create_by
+ Search for the document in the relation, and if not found create a newly persisted one.
+
+
+band.members.
+  find_or_create_by(name: "Fletch")
+
+
+collections[:members].find({
+  band_id: ..., name: "Fletch"
+})
+collections[:members].insert(
+  { name: "Fletch", band_id: ... }
+)
+
+Model#{name}.find_or_initialize_by
+ Search for the document in the relation, and if not found add a new one.
+
+
+band.members.
+  find_or_initialize_by(name: "Fletch")
+
+
+collections[:members].find({
+  band_id: ..., name: "Fletch"
+})
+
+Model#{name}.where
+ Find matching documents in the relation. This can be any criteria method, not just where.
+
+
+band.members.where(name: "Fletch")
+
+
+collections[:members].find({
+  band_id: ..., name: "Fletch"
+})
+
+Model#{name}.exists?
+ Returns whether or not the relation has any documents.
+
+
+band.members.exists?
+
+
+collections[:members].find(band_id: ...).count
+
+
+
+Referenced n-n
+
+Many to many relationships where the inverse documents are stored in a separate collection from the base document are defined using Mongoid's has_and_belongs_to_many macro. This exhibits similar behavior to Active Record with the exception that no join collection is needed, the foreign key ids are stored as arrays on either side of the relation.
+
+Defining
+
+Both sides of the relation use the same macro.
+
+
+class Band
+  include Mongoid::Document
+  has_and_belongs_to_many :tags
+end
+
+class Tag
+  include Mongoid::Document
+  field :name, type: String
+  has_and_belongs_to_many :bands
+end
+
+
+You can create a one sided many to many if you want to mimic a has_many that stores the keys as an array on the parent.
+
+
+class Band
+  include Mongoid::Document
+  has_and_belongs_to_many :tags, inverse_of: nil
+end
+
+class Tag
+  include Mongoid::Document
+  field :name, type: String
+end
+
+
+Storage
+
+When defining a relation of this nature, each document is stored in its respective collection, and each document contains a "foreign key" reference to the other in the form of an array.
+
+
+# The band document.
+{
+  "_id" : ObjectId("4d3ed089fb60ab534684b7e9"),
+  "tag_ids" : [ ObjectId("4d3ed089fb60ab534684b7f2") ]
+}
+
+# The tag document.
+{
+  "_id" : ObjectId("4d3ed089fb60ab534684b7f2"),
+  "band_ids" : [ ObjectId("4d3ed089fb60ab534684b7e9") ]
+}
+
+
+Operations
+
+Once the relation is defined, the following operations are available, and the following table shows any database operations that are performed if applicable. The previously defined models will be used for example code.
+
+
+
+Many to many relations require usually double the amount of hits to the database to keep both sides of the relation in sync, since keys are stored on both sides. Due to this they are slower and should be used with caution.
+
+
+
+Operation
+
+Mongoid
+
+Moped
+
+
+Model#{name}
+Get the related documents.
+
+
+band.tags
+
+Model#{name}=
+ Set the related documents. If the parent document is persisted, then the child will be saved immediately along with the parent to keep the keys consistent. If setting to nil or [] then the children will be deleted.
+
+
+band.tags = [ Tag.new(name: "electro") ]
+
+band.tags = nil
+band.tags = []
+
+
+collections[:tags].insert(
+  { name: "electro", band_ids: ... }
+)
+collections[:bands].find(...).
+  update("$push" => { tag_ids: ... })
+
+collections[:tags].find(...).remove
+collections[:bands].find(...).
+  update("$pull" => { tag_ids: ... })
+
+Model#{name}.<<
+Model#{name}.push
+ Push a new document onto the relation. If the parent is persisted, then the child documents will be automatically saved.
+
+
+band.tags << Tag.new(name: "electro")
+band.tags.push(Tag.new(name: "electro"))
+
+
+collections[:tags].insert(
+  { name: "electro", band_ids: ... }
+)
+collections[:bands].find(...).
+  update("$push" => { tag_ids: ... })
+
+Model#{name}.concat
+ Push multiple documents onto the relation. If the parent is persisted, then the child documents will be automatically saved in a single batch. Note that while batch operations limit the number of database calls to a single one for the new documents, it is in fact at least 2x slower from the Ruby side. This is due to the fact that 2 iterations over all documents must occur to ensure that all the before callbacks run before the db hit, and that all after callbacks have to wait until after.
+
+
+band.tags.concat(
+  Tag.new(name: "electro"),
+  Tag.new(name: "new wave")
+)
+
+
+collections[:tags].insert([
+  { name: "electro", band_ids: ... },
+  { name: "new wave", band_ids: ... }
+])
+collections[:bands].find(...).
+  update("$pushAll" => { tag_ids: ... })
+
+Model#{name}.build
+Model#{name}.new
+ Build a new document in the relation with the provided attributes. Does not save the new document.
+
+
+band.tags.build(name: "electro")
+band.tags.new(name: "electro")
+
+Model#{name}.create
+Model#{name}.create!
+ Create a new document in the relation with the provided attributes and saves. With the bang version an error will be raised if validation fails.
+
+
+band.tags.create(name: "electro")
+band.tags.create!(name: "electro")
+
+
+collections[:tags].insert(
+  { name: "electro", band_ids: ... }
+)
+collections[:bands].find(...).
+  update("$push" => { tag_ids: ... })
+
+Model#{name}.clear
+Model#{name}.delete_all
+ Deletes all documents from the relation, without running any callbacks.
+
+
+band.tags.clear
+band.tags.delete_all
+band.tags.delete_all(name: "electro")
+band.tags.
+  where(name: "electro").delete_all
+
+
+collections[:tags].find(_id: { "$in" => ... }).remove_all
+collections[:bands].find(...).
+  update("$pullAll" => { tag_ids: ... })
+
+collections[:tags].
+  find(_id: { "$in" => ... }, name: "electro").remove_all
+collections[:bands].find(...).
+  update("$pullAll" => { tag_ids: ... })
+
+Model#{name}.destroy_all
+ Deletes all documents from the relation, while running the destroy callbacks.
+
+
+band.tags.destroy_all
+band.tags.destroy_all(name: "electro")
+band.tags.
+  where(name: "electro").destroy_all
+
+
+collections[:tags].find(_id: { "$in" => ... }).remove_all
+collections[:bands].find(...).
+  update("$pullAll" => { tag_ids: ... })
+
+collections[:tags].
+  find(_id: { "$in" => ... }, name: "electro").remove_all
+collections[:bands].find(...).
+  update("$pullAll" => { tag_ids: ... })
+
+Model#{name}.delete
+ Deletes the matching document from the relation.
+
+
+band.tags.delete(tag)
+
+
+collections[:tags].
+  find(_id: { "$in" => ... }, name: "electro").remove
+collections[:bands].find(...).
+  update("$pull" => { tag_ids: ... })
+
+Model#{name}.find
+ Return documents in the relation with matching ids. Will raise an error if all the ids are not found by default.
+
+
+band.tags.find(id)
+
+band.tags.find(id_one, id_two)
+
+
+collections[:tags].find({
+  _id: { "$in" => ... }, { "$and" => [{ _id: id }] }
+})
+
+collections[:tags].find({
+  _id: { "$in" => ... },
+  { "$and" => [{ _id: { "$in" => [ id_one, id_two ]}}] }
+})
+
+Model#{name}.find_or_create_by
+ Search for the document in the relation, and if not found create a newly persisted one.
+
+
+band.tags.
+  find_or_create_by(name: "electro")
+
+
+collections[:tags].find({
+  _id: { "$in" => ... }, name: "electro"
+})
+collections[:tags].insert(
+  { name: "electro", band_ids: ... }
+)
+
+Model#{name}.find_or_initialize_by
+ Search for the document in the relation, and if not found add a new one.
+
+
+band.tags.
+  find_or_initialize_by(name: "electro")
+
+
+collections[:tags].find({
+  _id: { "$in" => ... }, name: "electro"
+})
+
+Model#{name}.where
+ Find matching documents in the relation. This can be any criteria method, not just where.
+
+
+band.tags.where(name: "electro")
+
+
+collections[:tags].find({
+  _id: { "$in" => ... }, name: "electro"
+})
+
+Model#{name}.exists?
+ Returns whether or not the relation has any documents.
+
+
+band.tags.exists?
+
+
+collections[:tags].
+  find(_id: { "$in" => ... }).count
+