sunstone 6.0.0.4 → 6.1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ecbeb6967817d2f58c9602526839eeee2b9aa161dc00adf1f962549874c49af
-  data.tar.gz: 7759fa8e537ae1dd04009dca78ae7ffad19cbb6166629e99778f2b22aa982837
+  metadata.gz: 52f0e0a557ddc1ec6d7dcc9728d3cfbf602d8c467d1647571cb887b56755e3cc
+  data.tar.gz: 8db1bd8849700b80328ac2cf1248ff5260659d0afc49648e694fae33790c79cc
 SHA512:
-  metadata.gz: c72e778804a92ea85dadd3f7adbae2f5171ca63c47da09b065dcb9c14202a8d78e9ecd95ad15f7b2f0bfe7384a858497a1758b056112f703cc87fb8dd91607dd
-  data.tar.gz: 26d94406a0f9b50ad8429c0dd5d49d3da1fd182e1b8b12d87d6e0f0604f343f0920a10b6f0597b4830e3d6856cf62e36b65382e081381f6d5e9b196e94f28c72
+  metadata.gz: a656ce5545ac0ad4a3f660f61857e8068a9c1f59060d4e9f9f06b1d80d2f6daca73e3317e02b35669a100ea1f8c578695f8ca0cc3a9eb2f00fc908708c1d18ff
+  data.tar.gz: 3395da82c6d52adc2029570a459f98cb7311c428a3f92c9f598d61ae8f0b7c5c7a354bb4d88933a6096e2cd5271997f929535f9ad2a35cda2c066d59472dae72

data/.github/workflows/main.yml

@@ -0,0 +1,141 @@
+name: CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  sunstone:
+    name: Sunstone Test
+    runs-on: ubuntu-20.04
+
+    steps:
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.0
+
+      - uses: actions/checkout@v2
+
+      - run: bundle
+
+      - run: bundle exec rake test
+
+  ar-postgresql:
+    name: ActiveRecord PostgresQL Test
+    strategy:
+      matrix:
+        rails: [v6.1.3]
+        
+    runs-on: ubuntu-20.04
+
+    steps:
+      - name: Install Postgresql
+        run: |
+          sudo apt-get install curl ca-certificates gnupg
+          curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -
+          sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
+          sudo apt-get update
+          sudo apt-get install postgresql-13
+          sudo systemctl start postgresql@13-main.service
+          sudo -u postgres createuser runner --superuser
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.0
+          
+      - uses: actions/checkout@v2
+    
+      - name: Download Rails
+        run: |
+          git clone --branch ${{ matrix.rails }} https://github.com/rails/rails.git ~/rails
+          pushd ~/rails
+          cat /home/runner/work/_temp/*.sh
+          sed -i "s/Gem.ruby, '-w'/Gem.ruby, '-w0'/" ~/rails/activerecord/Rakefile
+          sed -i "s/t.warning = true/t.warning = false/g" ~/rails/activerecord/Rakefile
+          sed -i "/require 'support\/connection'/a \$LOAD_PATH.unshift\(File.expand_path\(ENV['GITHUB_WORKSPACE']\)\)\nrequire 'sunstone'" ~/rails/activerecord/test/cases/helper.rb
+          rm ~/rails/Gemfile.lock
+          sed -i "/# Active Record./a gem 'sunstone', path: File.expand_path\(ENV['GITHUB_WORKSPACE']\)" ~/rails/Gemfile
+          cat ~/rails/Gemfile
+          bundle update --jobs=3 --retry=3
+
+      - run: |
+          pushd ~/rails/activerecord
+          bundle exec rake db:postgresql:rebuild postgresql:test
+          bundle exec rake db:postgresql:rebuild postgresql:isolated_test
+          
+  ar-sqlite:
+    name: ActiveRecord SQLite Test
+    strategy:
+      matrix:
+        rails: [v6.1.3]
+        
+    runs-on: ubuntu-20.04
+
+    steps:
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.0
+          
+      - uses: actions/checkout@v2
+    
+      - name: Download Rails
+        run: |
+          git clone --branch ${{ matrix.rails }} https://github.com/rails/rails.git ~/rails
+          pushd ~/rails
+          cat /home/runner/work/_temp/*.sh
+          sed -i "s/Gem.ruby, '-w'/Gem.ruby, '-w0'/" ~/rails/activerecord/Rakefile
+          sed -i "s/t.warning = true/t.warning = false/g" ~/rails/activerecord/Rakefile
+          sed -i "/require 'support\/connection'/a \$LOAD_PATH.unshift\(File.expand_path\(ENV['GITHUB_WORKSPACE']\)\)\nrequire 'sunstone'" ~/rails/activerecord/test/cases/helper.rb
+          rm ~/rails/Gemfile.lock
+          sed -i "/# Active Record./a gem 'sunstone', path: File.expand_path\(ENV['GITHUB_WORKSPACE']\)" ~/rails/Gemfile
+          cat ~/rails/Gemfile
+          bundle update --jobs=3 --retry=3
+
+      - run: |
+          pushd ~/rails/activerecord
+          bundle exec rake sqlite3:test
+          rm test/db/*.sqlite3 test/fixtures/*.sqlite3
+          bundle exec rake sqlite3:isolated_test
+          rm test/db/*.sqlite3 test/fixtures/*.sqlite3
+          bundle exec rake sqlite3_mem:test
+        
+  ar-mysql:
+    name: ActiveRecord MySQL Test
+    strategy:
+      matrix:
+        rails: [v6.1.3]
+        
+    runs-on: ubuntu-20.04
+
+    steps:
+      - name: Install MySQL
+        run: |
+          sudo /etc/init.d/mysql start
+          mysql -uroot -proot -e "CREATE USER 'rails'@'%';"
+          mysql -uroot -proot -e "GRANT ALL PRIVILEGES ON *.* TO 'rails'@'%' WITH GRANT OPTION;"
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.0
+          
+      - uses: actions/checkout@v2
+    
+      - name: Download Rails
+        run: |
+          git clone --branch ${{ matrix.rails }} https://github.com/rails/rails.git ~/rails
+          pushd ~/rails
+          cat /home/runner/work/_temp/*.sh
+          sed -i "s/Gem.ruby, '-w'/Gem.ruby, '-w0'/" ~/rails/activerecord/Rakefile
+          sed -i "s/t.warning = true/t.warning = false/g" ~/rails/activerecord/Rakefile
+          sed -i "/require 'support\/connection'/a \$LOAD_PATH.unshift\(File.expand_path\(ENV['GITHUB_WORKSPACE']\)\)\nrequire 'sunstone'" ~/rails/activerecord/test/cases/helper.rb
+          rm ~/rails/Gemfile.lock
+          sed -i "/# Active Record./a gem 'sunstone', path: File.expand_path\(ENV['GITHUB_WORKSPACE']\)" ~/rails/Gemfile
+          cat ~/rails/Gemfile
+          bundle update --jobs=3 --retry=3
+
+      - run: |
+          pushd ~/rails/activerecord
+          bundle exec rake db:mysql:rebuild mysql2:test
+          bundle exec rake db:mysql:rebuild mysql2:isolated_test

data/README.md

@@ -1,8 +1,44 @@
-# Sunstone  [![Travis CI](https://travis-ci.org/malomalo/sunstone.svg)](https://travis-ci.org/malomalo/sunstone)
+# Sunstone
 
-An [ActiveRecord](https://rubygems.org/gems/activerecord) adapter for quering
-APIs over Standard API (https://github.com/waratuman/standardapi).
+Sunstone is an [ActiveRecord](https://rubygems.org/gems/activerecord) adapter for quering
+APIs conforming to [Standard API](https://github.com/waratuman/standardapi).
 
+Configuration
+-------------
+
+### Rails
+
+Add `sunstone` to your Gemfile:
+
+```ruby
+gem 'sunstone'
+```
+
+Update `config/database.yml`"
+
+```yaml
+development:
+  adapter: sunstone
+  url: https://mystanda.rd/api
+  api_key: ..optional..
+  user_agent: ..optional..
+```
+
+### Standalone ActiveRecord
+
+Initialize the connection on `ActiveRecord::Base` or your abstract model (`ApplicationRecord` for example)
+
+```ruby
+ActiveRecord::Base.establish_connection(
+  adapter: 'sunstone',
+  url: 'https://mystanda.rd/api'
+)
+```
+
+Usage
+-----
+
+Mention fitler / etc...
 
 TODO:
 =====

data/ext/active_record/associations.rb

@@ -35,11 +35,11 @@ module ActiveRecord
         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|
+        [:before_add, :after_add, :before_remove, :after_remove, :autosave, :validate, :join_table, :class_name, :extend, :strict_loading].each do |k|
           hm_options[k] = options[k] if options.key? k
         end
 
-        has_many name, scope, hm_options, &extension
+        has_many name, scope, **hm_options, &extension
         _reflections[name.to_s].parent_reflection = habtm_reflection
       end
     end

data/ext/active_record/attribute_methods.rb

@@ -6,8 +6,8 @@ module ActiveRecord
     # Returns a Hash of the Arel::Attributes and attribute values that have been
     # typecasted for use in an Arel insert/update method.
     def attributes_with_values(attribute_names)
-      attrs = attribute_names.each_with_object({}) do |name, attrs|
-        attrs[name] = _read_attribute(name)
+      attrs = attribute_names.index_with do |name|
+        _read_attribute(name)
       end
 
       if self.class.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)

data/ext/active_record/callbacks.rb

@@ -2,7 +2,7 @@ module ActiveRecord
   module Callbacks
     private
 
-      def create_or_update(*) #:nodoc:
+      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|

data/ext/active_record/finder_methods.rb

@@ -1,24 +1,12 @@
-module Arel
-  module Visitors
-    class ToSql < Arel::Visitors::Visitor
-      
-      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)
+    def expand_from_hash(attributes, &block)
       return ["1=0"] if attributes.empty?
   
       attributes.flat_map do |key, value|
         if value.is_a?(Hash) && !table.has_column?(key)
-          ka = associated_predicate_builder(key).expand_from_hash(value)
+          ka = table.associated_table(key, &block).predicate_builder.expand_from_hash(value.stringify_keys)
           if self.send(: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)
@@ -40,13 +28,18 @@ module ActiveRecord
               value = [value] unless value.is_a?(Array)
               klass = PolymorphicArrayValue
             end
+          elsif associated_table.through_association?
+            next associated_table.predicate_builder.expand_from_hash(
+              associated_table.primary_key => value
+            )
           end
 
           klass ||= AssociationQueryValue
-          queries = klass.new(associated_table, value).queries.map do |query|
-            expand_from_hash(query).reduce(&:and)
+          queries = klass.new(associated_table, value).queries.map! do |query|
+            expand_from_hash(query)
           end
-          queries.reduce(&:or)
+
+          grouping_queries(queries)
         elsif table.aggregated_with?(key)
           mapping = table.reflect_on_aggregation(key).mapping
           values = value.nil? ? [nil] : Array.wrap(value)
@@ -55,17 +48,18 @@ module ActiveRecord
             values = values.map do |object|
               object.respond_to?(aggr_attr) ? object.public_send(aggr_attr) : object
             end
-            build(table.arel_attribute(column_name), values)
+            self[column_name, values]
           else
             queries = values.map do |object|
               mapping.map do |field_attr, aggregate_attr|
-                build(table.arel_attribute(field_attr), object.try!(aggregate_attr))
-              end.reduce(&:and)
+                self[field_attr, object.try!(aggregate_attr)]
+              end
             end
-            queries.reduce(&:or)
+
+            grouping_queries(queries)
           end
         else
-          build(table.arel_attribute(key), value)
+          self[key, value]
         end
       end
     end
@@ -89,7 +83,7 @@ module ActiveRecord
         relation
       end
       
-      def instantiate(result_set, &block)
+      def instantiate(result_set, strict_loading_value, &block)
         seen = Hash.new { |i, object_id|
           i[object_id] = Hash.new { |j, child_class|
             j[child_class] = {}
@@ -110,14 +104,14 @@ module ActiveRecord
           result_set.each { |row_hash|
             parent_key = @klass.primary_key ? row_hash[@klass.primary_key] : row_hash
             parent = parents[parent_key] ||= @klass.instantiate(row_hash.select{|k,v| @klass.column_names.include?(k.to_s) }, &block)
-            construct(parent, row_hash.select{|k,v| !@klass.column_names.include?(k.to_s) }, seen, model_cache)
+            construct(parent, row_hash.select{|k,v| !@klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
           }
         end
 
         parents.values
       end
 
-      def construct(parent, relations, seen, model_cache)
+      def construct(parent, relations, seen, model_cache, strict_loading_value)
         relations.each do |key, attributes|
           reflection = parent.class.reflect_on_association(key)
           next unless reflection
@@ -128,22 +122,22 @@ module ActiveRecord
           else
             if parent.association_cached?(reflection.name)
               model = parent.association(reflection.name).target
-              construct(model, attributes.select{|k,v| !model.class.column_names.include?(k.to_s) }, seen, model_cache)
+              construct(model, attributes.select{|k,v| !model.class.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
             end
           end
 
           if !reflection.collection?
-            construct_association(parent, reflection, attributes, seen, model_cache)
+            construct_association(parent, reflection, attributes, seen, model_cache, strict_loading_value)
           else
             attributes.each do |row|
-              construct_association(parent, reflection, row, seen, model_cache)
+              construct_association(parent, reflection, row, seen, model_cache, strict_loading_value)
             end
           end
 
         end
       end
 
-      def construct_association(parent, reflection, attributes, seen, model_cache)
+      def construct_association(parent, reflection, attributes, seen, model_cache, strict_loading_value)
         return if attributes.nil?
 
         klass = if reflection.polymorphic?
@@ -155,7 +149,7 @@ module ActiveRecord
         model = seen[parent.object_id][klass][id]
 
         if model
-          construct(model, attributes.select{|k,v| !klass.column_names.include?(k.to_s) }, seen, model_cache)
+          construct(model, attributes.select{|k,v| !klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
 
           other = parent.association(reflection.name)
 
@@ -167,14 +161,14 @@ module ActiveRecord
 
           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)
+          model = construct_model(parent, reflection, id, attributes.select{|k,v| klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
           seen[parent.object_id][model.class.base_class][id] = model
-          construct(model, attributes.select{|k,v| !klass.column_names.include?(k.to_s) }, seen, model_cache)
+          construct(model, attributes.select{|k,v| !klass.column_names.include?(k.to_s) }, seen, model_cache, strict_loading_value)
         end
       end
 
 
-      def construct_model(record, reflection, id, attributes, seen, model_cache)
+      def construct_model(record, reflection, id, attributes, seen, model_cache, strict_loading_value)
         klass = if reflection.polymorphic?
           record.send(reflection.foreign_type).constantize
         else
@@ -202,11 +196,22 @@ module ActiveRecord
         relation = except(:includes, :eager_load, :preload)
         relation.arel.eager_load = Arel::Nodes::EagerLoad.new(eager_load_values)
       else
-        join_dependency = construct_join_dependency(eager_load_values + includes_values)
+        join_dependency = construct_join_dependency(
+          eager_load_values | includes_values, Arel::Nodes::OuterJoin
+        )
         relation = except(:includes, :eager_load, :preload).joins!(join_dependency)
       end
 
-      if eager_loading && !using_limitable_reflections?(join_dependency.reflections)
+      if eager_loading && !(
+          using_limitable_reflections?(join_dependency.reflections) &&
+          using_limitable_reflections?(
+            construct_join_dependency(
+              select_association_list(joins_values).concat(
+                select_association_list(left_outer_joins_values)
+              ), nil
+            ).reflections
+          )
+      )
         if has_limit_or_offset?
           limited_ids = limited_ids_for(relation)
           limited_ids.empty? ? relation.none! : relation.where!(primary_key => limited_ids)

data/ext/active_record/persistence.rb

@@ -105,6 +105,8 @@ module ActiveRecord
         @_trigger_update_callback = affected_rows == 1
       end
 
+      @previously_new_record = false
+
       yield(self) if block_given?
 
       affected_rows

data/ext/active_record/relation/calculations.rb

@@ -5,13 +5,13 @@ module ActiveRecord
       if loaded? && (column_names.map(&:to_s) - @klass.attribute_names - @klass.attribute_aliases.keys).empty?
         return records.pluck(*column_names)
       end
-
+      
       if has_include?(column_names.first)
         relation = apply_join_dependency
         relation.pluck(*column_names)
       elsif klass.connection.is_a?(ActiveRecord::ConnectionAdapters::SunstoneAPIAdapter)
         load
-        return records.pluck(*column_names.map{|n| n.sub(/^#{klass.table_name}\./, "")})
+        return records.pluck(*column_names.map{|n| n.to_s.sub(/^#{klass.table_name}\./, "")})
       else
         klass.disallow_raw_sql!(column_names)
         relation = spawn

data/ext/active_record/statement_cache.rb

@@ -5,10 +5,9 @@ module ActiveRecord
       def initialize(values, sunstone=false)
         @values = values
         @indexes = if sunstone
-          
         else
-          values.each_with_index.find_all { |thing,i|
-            Arel::Nodes::BindParam === thing
+          values.each_with_index.find_all { |thing, i|
+            Substitute === thing
           }.map(&:last)
         end
       end
@@ -19,8 +18,13 @@ module ActiveRecord
           @values
         else
           val = @values.dup
-          casted_binds = binds.map(&:value_for_database)
-          @indexes.each { |i| val[i] = connection.quote(casted_binds.shift) }
+          @indexes.each do |i|
+            value = binds.shift
+            if ActiveModel::Attribute === value
+              value = value.value_for_database
+            end
+            val[i] = connection.quote(value)
+          end
           val.join
         end
       end