mongoid-dsl 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4fa301c9617088b3bf2b0f82609924c9a7aea0af
+  data.tar.gz: ddb141cc05b803af124b4b0a0dbd9c7f4ff747cc
+SHA512:
+  metadata.gz: 62be09d282612a3248c3d210bec2c13641c99f8ff38f69db607c288db2de7f5eb6def7c9c4544c89e844aee999a02e14ec887e7df809e59e9a2152c360a42f37
+  data.tar.gz: 215497d4ee504fd75c1f326098eed9aed04bf34e9e8ab10c61eb870635cccbb322dd9fa196f40aabb1ad1ceb85ac511c44eeaaf2b8bc97786fd7b482d648cb7f

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Adam Luzsi
+
+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,115 @@
+Mongoid-DSL
+==============
+
+Ruby Module for ease of use with mongoid based models
+
+with this module, you can do:
+* recursive methods by calling [:_find,:_find_by,:_where,:_all] on the model (even on deeply embedded ones)
+* check connection relation between two model
+* get :parents, :references or :documents
+
+
+### Examples for use
+
+recursive find
+If the model path is not clear by default the  shortest way will be chosen,
+You can modify this behavior by adding model names to the args, before or after the query hash
+for example: TestD._where( TestA, TestB, TestC, test: "world" ).inspect
+
+The return object will be array if the target model is not a main one but an embedded
+
+```ruby
+
+    require 'mongoid-dsl'
+    require_relative "helper/con"
+
+    :TestA.mongoid_name
+    #> nil
+
+    class TestA
+
+      include Mongoid::Document
+      include Mongoid::Timestamps
+
+      store_in :collection => self.mongoid_name
+
+      embeds_many :TestB.mongoid_name
+
+      field :test,
+            :type     => String,
+            :presence => true,
+            :desc     => "description for this field",
+            :accept_only  => %W[ hello world hello\ world ]
+
+    end
+
+    :TestA.mongoid_name
+    #> "test_a"
+
+    class TestB
+
+      include Mongoid::Document
+      include Mongoid::Timestamps
+
+      embedded_in :TestA.mongoid_name
+      embeds_many :TestC.mongoid_name
+
+      field :test,
+            :type         => String,
+            :presence     => true,
+            :desc         => "description for this field",
+            :uniq         => true
+
+    end
+
+    class TestC
+
+      include Mongoid::Document
+      include Mongoid::Timestamps
+
+      embedded_in :TestB.mongoid_name
+      embeds_many :TestD.mongoid_name
+
+      field :test,
+            :type         => String,
+            :presence     => true,
+            :desc         => "description for this field"
+
+    end
+
+    class TestD
+
+      include Mongoid::Document
+      include Mongoid::Timestamps
+
+      embedded_in :TestC.mongoid_name
+
+      field :test,
+            :type         => String,
+            :presence     => true,
+            :desc         => "description for this field"
+
+    end
+
+    test_a= TestA.create! test: "hello"
+    test_a.test_b.create(test: "world")
+    test_b= test_a.test_b.last
+    test_b.test_c.create(test: "world")
+    test_c= test_b.test_c.last
+    test_c.test_d.create(test: "world")
+    test_d= test_c.test_d.last
+
+    # puts TestD._find(test_d['_id']).inspect
+    #<TestD _id: 536a10f6241548c811000004, created_at: 2014-05-07 10:54:46 UTC, updated_at: 2014-05-07 10:54:46 UTC, test: "world">
+
+    puts TestD._all.inspect
+    #> return every embedded TestD obj
+
+    puts TestD._where( test: "world" ).inspect
+    #> return by criteria the embedded TestD objects
+
+    Mongoid.purge!
+
+
+```
+

data/Rakefile

@@ -0,0 +1 @@
+require File.join"bundler","gem_tasks"

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/examples/helper/con.rb

@@ -0,0 +1 @@
+Mongoid.load!(File.join(File.dirname(__FILE__),"mongoid.yml"), :development)

data/examples/helper/mongoid.yml

@@ -0,0 +1,6 @@
+development:
+  sessions:
+    default:
+      database: mongoid
+      hosts:
+        - localhost:27017

data/examples/recursive_find.rb

@@ -0,0 +1,87 @@
+require_relative "../lib/mongoid-dsl"
+require_relative "helper/con"
+
+:TestA.mongoid_name #> nil
+
+class TestA
+
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  store_in :collection => self.mongoid_name
+
+  embeds_many :TestB.mongoid_name
+
+  field :test,
+        :type     => String,
+        :presence => true,
+        :desc     => "description for this field",
+        :accept_only  => %W[ hello world hello\ world ]
+
+end
+
+:TestA.mongoid_name #> "test_a"
+
+class TestB
+
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  embedded_in :TestA.mongoid_name
+  embeds_many :TestC.mongoid_name
+
+  field :test,
+        :type         => String,
+        :presence     => true,
+        :desc         => "description for this field",
+        :uniq         => true
+
+end
+
+class TestC
+
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  embedded_in :TestB.mongoid_name
+  embeds_many :TestD.mongoid_name
+
+  field :test,
+        :type         => String,
+        :presence     => true,
+        :desc         => "description for this field"
+
+end
+
+class TestD
+
+  include Mongoid::Document
+  include Mongoid::Timestamps
+
+  embedded_in :TestC.mongoid_name
+
+  field :test,
+        :type         => String,
+        :presence     => true,
+        :desc         => "description for this field"
+
+end
+
+test_a= TestA.create! test: "hello"
+test_a.test_b.create(test: "world")
+test_b= test_a.test_b.last
+test_b.test_c.create(test: "world")
+test_c= test_b.test_c.last
+test_c.test_d.create(test: "world")
+test_d= test_c.test_d.last
+
+# puts TestD._find(test_d['_id']).inspect
+#<TestD _id: 536a10f6241548c811000004, created_at: 2014-05-07 10:54:46 UTC, updated_at: 2014-05-07 10:54:46 UTC, test: "world">
+
+puts TestD._all.inspect
+#> return every embedded TestD obj
+
+puts TestD._where( TestA, test: "world" ).inspect
+#> return by criteria the embedded TestD objects
+
+Mongoid.purge!

data/lib/mongoid-dsl/fields-ext.rb

@@ -0,0 +1,183 @@
+# Validates whether the value of the specified attribute is available in a
+# particular enumerable object.
+#
+#   class Person < ActiveRecord::Base
+#     validates_inclusion_of :gender, :in => %w( m f )
+#     validates_inclusion_of :age, :in => 0..99
+#     validates_inclusion_of :format, :in => %w( jpg gif png ), :message => "extension %{value} is not included in the list"
+#     validates_inclusion_of :states, :in => lambda{ |person| STATES[person.country] }
+#   end
+#
+# Configuration options:
+# * <tt>:in</tt> - An enumerable object of available items. This can be
+#   supplied as a proc or lambda which returns an enumerable. If the enumerable
+#   is a range the test is performed with <tt>Range#cover?</tt>
+#   (backported in Active Support for 1.8), otherwise with <tt>include?</tt>.
+# * <tt>:within</tt> - A synonym(or alias) for <tt>:in</tt>
+# * <tt>:message</tt> - Specifies a custom error message (default is: "is not
+#   included in the list").
+# * <tt>:allow_nil</tt> - If set to true, skips this validation if the attribute
+#   is +nil+ (default is +false+).
+# * <tt>:allow_blank</tt> - If set to true, skips this validation if the
+#   attribute is blank (default is +false+).
+# * <tt>:on</tt> - Specifies when this validation is active. Runs in all
+#   validation contexts by default (+nil+), other options are <tt>:create</tt>
+#   and <tt>:update</tt>.
+# * <tt>:if</tt> - Specifies a method, proc or string to call to determine if
+#   the validation should occur (e.g. <tt>:if => :allow_validation</tt>, or
+#   <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The method, proc
+#   or string should
+#   return or evaluate to a true or false value.
+# * <tt>:unless</tt> - Specifies a method, proc or string to call to determine
+#   if the validation should not occur (e.g. <tt>:unless => :skip_validation</tt>,
+#   or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The method,
+#   proc or string should return or evaluate to a true or false value.
+# * <tt>:strict</tt> - Specifies whether validation should be strict.
+#   See <tt>ActiveModel::Validation#validates!</tt> for more information.
+
+[ :desc, :description, :comment ].each do |name_to_use|
+  Mongoid::Fields.option name_to_use do |model, field, value|
+
+    if field.instance_variable_get('@options')[name_to_use].class <= Array
+      field.instance_variable_get('@options')[name_to_use]= field.instance_variable_get('@options')[name_to_use].join
+    end
+
+    field.instance_variable_get('@options')[:desc]= field.instance_variable_get('@options').delete(name_to_use)
+
+  end
+end
+
+[ :required, :present, :presence, :need ].each do |name_to_use|
+  Mongoid::Fields.option name_to_use do |model, field, value|
+
+    field.instance_variable_get('@options')[:presence]= field.instance_variable_get('@options').delete(name_to_use)
+    if value == true
+      model.instance_eval do
+        validates_presence_of field.instance_variable_get('@name')
+      end
+    end
+
+  end
+end
+
+[ :uniq, :unique, :uniqueness ].each do |name_to_use|
+  Mongoid::Fields.option name_to_use do |model, field, value|
+
+    field.instance_variable_get('@options')[:uniqueness]= field.instance_variable_get('@options').delete(name_to_use)
+    if value == true
+      model.instance_eval do
+        validates_uniqueness_of field.instance_variable_get('@name')
+      end
+    end
+
+  end
+end
+
+[ :accept, :accept_only, :can, :can_be, :only, :inclusion ].each do |name_to_use|
+  Mongoid::Fields.option name_to_use do |model, field, value|
+
+    field.instance_variable_get('@options')[:inclusion]= field.instance_variable_get('@options').delete(name_to_use)
+    model.instance_eval do
+
+      validates_inclusion_of field.instance_variable_get('@name'),
+                             in: [*value]
+
+    end
+
+  end
+end
+
+[ :deny, :denied, :denied_only, :not, :exclude, :exclusion ].each do |name_to_use|
+  Mongoid::Fields.option name_to_use do |model, field, value|
+
+    field.instance_variable_get('@options')[:exclusion]= field.instance_variable_get('@options').delete(name_to_use)
+    model.instance_eval do
+
+      validates_exclusion_of field.instance_variable_get('@name'),
+                             in: [*value]
+
+    end
+
+  end
+end
+
+
+[ :with, :match, :regex, :regexp ].each do |name_to_use|
+  Mongoid::Fields.option name_to_use do |model, field, value|
+
+    field.instance_variable_get('@options')[:format]= field.instance_variable_get('@options').delete(name_to_use)
+    model.instance_eval do
+
+      if value.class <= Regexp
+
+        validates_format_of field.instance_variable_get('@name'),
+                            with: value
+
+      elsif value.class <= Array
+
+        validates_format_of field.instance_variable_get('@name'),
+                            in: value
+
+      else
+        raise ArgumentError,"invalid regexp: #{value}"
+      end
+
+    end
+
+  end
+end
+
+
+[ :without, :not_match, :cant_be_regex, :cant_be_regexp ].each do |name_to_use|
+  Mongoid::Fields.option name_to_use do |model, field, value|
+
+    field.instance_variable_get('@options')[:format]= field.instance_variable_get('@options').delete(name_to_use)
+    model.instance_eval do
+
+      if value.class <= Regexp
+
+        validates_format_of field.instance_variable_get('@name'),
+                            without: value
+
+      else
+        raise ArgumentError,"invalid regexp: #{value}"
+      end
+
+    end
+
+  end
+end
+
+[ :length ].each do |name_to_use|
+  Mongoid::Fields.option name_to_use do |model, field, value|
+
+    field.instance_variable_get('@options')[:format]= field.instance_variable_get('@options').delete(name_to_use)
+    model.instance_eval do
+
+      if value.class <= Hash
+
+        options_to_use= {}
+
+        [:max,:maximum,'max','maximum'].each do |key_name|
+          options_to_use[:maximum] ||= value[key_name]
+        end
+
+        [:min,:minimum,'min','minimum'].each do |key_name|
+          options_to_use[:minimum] ||= value[key_name]
+        end
+
+        [:within,:range,'within','range'].each do |key_name|
+          options_to_use[:within] ||= value[key_name]
+        end
+
+        validates_length_of field.instance_variable_get('@name'),
+                            options_to_use
+
+      else
+        raise ArgumentError,"invalid Hash obj: #{value}"
+      end
+
+    end
+
+  end
+end

data/lib/mongoid-dsl/monkey.rb

@@ -0,0 +1,645 @@
+module Mongoid
+  module DSL
+
+    module Document
+
+      module Extend
+
+        def documents
+
+              exceptions= %w[
+            Mongoid::Relations::Embedded::In
+            Mongoid::Relations::Referenced::In
+          ]
+
+          return_array = Array.new
+          self.relations.each do |model_name,module_propertys|
+            if !exceptions.include?(module_propertys[:relation].to_s)
+              return_array.push model_name
+            end
+          end
+
+          return return_array
+        rescue Exception
+          return []
+
+        end
+
+        def relation_connection_type(to_model)
+          begin
+
+            return_none= "Mongoid::Relations::None"
+            return_self= "Mongoid::Relations::Self"
+
+            if to_model.nil?
+              return return_none
+            end
+
+            if self.to_s == to_model.to_s
+              return return_self
+            end
+
+            relation_type_data= self.reflect_on_association(to_model.convert_model_name)
+
+            if relation_type_data.nil?
+              return return_none
+            else
+              return relation_type_data[:relation].to_s
+            end
+
+          end
+        end
+        def reverse_relation_conn_type(from_model)
+          begin
+
+            return_none= "Mongoid::Relations::None"
+            return_self= "Mongoid::Relations::Self"
+
+            if from_model.nil?
+              return return_none
+            end
+
+            if self.to_s == from_model.to_s
+              return return_self
+            end
+
+            relation_type_data= from_model.reflect_on_association(self.convert_model_name)
+
+            if relation_type_data.nil?
+              return return_none
+            else
+              return relation_type_data[:relation].to_s
+            end
+
+          end
+        end
+
+        #> not yet finished
+        def available_fields
+          Mongoid::Document.available_fields(self)
+        end
+
+        def properties
+
+          hash_data = Hash.new
+          self.fields.each do |key,value|
+            hash_data[value.name]=value.options[:type]
+          end
+          return hash_data
+
+        end
+
+        def parents
+          begin
+
+            exceptions= %w[
+          Mongoid::Relations::Embedded::In
+        ]
+
+            return_array = Array.new
+            self.relations.each do |model_name,module_propertys|
+              if exceptions.include?(module_propertys[:relation].to_s)
+                return_array.push model_name
+              end
+            end
+            return return_array
+
+          end
+        end
+        def references
+          begin
+
+            exceptions= %w[
+          Mongoid::Relations::Referenced::In
+          Mongoid::Relations::Referenced::ManyToMany
+        ]
+
+            return_array = Array.new
+            self.relations.each do |model_name,module_propertys|
+              if exceptions.include?(module_propertys[:relation].to_s)
+                return_array.push model_name
+              end
+            end
+            return return_array
+
+          end
+        end
+
+        def get_path(*included)
+
+          # create defaults
+          begin
+            return_array= Array.new()
+            check_list= Array.new#.push(self.to_s)
+            relations_hash = Hash.new()
+            #chains= Hash.new
+            chains= Array.new
+          end
+
+          # get parents for every participants
+          begin
+            models_to_check = Array.new.push self
+            loop do
+              tmp_array = Array.new
+              break if models_to_check.empty?
+              models_to_check.each do |one_models_element|
+                begin
+                  one_models_element.parents.each do |one_parent_in_underscore|
+                    parent_model= one_parent_in_underscore.convert_model_name
+                    tmp_array.push parent_model if !relations_hash.keys.include?(parent_model)
+                    relations_hash[one_models_element] ||= Array.new
+                    relations_hash[one_models_element].push parent_model
+                  end
+                rescue NoMethodError
+                  #next
+                end
+              end
+              models_to_check= tmp_array
+            end
+            models_to_check.clear
+          end
+
+          # make connections from relation pairs
+          begin
+
+            # generate pre path chains
+            # minden egyes szulo,s szulo szulo elemen egyesevel menj vegig (csak elso elemet vizsgalva) es ahol tobb mint egy elem talalhato azt torold
+            # igy legkozelebb az mar nem lesz lehetseges utvonal, ahol pedig mindenhol csak 1 elem volt  ott ellenorzid
+            # hogy mar megtalalt sorrol van e szo, s ha igen torold a relations_hash[self] ből ezt a szulot (2. elem a path ban)
+            # the goal is to get every 1 element from sub arrays
+
+            begin
+              available_paths= Array.new
+              return nil if relations_hash[self].nil?
+              loop do
+
+                # defaults
+                begin
+                  next_element_to_find  = self
+                  delete_element        = Hash.new
+                  one_chain             = Array.new
+                end
+
+                # chain element builder
+                begin
+                  loop do
+                    if !relations_hash[next_element_to_find].nil? && relations_hash[next_element_to_find] != Array.new
+
+                      one_chain.push(relations_hash[next_element_to_find][0])
+                      if relations_hash[next_element_to_find].count > 1
+                        delete_element       = Hash.new
+                        delete_element[next_element_to_find]= relations_hash[next_element_to_find][0]
+                      end
+
+                      next_element_to_find= relations_hash[next_element_to_find][0]
+                    else
+                      break
+                    end
+                  end
+                end
+
+                # remove already checked tree
+                begin
+                  if delete_element != Hash.new
+                    relations_hash[delete_element.keys[0]].delete_at(
+                        relations_hash[delete_element.keys[0]].index(
+                            delete_element[delete_element.keys[0]]))
+                    delete_element= Hash.new
+                  end
+                end
+
+                # add new element to chains
+                begin
+                  unless chains.include? one_chain
+                    chains.push one_chain
+                  else
+                    break
+                  end
+                end
+              end
+
+            end
+
+          end
+
+          # after format and check params for contains
+          begin
+
+            # pre chains trim
+            begin
+
+              tmp_array= Array.new
+              chains.each do |one_element|
+                if !one_element.contain?(included)
+                  tmp_array.push one_element
+                end
+              end
+              tmp_array.each do |one_element_to_delete|
+                chains.delete_at(chains.index(one_element_to_delete))
+              end
+
+            end
+
+            # choose the shortest path
+            begin
+              chain_list_max_count= nil
+              chains.each do |one_chain_list|
+                counter= one_chain_list.count
+                chain_list_max_count ||= (counter+1)
+                if counter < chain_list_max_count
+                  return_array= one_chain_list
+                  counter= chain_list_max_count
+                end
+              end
+            end
+
+            # reverse array
+            begin
+              return_array.reverse!
+            end
+
+            # add new element as self for first
+            begin
+              return_array.push self
+            end
+
+
+          end
+
+          return return_array
+        end
+
+        def __query_wrapper(*args)
+
+          # defaults
+          begin
+            return_data= nil
+            # params field
+            field_hash= Hash.new
+            # models
+            models_container= Array.new
+            # mother model
+            mother_model= nil
+            # method_to_use
+            method_to_use= Hash.new
+
+            args.each do |one_argument|
+              case true
+
+                when one_argument.class <= String
+                  begin
+                    field_hash['_id']= Moped::BSON::ObjectId.from_string(one_argument)
+                  rescue
+                    begin
+                      models_container.push one_argument.constantize
+                    rescue NameError
+                      #method_to_use= one_argument
+                    end
+                  end
+
+                when one_argument.class <= Hash
+                  begin
+                    one_argument.each do |key,value|
+                      if key.to_s == '_id'
+                        field_hash['_id']= Moped::BSON::ObjectId.from_string(value.to_s)
+                      else
+                        field_hash[key]=value
+                      end
+                    end
+                  end
+
+                when one_argument.class <= Class
+                  models_container.push one_argument
+
+                when one_argument.class <= Array
+                  method_to_use= one_argument
+
+              end
+            end
+
+          end
+
+          # mother model find, and path generate
+          begin
+
+            full_path   = self.get_path(*models_container)  || Array.new.push(self)
+            mother_model= full_path.shift
+
+            full_path.count.times do |index|
+              full_path[index]= full_path[index].convert_model_name
+            end
+
+          end
+
+          # path trim
+          begin
+
+            deep_level = (full_path.count) || 0
+            chains= full_path
+
+            if !full_path.empty? && !full_path.nil?
+              full_path= full_path.join('.')+'.'
+            else
+              full_path= String.new
+            end
+
+          end
+
+          # start query
+          begin
+
+            # build app query args
+            begin
+
+              gen_field_hash= lambda { |query_hash,*pre_path_elements|
+                query_fields= Hash.new()
+
+                full_path_str= nil
+                if !pre_path_elements.empty? && !pre_path_elements.nil?
+                  full_path_str= pre_path_elements.join('.')+'.'
+                else
+                  full_path_str= ""
+                end
+
+                return query_hash.map_hash { |key,value|
+                  { "#{full_path_str}#{key}" => value }
+                }
+
+
+              }
+
+              query_fields= gen_field_hash.call field_hash, *chains
+
+            end
+
+            # do query ask from db
+            begin
+              if method_to_use[1][:arguments?]
+                query_data = mother_model.__send__(
+                    method_to_use[0].to_s,
+                    query_fields)
+              else
+                query_data = mother_model.__send__(
+                    method_to_use[0].to_s)
+              end
+            end
+
+            # return data level
+            begin
+
+              if deep_level == 0
+                return_data=query_data
+              else
+
+                # go down for embeds docs
+                begin
+
+                  last_round   = (chains.count-1)
+                  map_object   = query_data
+                  return_array = [] #> Mongoid::Criteria.new
+                  chains.count.times do |deepness|
+                    begin
+                      children = Array.new
+                      if map_object.class == Array || map_object.class == Mongoid::Criteria
+
+                        map_object.each do |one_element_of_the_map_array|
+                          subclass_data = one_element_of_the_map_array.__send__(chains[deepness])
+                          if subclass_data.class <= Array || subclass_data.class <= Mongoid::Criteria
+                            subclass_data.each do |one_element_of_tmp_children|
+                              if deepness < last_round
+                                children.push one_element_of_tmp_children
+                              else
+                                return_array.push one_element_of_tmp_children
+                              end
+                            end
+                          else
+                            if deepness < last_round
+                              children.push subclass_data
+                            else
+                              return_array.push subclass_data
+                            end
+                          end
+                        end
+
+                      else
+                        subclass_data = map_object.__send__(chains[deepness])
+                        if subclass_data.class == Array || subclass_data.class == Mongoid::Criteria
+                          subclass_data.each do |one_element_of_tmp_children|
+                            if deepness < last_round
+                              children.push one_element_of_tmp_children
+                            else
+                              return_array.push one_element_of_tmp_children
+                            end
+                          end
+                        else
+                          if deepness < last_round
+                            children.push subclass_data
+                          else
+                            return_array.push subclass_data
+                          end
+                        end
+                      end
+                      map_object=children.uniq
+                    rescue NoMethodError => ex
+                      STDERR.puts(ex)
+                    end
+                  end
+
+                  return_data= return_array
+
+                end
+              end
+            end
+
+            # trim not used class
+            if method_to_use[1][:arguments?]
+
+              tmp_array= []
+              return_data.map! { |one_element|
+
+                tmp_hash= one_element.convert_to_hash#instance_variables.each{ |var| tmp_hash[var.to_s.delete("@")] = one_element.instance_variable_get(var) }
+
+                if tmp_hash["attributes"].deep_include?(field_hash) || tmp_hash["attributes"].deep_include?(field_hash.map_hash{|k,v|[k.to_s,v]})
+                  one_element
+                else
+                  nil
+                end
+
+              }.compact!
+
+            end
+
+
+          end
+
+          # TODO find out how to add elements to a criteria obj
+          # # convert to mongid criteria
+          # begin
+          #
+          #   mongoid_crit= Mongoid::Criteria.new(self)
+          #
+          #   puts mongoid_crit.methods - Object.methods
+          #
+          #
+          #   mongoid_crit.add_to_set return_data[0]
+          #
+          #   return mongoid_crit
+          #
+          # rescue Exception
+          # end
+
+          return return_data
+
+        end
+
+        def _where(*args)
+          self.__query_wrapper(['where',{:arguments? => true}],*args)
+        end
+        def _all(*args)
+          self.__query_wrapper(['all',{:arguments? => false}],*args)
+        end
+
+        def _find(target_id)
+
+          # pre validation
+          begin
+            if target_id.class != Moped::BSON::ObjectId && target_id.class != String
+              raise ArgumentError, "id parameter must be id or ObjectId"
+            end
+          end
+
+          # Do the Gangnam style
+          begin
+            return_doc = self._where( '_id' => target_id )[0]
+          end
+
+          return return_doc
+        end
+        def _find_by(*args)
+
+          # Do the Gangnam style
+          begin
+            return_array = self._where(*args).first
+          end
+
+          return return_array
+        end
+
+        alias :this_to_me :relation_connection_type
+        alias :me_to_this :reverse_relation_conn_type
+
+      end
+
+      module Include
+
+        def _parent
+
+          self.class.parents.each do |parent_underscore_name|
+            if self.__send__("has_#{parent_underscore_name}?") == true
+              return self.__send__(parent_underscore_name)
+            end
+          end
+          return nil
+
+        end
+
+        def _reference
+
+          self.class.references.each do |parent_underscore_name|
+            if self.__send__("has_#{parent_underscore_name}?") == true
+              return self.__send__(parent_underscore_name)
+            end
+          end
+          return nil
+
+        end
+
+        alias :get_parent_doc     :_parent
+        alias :get_reference_doc  :_reference
+
+      end
+
+    end
+
+    module StringExt
+      module Include
+        def to_ObjectId
+          begin
+            Moped::BSON::ObjectId.from_string(self.to_s)
+          rescue Exception => ex
+            ex.logger
+            nil
+          end
+        end
+      end
+    end
+
+    module CoreExt
+
+      module Include
+
+        # convert mongoid name
+        def convert_model_name
+
+          unless self.class <= Class || self.class <= String || self.class <= Symbol || self.class <= NilClass
+            raise ArgumentError, "invalid input, must be Class or String: => #{self.class} (#{self})"
+          end
+
+          if self.class <= NilClass
+            return nil
+          end
+
+          case self.class.to_s
+
+            when "Class"
+              return self.to_s.split('::').last.underscore
+
+            when "String","Symbol"
+              Mongoid.models.each do |one_model_name|
+                if  self.to_s == one_model_name.to_s.split('::').last.underscore || \
+                    self.to_s == one_model_name.to_s.split('::').last.underscore+('s')
+
+                  return one_model_name.to_s.constantize
+
+                end
+              end
+
+              return self.to_s.split('::').last.underscore
+
+
+          end
+
+          return nil
+        end
+
+        alias :mongoise_name        :convert_model_name
+        alias :mongoize_name        :convert_model_name
+        alias :mongoid_name         :convert_model_name
+
+        alias :mongoid_name_convert :convert_model_name
+
+      end
+
+    end
+
+  end
+end
+
+begin
+  Mongoid::Config.inject_singleton_method :register_model, add: :before do |klass|
+    klass.__send__ :extend,  Mongoid::DSL::Document::Extend
+    klass.__send__ :include, Mongoid::DSL::Document::Include
+  end
+rescue NoMethodError
+end
+
+[
+    Class,
+    Symbol,
+    NilClass,
+    String
+].each do |class_name|
+  class_name.__send__ :include, Mongoid::DSL::CoreExt::Include
+end
+
+String.__send__ :include, Mongoid::DSL::StringExt::Include

data/lib/mongoid-dsl.rb

@@ -0,0 +1,6 @@
+
+require 'mpatch'
+require 'mongoid'
+require 'procemon'
+
+Dir.glob( File.join( File.dirname(__FILE__),'**','*.{ru,rb}') ).each{|p|require(p)}

data/mongoid-dsl.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+Gem::Specification.new do |spec|
+
+  spec.name          = "mongoid-dsl"
+  spec.version       = File.open(File.join(File.dirname(__FILE__),"VERSION")).read.split("\n")[0].chomp.gsub(' ','')
+  spec.authors       = ["Adam Luzsi"]
+  spec.email         = ["adamluzsi@gmail.com"]
+  spec.description   = "Ruby Module for ease of use with mongoid based models"
+  spec.summary       = "Ruby Module for ease of use mongoid models"
+
+  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_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+
+  spec.add_dependency "procemon", ">= 2.0.0"
+  spec.add_dependency "mongoid",  ">= 3.1.0"
+  spec.add_dependency "mpatch",   ">= 2.9.0"
+
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: mongoid-dsl
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Adam Luzsi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: 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: procemon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: mpatch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.9.0
+description: Ruby Module for ease of use with mongoid based models
+email:
+- adamluzsi@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- examples/helper/con.rb
+- examples/helper/mongoid.yml
+- examples/recursive_find.rb
+- lib/mongoid-dsl.rb
+- lib/mongoid-dsl/fields-ext.rb
+- lib/mongoid-dsl/monkey.rb
+- mongoid-dsl.gemspec
+homepage: 
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Ruby Module for ease of use mongoid models
+test_files: []