sunstone 5.0.1.3 → 5.0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 29f80fc835aafa5e3d90b698dfe9da88e770621a
-  data.tar.gz: 6ecfcee3f4071b1723f1b0c914242da6ca2f800e
+  metadata.gz: 5ff6dca76dfaa5922dd16a451f32f8ab27d8a4ce
+  data.tar.gz: 82dcd2022fb893e8f764e0ef032eedac6d1b8762
 SHA512:
-  metadata.gz: 7ce0c2a867d8e465303ce613b63f1000c391ad0f5abdda883dbf396a1521d36ca853de469f776e2cad03bed913d5f83f691ef6da23e5c9c1c3c8edff3e37bfb2
-  data.tar.gz: 7a6c00884660361a6b344f1929dca4899d6934b07e7458739896a8fe61ea448ff83a123b75762977a8ee3c39cdecbcc2753e5200766de9b2013591eaddee558e
+  metadata.gz: 56c8135fad00fc2739483afdaa76eab3cf1b2fc494ffe9ee6ec83654021d8e1dd83fc51aaca35df5a505c8204c7c6bfc5aad259741034f25f66b2290616ff8d7
+  data.tar.gz: 6d9549f7854ef738858b49ee53650920a1dc2c49b86ca9a69967b53edc5505e3c240babcb41f0dbc06574e55b8acfc63d4a6875a671e490dd9c204d0bfdd863e

data/Rakefile.rb

@@ -12,7 +12,7 @@ task :c => :console
 Rake::TestTask.new do |t|
     t.libs << 'test'
     t.test_files = FileList['test/**/*_test.rb']
-    t.warning = false
+    t.warning = true
     #t.verbose = true
 end
 
@@ -34,4 +34,4 @@ task :default => :test
 
 namespace :pages do
   #TODO: https://github.com/defunkt/sdoc-helpers/blob/master/lib/sdoc_helpers/pages.rb
-end
+end

data/ext/active_record/associations.rb

@@ -0,0 +1,52 @@
+require 'active_record'
+require 'active_record/associations'
+module ActiveRecord
+  module Associations
+    module ClassMethods
+      def has_and_belongs_to_many(name, scope = nil, options = {}, &extension)
+        if scope.is_a?(Hash)
+          options = scope
+          scope   = nil
+        end
+
+        habtm_reflection = ActiveRecord::Reflection::HasAndBelongsToManyReflection.new(name, scope, options, self)
+
+        builder = Builder::HasAndBelongsToMany.new name, self, options
+
+        join_model = builder.through_model
+
+        const_set join_model.name, join_model
+        private_constant join_model.name
+
+        middle_reflection = builder.middle_reflection join_model
+
+        Builder::HasMany.define_callbacks self, middle_reflection
+        Reflection.add_reflection self, middle_reflection.name, middle_reflection
+        middle_reflection.parent_reflection = habtm_reflection
+
+        include Module.new {
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def destroy_associations
+            if !self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+              association(:#{middle_reflection.name}).delete_all(:delete_all)
+              association(:#{name}).reset
+            end
+            super
+          end
+          RUBY
+        }
+
+        hm_options = {}
+        hm_options[:through] = middle_reflection.name
+        hm_options[:source] = join_model.right_reflection.name
+
+        [:before_add, :after_add, :before_remove, :after_remove, :autosave, :validate, :join_table, :class_name, :extend].each do |k|
+          hm_options[k] = options[k] if options.key? k
+        end
+
+        has_many name, scope, hm_options, &extension
+        self._reflections[name.to_s].parent_reflection = habtm_reflection
+      end
+    end
+  end
+end

data/ext/active_record/persistence.rb

@@ -1,6 +1,17 @@
 module ActiveRecord
   # = Active Record \Persistence
   module Persistence
+    
+    def update!(attributes)
+      @no_save_transaction = true
+      with_transaction_returning_status do
+        assign_attributes(attributes)
+        save!
+      end
+    ensure
+      @no_save_transaction = false
+    end
+    
     private
 
     def create_or_update(*args)

data/ext/active_record/relation.rb

@@ -45,5 +45,28 @@ module ActiveRecord
       end
     end
 
+    def _update_record(values, id, id_was) # :nodoc:
+      substitutes, binds = substitute_values values
+      scope = @klass.unscoped
+
+      if @klass.finder_needs_type_condition?
+        scope.unscope!(where: @klass.inheritance_column)
+      end
+
+      relation = scope.where(@klass.primary_key => (id_was || id))
+      bvs = binds + relation.bound_attributes
+      um = relation
+        .arel
+        .compile_update(substitutes, @klass.primary_key)
+      um.table @klass.arel_table
+
+      @klass.connection.update(
+        um,
+        'SQL',
+        bvs,
+      )
+    end
+
+
   end
 end

data/ext/active_record/transactions.rb

@@ -1,3 +1,6 @@
+require 'active_record'
+require 'active_record/transactions'
+
 module ActiveRecord
   # See ActiveRecord::Transactions::ClassMethods for documentation.
   module Transactions
@@ -17,16 +20,21 @@ module ActiveRecord
     #   end
     # end
     #
-    # def save!(*) #:nodoc:
-    #   with_transaction_returning_status { super }
-    # end
+    def save!(*) #:nodoc:
+      if instance_variable_defined?(:@no_save_transaction) && @no_save_transaction
+        super
+      else
+        with_transaction_returning_status { super }
+      end
+    end
+    
     #
     # def touch(*) #:nodoc:
     #   with_transaction_returning_status { super }
     # end
 
     def with_transaction_returning_status
-      if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && @updating
+      if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && instance_variable_defined?(:@updating) && @updating
         begin
           status = yield
         rescue ActiveRecord::Rollback

data/lib/active_record/connection_adapters/sunstone/database_statements.rb

@@ -21,7 +21,6 @@ module ActiveRecord
         end
 
         def exec_query(arel, name = 'SAR', binds = [], prepare: false)
-
           sars = []
           multiple_requests = arel.is_a?(Arel::SelectManager)
 
@@ -71,7 +70,7 @@ module ActiveRecord
             send_request.call(arel)
           end
 
-          if sars[0].instance_variable_get(:@sunstone_calculation)
+          if sars[0].instance_variable_defined?(:@sunstone_calculation) && sars[0].instance_variable_get(:@sunstone_calculation)
             # this is a count, min, max.... yea i know..
             ActiveRecord::Result.new(['all'], [result], {:all => type_map.lookup('integer')})
           elsif result.is_a?(Array)

data/lib/arel/collectors/sunstone.rb

@@ -8,6 +8,11 @@ module Arel
 
       # This is used to removed an bind values. It is not used in the request
       attr_accessor :join_source
+      
+      def initialize
+        @join_source = []
+        super
+      end
 
       def cast_attribute(v)
         if (v.is_a?(ActiveRecord::Attribute))
@@ -42,6 +47,8 @@ module Arel
             end
           end
           newhash
+        elsif hash.is_a?(Arel::Nodes::BindParam)
+          cast_attribute(bvs.last.is_a?(Array) ? bvs.shift.last : bvs.shift)
         else
           cast_attribute(bvs.last.is_a?(Array) ? bvs.shift.last : bvs.shift)
         end
@@ -73,17 +80,12 @@ module Arel
           }
         end
 
-        if join_source
+        if !join_source.empty?
           substitute_binds(join_source.clone, bvs)
         end
 
         params = {}
-        if where
-          params[:where] = substitute_binds(where.clone, bvs)
-          if params[:where].size == 1
-            params[:where] = params[:where].pop
-          end
-        end
+        params[:where] = substitute_binds(where.clone, bvs) if where
 
         if eager_loads
           params[:include] = eager_loads.clone

data/lib/arel/visitors/sunstone.rb

@@ -25,18 +25,19 @@ module Arel
       private
       
       def visit_Arel_Nodes_SelectStatement o, collector
+        collector.table = o.cores.first.source.left.name
+
         collector = o.cores.inject(collector) { |c,x|
           visit_Arel_Nodes_SelectCore(x, c)
         }
-
+        
         if !o.orders.empty?
           collector.order = o.orders.map { |x| visit(x, collector) }
         end
-        
+
         collector = maybe_visit o.limit, collector
         collector = maybe_visit o.offset, collector
         collector = maybe_visit o.eager_load, collector
-        # collector = maybe_visit o.lock, collector
 
         collector
       end
@@ -61,10 +62,10 @@ module Arel
           collector = visit o.source, collector
         end
 
-        if !o.wheres.empty?
-          collector.where = o.wheres.map { |x| visit(x, collector) }.inject([]) { |c, w|
-            w.is_a?(Array) ? c += w : c << w
-          }
+        if o.wheres.size == 1
+          collector.where = visit(o.wheres.first, collector)
+        elsif o.wheres.size > 1
+          collector.where = visit(Arel::Nodes::And.new(o.wheres), collector)
         end
 
         collector
@@ -135,6 +136,7 @@ module Arel
       
       def add_to_bottom_of_hash_or_array(hash, value)
         hash = find_bottom(hash)
+        
         if hash.is_a?(Hash)
           nkey = hash.keys.first
           nvalue = hash.values.first
@@ -160,7 +162,7 @@ module Arel
         if wheres.size != 1 && wheres.first.size != 1 && !wheres['id']
           raise 'Upsupported'
         else
-          collector.where = wheres
+          collector.where = wheres.first
         end
 
         collector
@@ -180,7 +182,8 @@ module Arel
       #
       def visit_Arel_Nodes_UpdateStatement o, collector
         collector.request_type  = Net::HTTP::Patch
-        collector.table         = o.relation.name
+        
+        collector.table = o.relation.name
         collector.operation     = :update
         
         # collector.id = o.wheres.first.children.first.right
@@ -193,10 +196,8 @@ module Arel
         if collector.where.size != 1 && collector.where.first.size != 1 && !collector.where.first['id']
           raise 'Upsupported'
         end
-        if !collector.where.first['id']
-          collector.table = collector.where.first.keys.first if collector.is_a?(Arel::Collectors::Sunstone)
-          collector.where[0] = {'id' => collector.where.first.values.first.values.first}
-        end
+        
+        collector.where = collector.where.first
         
         if o.values
           collector.updates = {}
@@ -465,7 +466,13 @@ module Arel
       #   visit o.expr, collector
       # end
       #
-      # def visit_Arel_Nodes_NamedFunction o, collector
+      def visit_Arel_Nodes_NamedFunction o, collector
+        case o.name
+        when 'ST_Within'
+          { visit(o.expressions.first, collector) => { within: o.expressions.last.expressions.map(&:expr)[0...4].reverse } }
+        else
+          raise 'xxx'
+        end
       #   collector << o.name
       #   collector << "("
       #   collector << "DISTINCT " if o.distinct
@@ -476,7 +483,7 @@ module Arel
       #   else
       #     collector
       #   end
-      # end
+      end
       #
       # def visit_Arel_Nodes_Extract o, collector
       #   collector << "EXTRACT(#{o.field.to_s.upcase} FROM "
@@ -513,7 +520,7 @@ module Arel
         if o.expressions.first.is_a?(Arel::Attributes::Attribute)
           relation = o.expressions.first.relation
           join_name = relation.table_alias || relation.name
-          collector.columns << {:maximum => join_name ? o.expressions.first.name : "#{join_name}.#{o.expressions.first.name}"}
+          collector.columns << {:maximum => join_name ? o.expressions.first.name : {join_name => o.expressions.first.name}}
         else
           collector.columns << {:maximum => o.expressions.first}
         end
@@ -526,7 +533,7 @@ module Arel
         if o.expressions.first.is_a?(Arel::Attributes::Attribute)
           relation = o.expressions.first.relation
           join_name = relation.table_alias || relation.name
-          collector.columns << {:minimum => join_name ? o.expressions.first.name : "#{join_name}.#{o.expressions.first.name}"}
+          collector.columns << {:minimum => join_name ? o.expressions.first.name : {join_name => o.expressions.first.name}}
         else
           collector.columns << {:minimum => o.expressions.first}
         end
@@ -539,18 +546,28 @@ module Arel
         if o.expressions.first.is_a?(Arel::Attributes::Attribute)
           relation = o.expressions.first.relation
           join_name = relation.table_alias || relation.name
-          collector.columns << {:average => join_name ? o.expressions.first.name : "#{join_name}.#{o.expressions.first.name}"}
+          collector.columns << {:average => join_name ? o.expressions.first.name : {join_name => o.expressions.first.name}}
         else
 
           collector.columns << {:average => o.expressions.first}
         end
       end
-      #
-      # def visit_Arel_Nodes_TableAlias o, collector
-      #   collector = visit o.relation, collector
-      #   collector << " "
-      #   collector << quote_table_name(o.name)
-      # end
+
+      def visit_Arel_Table o, collector
+        if o.table_alias
+          o.table_alias if collector.is_a?(Arel::Collectors::Sunstone)
+        else
+          o.name if collector.is_a?(Arel::Collectors::Sunstone)
+        end
+        collector
+      end
+
+      def visit_Arel_Nodes_TableAlias o, collector
+        # collector = visit o.relation, collector
+        # collector << " "
+        # collector << quote_table_name(o.name)
+        collector
+      end
       #
       # def visit_Arel_Nodes_Between o, collector
       #   collector = visit o.left, collector
@@ -627,16 +644,10 @@ module Arel
       # end
       #
       def visit_Arel_Nodes_JoinSource o, collector
-        if o.left
-          collector.table = o.left.name if collector.is_a?(Arel::Collectors::Sunstone)
-        end
         if o.right.any?
           # We need to visit the right to get remove bind values, but we don't
           # add it to the collector
-          # collector << " " if o.left
-          # collector = inject_join o.right, collector, ' '
-          collector.join_source = inject_join(o.right, Arel::Collectors::Sunstone.new, ' ')
-          # collector.join_source = Arel::Visitors::PostgreSQL.new(Arel::Collectors::SQLString.new).send(:inject_join, o.right, Arel::Collectors::SQLString.new, ' ')
+          collector.join_source << inject_join(o.right, collector, ' ')
         end
         collector
       end
@@ -658,8 +669,9 @@ module Arel
       # end
 
       def visit_Arel_Nodes_OuterJoin o, collector
-        collector = visit o.left, collector
-        visit o.right, collector
+        # collector = visit o.left, collector
+        # visit o.right, collector
+        collector
       end
 
       # def visit_Arel_Nodes_RightOuterJoin o
@@ -667,7 +679,7 @@ module Arel
       # end
 
       def visit_Arel_Nodes_InnerJoin o, collector
-        collector = visit o.left, collector
+        collector = visit(o.left, collector)
         if o.right
           visit(o.right, collector)
         else
@@ -684,48 +696,72 @@ module Arel
       #   visit(o.expr, collector) << ")"
       # end
       #
-      def visit_Arel_Table o, collector
-        if o.table_alias
-          collector.table = o.table_alias if collector.is_a?(Arel::Collectors::Sunstone)
-        else
-          collector.table = o.name if collector.is_a?(Arel::Collectors::Sunstone)
-        end
-        collector
-      end
 
       def visit_Arel_Nodes_In o, collector
-        {
-          visit(o.left, collector) => {in: visit(o.right, collector)}
-        }
+        key = visit(o.left, collector)
+        value = {in: visit(o.right, collector)}
+        if key.is_a?(Hash)
+          add_to_bottom_of_hash_or_array(key, value)
+          key
+        else
+          {key => value}
+        end
       end
       
       def visit_Arel_Nodes_NotIn o, collector
-        {
-          visit(o.left, collector) => {not_in: visit(o.right, collector)}
-        }
+        key = visit(o.left, collector)
+        value = {not_in: visit(o.right, collector)}
+        
+        if hash.is_a?(Hash)
+          add_to_bottom_of_hash_or_array(key, value)
+          key
+        else
+          {key => value}
+        end
+      end
+      
+      # You merge a into b if a keys do not colid with b keys
+      def mergeable?(hash_a, hash_b)
+        
+        hash_a.each do |key, value_a|
+          if hash_b.has_key?(key)
+            value_b = hash_b[key]
+            if value_a.is_a?(Hash) && value_b.is_a?(Hash)
+              return false if !mergeable?(value_a, value_b)
+            else
+              return false
+            end
+          end
+        end
+        true
       end
       
       def visit_Arel_Nodes_And o, collector
         ors = []
-        ors << o.children.inject({}) do |c, x|
-          value = visit(x, collector)
-          if value.is_a?(Hash)
-            c.deep_merge!(value)
-          elsif value.is_a?(Array)
-            value.size == 1 ? ors << value : ors += value
+
+        o.children.each do |child, i|
+          while child.is_a?(Arel::Nodes::Grouping)
+            child = child.expr
+          end
+          value = visit(child, collector)
+          if value.is_a?(Hash) && ors.last.is_a?(Hash) && mergeable?(value, ors.last)
+            ors.last.deep_merge!(value)
+          else
+            ors << value
           end
-          c
         end
-        ors
+        
+        result = []
+        ors.each_with_index do |c, i|
+          result << c
+          result << 'AND' if ors.size != i + 1
+        end
+        
+        result.size == 1 ? result.first : result
       end
       
       def visit_Arel_Nodes_Or o, collector
-        ors = []
-        [o.left, o.right].each do |x|
-          value = visit(x, collector)
-          value.is_a?(Array) ? ors += value : ors << value
-        end
-        ors
+        [visit(o.left, collector), 'OR', visit(o.right, collector)]
       end
 
       def visit_Arel_Nodes_Assignment o, collector
@@ -768,16 +804,13 @@ module Arel
       def visit_Arel_Nodes_Equality o, collector
         key = visit(o.left, collector)
         value = (o.right.nil? ? nil : visit(o.right, collector))
-        
+
         if key.is_a?(Hash)
           add_to_bottom_of_hash(key, {eq: value})
+        elsif o.left.class.name == 'Arel::Attributes::Key'
+          { key => {eq: value} }
         else
-          key = key.to_s.split('.')
-          hash = { key.pop => value }
-          while key.size > 0
-            hash = { key.pop => hash }
-          end
-          hash
+          { key => value }
         end
       end
       
@@ -848,46 +881,34 @@ module Arel
       end
       
       def visit_Arel_Attributes_Key o, collector
-        key = visit(o.relation, collector)
-        if key.is_a?(Hash)
-          okey = key
-          while okey.values.first.is_a?(Hash)
-            okey = okey.values.first
-          end
-          nkey = okey.keys.first
-          value = okey.values.first
-          okey[nkey] = {value => o.name}
-          key
-        else
-          { key => o.name }
-        end
+        "#{visit(o.relation, collector)}.#{o.name}"
       end
 
       def visit_Arel_Attributes_Relation o, collector, top=true
         value = if o.relation.is_a?(Arel::Attributes::Relation)
-          visit_Arel_Attributes_Relation(o.relation, collector, false)
+          { o.name => visit_Arel_Attributes_Relation(o.relation, collector, false) }
         else
           visit(o.relation, collector)
         end
-        value = value.to_s.split('.').last if !value.is_a?(Hash)
+        # value = value.to_s.split('.').last if !value.is_a?(Hash)
 
         if o.collection
           ary = []
-          ary[o.collection] = value
+          ary[o.collection] = value.values.first
           if top && o.name == collector.table
             ary
           elsif o.for_write
-            {"#{o.name}_attributes" => ary}
+            { "#{o.name}_attributes" => ary }
           else
-            {o.name => ary}
+            ary
           end
         else
           if top && o.name == collector.table
             value
           elsif o.for_write
-            {"#{o.name}_attributes" => value}
+            { "#{o.name}_attributes" => value.values.first }
           else
-            {o.name => value}
+            value
           end
         end
       end
@@ -898,7 +919,12 @@ module Arel
       
       def visit_Arel_Attributes_Attribute o, collector
         join_name = o.relation.table_alias || o.relation.name
-        collector.table == join_name ? o.name : "#{join_name}.#{o.name}" if collector.is_a?(Arel::Collectors::Sunstone)
+
+        if join_name && join_name != collector.table
+          {join_name => o.name}
+        else
+          o.name
+        end
       end
       alias :visit_Arel_Attributes_Integer :visit_Arel_Attributes_Attribute
       alias :visit_Arel_Attributes_Float :visit_Arel_Attributes_Attribute
@@ -978,9 +1004,8 @@ module Arel
       # end
 
       def inject_join list, collector, join_str
-        len = list.length - 1
-        list.each_with_index.inject(collector) { |c, (x,i)|
-          visit x, c
+        list.each_with_index.inject([]) { |c, (x,i)|
+          c + [visit(x, collector)]
         }
       end