sunstone 2.0.0 → 2.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5971616d7a67d451d0d618ed1aaa6f9de9b3daa0
-  data.tar.gz: df3a218c951f5070e2cfccdc91cfa88c0c6a895c
+  metadata.gz: e7571ad32bf7197a480c1f59c5a5158ce0f1d492
+  data.tar.gz: d10ec4207fc78c2e6ec8d3dee815469a7b4b868a
 SHA512:
-  metadata.gz: 6c2eed7323ae88fe0200bfbe83dff412602174d0f3559d94c8bce01117768b1f11b70b95f3b016f75de4751f051db8eb5dbee9ea9efa94743d0e5f9fc49ccfa0
-  data.tar.gz: 87f7fe2cf78a6d7b0e8a4d0c10b00f606b31d4058c4a8b0fe1ed5f70ab16d39414da4d8d350e778dc389fa19408fd3c980dd9cf03fc9cf7ec8acc94c6beb91fc
+  metadata.gz: 121532495ba520b5e66de7cc054e9fc1958076c6953c2dc10e710816d9944fc76e940a4dd6018cea3a5599aa43faecdee9c81259fd7d569ea659abcbc6ccb4d9
+  data.tar.gz: 815d5f4f6a5c89a1552b8dc8cde45ac8cf508608b5403c75f4516569fd834f2f3becf1fa3af3cf25c622cba2d3ade471dca215029d4aa2230a9b46fc916e730b

data/README.md

@@ -1,4 +1,11 @@
-sunstone
+Sunstone
 ========
 
-A library for interacting with REST APIs
+An [ActiveRecord](https://rubygems.org/gems/activerecord) adapter for quering
+APIs over Standard API (https://github.com/waratuman/standardapi).
+
+
+TODO:
+=====
+Make `cookie_store` and optional
+stream building model instances with wankel

data/ext/active_record/associations/builder/has_and_belongs_to_many.rb

@@ -1,48 +1,52 @@
-module ActiveRecord::Associations::Builder
-  class HasAndBelongsToMany # :nodoc:
-
-    def through_model
-      habtm = JoinTableResolver.build lhs_model, association_name, options
-      
-      join_model = Class.new(lhs_model.base_class.superclass) {
-        class << self;
-          attr_accessor :class_resolver
-          attr_accessor :name
-          attr_accessor :table_name_resolver
-          attr_accessor :left_reflection
-          attr_accessor :right_reflection
-        end
-
-        def self.table_name
-          table_name_resolver.join_table
-        end
-
-        def self.compute_type(class_name)
-          class_resolver.compute_type class_name
-        end
-
-        def self.add_left_association(name, options)
-          belongs_to name, options
-          self.left_reflection = _reflect_on_association(name)
-        end
-
-        def self.add_right_association(name, options)
-          rhs_name = name.to_s.singularize.to_sym
-          belongs_to rhs_name, options
-          self.right_reflection = _reflect_on_association(rhs_name)
-        end
-
-      }
-
-      join_model.name                = "HABTM_#{association_name.to_s.camelize}"
-      join_model.table_name_resolver = habtm
-      join_model.class_resolver      = lhs_model
-      join_model.primary_key         = nil
-
-      join_model.add_left_association :left_side, anonymous_class: lhs_model
-      join_model.add_right_association association_name, belongs_to_options(options)
-      join_model
-    end
-
-  end
-end
+# module ActiveRecord::Associations::Builder
+#   class HasAndBelongsToMany # :nodoc:
+#
+#     def through_model
+#       habtm = JoinTableResolver.build lhs_model, association_name, options
+#
+#       join_model = Class.new(lhs_model.base_class.superclass) { # Don't use ActiveRecord::Base here because that might not be the abstract class that we need and the connection may be different
+#         class << self;
+#           attr_accessor :left_model
+#           attr_accessor :name
+#           attr_accessor :table_name_resolver
+#           attr_accessor :left_reflection
+#           attr_accessor :right_reflection
+#         end
+#
+#         def self.table_name
+#           table_name_resolver.join_table
+#         end
+#
+#         def self.compute_type(class_name)
+#           left_model.compute_type class_name
+#         end
+#
+#         def self.add_left_association(name, options)
+#           belongs_to name, options
+#           self.left_reflection = _reflect_on_association(name)
+#         end
+#
+#         def self.add_right_association(name, options)
+#           rhs_name = name.to_s.singularize.to_sym
+#           belongs_to rhs_name, options
+#           self.right_reflection = _reflect_on_association(rhs_name)
+#         end
+#
+#         def self.retrieve_connection
+#           left_model.retrieve_connection
+#         end
+#
+#       }
+#
+#       join_model.name                = "HABTM_#{association_name.to_s.camelize}"
+#       join_model.table_name_resolver = habtm
+#       join_model.class_resolver      = lhs_model
+#       join_model.primary_key         = nil
+#
+#       join_model.add_left_association :left_side, anonymous_class: lhs_model
+#       join_model.add_right_association association_name, belongs_to_options(options)
+#       join_model
+#     end
+#
+#   end
+# end

data/ext/active_record/batches.rb

@@ -3,9 +3,9 @@ module ActiveRecord
 
     private
 
-    # "#{quoted_table_name}.#{quoted_primary_key} ASC"
+    # Arrrr Rails hard coding SQL
     def batch_order
-      {:id => :asc}
+      primary_key ? {primary_key => :asc} : {}
     end
 
   end

data/ext/active_record/calculations.rb

@@ -1,28 +1,28 @@
-module ActiveRecord
-  module Calculations
-    def pluck(*column_names)
-      
-      # column_names.map! do |column_name|
-      #   if column_name.is_a?(Symbol) && attribute_alias?(column_name)
-      #     attribute_alias(column_name)
-      #   else
-      #     column_name.to_s
-      #   end
-      # end
-
-      if has_include?(column_names.first)
-        construct_relation_for_association_calculations.pluck(*column_names)
-      else
-        relation = spawn
-        relation.select_values = column_names.map { |cn|
-          columns_hash.key?(cn) ? arel_table[cn] : cn
-        }
-        
-        result = klass.connection.exec_query(relation.arel, nil, relation.arel.bind_values + bind_values)
-        result.cast_values(klass.column_types)
-      end
-    end
-    
-  end
-end
-
+# module ActiveRecord
+#   module Calculations
+#     def pluck(*column_names)
+#
+#       # column_names.map! do |column_name|
+#       #   if column_name.is_a?(Symbol) && attribute_alias?(column_name)
+#       #     attribute_alias(column_name)
+#       #   else
+#       #     column_name.to_s
+#       #   end
+#       # end
+#
+#       if has_include?(column_names.first)
+#         construct_relation_for_association_calculations.pluck(*column_names)
+#       else
+#         relation = spawn
+#         relation.select_values = column_names.map { |cn|
+#           columns_hash.key?(cn) ? arel_table[cn] : cn
+#         }
+#
+#         result = klass.connection.exec_query(relation.arel, nil, relation.arel.bind_values + bind_values)
+#         result.cast_values(klass.column_types)
+#       end
+#     end
+#
+#   end
+# end
+#

data/ext/active_record/finder_methods.rb

@@ -1,22 +1,36 @@
 module ActiveRecord
   module FinderMethods
-    
-    def find_with_associations
-      arel.eager_load = Arel::Nodes::EagerLoad.new(eager_load_values)
 
+    def find_with_associations
+      join_dependency = nil
+      aliases = nil
+      relation = if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+        arel.eager_load = Arel::Nodes::EagerLoad.new(eager_load_values)
+        self
+      else
+        join_dependency = construct_join_dependency(joins_values)
+        aliases  = join_dependency.aliases
+        apply_join_dependency(select(aliases.columns), join_dependency)
+      end
+      
       if block_given?
-        yield self
+        yield relation
       else
-        if ActiveRecord::NullRelation === self
+        if ActiveRecord::NullRelation === relation
           []
         else
-          rows = connection.select_all(arel, 'SQL', arel.bind_values + bind_values)
-          instantiate_with_associations(rows, self)
-          # join_dependency.instantiate(rows, aliases)
+          arel = relation.arel
+          rows = connection.select_all(arel, 'SQL', arel.bind_values + relation.bind_values)
+          if join_dependency
+            join_dependency.instantiate(rows, aliases)
+          else
+            instantiate_with_associations(rows, relation)
+          end
+          
         end
       end
     end
-    
+
     def instantiate_with_associations(result_set, klass)
       seen = Hash.new { |h, parent_klass|
         h[parent_klass] = Hash.new { |i, parent_id|
@@ -26,20 +40,20 @@ module ActiveRecord
 
       model_cache = Hash.new { |h,klass| h[klass] = {} }
       parents = model_cache[self.base_class]
-      
+
       result_set.each { |row_hash|
         parent = parents[row_hash[primary_key]] ||= instantiate(row_hash.select{|k,v| column_names.include?(k.to_s) })
         construct(parent, row_hash.select{|k,v| !column_names.include?(k.to_s) }, seen, model_cache)
       }
-      
+
       parents.values
     end
-    
+
     def construct(parent, relations, seen, model_cache)
       relations.each do |key, attributes|
         reflection = parent.class.reflect_on_association(key)
         next unless reflection
-        
+
         if reflection.collection?
           other = parent.association(reflection.name)
           other.loaded!
@@ -49,7 +63,7 @@ module ActiveRecord
             construct(model, attributes.select{|k,v| !reflection.klass.column_names.include?(k.to_s) }, seen, model_cache)
           end
         end
-        
+
         if !reflection.collection?
           construct_association(parent, reflection, attributes, seen, model_cache)
         else
@@ -57,13 +71,13 @@ module ActiveRecord
             construct_association(parent, reflection, row, seen, model_cache)
           end
         end
-          
+
       end
     end
-    
+
     def construct_association(parent, reflection, attributes, seen, model_cache)
       return if attributes.nil?
-      
+
       klass = if reflection.polymorphic?
         parent.send(reflection.foreign_type).constantize.base_class
       else
@@ -71,12 +85,12 @@ module ActiveRecord
       end
       id = attributes[klass.primary_key]
       model = seen[parent.class.base_class][parent.id][klass][id]
-      
+
       if model
         construct(model, attributes.select{|k,v| !klass.column_names.include?(k.to_s) }, seen, model_cache)
 
         other = parent.association(reflection.name)
-        
+
         if reflection.collection?
           other.target.push(model)
         else
@@ -90,7 +104,7 @@ module ActiveRecord
         construct(model, attributes.select{|k,v| !klass.column_names.include?(k.to_s) }, seen, model_cache)
       end
     end
-    
+
 
     def construct_model(record, reflection, id, attributes, seen, model_cache)
       klass = if reflection.polymorphic?
@@ -98,7 +112,7 @@ module ActiveRecord
       else
         reflection.klass
       end
-      
+
       model = model_cache[klass][id] ||= klass.instantiate(attributes)
       other = record.association(reflection.name)
 
@@ -111,7 +125,7 @@ module ActiveRecord
       other.set_inverse_instance(model)
       model
     end
-    
+
   end
 
 end

data/ext/active_record/query_methods.rb

@@ -0,0 +1,23 @@
+module ActiveRecord
+  module QueryMethods
+      
+    def reverse_sql_order(order_query)
+      order_query = [arel_table[primary_key].asc] if order_query.empty?
+
+      order_query.flat_map do |o|
+        case o
+        when Arel::Nodes::Ordering
+          o.reverse
+        when String
+          o.to_s.split(',').map! do |s|
+            s.strip!
+            s.gsub!(/\sasc\Z/i, ' DESC') || s.gsub!(/\sdesc\Z/i, ' ASC') || s.concat(' DESC')
+          end
+        else
+          o
+        end
+      end
+    end
+      
+  end
+end

data/ext/active_record/relation.rb

@@ -1,11 +1,11 @@
 module ActiveRecord
   class Relation
+
     def to_sql
       @to_sql ||= begin
                     relation   = self
                     connection = klass.connection
-                    visitor    = connection.visitor
-                    collector  = connection.collector
+                    visitor    = connection.visitor.is_a?(Arel::Visitors::Sunstone) ? Arel::Visitors::ToSql.new(connection) : connection.visitor
 
                     if eager_loading?
                       find_with_associations { |rel| relation = rel }
@@ -14,13 +14,11 @@ module ActiveRecord
                     arel  = relation.arel
                     binds = (arel.bind_values + relation.bind_values).dup
                     binds.map! { |bv| connection.quote(*bv.reverse) }
-                    collect = visitor.accept(arel.ast, collector)
-                    if collector.is_a?(Arel::Collectors::Sunstone)
-                      collect.compile(binds)
-                    else
-                      collect.substitute_binds(binds).join
-                    end
+                    collect = visitor.accept(arel.ast, Arel::Collectors::Bind.new)
+                    collect.substitute_binds(binds).join
                   end
     end
+    
+    
   end
 end

data/ext/active_record/relation/predicate_builder.rb

@@ -1,23 +1,29 @@
-module ActiveRecord
-  class PredicateBuilder # :nodoc:
-
-    def self.expand(klass, table, column, value)
-      queries = []
-
-      # In standard Rails where takes :table => { columns }, but in sunstone we
-      # can can do nested tables eg: where(:properties => { :regions => {:id => 1}})
-      if klass && reflection = klass._reflect_on_association(column)
-        if reflection.polymorphic? && base_class = polymorphic_base_class_from_value(value)
-          queries << build(table[reflection.foreign_type], base_class)
-        end
-
-        # column = reflection.foreign_key
-        column # Don't need Rails to assume we are referencing a table
-      end
-
-      queries << build(table[column], value)
-      queries
-    end
-
-  end
-end
+# module ActiveRecord
+#   class PredicateBuilder # :nodoc:
+#
+#     def self.expand(klass, table, column, value)
+#       queries = []
+#
+#       # In standard Rails where takes :table => { columns }, but in sunstone we
+#       # can can do nested tables eg: where(:properties => { :regions => {:id => 1}})
+#       if klass && reflection = klass._reflect_on_association(column)
+#         base_class = polymorphic_base_class_from_value(value)
+#
+#         if reflection.polymorphic? && base_class
+#           queries << build(table[reflection.foreign_type], base_class)
+#         end
+#
+#         column = reflection.foreign_key
+#
+#         if base_class
+#           primary_key = reflection.association_primary_key(base_class)
+#           value = convert_value_to_association_ids(value, primary_key)
+#         end
+#       end
+#
+#       queries << build(table[column], value)
+#       queries
+#     end
+#
+#   end
+# end

data/ext/active_record/statement_cache.rb

@@ -1,23 +1,36 @@
 module ActiveRecord
   class StatementCache
     class PartialQuery
-      
-      def initialize collector
-        @collector = collector
-        @indexes = collector.value.find_all { |thing|
-          Arel::Nodes::BindParam === thing
-        }
+
+      def initialize(values, sunstone=false)
+        @values = values
+        if sunstone
+          @indexes = values.value.find_all { |thing|
+            Arel::Nodes::BindParam === thing
+          }
+        else
+          @indexes = values.each_with_index.find_all { |thing,i|
+            Arel::Nodes::BindParam === thing
+          }.map(&:last)
+        end
       end
 
       def sql_for(binds, connection)
         binds = binds.dup
-        @collector.compile(binds)
+        
+        if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+          @values.compile(binds)
+        else
+          val = @values.dup
+          @indexes.each { |i| val[i] = connection.quote(*binds.shift.reverse) }
+          val.join
+        end
       end
     end
 
     def self.partial_query(visitor, ast, collector)
       collected = visitor.accept(ast, collector)
-      PartialQuery.new collected
+      PartialQuery.new(visitor.is_a?(Arel::Visitors::Sunstone) ? collected : collected.value, visitor.is_a?(Arel::Visitors::Sunstone))
     end
 
   end