dm-persevere-adapter 0.52.1 → 0.60.0

data/lib/dm/resource.rb

@@ -0,0 +1,97 @@
+module DataMapper
+  module Resource
+
+    def get_new_objects
+      new_parents = parent_resources.select{|p| p.new? }
+      new_children = child_collections.collect{ |collection| collection.select{|c| c.new? }}.flatten
+      new_children_of_new_parents = new_parents.map{ |np| np.__send__(:child_collections).collect{ |n| select{ |p| p.new? }}}.flatten
+      new_parents_of_new_children = new_children.map{ |nc| nc.__send__(:parent_resources).select{|p| p.new? }}.flatten
+      [ new_parents, new_children, new_children_of_new_parents, new_parents_of_new_children, self.new? ? self : [] ].flatten.uniq
+    end
+
+    def create_hook
+      op = original_attributes.dup
+      _create
+      @_original_attributes = op.dup
+    end
+    
+    alias _old_update _update
+    def _update
+      if repository.adapter.is_a?(DataMapper::Adapters::PersevereAdapter)
+        # remove from the identity map
+        remove_from_identity_map
+    
+        repository.update(dirty_attributes, collection_for_self)
+    
+        # remove the cached key in case it is updated
+        remove_instance_variable(:@_key)
+    
+        add_to_identity_map
+    
+        true
+      else
+        _old_update
+      end
+    end
+
+    alias _old_save _save
+     def _save(safe)
+       objects = get_new_objects
+       objects.each do |obj|
+         obj.__send__(:save_self, safe)
+       end
+       _old_save(safe)
+     end
+
+    ##
+    # Convert a DataMapper Resource to a JSON.
+    #
+    # @param [Query] query
+    #   The DataMapper query object passed in
+    #
+    # @api semipublic
+    def to_json_hash(include_relationships=true)
+      json_rsrc = Hash.new
+      relations = self.model.relationships.keys
+      
+      if include_relationships
+        self.model.relationships.each do |nom, relation|
+          value = relation.get!(self)
+          parent = relation.parent_model
+          child = relation.child_model
+          
+          unless value.nil?
+            json_rsrc[nom] = case relation
+              # KEEP THIS CASE AT THE TOP BECAUSE IT IS_A OneToMany ARGH
+            when DataMapper::Associations::ManyToMany::Relationship then
+              [value].flatten.map{ |v| { "$ref" => "../#{v.model.storage_name}/#{v.key.first}" } }
+            when DataMapper::Associations::ManyToOne::Relationship then 
+              { "$ref" => "../#{value.model.storage_name}/#{value.key.first}" }
+            when DataMapper::Associations::OneToMany::Relationship then
+              value.map{ |v| { "$ref" => "../#{v.model.storage_name}/#{v.key.first}" } }
+            when DataMapper::Associations::OneToOne::Relationship then
+              { "$ref" => "../#{value.model.storage_name}/#{value.first.key.first}" }
+            end
+          end
+        end
+      end
+
+      attributes(:property).each do |property, value|
+        next if value.nil? || (value.is_a?(Array) && value.empty?) || relations.include?(property.name.to_s)
+
+        json_rsrc[property.field] = case value
+        when DateTime then value.new_offset(0).strftime("%Y-%m-%dT%H:%M:%SZ")
+        when Date then value.to_s
+        when Time then value.strftime("%H:%M:%S")
+        when Float then value.to_f
+        when BigDecimal then value.to_f
+        when Integer then value.to_i
+        else # when String, TrueClass, FalseClass then
+          self[property.name]
+        end
+      end
+
+      json_rsrc
+    end
+  end
+end

data/lib/persevere.rb

@@ -9,7 +9,6 @@
 #
 require 'net/http'
 require 'uri'
-
 require 'rubygems'
 require 'json'
 

data/lib/persevere_adapter.rb

@@ -3,16 +3,21 @@ require 'dm-core'
 require 'dm-aggregates'
 require 'dm-types'
 require 'extlib'
-# require 'json'
 require 'bigdecimal'
+require 'digest/md5'
 
-require 'model_json_support'
-require 'persevere'
+# Things we add or override in DataMapper
+require 'dm/associations/many_to_many'
+require 'dm/model'
+require 'dm/property'
+require 'dm/query'
+require 'dm/resource'
 
-require 'types/property'
-require 'types/json_reference'
-require 'types/json_reference_collection'
+require 'persevere'
 
+#
+#  Override BigDecimal to_json because it's ugly and doesn't work for us
+# 
 class BigDecimal
   alias to_json_old to_json
   
@@ -31,13 +36,12 @@ module DataMapper
         
         connect if @persevere.nil?
         resources = Array.new
-        json_query = make_json_query(query)
+        json_query = query.to_json_query
         path = "/#{query.model.storage_name}/#{json_query}"
-
+      
         response = @persevere.retrieve(path)
 
         if response.code == "200"
-          # results = JSON.parse(response.body)
           results = [response.body]
           results.each do |row_of_results|
            row = query.fields.zip([row_of_results].flatten).map do |field, value|
@@ -127,12 +131,18 @@ module DataMapper
       def create_model_storage(model)
         name       = self.name
         properties = model.properties_with_subclasses(name)
-
+        
         return false if storage_exists?(model.storage_name(name))
         return false if properties.empty?
 
-        schema_hash = model.to_json_schema_compatible_hash()
-
+        # Make sure storage for referenced objects exists
+        model.relationships.each_pair do |n, r|
+          if ! storage_exists?(r.child_model.storage_name)
+            put_schema({'id' => r.child_model.storage_name, 'properties' => {}})
+          end
+        end
+        schema_hash = model.to_json_schema_hash()
+        
         return true unless put_schema(schema_hash) == false
         false
       end
@@ -147,14 +157,16 @@ module DataMapper
       def upgrade_model_storage(model)
         name       = self.name
         properties = model.properties_with_subclasses(name)
-
+        
+        DataMapper.logger.debug("Upgrading #{model.name}")
+        
         if success = create_model_storage(model)
           return properties
         end
         
-        new_schema_hash = model.to_json_schema_compatible_hash()
+        new_schema_hash = model.to_json_schema_hash()
         current_schema_hash = get_schema(new_schema_hash['id'])[0]
-        # Diff of what is there and what will be added.
+        # TODO: Diff of what is there and what will be added.
 
         new_properties = properties.map do |property|
           prop_name = property.name.to_s
@@ -178,7 +190,7 @@ module DataMapper
       # @api semipublic
       def destroy_model_storage(model)
         return true unless storage_exists?(model.storage_name(name))
-        schema_hash = model.to_json_schema_compatible_hash()
+        schema_hash = model.to_json_schema_hash()
         return true unless delete_schema(schema_hash) == false
         false
       end
@@ -207,20 +219,20 @@ module DataMapper
           scale     = Property::DEFAULT_SCALE_BIGDECIMAL
 
           @type_map ||= {
-            Types::Serial => { :primitive => 'integer' },
-            Types::Boolean => { :primitive => 'boolean' },
-            Integer     => { :primitive => 'integer'},
-            String      => { :primitive => 'string'},
-            Class       => { :primitive => 'string'},
-            BigDecimal  => { :primitive => 'number'},
-            Float       => { :primitive => 'number'},
-            DateTime    => { :primitive => 'string', :format => 'date-time'},
-            Date        => { :primitive => 'string', :format => 'date'},
-            Time        => { :primitive => 'string', :format => 'time'},
-            TrueClass   => { :primitive => 'boolean'},
-            Types::Text => { :primitive => 'string'},
+            Types::Serial             => { :primitive => 'integer' },
+            Types::Boolean            => { :primitive => 'boolean' },
+            Integer                   => { :primitive => 'integer'},
+            String                    => { :primitive => 'string'},
+            Class                     => { :primitive => 'string'},
+            BigDecimal                => { :primitive => 'number'},
+            Float                     => { :primitive => 'number'},
+            DateTime                  => { :primitive => 'string', :format => 'date-time'},
+            Date                      => { :primitive => 'string', :format => 'date'},
+            Time                      => { :primitive => 'string', :format => 'time'},
+            TrueClass                 => { :primitive => 'boolean'},
+            Types::Text               => { :primitive => 'string'},
             DataMapper::Types::Object => { :primitive => 'string'},
-            DataMapper::Types::URI   => { :primitive => 'string', :format => 'uri'}
+            DataMapper::Types::URI    => { :primitive => 'string', :format => 'uri'}
           }.freeze
         end
       end
@@ -246,18 +258,20 @@ module DataMapper
       def create(resources)
         connect if @persevere.nil?
         created = 0
-        resources.each do |resource|
+        
+        check_schemas
+        
+        resources.each do |resource|          
           serial = resource.model.serial(self.name)
           path = "/#{resource.model.storage_name}/"
-          payload = make_json_compatible_hash(resource)
-          
-          payload.delete(:id)
-
+          # Invoke to_json_hash with a boolean to indicate this is a create
+          # We might want to make this a post-to_json_hash cleanup instead
+          payload = resource.to_json_hash(false)
+#          scrub_data(payload)
           response = @persevere.create(path, payload)
 
           # Check the response, this needs to be more robust and raise
           # exceptions when there's a problem
-
           if response.code == "201"# good:
             rsrc_hash = JSON.parse(response.body)
             # Typecast attributes, DM expects them properly cast
@@ -270,7 +284,7 @@ module DataMapper
                 when Time then rsrc_hash[prop.field.to_s] = value.getlocal
               end
             end
-
+            
             serial.set!(resource, rsrc_hash["id"]) unless serial.nil?
 
             created += 1
@@ -303,7 +317,9 @@ module DataMapper
       def update(attributes, query)
         connect if @persevere.nil?
         updated = 0
-
+        
+        check_schemas
+        
         if ! query.is_a?(DataMapper::Query)
           resources = [query].flatten
         else
@@ -313,9 +329,8 @@ module DataMapper
         resources.each do |resource|
           tblname = resource.model.storage_name
           path = "/#{tblname}/#{resource.key.first}"
-
-          payload = make_json_compatible_hash(resource)
-
+          payload = resource.to_json_hash()
+#          scrub_data(payload)
           result = @persevere.update(path, payload)
 
           if result.code == "200"
@@ -362,29 +377,58 @@ module DataMapper
       def read_many(query)
         connect if @persevere.nil?
 
-        resources = Array.new
-        json_query, headers = make_json_query(query)
+#        check_schemas
         
+        resources = Array.new
         tblname = query.model.storage_name
+        
+        json_query, headers = query.to_json_query
+        
         path = "/#{tblname}/#{json_query}"
-        # puts path
+        DataMapper.logger.debug("--> PATH/QUERY: #{path}")
+        
         response = @persevere.retrieve(path, headers)
-
+        
         if response.code.match(/20?/)
           results = JSON.parse(response.body)
           results.each do |rsrc_hash|
             # Typecast attributes, DM expects them properly cast
             query.fields.each do |prop|
-              value = rsrc_hash[prop.field.to_s]
-              if prop.field == 'id'
-                rsrc_hash[prop.field.to_s]  = prop.typecast(value.to_s.match(/(#{tblname})?\/?([a-zA-Z0-9_-]+$)/)[2])
-              else
-                rsrc_hash[prop.field.to_s] = prop.typecast(value) unless value.nil?
+              object_reference = false
+              pname = prop.field.to_s
+              if pname[-3,3] == "_id"
+                pname = pname[0..-4] 
+                object_reference = true
+              end
+              value = rsrc_hash[pname]
+#              debugger
+              # Dereference references
+              unless value.nil?
+                if value.is_a?(Hash)
+                  if value.has_key?("$ref")
+                    value = value["$ref"].split("/")[-1]
+                  else
+#                    value = value["id"].split("/")[-1]
+                  end
+                elsif value.is_a?(Array)
+                  value = value.map do |v| 
+                    if v.has_key?("$ref")
+                      v = v["$ref"].split("/")[-1]
+                    else
+#                      v = v["id"].split("/")[-1]
+                    end
+                  end
+                end
+                if prop.field == 'id'
+                  rsrc_hash[pname]  = prop.typecast(value.to_s.match(/(#{tblname})?\/?([a-zA-Z0-9_-]+$)/)[2])
+                else
+                  rsrc_hash[pname] = prop.typecast(value)
+                end
               end
               # Shift date/time objects to the correct timezone because persevere is UTC
               case prop 
-                when DateTime then rsrc_hash[prop.field.to_s] = value.new_offset(Rational(Time.now.getlocal.gmt_offset/3600, 24))
-                when Time then rsrc_hash[prop.field.to_s] = value.getlocal
+                when DateTime then rsrc_hash[pname] = value.new_offset(Rational(Time.now.getlocal.gmt_offset/3600, 24))
+                when Time then rsrc_hash[pname] = value.getlocal
               end
             end
           end
@@ -394,11 +438,14 @@ module DataMapper
 
         # This won't work if the RegExp is nested more then 1 layer deep.
         if query.conditions.class == DataMapper::Query::Conditions::AndOperation
-          regexp_conds = query.conditions.operands.select{ |obj| obj.is_a?(DataMapper::Query::Conditions::RegexpComparison) || 
-             (obj.is_a?(DataMapper::Query::Conditions::NotOperation) && obj.operand.is_a?(DataMapper::Query::Conditions::RegexpComparison))}
+          regexp_conds = query.conditions.operands.select do |obj| 
+            obj.is_a?(DataMapper::Query::Conditions::RegexpComparison) || 
+            ( obj.is_a?(DataMapper::Query::Conditions::NotOperation) && obj.operand.is_a?(DataMapper::Query::Conditions::RegexpComparison) )
+          end
           regexp_conds.each{|cond| resources = resources.select{|resource| cond.matches?(resource)} }
          
         end
+
         # query.match_records(resources)
         resources
       end
@@ -419,6 +466,8 @@ module DataMapper
         connect if @persevere.nil?
 
         deleted = 0
+        
+#        check_schemas
 
         if ! query.is_a?(DataMapper::Query)
           resources = [query].flatten
@@ -447,6 +496,9 @@ module DataMapper
       def get_schema(name = nil, project = nil)
         path = nil
         single = false
+
+#        check_schemas
+        
         if name.nil? & project.nil?
           path = "/Class/"
         elsif project.nil?
@@ -462,12 +514,16 @@ module DataMapper
           schemas.each do |schema|
             schema['properties']['id'] = { 'type' => "serial", 'index' => true }
           end
+#          save_schemas
+
           return name.nil? ? schemas : schemas[0..0]
         else
           return false
         end
       end
 
+      ##
+      # 
       def put_schema(schema_hash, project = nil)
         path = "/Class/"
         if ! project.nil?
@@ -476,23 +532,34 @@ module DataMapper
               schema_hash['id'] = "#{project}/#{schema_hash['id']}"
             end
           else
-            puts "You need an id key/value in the hash"
+            DataMapper.logger.error("You need an id key/value in the hash")
           end
         end
-        schema_hash['properties'].delete('id') if schema_hash['properties'].has_key?('id')
+        
+#        check_schemas
+        
+        scrub_schema(schema_hash['properties'])
         schema_hash['extends'] = { "$ref" => "/Class/Versioned" } if @options[:versioned]
+        
         result = @persevere.create(path, schema_hash)
         if result.code == '201'
+#          save_schemas
+
           return JSON.parse(result.body)
         else
           return false
         end
       end
 
+      ##
+      # 
       def update_schema(schema_hash, project = nil)
         id = schema_hash['id']
         payload = schema_hash.reject{|key,value| key.to_sym.eql?(:id) }
-        payload['properties'].delete('id') if payload['properties'].has_key?('id')
+        scrub_schema(payload['properties'])
+        payload['extends'] = { "$ref" => "/Class/Versioned" } if @options[:versioned]
+
+#        check_schemas
 
         if project.nil?
           path = "/Class/#{id}"
@@ -503,12 +570,15 @@ module DataMapper
         result = @persevere.update(path, payload)
 
         if result.code == '200'
+#          save_schemas
           return result.body
         else
           return false
         end
       end
 
+      ##
+      # 
       def delete_schema(schema_hash, project = nil)
         if ! project.nil?
           if schema_hash.has_key?("id")
@@ -516,13 +586,17 @@ module DataMapper
               schema_hash['id'] = "#{project}/#{schema_hash['id']}"
             end
           else
-            puts "You need an id key/value in the hash"
+            DataMapper.logger.error("You need an id key/value in the hash")
           end
         end
+
+#        check_schemas
+
         path = "/Class/#{schema_hash['id']}"
         result = @persevere.delete(path)
 
         if result.code == "204"
+#          save_schemas
           return true
         else
           return false
@@ -546,7 +620,6 @@ module DataMapper
       #   the adapter
       #
       # @api semipublic
-
       def initialize(name, uri_or_options)
         super
 
@@ -565,13 +638,18 @@ module DataMapper
 
         @resource_naming_convention = NamingConventions::Resource::Underscored
         @identity_maps = {}
-        @classes = []
         @persevere = nil
         @prepped = false
-
+        @schema_backups = Array.new
+        @last_backup = nil
+        
         connect
       end
       
+      private
+      
+      ##
+      # 
       def connect
         if ! @prepped
           uri = URI::HTTP.build(@options).to_s
@@ -580,27 +658,71 @@ module DataMapper
         end
       end
 
-      def prep_persvr
+      def scrub_data(json_hash)
+        items = [DataMapper::Model.descendants.map{|c| "#{c.name.downcase}_id"}].flatten
+        items.each { |item| json_hash.delete(item) if json_hash.has_key?(item) }
+        json_hash.reject! { |k,v| v.nil? }
+        json_hash
+      end
+      
+      ##
+      # 
+      def scrub_schema(json_hash)
+        items = [DataMapper::Model.descendants.map{|c| "#{c.name.downcase}_id"}, 'id'].flatten
+        items.each { |item| json_hash.delete(item) if json_hash.has_key?(item) }
+        json_hash
+      end
+
+      def check_schemas
+        schemas = @persevere.retrieve("/Class").body
+        md5 = Digest::MD5.hexdigest(schemas)
+
+        if ! @last_backup.nil?
+          if @last_backup[:hash] != md5
+            DataMapper.logger.debug("Schemas changed, do you know why? (#{md5} :: #{@last_backup[:hash]})")
+            @schema_backups.each do |sb| 
+              if sb[:hash] == md5 
+                DataMapper.logger.debug("Schemas reverted to #{sb.inspect}")
+              end
+            end
+          end
+        end
+      end
+      
+      def save_schemas
+        schemas = @persevere.retrieve("/Class").body
+        md5 = Digest::MD5.hexdigest(schemas)
+        @last_backup = { :hash => md5, :schemas => schemas, :timestamp => Time.now }
+        @schema_backups << @last_backup
+        # Dump to filesystem
+      end
+      
+      def get_classes
         # Because this is an AbstractAdapter and not a
         # DataObjectAdapter, we can't assume there are any schemas
         # present, so we retrieve the ones that exist and keep them up
         # to date
+        classes = Array.new
         result = @persevere.retrieve('/Class[=id]')
         if result.code == "200"
           hresult = JSON.parse(result.body)
           hresult.each do |cname|
             junk,name = cname.split("/")
-            @classes << name
+            classes << name
           end
-          @prepped = true
         else
-          puts "Error retrieving existing tables: ", result
+          DataMapper.logger.error("Error retrieving existing tables: #{result}")
         end
-        
+        classes
+      end
+      
+      ##
+      # 
+      def prep_persvr
         #
         # If the user specified a versioned datastore load the versioning REST code
         # 
-        if ! @classes.include?("Versioned") && @options[:versioned]
+        unless get_classes.include?("Versioned") && @options[:versioned]
           versioned_class = <<-EOF
           {
               id: "Versioned",
@@ -651,176 +773,10 @@ module DataMapper
             response = @persevere.persevere.send_request('POST', URI.encode('/Class/'), versioned_class, { 'Content-Type' => 'application/javascript' } )
           rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError,
                 Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
-            puts "Persevere Create Failed: #{e}, Trying again."
+            DataMapper.logger.error("Persevere Create Failed: #{e}, Trying again.")
           end
         end
       end
-      
-      ##
-      # Convert a DataMapper Resource to a JSON.
-      #
-      # @param [Query] query
-      #   The DataMapper query object passed in
-      #
-      # @api semipublic
-      def make_json_compatible_hash(resource)
-        json_rsrc = Hash.new                
-        resource.attributes(:property).each do |property, value|
-
-          next if value.nil? || (value.is_a?(Array) && value.empty?)
-
-          if property.type == DataMapper::Types::JsonReference || 
-             property.type == DataMapper::Types::JsonReferenceCollection
-            json_rsrc[property.field] = property.value(value)
-          else
-            json_rsrc[property.field] = case value
-              when DateTime then value.new_offset(0).strftime("%Y-%m-%dT%H:%M:%SZ")
-              when Date then value.to_s
-              when Time then value.strftime("%H:%M:%S")
-              when Float then value.to_f
-              when BigDecimal then value.to_f
-              when Integer then value.to_i
-              else resource[property.name]
-            end
-          end
-        end
-
-        json_rsrc
-      end
-
-      ##
-      # Convert a DataMapper Query to a JSON Query.
-      #
-      # @param [Query] query
-      #   The DataMapper query object passed in
-      #
-      # @api semipublic
-      def make_json_query(query)
-        def process_in(value, candidate_set)
-          result_string = Array.new
-          candidate_set.to_a.each do |candidate|
-            result_string << "#{value}=#{candidate}"
-          end
-          if result_string.length > 0
-            "(#{result_string.join("|")})"
-          else
-            "#{value}=''"
-          end
-        end
-
-        def munge_condition(condition)
-          cond = condition.loaded_value
-
-          cond = "\"#{cond}\"" if cond.is_a?(String)
-          cond = "date(%10.f)" % (Time.parse(cond.to_s).to_f * 1000) if cond.is_a?(DateTime)
-          cond = 'undefined' if cond.nil?
-          return cond
-        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 process_in(condition.subject.name, condition.value)
-            when DataMapper::Query::Conditions::EqualToComparison then
-              "#{condition.subject.field}=#{munge_condition(condition)}"
-            when DataMapper::Query::Conditions::GreaterThanComparison then
-              "#{condition.subject.field}>#{munge_condition(condition)}"
-            when DataMapper::Query::Conditions::LessThanComparison then
-              "#{condition.subject.field}<#{munge_condition(condition)}"
-            when DataMapper::Query::Conditions::GreaterThanOrEqualToComparison then
-              "#{condition.subject.field}>=#{munge_condition(condition)}"
-            when DataMapper::Query::Conditions::LessThanOrEqualToComparison then
-              "#{condition.subject.field}<=#{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
-
-        json_query = ""
-        query_terms = Array.new
-        order_operations = Array.new
-        field_ops = Array.new
-        fields = Array.new
-        headers = Hash.new
-
-        query_terms << process_condition(query.conditions) 
-
-        if query_terms.flatten.length != 0
-          json_query += "[?#{query_terms.join("][?")}]"
-        end
-        
-        query.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
-          fields << "'#{field.field}':#{field.field}"
-        end
-        end
-           
-        json_query += field_ops.join("")
-        
-        if query.order && query.order.any?
-          query.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 += "[={" + fields.join(',') + "}]" unless fields.empty?
-
-        offset = query.offset.to_i
-        limit = query.limit.nil? ? nil : query.limit.to_i + offset - 1
-        
-        if offset != 0 || !limit.nil?
-          headers.merge!({"Range", "items=#{offset}-#{limit}"})
-        end
-#        puts "#{query.inspect}"
-        # puts json_query, headers
-        return json_query, headers
-      end
     end # class PersevereAdapter
     const_added(:PersevereAdapter)
   end # module Adapters