hyper-mesh 0.4.0

data/reactive_record_test_app/spec_dont_run/moved_to_main_spec_dir/zzzupdate_associations_spec_moved.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+
+describe "updating associations" do
+
+  before(:all) do
+    React::IsomorphicHelpers.load_context
+    User.new({first_name: "Jon", last_name: "Weaver"})
+  end
+
+  it "a new model will have empty has_many assocation" do
+    jon =  User.find_by_first_name("Jon")
+    expect(jon.todo_items).to be_empty
+  end
+
+  it "an item can be added to a has_many association" do
+    jon = User.find_by_first_name("Jon")
+    result = (jon.todo_items << (item = TodoItem.new({title: "Jon's first todo!"})))
+    expect(result).to be(jon.todo_items)
+    expect(jon.todo_items.count).to be(1)
+  end
+
+  async "it will persist the new has_many association" do
+    User.find_by_first_name("Jon").save do
+      React::IsomorphicHelpers.load_context
+      ReactiveRecord.load do
+        User.find_by_first_name("Jon").todo_items.count
+      end.then do | count |
+        async { expect(count).to be(1) }
+      end
+    end
+  end
+
+  it "and will reconstruct the association and values on reloading" do
+    ReactiveRecord.load do
+      User.find_by_first_name("Jon").todo_items.collect { | todo | todo.title }
+    end.then do | titles |
+      expect(titles).to eq(["Jon's first todo!"])
+    end
+  end # BROKEN BROKEN
+
+  it "the inverse belongs_to association will be set" do
+    todo = TodoItem.find_by_title("Jon's first todo!")
+    expect(todo.user.first_name).to eq("Jon")
+  end
+
+  it "a model can be moved to a new owner, and will be removed from the old owner" do
+    TodoItem.find_by_title("Jon's first todo!").user = User.new({first_name: "Jan", last_name: "VanDuyn"})
+    expect(User.find_by_first_name("Jon").todo_items).to be_empty
+  end
+
+  it "and will belong to the new owner" do
+    expect(User.find_by_first_name("Jan").todo_items.all == [TodoItem.find_by_title("Jon's first todo!")]).to be_truthy
+  end
+
+  async "and can be saved and it will remember its new owner" do
+    TodoItem.find_by_title("Jon's first todo!").save do
+      React::IsomorphicHelpers.load_context
+      ReactiveRecord.load do
+        TodoItem.find_by_title("Jon's first todo!").user.first_name
+      end.then do | first_name |
+        async { expect(first_name).to be("Jan") }
+      end
+    end
+  end # MAYBE BROKEN PREVIOUS BREAK CAUSING????
+
+  it "and after saving will have been removed from original owners association" do
+    ReactiveRecord.load do
+      User.find_by_first_name("Jon").todo_items.all
+    end.then do | todos |
+      expect(todos).to be_empty
+    end
+  end
+
+  it "a belongs to association can be set to nil and the model saved" do
+    todo = TodoItem.find_by_title("Jon's first todo!")
+    todo.user = nil
+    todo.save.then do | response |
+      expect(response[:success]).to be_truthy
+    end
+  end
+
+  it "and will not belong to the previous owner anymore" do
+    React::IsomorphicHelpers.load_context
+    ReactiveRecord.load do
+      TodoItem.find_by_title("Jon's first todo!").user # load the todo in prep for the next test
+      User.find_by_first_name("Jan").todo_items.all.count
+    end.then do |count|
+      expect(count).to be(0)
+    end
+  end
+
+  it "but can be reassigned to the previous owner" do
+    todo = TodoItem.find_by_title("Jon's first todo!")
+    todo.user = User.find_by_first_name("Jan")
+    todo.save.then do | response |
+      expect(response[:success]).to be_truthy
+    end
+  end
+
+  it "and a model in a belongs_to relationship can be deleted" do
+    User.find_by_first_name("Jan").todo_items.first.destroy.then do
+      expect(User.find_by_first_name("Jan").todo_items).to be_empty
+    end
+  end
+
+  it "and it won't exist" do
+    React::IsomorphicHelpers.load_context
+    ReactiveRecord.load do
+      TodoItem.find_by_title("Jon's first todo!").id
+    end.then do | id |
+      expect(id).to be_nil
+    end
+  end
+
+  it "an item in a belongs_to relationship can be created without belonging to anybody" do
+    nobodys_business = TodoItem.new({title: "round to it"})
+    nobodys_business.save.then do |saved|
+      expect(saved).to be_truthy
+    end
+  end
+
+  it "and can be reloaded" do
+    React::IsomorphicHelpers.load_context
+    ReactiveRecord.load do
+      TodoItem.find_by_title("round to it").id
+    end.then do |id|
+      expect(id).not_to be_nil
+    end
+  end
+
+  it "and can be deleted" do
+    TodoItem.find_by_title("round to it").destroy.then do
+      expect(TodoItem.find_by_title("round to it")).to be_destroyed
+    end
+  end
+
+  after(:all) do
+    Promise.when(User.find_by_first_name("Jan").destroy, User.find_by_first_name("Jon").destroy)
+  end
+
+
+end

data/reactive_record_test_app/spec_dont_run/moved_to_main_spec_dir/zzzupdate_scopes_movedspec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe "updating scopes" do
+
+  # this spec needs some massive cleanup... the rendering tests continue to run... that needs to be fixed
+
+  # the tests depend on each other.
+
+  # there are no test for nested scopes like User.todos.active for example which will certainly fail
+
+  rendering("saving a new record will update .all and cause a rerender") do
+    unless @starting_count
+      TodoItem.all.last.title
+      unless TodoItem.all.count == 1
+        @starting_count = TodoItem.all.count
+
+        after(0.1) do
+          TodoItem.new(title: "play it again sam").save
+        end
+      end
+    end
+    (TodoItem.all.count - (@starting_count || 100)).to_s
+  end.should_generate do
+    html == "1"
+  end
+
+  rendering("destroying records will cause a re-render") do
+    unless @starting_count
+      TodoItem.all.last.title
+      unless TodoItem.all.count == 1
+        @starting_count = TodoItem.all.count
+        after(0.1) do
+          TodoItem.all.last.destroy do
+            TodoItem.all.last.destroy do
+              TodoItem.all.last.destroy do
+                TodoItem.all.last.destroy
+              end
+            end
+          end
+        end
+      end
+    end
+    (TodoItem.all.count - (@starting_count || 100)).to_s
+  end.should_generate do
+    html == "-3"
+  end
+
+end

data/remote.md

@@ -0,0 +1,115 @@
+```ruby
+class Model < ActiveRecord::Base
+
+  def <=>(other)
+    self.text.downcase <=> other.text.downcase
+  end
+
+  scope :sorted, -> { order('lower(text) ASC')}, client: -> { sort }
+
+  scope :proper_nouns, -> { where('lower(text) <> text ')}, client: -> (r) { r.text.downcase != r.text }
+end
+```
+
+if the remote proc takes a param it is given each record to check  (i.e. its wrapped in a select)
+
+if there is no param the proc is executed in context of a collection which it can return a modified version of.
+
+How:
+
+three kinds of scopes:
+
+Base collections (i.e. has_many, all, and unscoped)
+
+outer scopes (i.e. directly following a base collection  Model.sorted === Model.all.sorted parent.children.proper_nouns )
+
+inner scopes (i.e. other scopes that follow outer scopes)
+
+
+First we need to update the base collections based on the changed models.  By definition everything we need to know to update the base scopes is available in the changed record.
+
++ has_many collections get updated by the load_from_json method
++ all, and unscoped get updated by a new method on the class:  update_base_scopes (maybe not needed?  )
+
+Then we need to find all the outer scopes in the world.
+
+To do this whenever an scope is applied, if it is being applied to a base collection (or to a Model itself which is equivilent to applying it Model.all) then it is added to a list, along with its parent base scope.
+
+We can then iterate through this list.
+
+During the iteration we do this:
+
+```ruby
+def update_collections(updated_record, base_collection, local_updates)
+  if this scope is joined with the updated_record
+    if local_updates && updated_record.class = self.class && my_client_proc
+      local_updates << self
+    else
+      update_from_server
+      client_procs = nil
+    end
+  end
+  if children_collections
+    children_collections.each { |child| child.update_collections(udpated_record, base_collection, client_procs)}
+  elsif client_procs
+    client_procs.inject(base_collection) do |collection, scope|
+      dup collection into scope.all
+      either call scope.proc with each record in a select
+      or just call the proc in the context of scope
+    end
+  end
+end
+```
+
+how about initial load?
+
+
+1) if there is client_proc then run it on first load...
+
+filter_most_out_on_server.filter_a_few_out_on_client  <- good
+filter_a_few_out_on_client.filter_most_out_on_server <- blah
+
+fix later...
+or
+as each scope is applied... of course we go back through all parent scopes and clear a filter flag (proc?)
+
+
+then on a load as we add each scope in, we can do the initial filter right then... which is okay because
+we don't have that data yet!!!
+
+or don't even bother, just run the filter as things are replaced from the server...
+
+its static... can always know if something should be filtered
+
+
+arghhh...
+
+Model.filter1.filter2...
+
+its still true that to filter, all scopes in chain must be client filters.
+
+but what is the diff between
+
+Model.inc_filter1.coll_filter1.inc_filter2.coll_filter2
+
+vs.
+
+Model.coll_filter
+
+right because this implies:
+
+Model.all.coll_filter, which means we have to do Model.all.each  
+
+but Model.all.inc_filter should just pass any new/changed entries to inc_filter, and then update the collection
+
+Model.inc_filter1.inc_filter2
+
+is okay because we should not have inc_filter1's collection all updated.
+
+but really?  what if we are doing this:
+
+Model.inc_minor_filter.inc_major_filter.count
+
+We do not have to fetch all inc_minor_filter's collection ever.
+
+We do not have to 

data/spec/component_helpers_xspec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe 'component helpers', js: true do
+
+  it "can mount" do
+
+    mount "MyComponent" do
+      class MyComponent < React::Component::Base
+        class << self
+          attr_accessor :foo
+        end
+        after_mount do
+          self.class.foo = 12
+        end
+        render do
+          "hello"
+        end
+      end
+    end
+    page.evaluate_ruby("MyComponent.foo").should eq(12)
+    page.evaluate_ruby("TestModel").should eq("TestModel")
+  end
+
+  it "can instrument some methods" do
+    mount "MyComponent" do
+      class MyComponent < React::Component::Base
+        def some_method
+          "fact(5) = #{SomeClass.new.fact(5)}"
+        end
+        def render
+          some_method
+        end
+      end
+      class SomeClass
+        def fact(n)
+          n == 1 ? n : fact(n-1) * n
+        end
+      end
+      SomeClass.hypertrace do
+        instrument :all
+        break_on_exit? :fact do |_r, n|
+          puts "self = #{self}"; n == 1
+        end
+      end
+      MyComponent.hypertrace instrument: :all, break_on_exit: [:some_method, :render]
+    end
+    pause
+  end
+end

data/spec/factories/child_model.rb

@@ -0,0 +1,5 @@
+FactoryGirl.define do
+
+  factory :child_model
+
+end

data/spec/factories/comment.rb

@@ -0,0 +1,5 @@
+FactoryGirl.define do
+
+  factory :comment
+
+end

data/spec/factories/test_models.rb

@@ -0,0 +1,5 @@
+FactoryGirl.define do
+
+  factory :test_model
+
+end

data/spec/factories/todo.rb

@@ -0,0 +1,5 @@
+FactoryGirl.define do
+
+  factory :todo
+
+end

data/spec/factories/user.rb

@@ -0,0 +1,5 @@
+FactoryGirl.define do
+
+  factory :user
+
+end

data/spec/reactive_record/edge_cases_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'synchromesh/integration/test_components'
+
+describe "reactive-record edge cases", js: true do
+
+  before(:each) do
+    # spec_helper resets the policy system after each test so we have to setup
+    # before each test
+    stub_const 'TestApplication', Class.new
+    stub_const 'TestApplicationPolicy', Class.new
+    TestApplicationPolicy.class_eval do
+      regulate_all_broadcasts { |policy| policy.send_all }
+      allow_change(to: :all, on: [:create, :update, :destroy]) { true }
+    end
+    size_window(:small, :portrait)
+  end
+
+  it "trims the association tree" do
+    5.times do |i|
+      user = FactoryGirl.create(:user, first_name: i) unless i == 3
+      FactoryGirl.create(:todo, title: "User #{i}'s todo", owner: user)
+    end
+    expect_promise do
+      ReactiveRecord.load do
+        Todo.all.collect do |todo|
+          todo.owner && todo.owner.first_name
+        end.compact
+      end
+    end.to contain_exactly('0', '1', '2', '4')
+  end
+end

data/spec/reactive_record/factory.rb

@@ -0,0 +1,62 @@
+def seed_database
+  users = [
+    ["Mitch", "VanDuyn", "mitch@catprint.com"],
+    ["Todd", "Russell", "todd@catprint.com"],
+    ["Adam", "George", "adamg@catprint.com"],
+    ["Test1", "Test1", "test1@catprint.com"]
+  ]
+
+  users.each do |first_name, last_name, email|
+    User.create({
+      first_name: first_name, last_name: last_name, email: email,
+      address_street: "4348 Culver Road", address_city: "Rochester", address_state: "NY", address_zip: "14617"
+      }
+      #without_protection: true
+    )
+  end
+
+  todo_items = [
+    {
+      title: "a todo for mitch",
+      description: "mitch has a big fat todo to do!",
+      user: User.find_by_email("mitch@catprint.com"),
+      comments: [{user: User.find_by_email("adamg@catprint.com"), comment: "get it done mitch"}]
+    },
+    {
+      title: "another todo for mitch",
+      description: "mitch has too many todos",
+      user: User.find_by_email("mitch@catprint.com")
+    },
+    {
+      title: "do it again Todd",
+      description: "Todd please do that great thing you did again",
+      user: User.find_by_email("todd@catprint.com")
+    },
+    {
+      title: "no user todo",
+      description: "the description"
+    },
+    {
+      title: "test 1 todo 1", description: "test 1 todo 1", user: User.find_by_email("test1@catprint.com"),
+      comments: [
+        {user: User.find_by_email("mitch@catprint.com"), comment: "test 1 todo 1 comment 1"},
+        {user: User.find_by_email("mitch@catprint.com"), comment: "test 1 todo 1 comment 2"}
+      ]
+    },
+    {
+      title: "test 1 todo 2", description: "test 1 todo 2", user: User.find_by_email("test1@catprint.com"),
+      comments: [
+        {user: User.find_by_email("mitch@catprint.com"), comment: "test 1 todo 2 comment 1"},
+        {user: User.find_by_email("mitch@catprint.com"), comment: "test 1 todo 2 comment 2"}
+      ]
+    }
+  ]
+
+  todo_items.each do |attributes|
+    comments = attributes.delete(:comments) || []
+    todo = TodoItem.create(attributes) #, without_protection: true)
+    comments.each do |attributes|
+      Comment.create(attributes.merge(todo_item: todo))
+    end
+  end
+end