hyper-mesh 0.4.0

data/spec/synchromesh/examples/random_examples.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+require 'synchromesh/integration/test_components'
+
+describe "random examples", js: true do
+
+  it "can pass an array subclass as a param" do
+    mount "Tester" do
+      class SubArray < Array
+      end
+
+      class HelloWorld < React::Component::Base
+        param :array, type: SubArray
+        render do
+          i = 10
+          div {
+            div { "params.array.is_a? #{params.array.class}" }
+            params.array.each {|i| h1 {i.to_s}}
+          }
+        end
+      end
+
+      class Tester < React::Component::Base
+        def render
+          normal_array = [1, 2]
+          sub_array = SubArray.new
+          sub_array << 1; sub_array << 2
+          DIV do
+            # this works
+            HelloWorld(array: normal_array)
+            # this doesn't
+            DIV { "out here a sub_array is a #{sub_array.class}" }
+            HelloWorld(array: sub_array)
+          end
+        end
+      end
+    end
+    pause
+  end
+
+  it "can destroy on the fly" do
+
+    5.times do |i|
+      FactoryGirl.create(:test_model, test_attribute: "I am model #{i}")
+    end
+
+    mount "RecordsComp" do
+      class RecordsComp < React::Component::Base
+        # you had state.credits as an expression... not sure that is what you wanted
+        render(:div, class: "state.credits") do
+          h2.title { 'Records' }
+          #RecordFormComp()
+          hr { nil }
+          table.table.table_bordered do
+            thead { tr { th { 'Date' }
+                         th { 'Title' }
+                         #th { 'Amount' }
+                         th { 'Actions' } } }
+            tbody do
+              TestModel.each do |record|
+                RecordComp key: record[:id], record: record
+              end
+            end
+          end
+        end
+      end
+
+      class RecordComp < React::Component::Base
+        param :key, type: String
+        param :record, type: TestModel  # type is optional here
+
+        def handle_delete
+          params.record.destroy do |result|
+            alert 'unable to delete record' unless result
+          end
+        end
+
+        def render
+          tr do
+            # currently you should access attributes using
+            # dot notation only.  Currently the [] operator
+            # accesses record values directly without setting up
+            # any reactive response.  This will probably change
+            # with release of Hypermesh
+            td { params.record.created_at }
+            td { params.record.test_attribute }
+            #td { amount_format(params.record[:amount]) }
+            td { a.btn.btn_danger { 'Delete' }.on(:click) { handle_delete } }
+          end
+        end
+
+        def amount_format(amount)
+          '$ ' + amount.to_s.reverse.gsub(/...(?!-)(?=.)/,'\&,').reverse
+        end
+      end
+    end
+
+    pause
+
+  end
+end

data/spec/synchromesh/examples/scoped_todos_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+require 'synchromesh/integration/test_components'
+
+describe "example scopes", js: true do
+
+  before(:all) do
+    require 'pusher'
+    require 'pusher-fake'
+    Pusher.app_id = "MY_TEST_ID"
+    Pusher.key =    "MY_TEST_KEY"
+    Pusher.secret = "MY_TEST_SECRET"
+    require "pusher-fake/support/base"
+
+    HyperMesh.configuration do |config|
+      config.transport = :pusher
+      config.channel_prefix = "synchromesh"
+      config.opts = {app_id: Pusher.app_id, key: Pusher.key, secret: Pusher.secret}.merge(PusherFake.configuration.web_options)
+    end
+  end
+
+  before(:each) do
+    # spec_helper resets the policy system after each test so we have to setup
+    # before each test
+    stub_const 'TestApplicationPolicy', Class.new
+    TestApplicationPolicy.class_eval do
+      always_allow_connection
+      regulate_all_broadcasts { |policy| policy.send_all }
+      allow_change(to: :all, on: [:create, :update, :destroy]) { true }
+    end
+    isomorphic do
+      Todo.class_eval do
+      scope :with_managers_comments,
+            -> { joins(owner: :manager, comments: :author).where('managers_users.id = authors_comments.id').distinct },
+            joins: ['comments.author', 'owner'],
+            client: -> { comments.detect { |comment| comment.author == owner.manager } }
+      end
+      Comment.class_eval do
+        scope :by_manager,
+              -> { joins(todoz: { owner: :manager }).where('managers_users.id = author_id').distinct},
+              joins: ['todoz.owner.manager', 'author'],
+              client: -> { todoz.owner.manager == author }
+      end
+    end
+    size_window(:small, :portrait)
+  end
+
+  it "runs the server side scopes okay" do
+    expect(Todo.with_managers_comments).to be_empty
+    expect(Comment.by_manager).to be_empty
+    boss = FactoryGirl.create(:user, first_name: :boss)
+    employee = FactoryGirl.create(:user, first_name: :fred, manager: boss)
+    todo = FactoryGirl.create(:todo, owner: employee)
+    comment = FactoryGirl.create(:comment, author: boss, todoz: todo)
+    FactoryGirl.create(:comment, author: employee, todoz: todo)
+    FactoryGirl.create(:comment, author: employee, todoz: FactoryGirl.create(:todo, owner: employee))
+    expect(Todo.with_managers_comments).to match_array [todo]
+    expect(Comment.by_manager).to match_array [comment]
+  end
+
+  it "a complex client side scope" do
+
+    mount "TestComponent3" do
+      class UserTodos < React::Component::Base
+        render(DIV) do
+          div { "todos by user with comments" }
+          User.each do |user|
+            DIV do
+              DIV { "#{user.first_name}'s Todos'" }
+              UL do
+                user.assigned_todos.each do |todo|
+                  LI do
+                    todo.title.span
+                    UL do
+                      todo.comments.by_manager.each do |comment|
+                        LI { "MANAGER SAYS: #{comment.comment}" }
+                      end
+                    end unless todo.comments.by_manager.empty?
+                  end; end; end; end; end; end; end
+      class ManagerComments < React::Component::Base
+        render(DIV) do
+          puts "managers have made comments: #{!!Todo.with_managers_comments.any?}"
+          if Todo.with_managers_comments.any?
+            DIV { "managers comments" }
+            UL do
+              Todo.with_managers_comments.each do |todo|
+                DIV do
+                  "#{todo.owner.first_name} - #{todo.title}".span
+                  UL do
+                    todo.comments.each do |comment|
+                      LI { "BOSS SAYS: #{comment.comment}" } if comment.author == todo.owner.manager
+                    end; end; end; end; end
+          else
+            DIV { "no manager comments" }
+          end; end; end
+      class TestComponent3 < React::Component::Base
+        def render
+          puts "RENDERING TESTCOMPONENT3"
+          div do
+            UserTodos {}
+            ManagerComments {}
+          end; end; end; end
+    # evaluate_ruby do
+    #   ReactiveRecord::Collection.hypertrace instrument: :all
+    #   UserTodos.hypertrace instrument: :all
+    # end
+    starting_fetch_time = evaluate_ruby("ReactiveRecord::Base.last_fetch_at")
+    #pause "about to add the boss"
+    boss = FactoryGirl.create(:user, first_name: :boss)
+    #pause "about to add the employee"
+    employee = FactoryGirl.create(:user, first_name: :joe, manager: boss)
+    #pause "about to add the todo"
+    todo = FactoryGirl.create(:todo, title: "joe's todo", owner: employee)
+    wait_for_ajax
+    evaluate_ruby("ReactiveRecord::Base.last_fetch_at").should eq(starting_fetch_time)
+    #pause "adding a comment from the boss"
+    comment = FactoryGirl.create(:comment, comment: "The Boss Speaks", author: boss, todoz: todo)
+    page.should have_content('The Boss Speaks')
+    #pause "added the boss speaks"
+    fred = FactoryGirl.create(:user, role: :employee, first_name: :fred)
+    #pause "fred added"
+    fred.assigned_todos << FactoryGirl.create(:todo, title: 'fred todo')
+    #pause "added another todo to fred" # HAPPENS AFTER HERE.....
+    evaluate_ruby do
+      #   ReactiveRecord::Collection.hypertrace instrument: :all
+      #   UserTodos.hypertrace instrument: :all
+
+      mitch = User.new(first_name: :mitch)
+      mitch.assigned_todos << Todo.new(title: 'mitch todo')
+      mitch.save
+    end
+    wait_for_ajax
+    #pause "mitch added"
+    user1 = FactoryGirl.create(:user, role: :employee, first_name: :frank)
+    user2 = FactoryGirl.create(:user, role: :employee, first_name: :bob)
+    mgr   = FactoryGirl.create(:user, role: :manager, first_name: :sally)
+    #pause "frank, bob, and sally added"
+    user1.assigned_todos << FactoryGirl.create(:todo, title: 'frank todo 1')
+    user1.assigned_todos << FactoryGirl.create(:todo, title: 'frank todo 2')
+    user2.assigned_todos << FactoryGirl.create(:todo, title: 'bob todo 1')
+    user2.assigned_todos << FactoryGirl.create(:todo, title: 'bob todo 2')
+    user1.commentz << FactoryGirl.create(:comment, comment: "frank made this comment", todoz: user2.assigned_todos.first)
+    user2.commentz << FactoryGirl.create(:comment, comment: "bob made this comment", todoz: user1.assigned_todos.first)
+    # evaluate_ruby do
+    #   HyperMesh::IncomingBroadcast.hypertrace do
+    #     break_on_exit?(:merge_current_values) { Todo.find(5).comments.last.todo.nil? rescue nil }
+    #   end
+    #   ReactiveRecord::ScopeDescription.hypertrace do
+    #     break_on_enter?(:filter_records) { Todo.find(5).comments.last.todo.nil? rescue nil }
+    #   end
+    #   ReactiveRecord::Collection.hypertrace do
+    #     break_on_enter?(:all) { Todo.find(5).comments.last.todo.nil? rescue nil }
+    #     break_on_exit?(:all) { Todo.find(5).comments.last.todo.nil? rescue nil }
+    #   end
+    # end
+
+    mgr.commentz << FactoryGirl.create(:comment, comment: "Me BOSS", todoz: user1.assigned_todos.last)
+    page.should have_content('MANAGER SAYS: The Boss Speaks')
+    page.should have_content('BOSS SAYS: The Boss Speaks')
+    wait_for_ajax
+    page.should_not have_content('MANAGER SAYS: Me BOSS', wait: 0)
+    page.should_not have_content('BOSS SAYS: Me BOSS', wait: 0)
+    user1.update_attribute(:manager, mgr)
+    page.should have_content('MANAGER SAYS: Me BOSS')
+    page.should have_content('BOSS SAYS: Me BOSS')
+    evaluate_ruby("ReactiveRecord::Base.last_fetch_at").should eq(starting_fetch_time)
+  end
+end

data/spec/synchromesh/integration/authorization_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+require 'synchromesh/integration/test_components'
+
+describe "authorization integration", js: true do
+
+  before(:all) do
+    # HyperMesh.configuration do |config|
+    #   config.transport = :simple_poller
+    #   # slow down the polling so wait_for_ajax works
+    #   config.opts = { seconds_between_poll: 2 }
+    # end
+
+    require 'pusher'
+    require 'pusher-fake'
+    Pusher.app_id = "MY_TEST_ID"
+    Pusher.key =    "MY_TEST_KEY"
+    Pusher.secret = "MY_TEST_SECRET"
+    require "pusher-fake/support/base"
+
+    HyperMesh.configuration do |config|
+      config.transport = :pusher
+      config.channel_prefix = "synchromesh"
+      config.opts = {app_id: Pusher.app_id, key: Pusher.key, secret: Pusher.secret}.merge(PusherFake.configuration.web_options)
+    end
+
+  end
+
+  after(:all) do
+    ApplicationController.acting_user = nil
+    ActiveRecord::Base.class_eval do
+      def create_permitted?
+        true
+      end
+      def update_permitted?
+        true
+      end
+      def destroy_permitted?
+        true
+      end
+      def view_permitted?(attribute)
+        true
+      end
+    end
+  end
+
+  before(:each) do
+    # spec_helper resets the policy system after each test so we have to setup
+    # before each test
+    stub_const "User", Class.new
+    User.class_eval do
+      include ActiveModel::Model
+      attr_accessor :name
+    end
+    ApplicationController.acting_user = nil
+    stub_const 'TestApplicationPolicy', Class.new
+    TestApplicationPolicy.class_eval do
+      regulate_class_connection { self }
+      regulate_instance_connections(TestModel) { TestModel.find_by_test_attribute(name) }
+      regulate_all_broadcasts { |policy| policy.send_all_but(:completed, :test_attribute) }
+      regulate_broadcast(TestModel) { |policy| policy.send_all_but(:created_at).to(self) }
+    end
+    size_window(:small, :portrait)
+  end
+
+  it "will only synchronize the connected channels" do
+    mount "TestComponent2"
+    model1 = FactoryGirl.create(:test_model, test_attribute: "hello")
+    wait_for_ajax
+    model1.attributes_on_client(page).should eq({id: 1})
+    ApplicationController.acting_user = User.new(name: "fred")
+    page.evaluate_ruby('HyperMesh.connect("TestApplication")')
+    wait_for_ajax
+    model1.update_attribute(:test_attribute, 'george')
+    wait_for_ajax
+    model1.attributes_on_client(page).should eq({
+      id: 1,
+      created_at: model1.created_at.localtime.strftime('%Y-%m-%dT%H:%M:%S%z'),
+      updated_at: model1.updated_at.localtime.strftime('%Y-%m-%dT%H:%M:%S%z')
+    })
+    ApplicationController.acting_user = User.new(name: "george")
+    page.evaluate_ruby("HyperMesh.connect(['TestModel', #{model1.id}])")
+    wait_for_ajax
+    model1.update_attribute(:completed, true)
+    wait_for_ajax
+    model1.attributes_on_client(page).should eq({
+      id: 1, test_attribute: "george", completed: true,
+      created_at: model1.created_at.localtime.strftime('%Y-%m-%dT%H:%M:%S%z'),
+      updated_at: model1.updated_at.localtime.strftime('%Y-%m-%dT%H:%M:%S%z')
+    })
+  end
+
+  it "will fail on illegal class connections" do
+    mount "TestComponent2"
+    model1 = FactoryGirl.create(:test_model, test_attribute: "hello")
+    page.evaluate_ruby('HyperMesh.connect("TestApplication")')
+    model1.update_attribute(:test_attribute, 'george')
+    wait_for_ajax
+    model1.attributes_on_client(page).should eq({id: 1})
+  end
+
+  it "will fail on illegal instance connections" do
+    mount "TestComponent2"
+    model1 = FactoryGirl.create(:test_model, test_attribute: "george")
+    ApplicationController.acting_user = User.new(name: "fred")
+    page.evaluate_ruby("HyperMesh.connect(['TestModel', #{model1.id}])")
+    model1.update_attribute(:completed, true)
+    wait_for_ajax
+    model1.attributes_on_client(page).should eq({id: 1})
+  end
+
+end

data/spec/synchromesh/integration/default_scope_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+require 'synchromesh/integration/test_components'
+
+describe "default_scope" do
+
+  context "client tests", js: true do
+
+    before(:all) do
+      require 'pusher'
+      require 'pusher-fake'
+      Pusher.app_id = "MY_TEST_ID"
+      Pusher.key =    "MY_TEST_KEY"
+      Pusher.secret = "MY_TEST_SECRET"
+      require "pusher-fake/support/base"
+
+      HyperMesh.configuration do |config|
+        config.transport = :pusher
+        config.channel_prefix = "synchromesh"
+        config.opts = {app_id: Pusher.app_id, key: Pusher.key, secret: Pusher.secret}.merge(PusherFake.configuration.web_options)
+      end
+    end
+
+    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
+        always_allow_connection
+        regulate_all_broadcasts { |policy| policy.send_all }
+        allow_change(to: :all, on: [:create, :update, :destroy]) { true }
+      end
+      size_window(:small, :portrait)
+    end
+
+    after(:each) do
+      TestModel.default_scopes = []
+    end
+
+    it "a default scope can be added server side using either a block or proc" do
+      isomorphic do
+        TestModel.class_eval do
+          default_scope -> { where(completed: true) }
+          default_scope { where(test_attribute: 'foo') }
+        end
+      end
+      mount "TestComponent2" do
+        class TestComponent2 < React::Component::Base
+          render(:div) do
+            "#{TestModel.count} items".br
+            "#{TestModel.unscoped.count} unscoped items"
+          end
+        end
+      end
+      page.should have_content("0 items")
+      page.should have_content("0 unscoped items")
+      m1 = FactoryGirl.create(:test_model, completed: false, test_attribute: nil)
+      page.should have_content("0 items")
+      page.should have_content("1 unscoped items")
+      m2 = FactoryGirl.create(:test_model, completed: true, test_attribute: nil)
+      page.should have_content("0 items")
+      page.should have_content("2 unscoped items")
+      m2.update(test_attribute: 'foo')
+      page.should have_content("1 items")
+      page.should have_content("2 unscoped items")
+      m3 = FactoryGirl.create(:test_model)
+      page.should have_content("2 items")
+      page.should have_content("3 unscoped items")
+      m3.update_attribute(:completed, false)
+      page.should have_content("1 items")
+      page.should have_content("3 unscoped items")
+      m2.destroy
+      page.should have_content("0 items")
+      page.should have_content("2 unscoped items")
+    end
+
+    it "a default scope can be added client side" do
+      isomorphic do
+        TestModel.class_eval do
+          default_scope server: -> { where(completed: true) },
+                        client: -> { completed }
+          default_scope server: -> { where(test_attribute: 'foo') },
+                        client: -> { test_attribute == 'foo' }
+        end
+      end
+      mount "TestComponent2" do
+        class TestComponent2 < React::Component::Base
+          render(:div) do
+            "#{TestModel.count} items".br
+            "#{TestModel.unscoped.count} unscoped items"
+          end
+        end
+      end
+      starting_fetch_time = evaluate_ruby("ReactiveRecord::Base.last_fetch_at")
+      page.should have_content("0 items")
+      page.should have_content("0 unscoped items")
+      m1 = FactoryGirl.create(:test_model, completed: false, test_attribute: nil)
+      page.should have_content("0 items")
+      page.should have_content("1 unscoped items")
+      m2 = FactoryGirl.create(:test_model, completed: true, test_attribute: nil)
+      page.should have_content("0 items")
+      page.should have_content("2 unscoped items")
+      m2.update(test_attribute: 'foo')
+      page.should have_content("1 items")
+      page.should have_content("2 unscoped items")
+      m3 = FactoryGirl.create(:test_model)
+      page.should have_content("2 items")
+      page.should have_content("3 unscoped items")
+      m3.update_attribute(:completed, false)
+      page.should have_content("1 items")
+      page.should have_content("3 unscoped items")
+      m2.destroy
+      page.should have_content("0 items")
+      page.should have_content("2 unscoped items")
+      # there should be no client fetches should replace this with a double of
+      # ServerDataCache[] which should not be called
+      wait_for_ajax
+      starting_fetch_time.should eq(evaluate_ruby("ReactiveRecord::Base.last_fetch_at"))
+    end
+  end
+end