dm-persevere-adapter 0.52.1 → 0.60.0

data/.gitignore

@@ -2,3 +2,4 @@ pkg
 tmp
 coverage
 *.gemspec
+.rvmrc

data/Rakefile

@@ -1,4 +1,5 @@
 require 'rubygems'
+require 'rake'
 require 'pathname'
 
 begin
@@ -14,18 +15,9 @@ begin
     gemspec.add_dependency(%q<dm-core>, [">= 0.10.1"])
     gemspec.add_dependency(%q<extlib>)
   end
-  # Jeweler::Tasks.new do |gemspec|
-  #    gemspec.name = %q{persevere}
-  #    gemspec.summary = %q{A ruby wrapper for persevere}
-  #    gemspec.description = %q{A ruby wrapper for persevere}
-  #    gemspec.email = ["irjudson [a] gmail [d] com"]
-  #    gemspec.homepage = %q{http://github.com/yogo/persevere}
-  #    gemspec.authors = ["Ivan R. Judson", "The Yogo Data Management Development Team" ]
-  #    gemspec.rdoc_options = ["--main", "persevere/README.txt"]
-  #    gemspec.files = ["LICENSE.txt", "persevere/History.txt", "persevere/README.txt", "Rakefile", "lib/persevere.rb"]
-  #    gemspec.test_files = ["spec/persevere_spec.rb", "spec/spec.opts", "spec/spec_helper.rb"]
-  #  end
+
   Jeweler::GemcutterTasks.new
+  FileList['tasks/**/*.rake'].each { |task| import task }
 rescue LoadError
   puts "Jeweler not available. Install it with: gem install jeweler"
 end
@@ -33,6 +25,4 @@ end
 ROOT    = Pathname(__FILE__).dirname.expand_path
 JRUBY   = RUBY_PLATFORM =~ /java/
 WINDOWS = Gem.win_platform?
-SUDO    = (WINDOWS || JRUBY) ? '' : ('sudo' unless ENV['SUDOLESS'])
-
-Pathname.glob(ROOT.join('tasks/**/*.rb').to_s).each { |f| require f }
+SUDO    = (WINDOWS || JRUBY) ? '' : ('sudo' unless ENV['SUDOLESS'])

data/VERSION

@@ -1 +1 @@
-0.52.1
+0.60.0

data/lib/dm/associations/many_to_many.rb

@@ -0,0 +1,270 @@
+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, target_model
+          lazy_load(source) unless loaded?(source)
+          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
+          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| r._original_delete(source) }
+          new_resources.each{|r| r._original_add(source) }
+          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/model.rb

@@ -0,0 +1,48 @@
+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
+          child = relation.child_model
+          parent = relation.parent_model
+
+          case relation
+            when DataMapper::Associations::OneToMany::Relationship, DataMapper::Associations::ManyToMany::Relationship
+              schema_hash['properties'][nom] = { "type"     => "array", 
+                                                 "optional" => true,  
+                                                 "items"    => {"$ref" => "../#{child.storage_name}"},
+                                                 "minItems" => relation.min,
+                                               }
+                                               
+              schema_hash['properties'][nom]["maxItems"] = relation.max if relation.max != Infinity 
+            when DataMapper::Associations::ManyToOne::Relationship, DataMapper::Associations::OneToOne::Relationship
+              if self == relation.child_model
+                ref = "../#{parent.storage_name}"
+              else
+                ref = "../#{child.storage_name}"
+              end
+              schema_hash['properties'][nom] = { "type" => { "$ref" => ref }, "optional" => true }
+          end
+        end
+        return schema_hash
+      end
+  end
+end

data/lib/dm/property.rb

@@ -0,0 +1,19 @@
+module DataMapper
+  class Property
+
+    def to_json_schema_hash(repo)
+      tm = repository(repo).adapter.type_map
+      json_hash = Hash.new
+      json_hash = {      "type"      => tm[type][: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!(  tm[type].reject{ |key,value| key == :primitive } )
+
+      json_hash
+    end
+    
+  end
+end

data/lib/dm/query.rb

@@ -0,0 +1,166 @@
+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 
+          return_value = "#{condition.subject.field}#{condition.__send__(:comparator_string)}/#{subject.parent_model.storage_name}/#{loaded_value.key.first}"
+        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
+           return_value = "#{condition.subject.field}#{condition.__send__(:comparator_string)}/#{subject.parent_model.storage_name}/#{loaded_value.key.first}"
+          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)
+              # debugger
+              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