closes #113

Author: catmando

ruby/hyper-model/lib/active_record_base.rb

@@ -329,6 +329,10 @@ def __hyperstack_secure_attributes(acting_user)
       %i[limit offset].each do |scope|
         regulate_scope(scope) {}
       end
+
+      finder_method :__hyperstack_internal_scoped_find_by do |hash|
+        find_by(hash)
+      end
     end
   end
 

ruby/hyper-model/lib/reactive_record/active_record/base.rb

@@ -6,5 +6,7 @@ class Base
 
     scope :limit, ->() {}
     scope :offset, ->() {}
+
+    finder_method :__hyperstack_internal_scoped_find_by
   end
 end

ruby/hyper-model/lib/reactive_record/active_record/class_methods.rb

@@ -213,9 +213,6 @@ def scope(name, *args)
       singleton_class.send(:define_method, name) do |*vargs|
         all.build_child_scope(scope_description, *name, *vargs)
       end
-      # singleton_class.send(:define_method, "#{name}=") do |_collection|
-      #   raise 'NO LONGER IMPLEMENTED - DOESNT PLAY WELL WITH SYNCHROMESH'
-      # end
     end
 
     def default_scope(*args, &block)
@@ -261,10 +258,10 @@ def unscoped
     end
 
     def finder_method(name)
-      ReactiveRecord::ScopeDescription.new(self, "_#{name}", {}) # was adding _ to front
+      ReactiveRecord::ScopeDescription.new(self, "_#{name}", {})
       [name, "#{name}!"].each do |method|
         singleton_class.send(:define_method, method) do |*vargs|
-          all.apply_scope("_#{method}", *vargs).first # was adding _ to front
+          all.apply_scope("_#{method}", *vargs).first
         end
       end
     end

ruby/hyper-model/lib/reactive_record/active_record/reactive_record/collection.rb

@@ -252,6 +252,9 @@ def apply_scope(name, *vector)
       collection = build_child_scope(description, *description.name, *vector)
       collection.reload_from_db if name == "#{description.name}!"
       collection
+    rescue
+      debugger
+      nil
     end
 
     def child_scopes
@@ -551,7 +554,7 @@ def method_missing(method, *args, &block)
       elsif ScopeDescription.find(@target_klass, method)
         apply_scope(method, *args)
       elsif args.count == 1 && method.start_with?('find_by_')
-        apply_scope(:find_by, method.sub(/^find_by_/, '') => args.first)
+        apply_scope(:___hyperstack_internal_scoped_find_by, method.sub(/^find_by_/, '') => args.first).first
       elsif @target_klass.respond_to?(method) && ScopeDescription.find(@target_klass, "_#{method}")
         apply_scope("_#{method}", *args).first
       else

ruby/hyper-model/spec/batch3/edge_cases_spec.rb

@@ -123,4 +123,23 @@ class TestComponent77 < HyperComponent
       page.should have_content(todo.title)
     end
   end
+
+  it 'can use find_by method on scopes' do
+    isomorphic do
+      Todo.finder_method :with_title do |title|
+        find_by_title(title)
+      end
+      Todo.scope :completed, -> () { where(completed: true) }
+    end
+    FactoryBot.create(:todo, title: 'todo 1', completed: true)
+    FactoryBot.create(:todo, title: 'todo 2', completed: true)
+    FactoryBot.create(:todo, title: 'todo 1', completed: false)
+    FactoryBot.create(:todo, title: 'todo 2', completed: false)
+    expect_promise do
+      Hyperstack::Model.load do
+        Todo.completed.find_by_title('todo 2').id
+      end
+    end.to eq(Todo.completed.find_by_title('todo 2').id)
+  end
+
 end

ruby/hyper-model/spec/batch7/aaa-unit_tests/ar_basics_tbdspec.rb

@@ -1,126 +1,123 @@
 require 'spec_helper'
-#Opal::RSpec::Runner.autorun
 
-class BaseClass < ActiveRecord::Base
-end
-
-class SubClass < BaseClass
-end
-
-class Funky < ActiveRecord::Base
-  self.primary_key = :funky_id
-  self.inheritance_column = :funky_type
-end
-
-class BelongsTo < ActiveRecord::Base
-  belongs_to :has_many
-  belongs_to :has_one
-  belongs_to :best_friend, class_name: "HasMany", foreign_key: :bf_id
-end
-
-class HasMany < ActiveRecord::Base
-  has_many :belongs_to
-  has_many :best_friends, class_name: "BelongsTo", foreign_key: :bf_id
-end
-
-class HasOne < ActiveRecord::Base
-  has_one :belongs_to
-end
-
-class Scoped < ActiveRecord::Base
-  scope :only_those_guys, -> () {}
-end
+# this never completed conversion from old react.rb days...
+# all this content is tested elsewhere, but it would be nice
+# to have these basic unit tests executing  as well.
 
-describe "ActiveRecord" do
+describe 'ActiveRecord client side basics', js: true do
 
-  before(:all) { Hyperstack::Component::IsomorphicHelpers.load_context }
-
-  after(:each) { React::API.clear_component_class_cache }
-
-  # uncomment if you are having trouble with tests failing.  One non-async test must pass for things to work
-
-  # describe "a passing dummy test" do
-  #   it "passes" do
-  #     expect(true).to be(true)
-  #   end
-  # end
-
-  describe "reactive_record active_record base methods" do
-
-    it "will find the base class" do
-      expect(SubClass.base_class).to eq(BaseClass)
+  before(:all) do
+    class ActiveRecord::Base
+      class << self
+        def public_columns_hash
+          @public_columns_hash ||= {}
+        end
+      end
     end
 
-    it "knows the primary key" do
-      expect(BaseClass.primary_key).to eq(:id)
+    class BaseClass < ActiveRecord::Base
     end
 
-    it "can override the primary key" do
-      expect(Funky.primary_key).to eq(:funky_id)
+    class SubClass < BaseClass
     end
 
-    it "knows the inheritance column" do
-      expect(BaseClass.inheritance_column).to eq(:type)
+    class Funky < ActiveRecord::Base
+      self.primary_key = :funky_id
+      self.inheritance_column = :funky_type
     end
 
-    it "can override the inheritance column" do
-      expect(Funky.inheritance_column).to eq(:funky_type)
+    class BelongsTo < ActiveRecord::Base
+      belongs_to :has_many
+      belongs_to :has_one
+      belongs_to :best_friend, class_name: "HasMany", foreign_key: :bf_id
     end
 
-    it "knows the model name" do
-      expect(BaseClass.model_name).to eq("BaseClass")
+    class HasMany < ActiveRecord::Base
+      has_many :belongs_to
+      has_many :best_friends, class_name: "BelongsTo", foreign_key: :bf_id
     end
 
-    it "can find a record by id" do
-      expect(BaseClass.find(12).id).to eq(12)
+    class HasOne < ActiveRecord::Base
+      has_one :belongs_to
     end
 
-    it "has a find_by_xxx method" do
-      expect(BaseClass.find_by_xxx("beer").xxx).to eq("beer")
+    class Scoped < ActiveRecord::Base
+      scope :only_those_guys, -> () {}
     end
 
-    it "will correctly infer the model type from the inheritance column" do
-      expect(BaseClass.find_by_type("SubClass").class).to eq(SubClass)
-      expect(BaseClass.find_by_type(nil).class).to eq(BaseClass)
-    end
+  end
 
-    it "can have a has_many association" do
-      expect(HasMany.reflect_on_association(:belongs_to).klass.reflect_on_association(:has_many).klass).to eq(HasMany)
-    end
+  it "will find the base class" do
+    expect(SubClass.base_class).to eq(BaseClass)
+  end
 
-    it "can have a has_one association" do
-      expect(HasOne.reflect_on_association(:belongs_to).klass.reflect_on_association(:has_one).klass).to eq(HasOne)
-    end
+  it "knows the primary key" do
+    expect(BaseClass.primary_key).to eq(:id)
+  end
 
-    it "can override the class and foreign_key values when creating an association" do
-      reflection = HasMany.reflect_on_association(:best_friends)
-      expect(reflection.klass).to eq(BelongsTo)
-      expect(reflection.association_foreign_key).to eq(:bf_id)
-    end
+  it "can override the primary key" do
+    expect(Funky.primary_key).to eq(:funky_id)
+  end
 
-    it "can have a scoping method" do
-      expect(Scoped.only_those_guys.respond_to? :all).to be_truthy
-    end
+  it "knows the inheritance column" do
+    expect(BaseClass.inheritance_column).to eq(:type)
+  end
 
-    it "can type check parameters" do
-      expect(SubClass._react_param_conversion({attr1: 1, attr2: 2, type: "SubClass", id: 123}.to_n, :validate_only)).to be(true)
-    end
+  it "can override the inheritance column" do
+    expect(Funky.inheritance_column).to eq(:funky_type)
+  end
 
-    it "can type check parameters with native wrappers" do
-      expect(SubClass._react_param_conversion(Native({attr1: 1, attr2: 2, type: "SubClass", id: 123}.to_n), :validate_only)).to be(true)
-    end
+  it "knows the model name" do
+    expect(BaseClass.model_name).to eq("BaseClass")
+  end
 
-    it "will fail type checking if type does not match" do
-      expect(SubClass._react_param_conversion({attr1: 1, attr2: 2, type: nil, id: 123}.to_n, :validate_only)).to be_falsy
-    end
+  it "can find a record by id" do
+    expect(BaseClass.find(12).id).to eq(12)
+  end
 
-    it "will convert a hash to an instance" do
-      ar = SubClass._react_param_conversion({attr1: 1, attr2: 2, type: "SubClass", id: 123}.to_n)
-      expect(ar.attr1).to eq(1)
-      expect(ar.attr2).to eq(2)
-      expect(ar.id).to eq(123)
-    end
+  it "has a find_by_xxx method" do
+    expect(BaseClass.find_by_xxx("beer").xxx).to eq("beer")
+  end
 
+  it "will correctly infer the model type from the inheritance column" do
+    expect(BaseClass.find_by_type("SubClass").class).to eq(SubClass)
+    expect(BaseClass.find_by_type(nil).class).to eq(BaseClass)
   end
 
+  it "can have a has_many association" do
+    expect(HasMany.reflect_on_association(:belongs_to).klass.reflect_on_association(:has_many).klass).to eq(HasMany)
+  end
+
+  it "can have a has_one association" do
+    expect(HasOne.reflect_on_association(:belongs_to).klass.reflect_on_association(:has_one).klass).to eq(HasOne)
+  end
+
+  it "can override the class and foreign_key values when creating an association" do
+    reflection = HasMany.reflect_on_association(:best_friends)
+    expect(reflection.klass).to eq(BelongsTo)
+    expect(reflection.association_foreign_key).to eq(:bf_id)
+  end
+
+  it "can have a scoping method" do
+    expect(Scoped.only_those_guys.respond_to? :all).to be_truthy
+  end
+
+  it "can type check parameters" do
+    expect(SubClass._react_param_conversion({attr1: 1, attr2: 2, type: "SubClass", id: 123}.to_n, :validate_only)).to be(true)
+  end
+
+  it "can type check parameters with native wrappers" do
+    expect(SubClass._react_param_conversion(Native({attr1: 1, attr2: 2, type: "SubClass", id: 123}.to_n), :validate_only)).to be(true)
+  end
+
+  it "will fail type checking if type does not match" do
+    expect(SubClass._react_param_conversion({attr1: 1, attr2: 2, type: nil, id: 123}.to_n, :validate_only)).to be_falsy
+  end
+
+  it "will convert a hash to an instance" do
+    ar = SubClass._react_param_conversion({attr1: 1, attr2: 2, type: "SubClass", id: 123}.to_n)
+    expect(ar.attr1).to eq(1)
+    expect(ar.attr2).to eq(2)
+    expect(ar.id).to eq(123)
+  end
 end