sunstone 2.0.4 → 5.0.0.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9d7b7cb926a0045ee4a771a87ce5f3f3096fb035
-  data.tar.gz: 0edf0869c5ac58e901579d47b8979ed4ecf98c39
+  metadata.gz: c5c130a7d5b7307e472bd22688ee0b8621db478e
+  data.tar.gz: a3fde9dce1b08795ea7ff9a1217921fb57c099ef
 SHA512:
-  metadata.gz: 2bf1d1921cf1cad5967be3398b0a49de76cac94b65bc268952c549b994b1e48487913b062a29e33f4968c84fecb90aec0691f24cce06261c61f0a7cf2bce5ddb
-  data.tar.gz: 8bce1e614955c036c7d46df1c109b2650dec40ad5d0b3168d9c33963005c94f91a80a6737d1b00b045ffafea006efc43faaef28f66053f811975e0efa33e2f46
+  metadata.gz: 383524737f0c0fefbec2c99d62d35ce23c6e3060f772e11ebac65418493cf2ee892e34cd637a6f86bbf5439275103c986887f4dd05494cb223a8cc51a9b67349
+  data.tar.gz: df9fe4e2e39011303804a12fe26b49b99c84c3651c017a202fbcec907b8439708f4ae04ca72400c47cc5031687de9c179495e23a5644a71ec6666ff69bcd1590

data/ext/active_record/associations/collection_association.rb

@@ -0,0 +1,46 @@
+module ActiveRecord
+  module Associations
+    class CollectionAssociation
+
+      def replace(other_array)
+        other_array.each { |val| raise_on_type_mismatch!(val) }
+        original_target = load_target.dup
+
+        if owner.instance_variable_get(:@updateing)
+          replace_common_records_in_memory(other_array, original_target)
+          concat(other_array - original_target)
+          other_array
+        elsif owner.new_record?
+          replace_records(other_array, original_target)
+        else
+          replace_common_records_in_memory(other_array, original_target)
+          if other_array != original_target
+            transaction { replace_records(other_array, original_target) }
+          else
+            other_array
+          end
+        end
+      end
+
+    end
+  end
+end
+
+module ActiveRecord
+  module Persistence
+    # Updates the attributes of the model from the passed-in hash and saves the
+    # record, all wrapped in a transaction. If the object is invalid, the saving
+    # will fail and false will be returned.
+    def update(attributes)
+      @updateing = true
+      # The following transaction covers any possible database side-effects of the
+      # attributes assignment. For example, setting the IDs of a child collection.
+      with_transaction_returning_status do
+        assign_attributes(attributes)
+        save
+      end
+    ensure
+      @updateing = false
+    end
+  end
+end

data/ext/active_record/attribute_methods.rb

@@ -0,0 +1,137 @@
+module ActiveRecord
+  module AttributeMethods
+    
+    protected
+    
+    # Returns a Hash of the Arel::Attributes and attribute values that have been
+    # typecasted for use in an Arel insert/update method.
+    def arel_attributes_with_values(attribute_names)
+      attrs = {}
+      arel_table = self.class.arel_table
+      
+      attribute_names.each do |name|
+        attrs[arel_table[name]] = typecasted_attribute_value(name)
+      end
+      
+      if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+        self.class.reflect_on_all_associations.each do |reflection|
+          if reflection.belongs_to?
+            add_attributes_for_belongs_to_association(reflection, attrs)
+          elsif reflection.has_one?
+            add_attributes_for_has_one_association(reflection, attrs)
+          elsif reflection.collection?
+            add_attributes_for_collection_association(reflection, attrs)
+          end
+        end
+      end
+      
+      attrs
+    end
+    
+    def add_attributes_for_belongs_to_association(reflection, attrs)
+      key = :"add_attributes_for_belongs_to_association#{reflection.name}"
+      @_already_called ||= {}
+      return if @_already_called[key]
+      @_already_called[key]=true
+      @_already_called[:"autosave_associated_records_for_#{reflection.name}"] = true
+      
+      association = association_instance_get(reflection.name)
+      record      = association && association.load_target
+      if record && !record.destroyed?
+        autosave = reflection.options[:autosave]
+
+        if autosave && record.marked_for_destruction?
+          self[reflection.foreign_key] = nil
+          record.destroy
+        elsif autosave != false
+          if record.new_record? || (autosave && record.changed_for_autosave?)
+            if record.new_record?
+              record.send(:arel_attributes_with_values_for_create, record.attribute_names).each do |k, v|
+                attrs[Arel::Attributes::Relation.new(k, reflection.name)] = v
+              end
+            else
+              record.send(:arel_attributes_with_values_for_update, record.attribute_names).each do |k, v|
+                attrs[Arel::Attributes::Relation.new(k, reflection.name)] = v
+              end
+            end
+          end
+        end
+      end
+    end
+    
+    def add_attributes_for_has_one_association(reflection, attrs)
+      key = :"add_attributes_for_has_one_association#{reflection.name}"
+      @_already_called ||= {}
+      return if @_already_called[key]
+      @_already_called[key]=true
+      @_already_called[:"autosave_associated_records_for_#{reflection.name}"] = true
+      
+      association = association_instance_get(reflection.name)
+      record      = association && association.load_target
+
+      if record && !record.destroyed?
+        autosave = reflection.options[:autosave]
+
+        if autosave && record.marked_for_destruction?
+          record.destroy
+        elsif autosave != false
+          key = reflection.options[:primary_key] ? send(reflection.options[:primary_key]) : id
+
+          if (autosave && record.changed_for_autosave?) || new_record? || record_changed?(reflection, record, key)
+            unless reflection.through_reflection
+              record[reflection.foreign_key] = key
+            end
+
+            if record.new_record?
+              record.send(:arel_attributes_with_values_for_create, record.attribute_names).each do |k, v|
+                attrs[Arel::Attributes::Relation.new(k, reflection.name)] = v
+              end
+            else
+              record.send(:arel_attributes_with_values_for_update, record.attribute_names).each do |k, v|
+                attrs[Arel::Attributes::Relation.new(k, reflection.name)] = v
+              end
+            end
+          end
+        end
+      end
+    end
+    
+    def add_attributes_for_collection_association(reflection, attrs)
+      key = :"add_attributes_for_collection_association#{reflection.name}"
+      @_already_called ||= {}
+      return if @_already_called[key]
+      @_already_called[key]=true
+      @_already_called[:"autosave_associated_records_for_#{reflection.name}"] = true
+      if reflection.is_a?(ActiveRecord::Reflection::HasAndBelongsToManyReflection)
+        @_already_called[:"autosave_associated_records_for_#{self.class.name.downcase.pluralize}_#{reflection.name}"] = true
+      end
+      
+      if association = association_instance_get(reflection.name)
+        autosave = reflection.options[:autosave]
+        if records = associated_records_to_validate_or_save(association, @new_record_before_save, autosave)
+
+          records.each_with_index do |record, idx|
+            next if record.destroyed?
+
+            if record.new_record?
+              record.send(:arel_attributes_with_values_for_create, record.attribute_names).each do |k, v|
+                attrs[Arel::Attributes::Relation.new(k, reflection.name, idx)] = v
+              end
+            else
+              record.send(:arel_attributes_with_values_for_update, record.attribute_names).each do |k, v|
+                attrs[Arel::Attributes::Relation.new(k, reflection.name, idx)] = v
+              end
+            end
+
+          end
+        end
+
+        # reconstruct the scope now that we know the owner's id
+        association.reset_scope if association.respond_to?(:reset_scope)
+      end
+    end
+
+
+    
+  end
+end

data/ext/active_record/calculations.rb

@@ -9,7 +9,11 @@ module ActiveRecord
       #     column_name.to_s
       #   end
       # end
-
+      
+      if loaded? && (column_names - @klass.column_names).empty?
+        return @records.pluck(*column_names)
+      end
+      
       if has_include?(column_names.first)
         construct_relation_for_association_calculations.pluck(*column_names)
       else

data/ext/active_record/finder_methods.rb

@@ -20,13 +20,12 @@ module ActiveRecord
           []
         else
           arel = relation.arel
-          rows = connection.select_all(arel, 'SQL', arel.bind_values + relation.bind_values)
+          rows = connection.select_all(arel, 'SQL', arel.bind_values + relation.bound_attributes)
           if join_dependency
             join_dependency.instantiate(rows, aliases)
           else
             instantiate_with_associations(rows, relation)
           end
-          
         end
       end
     end
@@ -58,7 +57,7 @@ module ActiveRecord
           other = parent.association(reflection.name)
           other.loaded!
         else
-          if parent.association_cache.key?(reflection.name)
+          if parent.association_cached?(reflection.name)
             model = parent.association(reflection.name).target
             construct(model, attributes.select{|k,v| !reflection.klass.column_names.include?(k.to_s) }, seen, model_cache)
           end

data/ext/active_record/persistence.rb

@@ -0,0 +1,21 @@
+module ActiveRecord
+  # = Active Record \Persistence
+  module Persistence
+    private
+
+    def create_or_update(*args)
+      raise ReadOnlyRecord, "#{self.class} is marked as readonly" if readonly?
+      result = new_record? ? _create_record : _update_record(*args)
+      result != false
+    rescue Sunstone::Exception::BadRequest => e
+      JSON.parse(e.message)['errors'].each do |field, message|
+        if message.is_a?(Array)
+          message.each { |m| errors.add(field, m) }
+        else
+          errors.add(field, message)
+        end
+      end
+      raise ActiveRecord::RecordInvalid
+    end
+  end
+end

data/ext/active_record/query_methods.rb

@@ -1,6 +1,6 @@
 module ActiveRecord
   module QueryMethods
-      
+    
     def reverse_sql_order(order_query)
       order_query = [arel_table[primary_key].asc] if order_query.empty?
 
@@ -18,6 +18,13 @@ module ActiveRecord
         end
       end
     end
-      
+    
+    def joins(*args)
+      # If a joins happen with sunstone messes up visitor / collector
+      return self if klass.connection.class.name == "ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter"
+      check_if_method_has_arguments!(:joins, args)
+      spawn.joins!(*args)
+    end
+    
   end
 end

data/ext/active_record/relation.rb

@@ -12,13 +12,13 @@ module ActiveRecord
                     end
 
                     arel  = relation.arel
-                    binds = (arel.bind_values + relation.bind_values).dup
-                    binds.map! { |bv| connection.quote(*bv.reverse) }
+                    binds = connection.prepare_binds_for_database(arel.bind_values + relation.bound_attributes)
+                    binds.map! { |bv| connection.quote(bv) }
                     collect = visitor.accept(arel.ast, Arel::Collectors::Bind.new)
                     collect.substitute_binds(binds).join
                   end
     end
     
-    
+
   end
 end

data/ext/active_record/statement_cache.rb

@@ -16,7 +16,7 @@ module ActiveRecord
       end
 
       def sql_for(binds, connection)
-        binds = binds.dup
+        binds = connection.prepare_binds_for_database(binds)
         
         if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
           @values.compile(binds)

data/ext/active_support/core_ext/object/to_query.rb

@@ -1,7 +1,20 @@
 class NilClass
   
   def to_query(namespace)
-    namespace
+    namespace.to_s
   end
   
+end
+
+class Hash
+  
+  def to_query(namespace = nil)
+    collect do |key, value|
+      # unless (value.is_a?(Hash) || value.is_a?(Array)) && value.empty?
+        value.to_query(namespace ? "#{namespace}[#{key}]" : key)
+      # end
+    end.compact.sort! * '&'
+  end
+
+  alias_method :to_param, :to_query
 end

data/ext/arel/attributes/relation.rb

@@ -0,0 +1,30 @@
+module Arel
+  module Attributes
+    class Relation < Attribute
+      
+      attr_accessor :collection
+      
+      def initialize(relation, name, collection = false)
+        self[:relation] = relation
+        self[:name] = name
+        @collection = collection
+      end
+      
+      def able_to_type_cast?
+        false
+      end
+      
+      def table_name
+        nil
+      end
+      
+      def eql? other
+        self.class == other.class &&
+          self.relation == other.relation &&
+          self.name == other.name &&
+          self.collection == other.collection
+      end
+      
+    end
+  end
+end

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

@@ -2,16 +2,18 @@ module ActiveRecord
   module ConnectionAdapters
     # Sunstone-specific extensions to column definitions in a table.
     class SunstoneColumn < Column #:nodoc:
-      attr_accessor :array
-
-      def initialize(name, cast_type, options={})
+      delegate :array, to: :sql_type_metadata
+      alias :array? :array
+      
+      def initialize(name, sql_type_metadata, options={})
+        @name = name.freeze
+        @sql_type_metadata = sql_type_metadata
+        @null = options['null']
+        @default = options['default']
+        @default_function = nil
+        @collation = nil
+        @table_name = nil
         @primary_key = (options['primary_key'] == true)
-        @array = !!options['array']
-        if @array
-          super(name, options['default'], Sunstone::Type::Array.new(cast_type), nil, options['null'])
-        else
-          super(name, options['default'], cast_type, nil, options['null'])
-        end
       end
       
       def primary_key?

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

@@ -13,12 +13,7 @@ module ActiveRecord
           end
         end
 
-        # Returns an ActiveRecord::Result instance.
-        def select_all(arel, name = nil, binds = [], &block)
-          exec_query(arel, name, binds)
-        end
-
-        def exec_query(arel, name = 'SAR', binds = [])
+        def exec_query(arel, name = 'SAR', binds = [], prepare: false)
           sar = to_sar(arel, binds)
           result = exec(sar, name)
 

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

@@ -15,7 +15,7 @@ module ActiveRecord
         def columns(table_name)
           # Limit, precision, and scale are all handled by the superclass.
           column_definitions(table_name).map do |column_name, options|
-            new_column(column_name, lookup_cast_type(options['type']), options)
+            new_column(column_name, options)
           end
         end
 
@@ -34,8 +34,25 @@ module ActiveRecord
           Wankel.parse(@connection.get('/tables').body)
         end
         
-        def new_column(name, cast_type, options={}) # :nodoc:
-          SunstoneColumn.new(name, cast_type, options)
+        def views
+          []
+        end
+        
+        def new_column(name, options)
+          sql_type_metadata = fetch_type_metadata(options)
+          SunstoneColumn.new(name, sql_type_metadata, options)
+        end
+        
+        def fetch_type_metadata(options)
+          cast_type = lookup_cast_type(options['type'])
+          simple_type = SqlTypeMetadata.new(
+            sql_type: options['type'],
+            type: cast_type.type,
+            limit: cast_type.limit,
+            precision: cast_type.precision,
+            scale: cast_type.scale,
+          )
+          SunstoneSQLTypeMetadata.new(simple_type, options)
         end
         
         def column_name_for_operation(operation, node) # :nodoc:
@@ -46,7 +63,7 @@ module ActiveRecord
 
         # Returns just a table's primary key
         def primary_key(table)
-          columns(table).find{ |c| c.primary_key? }.name
+          columns(table).find{ |c| c.primary_key? }.try(:name)
         end
 
       end