hyper-mesh 0.6.0 → 1.0.0.lap22

data/spec/batch4/scoped_todos_spec.rb

@@ -1,167 +0,0 @@
-require 'spec_helper'
-require '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"
-
-    Hyperloop.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
-    #   Hyperloop::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/batch4/synchromesh_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-require 'test_components'
-
-describe "HyperMesh", 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"
-
-    Hyperloop.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 }
-    end
-    size_window(:small, :portrait)
-  end
-
-  it "will synchronize on an attribute update" do
-    mount "TestComponent"
-    FactoryGirl.create(:test_model, test_attribute: "hello")
-    page.should have_content("hello")
-    TestModel.first.update_attribute(:test_attribute, 'goodby')
-    page.should have_content("goodby")
-  end
-
-  describe "the .all method" do
-    before(:each) do
-      mount "TestComponent"
-      5.times { |i| FactoryGirl.create(:test_model, test_attribute: "I am item #{i}") }
-      page.should have_content("5 items")
-    end
-
-    it "will synchronize on create" do
-      TestModel.new(test_attribute: "I'm new here!").save
-      page.should have_content("6 items")
-    end
-
-    it "will synchronize on destroy" do
-      TestModel.first.destroy
-      page.should have_content("4 items")
-    end
-  end
-
-  describe "scopes" do
-    before(:each) do
-      mount "TestComponent", scope: :active
-      5.times { |i| FactoryGirl.create(:test_model, test_attribute: "I am item #{i}", completed: false) }
-      page.should have_content("5 items")
-    end
-
-    it "will synchronize on create" do
-      TestModel.new(test_attribute: "I'm new here!", completed: false).save
-      page.should have_content("6 items")
-    end
-
-    it "will synchronize on destroy" do
-      TestModel.first.destroy
-      page.should have_content("4 items")
-    end
-
-    it "will syncronize on an update" do
-      TestModel.first.update_attribute(:completed, true)
-      page.should have_content("4 items")
-    end
-  end
-end

data/spec/component_helpers_xspec.rb

@@ -1,49 +0,0 @@
-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/examples/dictionary.rb

@@ -1,239 +0,0 @@
-require 'spec_helper'
-require 'test_components'
-
-describe "dictionary examples", js: true do
-
-
-  Hyperloop.configuration do |config|
-    config.transport = :action_cable
-    config.channel_prefix = "synchromesh"
-  end
-
-  before(:all) do
-    class DictionaryEntry < ActiveRecord::Base
-      def self.build_tables
-        connection.create_table(:dictionary_entries, force: true) do |t|
-          t.string :word
-          t.string :pronunciation
-        end
-      end
-    end
-
-    class Definition < ActiveRecord::Base
-      def self.build_tables
-        connection.create_table(:definitions, force: true) do |t|
-          t.integer   :dictionary_entry_id
-          t.text      :definition
-          t.integer   :votes
-        end
-      end
-    end
-
-  end
-
-  before(:each) do
-
-
-    stub_const 'ApplicationPolicy', Class.new
-    ApplicationPolicy.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)
-
-    isomorphic do
-      class DictionaryEntry < ActiveRecord::Base
-        has_many :definitions
-        scope :defined, ->() {joins(:definitions).where('definitions.dictionary_entry_id IS NOT NULL')}
-      end
-      class Definition < ActiveRecord::Base
-        belongs_to :dictionary_entry
-        scope :order_by_votes, ->() { order('votes DESC') }
-      end
-    end
-
-    DictionaryEntry.build_tables
-    Definition.build_tables
-
-    foo = DictionaryEntry.create(word: 'foo', pronunciation: 'foo')
-    Definition.create(
-      definition: 'every programmers favorite symbol',
-      votes: 3, dictionary_entry: foo
-    )
-
-    DictionaryEntry.create(word: 'meaningless')
-
-    bar = DictionaryEntry.create(word: 'bar', pronunciation: 'bahr')
-    Definition.create(
-      definition: 'every programmers 2nd favorite symbol',
-      votes: 2, dictionary_entry: bar
-    )
-    Definition.create(
-      definition: 'every programmers favorite place',
-      votes: 4, dictionary_entry: bar
-    )
-
-    ruby = DictionaryEntry.create(word: 'ruby', pronunciation: 'roo-bee')
-    Definition.create(
-      definition: 'every programmers favorite language',
-      votes: 30, dictionary_entry: ruby
-    )
-    Definition.create(
-      definition: 'a red gem stone',
-      votes: 4, dictionary_entry: ruby
-    )
-
-    hyperloop = DictionaryEntry.create(word: 'hyperloop', pronunciation: 'hahy-per-loop')
-    Definition.create(
-      definition: 'every programmers favorite UI framework',
-      votes: 25, dictionary_entry: hyperloop
-    )
-    Definition.create(
-      definition: 'high speed rail for the 21st century',
-      votes: 24, dictionary_entry: hyperloop
-    )
-
-  end
-
-  it "displays a word" do
-    mount "WordOfTheDay" do
-
-class WordOfTheDay < React::Component::Base
-
-  # The current word displayed is stored in the
-  # entry state variable.   We use a state
-  # variable so that the display will refresh
-  # when the user chooses a new word
-
-  define_state :entry
-
-  def pick_entry!
-    # pick a random word and assign the selected record to entry
-    # the ! will notify react that the state is changing.
-    state.entry! DictionaryEntry.all[rand(DictionaryEntry.count)]
-  end
-
-  # before we mount our component pick the first entry to display
-
-  before_mount :pick_entry!
-
-  render(DIV) do
-    DIV { "Total definitions: #{DictionaryEntry.count}" }
-    DIV do
-      DIV { "word: #{state.entry.word}" }
-      DIV { "pronunciation: #{state.entry.pronunciation}" }
-      definitions
-      AddDefinition(entry: state.entry)
-    end
-    BUTTON { 'pick another' }.on(:click) { pick_entry! }
-  end
-
-  def definitions
-    # Display the ordered list of definitions
-    # note the use of relationships as scopes
-    # To keep things tidy we break out ShowDefinition
-    # as a separate component.
-    OL do
-      state.entry.definitions.order_by_votes.each do |definition|
-        LI { ShowDefinition definition: definition }
-      end
-    end
-  end
-end
-
-class ShowDefinition < React::Component::Base
-
-  # The ShowDefinition component has one param
-  # of type as "Definition". Typing  is not
-  # necessary but will raise a warning if the
-  # type is wrong, so its helpful in debug.
-
-  param :definition, type: Definition
-
-  # display the number of votes and let the user
-  # up or down vote the definition
-
-  render(DIV) do
-    DIV do
-      SPAN { "votes: #{params.definition.votes}" }
-      BUTTON { '+' }.on(:click) { inc_vote(1) }
-      BUTTON { '-' }.on(:click) { inc_vote(-1) }
-    end
-    DIV { params.definition.definition }
-  end
-
-  def inc_vote(amt)
-    # update the votes attribute on the definition
-    # record.  If votes goes to zero destroy the
-    # record, otherwise just save it.
-    params.definition.votes += amt
-    if params.definition.votes.zero?
-      params.definition.destroy
-    else
-      params.definition.save
-    end
-  end
-end
-
-class AddDefinition < React::Component::Base
-
-  # The AddDefinition component takes a
-  # DictionaryEntry, and will allow the user
-  # add a new definition.
-
-  param :entry, type: DictionaryEntry
-
-  # The definition state just holds the current
-  # text that the user has typed.
-
-  # More interesting is adding_definition which
-  # controls whether we diplay a editable text area,
-  # or the 'add new definition' button.
-
-  define_state definition: ''
-  define_state :adding_definition
-
-  def text_area
-    # display the text area and provide  add& cancel buttons
-    DIV do
-      TEXTAREA(rows: 4, cols: 30, value: state.definition)
-      .on(:change) { |e| state.definition! e.target.value }
-
-      BUTTON { 'add' }
-      .on(:click) { add_definition }
-
-      BUTTON { 'cancel' }.on(:click) { state.adding_definition! false }
-    end
-  end
-
-  def add_definition
-    # Use ActiveRecord create to add a new
-    # record.  Using the promise returned by
-    # create we will wait until the operation is
-    # finished to update the UI.
-    Definition.create(
-      definition: state.definition,
-      votes: 1, dictionary_entry: params.entry
-    ).then do
-      state.adding_definition! false
-      state.definition! ''
-    end
-  end
-
-  render do
-    if state.adding_definition
-      text_area
-    else
-      BUTTON { 'add new definition' }
-      .on(:click) { state.adding_definition! true }
-    end
-  end
-end
-    end
-    #binding.pry
-    pause
-  end
-
-end