sunstone 5.0.0.beta3 → 5.0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c5c130a7d5b7307e472bd22688ee0b8621db478e
-  data.tar.gz: a3fde9dce1b08795ea7ff9a1217921fb57c099ef
+  metadata.gz: a1fc21e0215013059317cc971ba06e8a221343e2
+  data.tar.gz: 9c9f8128129d8d9ff50e398f7982f9288573a41f
 SHA512:
-  metadata.gz: 383524737f0c0fefbec2c99d62d35ce23c6e3060f772e11ebac65418493cf2ee892e34cd637a6f86bbf5439275103c986887f4dd05494cb223a8cc51a9b67349
-  data.tar.gz: df9fe4e2e39011303804a12fe26b49b99c84c3651c017a202fbcec907b8439708f4ae04ca72400c47cc5031687de9c179495e23a5644a71ec6666ff69bcd1590
+  metadata.gz: ccb44a14900ab3434926246a341740026723695e868283a0d09f3b4d6e41700da0aaf2f77f61c4bc69ca6fe3cdeee5204924fc67695b5ddcc09c211ae4a466a4
+  data.tar.gz: 2fb90af0945f9c7ae8dbd1dad2dc7c0072efa24dcd2bd3cf1b76507fb6754e4a06f6093117d2e94c5900624f7083effdcaab8d02a00ff648c28e268fa2fc46b7

data/.gitignore

@@ -8,6 +8,7 @@
 /test/tmp/
 /test/version_tmp/
 /tmp/
+.DS_Store
 
 ## Documentation cache and generated files:
 /.yardoc/

data/.tm_properties

@@ -0,0 +1 @@
+exclude = '{$exclude,log,bin,tmp,.tm_properties,coverage}'

data/.travis.yml

@@ -0,0 +1,36 @@
+language: ruby
+rvm: 2.3.1
+
+cache:
+  bundler: true
+  directories:
+    - /home/travis/.rvm/gems
+
+addons:
+  postgresql: "9.4"
+
+before_install:
+  - unset BUNDLE_GEMFILE
+
+install:
+  - git clone https://github.com/rails/rails.git ~/build/rails
+
+before_script:
+  - export RAILS_VERSION=`cat sunstone.gemspec | grep activerecord | grep -ow "[0-9\.]\{1,\}"`
+  - pushd ~/build/rails
+  - git checkout v$RAILS_VERSION
+  - sed -i "/require 'support\/connection'/a \$LOAD_PATH.unshift\(File.expand_path\('~\/build\/malomalo\/sunstone\/lib'\)\)\nrequire 'sunstone'" ~/build/rails/activerecord/test/cases/helper.rb
+  - cat ~/build/rails/Gemfile
+  - "sed -i \"/group :db do/a gem 'sunstone', path: File.expand_path\\('~\\/build\\/malomalo\\/sunstone'\\)\" ~/build/rails/Gemfile"
+  - cat ~/build/rails/Gemfile
+  - bundle install --jobs=3 --retry=3
+  - createdb activerecord_unittest
+  - createdb activerecord_unittest2
+  - mysql -e "create database IF NOT EXISTS activerecord_unittest DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_unicode_ci;"
+  - mysql -e "create database IF NOT EXISTS activerecord_unittest2 DEFAULT CHARACTER SET utf8 DEFAULT COLLATE utf8_unicode_ci;"
+  - gem environment gempath
+  - popd
+  - bundle install --jobs=3 --retry=3
+  - gem environment gempath
+
+script: bundle exec rake test && cd ~/build/rails/activerecord && bundle exec rake test --verbose

data/README.md

@@ -1,5 +1,4 @@
-Sunstone
-========
+# Sunstone  [![Travis CI](https://travis-ci.org/malomalo/sunstone.svg)](https://travis-ci.org/malomalo/sunstone)
 
 An [ActiveRecord](https://rubygems.org/gems/activerecord) adapter for quering
 APIs over Standard API (https://github.com/waratuman/standardapi).

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 = true
+    t.warning = false
     #t.verbose = true
 end
 

data/ext/active_record/associations/collection_association.rb

@@ -6,12 +6,22 @@ module ActiveRecord
         other_array.each { |val| raise_on_type_mismatch!(val) }
         original_target = load_target.dup
 
-        if owner.instance_variable_get(:@updateing)
+        if owner.new_record?
+          replace_records(other_array, original_target)
+        elsif owner.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && owner.instance_variable_defined?(:@updating) && owner.instance_variable_get(:@updating)
           replace_common_records_in_memory(other_array, original_target)
-          concat(other_array - original_target)
+
+          # Remove from target
+          (original_target - other_array).each { |record| callback(:before_remove, record) }
+          (original_target - other_array).each { |record| target.delete(record) }
+          (original_target - other_array).each { |record| callback(:after_remove, record) }
+
+          # Add to target
+          (other_array - original_target).each do |record|
+            add_to_target(record)
+          end
+
           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
@@ -22,17 +32,47 @@ module ActiveRecord
         end
       end
 
+
+    end
+
+    class HasManyAssociation
+
+      def insert_record(record, validate = true, raise = false)
+        set_owner_attributes(record)
+        set_inverse_instance(record)
+
+        if record.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && (!owner.instance_variable_defined?(:@updating) && owner.instance_variable_get(:@updating))
+          true
+        elsif raise
+          record.save!(:validate => validate)
+        else
+          record.save(:validate => validate)
+        end
+      end
+
+      private
+      def save_through_record(record)
+        return if record.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+        build_through_record(record).save!
+      ensure
+        @through_records.delete(record.object_id)
+      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
+      @updating = :updating
+      $updating_model = self
+      
       # 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
@@ -40,7 +80,9 @@ module ActiveRecord
         save
       end
     ensure
-      @updateing = false
+      @updating = false
+      $updating_model = nil
     end
+    
   end
 end

data/ext/active_record/attribute_methods.rb

@@ -12,15 +12,19 @@ module ActiveRecord
       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)
+            if association(reflection.name).loaded? && association(reflection.name).target == $updating_model
+              attrs.delete(arel_table[reflection.foreign_key])
+            else
+              add_attributes_for_belongs_to_association(reflection, attrs)
+            end
           elsif reflection.has_one?
             add_attributes_for_has_one_association(reflection, attrs)
           elsif reflection.collection?
-            add_attributes_for_collection_association(reflection, attrs)
+            add_attributes_for_collection_association(reflection, attrs, arel_table)
           end
         end
       end
@@ -29,7 +33,7 @@ module ActiveRecord
     end
     
     def add_attributes_for_belongs_to_association(reflection, attrs)
-      key = :"add_attributes_for_belongs_to_association#{reflection.name}"
+      key = :"add_attributes_for_belongs_to_association_#{reflection.name}"
       @_already_called ||= {}
       return if @_already_called[key]
       @_already_called[key]=true
@@ -47,11 +51,11 @@ module ActiveRecord
           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
+                attrs[Arel::Attributes::Relation.new(k, reflection.name, false, true)] = 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
+                attrs[Arel::Attributes::Relation.new(k, reflection.name, false, true)] = v
               end
             end
           end
@@ -84,11 +88,11 @@ module ActiveRecord
 
             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
+                attrs[Arel::Attributes::Relation.new(k, reflection.name, false, true)] = 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
+                attrs[Arel::Attributes::Relation.new(k, reflection.name, false, true)] = v
               end
             end
           end
@@ -96,7 +100,7 @@ module ActiveRecord
       end
     end
     
-    def add_attributes_for_collection_association(reflection, attrs)
+    def add_attributes_for_collection_association(reflection, attrs, arel_table=nil)
       key = :"add_attributes_for_collection_association#{reflection.name}"
       @_already_called ||= {}
       return if @_already_called[key]
@@ -108,22 +112,22 @@ module ActiveRecord
       
       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?
+        attrs[Arel::Attributes::EmptyRelation.new(arel_table, reflection.name, true, true)] = [] if association.target.empty?
+        
+        association.target.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
+          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, true)] = 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, true)] = v
             end
-
           end
+
         end
 
         # reconstruct the scope now that we know the owner's id

data/ext/active_record/callbacks.rb

@@ -0,0 +1,17 @@
+module ActiveRecord
+  module Callbacks
+    private
+
+      def create_or_update(*) #:nodoc:
+        if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+          @_already_called ||= {}
+          self.class.reflect_on_all_associations.each do |r|
+            @_already_called[:"autosave_associated_records_for_#{r.name}"] = true
+          end
+        end
+
+        _run_save_callbacks { super }
+      end
+
+  end
+end

data/ext/active_record/finder_methods.rb

@@ -1,3 +1,41 @@
+module Arel
+  module Visitors
+    class ToSql < Arel::Visitors::Reduce
+      
+      def visit_Arel_Attributes_Relation o, collector
+        visit(o.relation, collector)
+      end
+      
+    end
+  end
+end
+
+module ActiveRecord
+  class PredicateBuilder # :nodoc:
+
+    def expand_from_hash(attributes)
+      return ["1=0"] if attributes.empty?
+  
+      attributes.flat_map do |key, value|
+        if value.is_a?(Hash)
+          ka = associated_predicate_builder(key).expand_from_hash(value)
+          if self.table.instance_variable_get(:@klass).connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+            ka.each { |k|
+              if k.left.is_a?(Arel::Attributes::Attribute) || k.left.is_a?(Arel::Attributes::Relation)
+                k.left = Arel::Attributes::Relation.new(k.left, key)
+              end
+            }
+          end
+          ka
+        else
+          expand(key, value)
+        end
+      end
+    end
+
+  end
+end
+
 module ActiveRecord
   module FinderMethods
 
@@ -20,7 +58,11 @@ module ActiveRecord
           []
         else
           arel = relation.arel
-          rows = connection.select_all(arel, 'SQL', arel.bind_values + relation.bound_attributes)
+          rows = if connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+            connection.select_all(arel, 'SQL', arel.bind_values + relation.bound_attributes)
+          else
+            connection.select_all(arel, 'SQL', relation.bound_attributes)
+          end
           if join_dependency
             join_dependency.instantiate(rows, aliases)
           else
@@ -37,7 +79,7 @@ module ActiveRecord
         }
       }
 
-      model_cache = Hash.new { |h,klass| h[klass] = {} }
+      model_cache = Hash.new { |h,kklass| h[kklass] = {} }
       parents = model_cache[self.base_class]
 
       result_set.each { |row_hash|

data/ext/active_record/persistence.rb

@@ -4,10 +4,36 @@ module ActiveRecord
     private
 
     def create_or_update(*args)
+      @updating = new_record? ? :creating : :updating
+      $updating_model = self
+
       raise ReadOnlyRecord, "#{self.class} is marked as readonly" if readonly?
       result = new_record? ? _create_record : _update_record(*args)
+
+      if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter) && result != 0
+        row_hash = result.rows.first
+
+        seen = Hash.new { |h, parent_klass|
+          h[parent_klass] = Hash.new { |i, parent_id|
+            i[parent_id] = Hash.new { |j, child_klass| j[child_klass] = {} }
+          }
+        }
+
+        model_cache = Hash.new { |h,klass| h[klass] = {} }
+        parents = model_cache[self.class.base_class]
+        
+        self.assign_attributes(row_hash.select{|k,v| self.class.column_names.include?(k.to_s) })
+        row_hash.select{|k,v| !self.class.column_names.include?(k.to_s) }.each do |relation_name, value|
+          assc = association(relation_name.to_sym)
+          assc.reset if assc.reflection.collection?
+        end
+
+        construct(self, row_hash.select{|k,v| !self.class.column_names.include?(k.to_s) }, seen, model_cache)
+      end
+
       result != false
-    rescue Sunstone::Exception::BadRequest => e
+    # TODO: perhaps this can go further down the stack?
+    rescue Sunstone::Exception::BadRequest, Sunstone::Exception::Forbidden => e
       JSON.parse(e.message)['errors'].each do |field, message|
         if message.is_a?(Array)
           message.each { |m| errors.add(field, m) }
@@ -16,6 +42,106 @@ module ActiveRecord
         end
       end
       raise ActiveRecord::RecordInvalid
+    ensure
+      @updating = false
+      $updating_model = nil
+    end
+    
+    # Creates a record with values matching those of the instance attributes
+    # and returns its id.
+    def _create_record(attribute_names = self.attribute_names)
+      attributes_values = arel_attributes_with_values_for_create(attribute_names)
+      
+      new_id = self.class.unscoped.insert attributes_values
+
+      @new_record = false
+      
+      if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
+        new_id
+      else
+        self.id ||= new_id if self.class.primary_key
+        id
+      end
+    end
+    
+    #!!!! TODO: I am duplicated from finder_methods.....
+    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!
+        else
+          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
+        end
+
+        if !reflection.collection?
+          construct_association(parent, reflection, attributes, seen, model_cache)
+        else
+          attributes.each do |row|
+            construct_association(parent, reflection, row, seen, model_cache)
+          end
+        end
+
+      end
+    end
+    
+    #!!!! TODO: I am duplicated from finder_methods.....
+    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
+        reflection.klass
+      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
+          other.target = model
+        end
+
+        other.set_inverse_instance(model)
+      else
+        model = construct_model(parent, reflection, id, attributes.select{|k,v| klass.column_names.include?(k.to_s) }, seen, model_cache)
+        seen[parent.class.base_class][parent.id][model.class.base_class][id] = model
+        construct(model, attributes.select{|k,v| !klass.column_names.include?(k.to_s) }, seen, model_cache)
+      end
+    end
+
+    #!!!! TODO: I am duplicated from finder_methods.....
+    def construct_model(record, reflection, id, attributes, seen, model_cache)
+      klass = if reflection.polymorphic?
+        record.send(reflection.foreign_type).constantize
+      else
+        reflection.klass
+      end
+
+      model = model_cache[klass][id] ||= klass.instantiate(attributes)
+      other = record.association(reflection.name)
+
+      if reflection.collection?
+        other.target.push(model)
+      else
+        other.target = model
+      end
+
+      other.set_inverse_instance(model)
+      model
     end
+    
   end
 end