dm-persevere-adapter 0.71.4 → 0.72.0

data/lib/persevere_adapter/aggregates.rb

@@ -0,0 +1,75 @@
+module DataMapper
+  module Persevere
+    module Aggregates
+        def aggregate(query)
+          records = []
+          fields = query.fields
+          field_size = fields.size
+      
+          connect if @persevere.nil?
+          resources = Array.new
+
+          query = Persevere.enhance(query)
+
+          json_query, headers = query.to_json_query
+          path = "/#{query.model.storage_name}/#{json_query}"
+          DataMapper.logger.debug("--> PATH/QUERY/HEADERS: #{path} #{headers.inspect}")
+          
+          response = @persevere.retrieve(path, headers)
+
+          if response.code == "200"
+            results = [response.body]
+            results.each do |row_of_results|
+             row = query.fields.zip([row_of_results].flatten).map do |field, value|
+                if field.respond_to?(:operator)
+                  send(field.operator, field.target, value)
+                else
+                  field.typecast(value)
+                end
+              end            
+              records << (field_size > 1 ? row : row[0])
+            end
+          end
+          records
+        end # aggregate method
+    
+        private
+    
+        def count(property, value)
+          value.to_i
+        end
+    
+        def min(property, value)
+          values = JSON.parse("[#{value}]").flatten.compact
+          if values.is_a?(Array)
+            values.map! { |v| property.typecast(v) }
+            return values.sort[0].new_offset(Rational(Time.now.getlocal.gmt_offset/3600, 24)) if property.kind_of?(DataMapper::Property::DateTime)
+            return values.sort[0]
+          end
+          property.typecast(value)
+        end
+    
+        def max(property, value)
+          values = JSON.parse("[#{value}]").flatten.compact
+          if values.is_a?(Array)
+            values.map! { |v| property.typecast(v) }
+            return values.sort[-1].new_offset(Rational(Time.now.getlocal.gmt_offset/3600, 24)) if property.kind_of?(DataMapper::Property::DateTime)
+            return values.sort[-1]
+          end
+          property.typecast(value)
+        end
+    
+        def avg(property, value)
+          values = JSON.parse(value).compact
+          result = values.inject(0.0){|sum,i| sum+=i }/values.length
+          property.kind_of?(DataMapper::Property::Integer) ? result.to_f : property.typecast(result)
+        end
+    
+        def sum(property, value)
+          property.typecast(value)
+        end
+    end # module Aggregates
+  end # module Persevere
+
+  DataMapper::Persevere::Adapter.send(:include, DataMapper::Persevere::Aggregates)
+end # module DataMapper

data/lib/persevere_adapter/enhance.rb

@@ -0,0 +1,49 @@
+module DataMapper
+  module Persevere
+    def self.enhance(object)
+      Persevere::Proxy[object]
+    end
+    
+    class Proxy
+      instance_methods.each do |m|
+        undef_method(m) if m.to_s !~ /(?:^__|^nil\?$|^send$|^object_id$|^extend$)/
+      end
+      
+      def raise(*args)
+        ::Object.send(:raise, *args)
+      end
+      
+      def self.[](target)
+        proxy = self.new(target)
+        
+        case target
+        when DataMapper::Resource
+          proxy.extend(JSONSupport::Core)
+          proxy.extend(JSONSupport::Resource)
+        when DataMapper::Model
+          proxy.extend(JSONSupport::Core)
+          proxy.extend(JSONSupport::Model)
+          proxy.extend(JSONSupport::Model::Properties)
+        when DataMapper::Property
+          proxy.extend(JSONSupport::Core)
+          proxy.extend(JSONSupport::Property)
+        when DataMapper::Query
+          proxy.extend(Persevere::Query)
+        else
+          return target
+        end
+        return proxy
+      end
+      
+      def initialize(target)
+        
+        @target = target
+      end
+      
+      def method_missing(method, *args, &block)
+        @target.send(method, *args, &block)
+      end
+      
+    end # Proxy
+  end # Persevere
+end # DataMapper

data/lib/persevere_adapter/json_support.rb

@@ -0,0 +1,6 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), 'json_support'))
+require File.join(dir, 'core')
+require File.join(dir, 'model')
+require File.join(dir, 'model', 'properties')
+require File.join(dir, 'property')
+require File.join(dir, 'resource')

data/lib/persevere_adapter/json_support/core.rb

@@ -0,0 +1,17 @@
+module DataMapper
+  module Persevere
+    module JSONSupport
+      module Core
+        def to_json(id = nil)
+          to_json_hash(id).to_json
+        end
+    
+        def to_json_hash(id = nil)
+          return {
+            'id' => id || self.to_s
+          }
+        end
+      end # Core
+    end # JSONSupport
+  end # Persevere
+end # DataMapper

data/lib/persevere_adapter/json_support/model.rb

@@ -0,0 +1,22 @@
+module DataMapper
+  module Persevere
+    module JSONSupport
+      module Model   
+        def to_json_hash(repository_name = default_repository_name)
+          schema_hash = super
+          schema_hash['id'] = self.storage_name(repository_name)
+          schema_hash['prototype'] ||= {}
+          return schema_hash
+        end
+        
+        def to_json_schema(repository_name = default_repository_name)
+          to_json(repository_name)
+        end
+        
+        def to_json_schema_hash(repository_name = default_repository_name)
+          to_json_hash(repository_name)
+        end
+      end # JSONSchema
+    end # Model
+  end # Persevere
+end # DataMapper

data/lib/persevere_adapter/json_support/model/properties.rb

@@ -0,0 +1,23 @@
+module DataMapper
+  module Persevere
+    module JSONSupport
+      module Model
+        module Properties
+          #TODO: Add various options in.
+          def to_json_hash(repository_name = default_repository_name)
+            schema_hash = super
+            schema_hash['properties'] ||= {}
+            
+            # Handle properties
+            properties.select { |prop| prop.field != 'id' }.each do |prop| 
+              prop = Persevere.enhance(prop)
+              schema_hash['properties'][prop.field] = prop.to_json_hash(repository_name) 
+            end
+          
+            return schema_hash
+          end
+        end # Properties
+      end # Model
+    end # JSON
+  end # Persevere
+end # DataMapper

data/lib/persevere_adapter/json_support/property.rb

@@ -0,0 +1,23 @@
+module DataMapper
+  module Persevere
+    module JSONSupport
+      module Property
+        def to_json_hash(repo)
+          tm = repository(repo).adapter.type_map
+          type_information = tm[primitive]
+          
+          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 # Property
+    end # JSON
+  end # Persevere
+end # DataMapper

data/lib/persevere_adapter/json_support/resource.rb

@@ -0,0 +1,37 @@
+module DataMapper
+  module Persevere
+    module JSONSupport
+      module Resource
+
+        ##
+        # Convert a DataMapper Resource to a JSON.
+        #
+        # @param [Query] query
+        #   The DataMapper query object passed in
+        #
+        # @api semipublic
+        def to_json_hash
+          json_rsrc = Hash.new
+          
+
+          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 # Resource
+    end # JSON
+  end # Persevere
+end # DataMapper

data/lib/persevere_adapter/migrations.rb

@@ -0,0 +1,104 @@
+module DataMapper
+  module Persevere
+    module Migrations
+
+      # Returns whether the storage_name exists.
+      #
+      # @param [String] storage_name
+      #   a String defining the name of a storage, for example a table name.
+      #
+      # @return [Boolean]
+      #   true if the storage exists
+      #
+      # @api semipublic
+      def storage_exists?(storage_name)
+        class_names = JSON.parse(@persevere.retrieve('/Class/[=id]').body)
+        return true if class_names.include?("Class/"+storage_name)
+        false
+      end
+
+      ##
+      # Creates the persevere schema from the model.
+      #
+      # @param [DataMapper::Model] model
+      #   The model that corresponds to the storage schema that needs to be created.
+      #
+      # @api semipublic
+      def create_model_storage(model)
+        model = Persevere.enhance(model)
+        name       = self.name
+        properties = model.properties_with_subclasses(name)
+        
+        return false if storage_exists?(model.storage_name(name))
+        return false if properties.empty?
+
+        # 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
+
+      ##
+      # Updates the persevere schema from the model.
+      #
+      # @param [DataMapper::Model] model
+      #   The model that corresponds to the storage schema that needs to be updated.
+      #
+      # @api semipublic
+      def upgrade_model_storage(model)
+        model = Persevere.enhance(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_hash()
+        current_schema_hash = get_schema(new_schema_hash['id'])[0]
+        # TODO: Diff of what is there and what will be added.
+
+        new_properties = properties.map do |property|
+          prop_name = property.name.to_s
+          prop_type = property.type
+          next if prop_name == 'id' || 
+                  (current_schema_hash['properties'].has_key?(prop_name) && 
+                  new_schema_hash['properties'][prop_name]['type'] == current_schema_hash['properties'][prop_name]['type'] )
+          property
+        end.compact
+        
+        return new_properties unless update_schema(new_schema_hash) == false
+        return nil
+      end
+
+      ##
+      # Destroys the persevere schema from the model.
+      #
+      # @param [DataMapper::Model] model
+      #   The model that corresponds to the storage schema that needs to be destroyed.
+      #
+      # @api semipublic
+      def destroy_model_storage(model)
+        model = Persevere.enhance(model)
+        return true unless storage_exists?(model.storage_name(name))
+        schema_hash = model.to_json_schema_hash()
+        return true unless delete_schema(schema_hash) == false
+        false
+      end
+
+    end # module Migrations
+  end # module Persevere
+end # module DataMapper
+
+DataMapper::Migrations.include_migration_api
+DataMapper::Persevere::Adapter.send(:include, DataMapper::Persevere::Migrations)
+
+

data/lib/persevere_adapter/query.rb

@@ -0,0 +1,208 @@
+module DataMapper
+  module Persevere
+    module Query
+      ##
+      # TODO: Clean this mess up.
+      # 
+      # @author lamb
+      def munge_condition(condition)
+        loaded_value = condition.loaded_value
+        return_value = ""
+        subject = condition.subject 
+        
+        if 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}"
+        elsif subject.is_a?(DataMapper::Associations::ManyToOne::Relationship)
+          # Join relationship, bury it down!
+          if self.model != subject.child_model
+            my_side_of_join = links.select{|relation| 
+              relation.kind_of?(DataMapper::Associations::ManyToOne::Relationship) &&
+              relation.child_model == subject.child_model &&
+              # I would really like this to not look at the name, 
+              # but sometimes they are different object of the same model
+              relation.parent_model.name == self.model.name }.first
+              
+            # join_results = subject.child_model.all(subject.field.to_sym => loaded_value)
+            join_results = subject.child_model.all(subject.child_key.first.name => loaded_value[subject.parent_key.first.name])
+            
+            return_value = join_results.map{|r| "#{self.model.key.first.name}=#{r[my_side_of_join.child_key.first.name]}"}.join('|')
+          else
+            comparator = loaded_value.nil? ? 'undefined' : loaded_value.key.first
+            return_value = "#{subject.child_key.first.name}#{condition.__send__(:comparator_string)}#{comparator}"
+          end
+        elsif subject.is_a?(DataMapper::Associations::Relationship)
+          if self.model != subject.child_model
+            return_value = "#{subject.child_key.first.name}#{condition.__send__(:comparator_string)}#{loaded_value.key.first}"
+          else
+            comparator = loaded_value.nil? ? 'undefined' : loaded_value.key.first
+            return_value = "#{subject.field}_id#{condition.__send__(:comparator_string)}#{comparator}"
+          end
+        end
+        return_value
+      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 << "#{condition.subject.child_key.first.name}=#{candidate.key.first}" #munge_condition(condition)
+            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 = ''
+        field_ops = Array.new
+        outfields = Array.new
+        
+        json_query += self.to_json_query_filter
+
+        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.kind_of?(DataMapper::Property::DateTime) || 
+                field.target.kind_of?(DataMapper::Property::Time) || 
+                field.target.kind_of?(DataMapper::Property::Date)
+                "[=#{field.target.field}]"
+              else
+                ".min(?#{field.target.field})"
+              end
+            when :max
+              if field.target.kind_of?(DataMapper::Property::DateTime) || 
+                field.target.kind_of?(DataMapper::Property::Time) || 
+                field.target.kind_of?(DataMapper::Property::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("")
+
+        json_query += self.to_json_query_ordering
+
+        json_query += "[={" + outfields.join(',') + "}]" unless outfields.empty?
+
+
+        # puts json_query, headers
+        return json_query, self.json_query_headers
+      end
+      
+      ##
+      # The filter portion on a json query
+      # 
+      # @author lamb
+      def to_json_query_filter
+        query_terms = []
+        query_terms << process_condition(conditions) 
+
+        if query_terms.flatten.length != 0
+          return "[?#{query_terms.join("][?")}]"
+        else
+          return ''
+        end
+        
+      end
+      
+      ##
+      # The ordering portion of a json query
+      # 
+      # @author lamb
+      def to_json_query_ordering
+        order_operations = []
+        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
+
+        order_operations.join("")
+      end
+      
+      ##
+      # The headers of a json query
+      # 
+      # @author lamb
+      def json_query_headers
+        headers = Hash.new
+        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
+        return headers
+      end
+      
+    end # Query
+  end # Persevere
+end # DataMapper