dm-persevere-adapter 0.71.4 → 0.72.0

data/lib/dm/associations/many_to_many.rb

@@ -1,278 +0,0 @@
-module DataMapper
-  module Associations
-    module ManyToMany #:nodoc:
-      class Relationship < Associations::OneToMany::Relationship
-
-        OPTIONS.delete(:via)
-        OPTIONS.delete(:through)
-
-        remove_method :through
-        remove_method :via
-        remove_method :lazy_load
-        remove_method :source_scope
-        remove_method :inverted_options
-        remove_method :valid_target?
-        remove_method :valid_source?
-
-        # 
-        # @api private
-        def query
-          @query
-        end
-        
-        def set(source, target)
-          assert_kind_of 'source',  source,  source_model
-          assert_kind_of 'target', target, Array
-          target.each {|item| assert_kind_of 'target array element', item, target_model }
-          lazy_load(source) unless loaded?(source)
-          # NOTE: This seems semantically wrong, a set should just erase the contents, 
-          # not calculate the difference and replace the common elements...
-          get!(source).replace(target)
-        end
-        
-        # Loads association targets and sets resulting value on
-        # given source resource
-        #
-        # @param [Resource] source
-        #   the source resource for the association
-        #
-        # @return [undefined]
-        #
-        # @api private
-        def lazy_load(source)
-          
-          # SEL: load all related resources in the source collection
-          collection = source.collection
-          
-          # if source.saved? && collection.size > 1 #OLD LINE --IRJ
-          if source.saved?
-            eager_load(collection)
-          end
-
-          unless loaded?(source)
-            set!(source, collection_for(source))
-          end
-        end
-         
-         # Eager load the collection using the source as a base
-         #
-         # @param [Collection] source
-         #   the source collection to query with
-         # @param [Query, Hash] query
-         #   optional query to restrict the collection
-         #
-         # @return [Collection]
-         #   the loaded collection for the source
-         #
-         # @api private
-         def eager_load(source, query = nil)
-
-           targets = source.model.all(query_for(source, query))
-         
-           # FIXME: cannot associate targets to m:m collection yet, maybe we fixed it.
-           # if source.loaded? && !source.kind_of?(ManyToMany::Collection) WE CHANGED THIS: IRJ/RL
-           if source.loaded?
-             associate_targets(source, targets)
-           end
-         
-           targets
-         end
-
-         def associate_targets(source, targets)
-           # TODO: create an object that wraps this logic, and when the first
-           # kicker is fired, then it'll load up the collection, and then
-           # populate all the other methods
-           target_maps = Hash.new { |hash, key| hash[key] = [] }
-
-           targets.each do |target|
-             target_maps[target_key.get(target)] << target
-           end
-
-           Array(source).each do |source|
-             key = source_key.get(source)
-             # eager_load_targets(source, target_maps[key], query)
-
-             set!(source, collection_for(source, query).set(targets))
-           end
-         end
-
-        private
-
-        # Returns the inverse relationship class
-        #
-        # @api private
-        def inverse_class
-          self.class
-        end
-
-        def inverse_name
-          self.prefix = "" if self.prefix.nil? 
-          (self.prefix + Extlib::Inflection.underscore(Extlib::Inflection.demodulize(source_model.name)).pluralize).to_sym
-        end
-
-        # @api private
-        def invert
-          inverse_class.new(inverse_name, parent_model, child_model, inverted_options)
-        end
-
-        # @api semipublic
-        def initialize(name, target_model, source_model, options = {})
-          options.delete(:through)
-          super
-        end
-
-        # Returns collection class used by this type of
-        # relationship
-        #
-        # @api private
-        def collection_class
-          ManyToMany::Collection
-        end
-      end # class Relationship
-
-      class Collection < Associations::OneToMany::Collection
-        remove_method :_save
-        remove_method :_create
-
-        def inverse_add(*resources)
-          resources.each do |r|
-            r.send(relationship.inverse.name)._original_add(source)
-          end
-        end
-
-        alias :_original_add :"<<"
-        def <<(resource)
-          resource.send(relationship.inverse.name)._original_add(source)
-          _original_add(resource)
-        end
-        
-        alias :_original_concat :concat
-        def concat(resources)
-          inverse_add(*resources)
-          _original_concat(resources)
-        end
-        
-        alias :_original_push :push
-        def push(*resources)
-          inverse_add(*resources)
-          _original_push(*resources)
-        end
-        
-        
-        alias :_original_unshift :unshift
-        def unshift(*resources)
-          inverse_add(*resources)
-          _original_unshift(*resources)
-        end
-        
-        alias :_original_insert :insert
-        def insert(offset, *resources)
-          inverse_add(*resources)
-          _original_insert(offset, *resources)
-        end
-        
-        alias :_original_delete :delete
-        def delete(resource)
-          result = _original_delete(resource)
-          resource.send(relationship.inverse.name)._original_delete(source)
-          result
-        end
-        
-        alias :_original_pop :pop
-        def pop(*)
-          removed = _original_pop
-          removed._original_delete(source) unless removed.nil?
-          removed
-        end
-        
-        alias :_original_shift :shift
-        def shift(*)
-          removed = _original_pop
-          removed._original_delete(source) unless removed.nil?
-          removed
-        end
-        
-        alias :_original_delete_at :delete_at
-        def delete_at(offset)
-          resource = _original_delete_at(offset)
-          resource._original_delete(source) unless removed.nil?
-          resource
-        end
-        
-        # alias :_original_delete_if :delete_if
-        def delete_if
-          results = super { |resource| yield(resource) && resource_removed(resource) }
-          results.each{|r| r._original_delete(source) }
-          results
-        end
-        
-        def reject!
-          results = super { |resource| yield(resource) && resource_removed(resource) }
-          results.each{|r| r._original_delete(source) }
-          results
-        end
-         
-        def replace(other)
-          other = resources_added(other)
-          removed = entries - other
-          new_resources = other - removed
-          resources_removed(removed)
-          removed.each{ |r| delete(r) }
-          new_resources.each do |resource| 
-            resource.send(relationship.inverse.name)._original_add(source)
-            _original_add(resource)
-          end
-          super(other)
-        end
-        
-        alias :_original_clear :clear
-        def clear
-          self.each{|r| r._original_delete(source) }
-          _original_clear
-        end
-         
-        # TODO: Add these
-        # slice!, splice, collect!
-
-        def _save(safe)
-          loaded_entries = self.loaded_entries
-          @removed.clear
-          loaded_entries.all? { |resource| resource.__send__(safe ? :save : :save!) }
-        end
-        
-        private
-
-        # Track the added resource
-        #
-        # @param [Resource] resource
-        #   the resource that was added
-        #
-        # @return [Resource]
-        #   the resource that was added
-        #
-        # @api private
-        def resource_added(resource)
-          resource = initialize_resource(resource)
-
-          if resource.saved?
-            @identity_map[resource.key] = resource
-            @removed.delete(resource)
-          else
-            resource.save
-          end
-          resource
-        end
-
-        # @api private
-        def resource_removed(resource)
-          if resource.saved?
-            @identity_map.delete(resource.key)
-            @removed << resource
-          end
-
-          resource
-        end
-      end # class Collection
-    end # module ManyToMany
-  end # module Associations
-end # module DataMapper

data/lib/dm/associations/relationship.rb

@@ -1,57 +0,0 @@
-module DataMapper
-  module Associations
-    class Relationship
-      
-      # Prefix
-      # @example property.prefix
-      # @return [String]
-      # @api public
-      attr_accessor :prefix
-      
-      def to_json_schema_hash
-        child = self.child_model
-        parent = self.parent_model
-        relationship_schema = {}
-
-        case self
-        when DataMapper::Associations::ManyToMany::Relationship
-#          puts "-> M:M #{child.storage_name}"
-         relationship_schema = { "type"     => "array", 
-                                 "dm_relation" => "many_to_many",
-                                 "lazy"     => true,
-                                 "optional" => true,  
-                                 "items"    => {"$ref" => "/Class/#{child.storage_name}"},
-                                 "minItems" => self.min
-          }
-          relationship_schema["maxItems"] = self.max if self.max != Infinity
-        when DataMapper::Associations::OneToMany::Relationship 
-#          puts "-> 1:M #{child.storage_name}"
-          relationship_schema = { "type"     => "array", 
-                                  "dm_relation" => "has_n",
-                                  "lazy"     => true,
-                                  "optional" => true,  
-                                  "items"    => {"$ref" => "/Class/#{child.storage_name}"},
-                                  "minItems" => self.min
-           }
-           relationship_schema["maxItems"] = self.max if self.max != Infinity
-         when DataMapper::Associations::ManyToOne::Relationship
-#           puts "-> M:1 #{parent.storage_name}"
-           relationship_schema = { "type" => { "$ref" => "/Class/#{parent.storage_name}" }, 
-                                   "dm_relation" => "belongs_to",
-                                   "lazy" => true, 
-                                   "optional" => true }
-        when DataMapper::Associations::OneToOne::Relationship
-#          puts "-> 1:1 #{child.storage_name}"
-          relationship_schema = { "type" => { "$ref" => "/Class/#{child.storage_name}" }, 
-                                  "dm_relation" => "has_n",
-                                  "lazy" => true, 
-                                  "optional" => true }
-        end
-        
-        relationship_schema.merge!("prefix" => @prefix ) unless @prefix.nil?
-        return relationship_schema
-        
-      end
-    end
-  end
-end

data/lib/dm/model.rb

@@ -1,29 +0,0 @@
-module DataMapper
-  module Model
-    # module Json
-      def to_json_schema(repository_name = default_repository_name)
-        to_json_schema_hash(repository_name).to_json
-      end
-      
-      #TODO: Add various options in.
-      def to_json_schema_hash(repository_name = default_repository_name)
-        schema_hash               = {
-                                      'id' => self.storage_name(repository_name),
-                                      'prototype'  => Hash.new,
-                                      'properties' => Hash.new
-                                    }
-
-        # Handle properties
-        properties.select { |prop| prop.field != 'id' }.each do |prop| 
-          schema_hash['properties'][prop.field] = prop.to_json_schema_hash(repository_name) 
-        end
-        
-        # Handle relationships
-        relationships.each_pair do |nom,relation|
-          next if self.name.downcase == nom
-          schema_hash['properties'][nom] = relation.to_json_schema_hash
-        end
-        return schema_hash
-      end
-  end
-end

data/lib/dm/property.rb

@@ -1,25 +0,0 @@
-module DataMapper
-  class Property
-
-    def to_json_schema_hash(repo)
-
-      tm = repository(repo).adapter.type_map
-      type_information = tm[type]
-      if type_information.nil? && type.respond_to?(:primitive)
-        type_information = tm[type.primitive]
-      end
-      
-      json_hash = Hash.new
-      json_hash = {      "type"      => type_information[:primitive] }
-      json_hash.merge!({ "optional"  => true })       unless required?
-      json_hash.merge!({ "unique"    => true})        if     unique?
-      json_hash.merge!({ "position"  => @position })  unless @position.nil?
-      json_hash.merge!({ "prefix"    => @prefix })    unless @prefix.nil?
-      json_hash.merge!({ "separator" => @separator }) unless @separator.nil?
-      json_hash.merge!(  type_information.reject{ |key,value| key == :primitive } )
-
-      json_hash
-    end
-    
-  end
-end

data/lib/dm/query.rb

@@ -1,174 +0,0 @@
-module DataMapper
-  class Query
-    ##
-    def munge_condition(condition)
-      loaded_value = condition.loaded_value
-      return_value = ""
-              
-      if condition.subject.is_a?(DataMapper::Property)
-        rhs = case loaded_value
-        when String               then "\"#{loaded_value}\""
-        when DateTime             then "date(%10.f)" % (Time.parse(loaded_value.to_s).to_f * 1000)
-        when nil                  then "undefined"
-        else                           loaded_value
-        end
-        return_value = "#{condition.subject.field}#{condition.__send__(:comparator_string)}#{rhs}"
-      end
-      
-      return_value = _fugly_munger(condition, loaded_value) if condition.subject.is_a?(DataMapper::Associations::Relationship)
-      return_value
-    end
-
-    def _fugly_munger(condition, loaded_value)
-      subject = condition.subject
-
-      case subject
-        when DataMapper::Associations::ManyToMany::Relationship then
-          return_value = "#{condition.subject.field}.contains(/#{subject.child_model.storage_name}/#{loaded_value.key.first})"            
-        when DataMapper::Associations::OneToMany::Relationship then
-          return_value = "#{condition.subject.field}.contains(/#{subject.parent_model.storage_name}/#{loaded_value.key.first})"
-        when DataMapper::Associations::OneToOne::Relationship then 
-          if loaded_value.nil?
-            return_value = "#{condition.subject.field}#{condition.__send__(:comparator_string)}undefined"
-          else
-           return_value = "#{condition.subject.field}#{condition.__send__(:comparator_string)}/#{subject.parent_model.storage_name}/#{loaded_value.key.first}"
-         end
-        when DataMapper::Associations::ManyToOne::Relationship then
-          if self.model != subject.child_model
-            return_value = "#{condition.subject.field}.contains(/#{subject.parent_model.storage_name}/#{loaded_value.key.first})"
-          else
-            if loaded_value.nil?
-              return_value = "#{condition.subject.field}#{condition.__send__(:comparator_string)}undefined"
-            else
-             return_value = "#{condition.subject.field}#{condition.__send__(:comparator_string)}/#{subject.parent_model.storage_name}/#{loaded_value.key.first}"
-           end
-          end
-      end
-    end
-    
-    ##
-    def process_condition(condition)
-      case condition
-        # Persevere 1.0 regular expressions are disable for security so we pass them back for DataMapper query filtering
-        # without regular expressions, the like operator is inordinately challenging hence we pass it back
-        # when :regexp then "RegExp(\"#{condition.value.source}\").test(#{condition.subject.name})"
-        when DataMapper::Query::Conditions::RegexpComparison then []
-        when DataMapper::Query::Conditions::LikeComparison then "#{condition.subject.field}='#{condition.loaded_value.gsub('%', '*')}'"
-        when DataMapper::Query::Conditions::AndOperation then 
-          inside = condition.operands.map { |op| process_condition(op) }.flatten
-          inside.empty? ? []  : "(#{inside.join("&")})"
-        when DataMapper::Query::Conditions::OrOperation then "(#{condition.operands.map { |op| process_condition(op) }.join("|")})"
-        when DataMapper::Query::Conditions::NotOperation then 
-          inside = process_condition(condition.operand) 
-          inside.empty? ? [] : "!(%s)" % inside
-        when DataMapper::Query::Conditions::InclusionComparison then 
-          result_string = Array.new
-          condition.value.to_a.each do |candidate|
-            if condition.subject.is_a?(DataMapper::Associations::Relationship)
-              result_string << _fugly_munger(condition, candidate)
-            else
-              result_string << "#{condition.subject.name}=#{candidate}"
-            end
-          end
-          if result_string.length > 0
-            "(#{result_string.join("|")})"
-          else
-            "#{condition.subject.name}=''"
-          end
-        when DataMapper::Query::Conditions::EqualToComparison,
-             DataMapper::Query::Conditions::GreaterThanComparison,
-             DataMapper::Query::Conditions::LessThanComparison, 
-             DataMapper::Query::Conditions::GreaterThanOrEqualToComparison,
-             DataMapper::Query::Conditions::LessThanOrEqualToComparison then
-          munge_condition(condition)
-        when DataMapper::Query::Conditions::NullOperation then []
-        when Array then
-           old_statement, bind_values = condition
-           statement = old_statement.dup
-           bind_values.each{ |bind_value| statement.sub!('?', bind_value.to_s) }
-           statement.gsub(' ', '')
-        else condition.to_s.gsub(' ', '')
-      end
-    end
-    
-    ##
-    # Convert a DataMapper Query to a JSON Query.
-    #
-    # @param [Query] query
-    #   The DataMapper query object passed in
-    #
-    # @api semipublic
-    def to_json_query
-
-      # Body of main function
-      json_query = ""
-      query_terms = Array.new
-      order_operations = Array.new
-      field_ops = Array.new
-      outfields = Array.new
-      headers = Hash.new
-
-      query_terms << process_condition(conditions) 
-
-      if query_terms.flatten.length != 0
-        json_query += "[?#{query_terms.join("][?")}]"
-      end
-      
-      self.fields.each do |field|
-        if field.respond_to?(:operator)
-        field_ops << case field.operator
-          when :count then
-            if field.target.is_a?(DataMapper::Property)
-              "[?#{field.target.field}!=undefined].length"
-            else # field.target is all.
-              ".length"
-            end
-          when :min
-            if field.target.type == DateTime || field.target.type == Time || field.target.type == Date
-              "[=#{field.target.field}]"
-            else
-              ".min(?#{field.target.field})"
-            end
-          when :max
-            if field.target.type == DateTime || field.target.type == Time || field.target.type == Date
-              "[=#{field.target.field}]"
-            else
-              ".max(?#{field.target.field})"
-            end
-          when :sum
-            ".sum(?#{field.target.field})"
-          when :avg
-            "[=#{field.target.field}]"
-        end
-      else
-        outfields << "'#{field.field}':#{field.field}"
-      end
-      end
-         
-      json_query += field_ops.join("")
-      
-      if order && order.any?
-        order.map do |direction|
-          order_operations << case direction.operator
-            when :asc then "[\/#{direction.target.field}]"
-            when :desc then "[\\#{direction.target.field}]"
-          end
-        end
-      end
-
-      json_query += order_operations.join("")
-
-      json_query += "[={" + outfields.join(',') + "}]" unless outfields.empty?
-
-      offset = self.offset.to_i
-      limit = self.limit.nil? ? nil : self.limit.to_i + offset - 1
-      
-      if offset != 0 || !limit.nil?
-        headers.merge!( {"Range" => "items=#{offset}-#{limit}"} )
-      end
-      # puts "#{inspect}"
-      # puts json_query, headers
-      return json_query, headers
-    end
-  end
-end