hyper-mesh 0.4.0

data/spec/reactive_record/update_scopes_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'synchromesh/integration/test_components'
+require 'reactive_record/factory'
+require 'rspec-steps'
+
+RSpec::Steps.steps "updating scopes", js: true do
+
+  before(:all) do
+    seed_database
+  end
+
+  before(:step) 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 "will update .all and rerender after saving a record" do
+    mount "TestComponent" do
+      class TestComponent < React::Component::Base
+        def render
+          #div do
+            "TodoItem.count = #{TodoItem.all.count}".span
+            #ul { TodoItem.each { |todo| li { todo.id.to_s } }}
+          #end
+        end
+      end
+    end
+    starting_count = TodoItem.count
+    expect(page).to have_content("TodoItem.count = #{starting_count}")
+    evaluate_ruby { TodoItem.new(title: "play it again sam").save }
+    expect(page).to have_content("TodoItem.count = #{starting_count+1}")
+  end
+
+  it "destroying records causes a rerender" do
+    count = TodoItem.count
+    while count > 0
+      expect(page).to have_content("TodoItem.count = #{count}")
+      evaluate_ruby do
+        ReactiveRecord.load { TodoItem.last.itself }.then { |todo| todo.destroy }
+      end
+      count -= 1
+    end
+    expect(page).to have_content("TodoItem.count = 0")
+  end
+
+  end

data/spec/spec_helper.rb

@@ -0,0 +1,366 @@
+# spec/spec_helper.rb
+ENV["RAILS_ENV"] ||= 'test'
+
+require 'opal'
+
+def opal?
+  RUBY_ENGINE == 'opal'
+end
+
+def ruby?
+  !opal?
+end
+
+if RUBY_ENGINE == 'opal'
+  require 'hyper-react'
+  require File.expand_path('../support/react/spec_helpers', __FILE__)
+
+  module Opal
+    module RSpec
+      module AsyncHelpers
+        module ClassMethods
+          def rendering(title, &block)
+            klass = Class.new do
+              include React::Component
+
+              def self.block
+                @block
+              end
+
+              def self.name
+                "dummy class"
+              end
+
+              def render
+                instance_eval &self.class.block
+              end
+
+              def self.should_generate(opts={}, &block)
+                sself = self
+                @self.async(@title, opts) do
+                  expect_component_to_eventually(sself, &block)
+                end
+              end
+
+              def self.should_immediately_generate(opts={}, &block)
+                sself = self
+                @self.it(@title, opts) do
+                  element = build_element sself, {}
+                  context = block.arity > 0 ? self : element
+                  expect((element and context.instance_exec(element, &block))).to be(true)
+                end
+              end
+
+            end
+            klass.instance_variable_set("@block", block)
+            klass.instance_variable_set("@self", self)
+            klass.instance_variable_set("@title", "it can render #{title}")
+            klass
+          end
+        end
+      end
+    end
+  end
+
+
+  RSpec.configure do |config|
+    config.include React::SpecHelpers
+    config.filter_run_including :opal => true
+  end
+end
+
+if RUBY_ENGINE != 'opal'
+  require 'pry'
+  begin
+    require File.expand_path('../test_app/config/environment', __FILE__)
+  rescue LoadError
+    puts 'Could not load test application. Please ensure you have run `bundle exec rake test_app`'
+  end
+  require 'rspec/rails'
+  require 'timecop'
+  require "rspec/wait"
+  #require 'pusher-fake/support/base'
+
+  Dir["./spec/support/**/*.rb"].sort.each { |f| require f }
+
+  RSpec.configure do |config|
+    config.color = true
+    config.fail_fast = ENV['FAIL_FAST'] || false
+    config.fixture_path = File.join(File.expand_path(File.dirname(__FILE__)), "fixtures")
+    config.infer_spec_type_from_file_location!
+    config.mock_with :rspec
+    config.raise_errors_for_deprecations!
+
+    # If you're not using ActiveRecord, or you'd prefer not to run each of your
+    # examples within a transaction, comment the following line or assign false
+    # instead of true.
+    config.use_transactional_fixtures = true
+
+    config.after :each do
+      Rails.cache.clear
+    end
+
+    config.after(:each) do |example|
+      unless example.exception
+        #Object.send(:remove_const, :Application) rescue nil
+        ObjectSpace.each_object(Class).each do |klass|
+          if klass < HyperMesh::Regulation
+            klass.instance_variables.each { |v| klass.instance_variable_set(v, nil) }
+          end
+        end
+        PusherFake::Channel.reset if defined? PusherFake
+      end
+    end
+
+    config.filter_run_including focus: true
+    config.filter_run_excluding opal: true
+    config.run_all_when_everything_filtered = true
+  end
+
+  FACTORY_GIRL = false
+
+  #require 'rails_helper'
+  require 'rspec'
+  require 'rspec/expectations'
+  begin
+    require 'factory_girl_rails'
+  rescue LoadError
+  end
+  require 'shoulda/matchers'
+  require 'database_cleaner'
+  require 'capybara/rspec'
+  require 'capybara/rails'
+  require 'support/component_helpers'
+  require 'capybara/poltergeist'
+  require 'selenium-webdriver'
+
+  module React
+    module IsomorphicHelpers
+      def self.load_context(ctx, controller, name = nil)
+        @context = Context.new("#{controller.object_id}-#{Time.now.to_i}", ctx, controller, name)
+      end
+    end
+  end
+
+  #Capybara.default_max_wait_time = 4.seconds
+
+  Capybara.server = :puma
+
+  # The following is deprecated and replaced by the above... just make sure it works
+  # before removing
+  # Capybara.server { |app, port|
+  #   require 'puma'
+  #   Puma::Server.new(app).tap do |s|
+  #     s.add_tcp_listener Capybara.server_host, port
+  #   end.run.join
+  # }
+
+  module WaitForAjax
+
+    def wait_for_ajax
+      Timeout.timeout(Capybara.default_max_wait_time) do
+        begin
+          sleep 0.25
+        end until finished_all_ajax_requests?
+      end
+    end
+
+    def running?
+      result = page.evaluate_script("(function(active) {console.log('jquery is active? '+active); return active})(jQuery.active)")
+      result && !result.zero?
+    rescue Exception => e
+      puts "wait_for_ajax failed while testing state of jQuery.active: #{e}"
+    end
+
+    def finished_all_ajax_requests?
+      unless running?
+        sleep 0.25 # this was 1 second, not sure if its necessary to be so long...
+        !running?
+      end
+    rescue Capybara::NotSupportedByDriverError
+      true
+    rescue Exception => e
+      e.message == "jQuery is not defined"
+    end
+
+  end
+
+  RSpec.configure do |config|
+    config.include WaitForAjax
+  end
+
+  RSpec.configure do |config|
+    # rspec-expectations config goes here. You can use an alternate
+    # assertion/expectation library such as wrong or the stdlib/minitest
+    # assertions if you prefer.
+    config.expect_with :rspec do |expectations|
+      # Enable only the newer, non-monkey-patching expect syntax.
+      # For more details, see:
+      #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+      expectations.syntax = [:should, :expect]
+    end
+
+    # rspec-mocks config goes here. You can use an alternate test double
+    # library (such as bogus or mocha) by changing the `mock_with` option here.
+    config.mock_with :rspec do |mocks|
+      # Enable only the newer, non-monkey-patching expect syntax.
+      # For more details, see:
+      #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+      mocks.syntax = :expect
+
+      # Prevents you from mocking or stubbing a method that does not exist on
+      # a real object. This is generally recommended.
+      mocks.verify_partial_doubles = true
+    end
+
+    config.include FactoryGirl::Syntax::Methods if defined? FactoryGirl
+
+    config.use_transactional_fixtures = false
+
+    Capybara.default_max_wait_time = 10.seconds
+
+    config.before(:suite) do
+      DatabaseCleaner.clean_with(:truncation)
+    end
+
+    config.before(:each) do
+      DatabaseCleaner.strategy = :transaction
+    end
+
+    config.before(:each) do |x|
+      #puts "            RUNNING #{x.full_description}"
+    end
+
+    config.before(:each, :js => true) do
+      DatabaseCleaner.strategy = :truncation
+    end
+
+    config.before(:each, :js => true) do
+      size_window
+    end
+
+    config.before(:each) do
+      DatabaseCleaner.start
+    end
+
+    config.after(:each) do |example|
+      unless example.exception
+        # Clear session data
+        Capybara.reset_sessions!
+        # Rollback transaction
+        DatabaseCleaner.clean
+      end
+    end
+
+    config.after(:all, :js => true) do
+      #size_window(:default)
+    end
+
+    config.after(:each, :js => true) do
+      page.instance_variable_set("@hyper_spec_mounted", false)
+    end
+
+    config.include Capybara::DSL
+
+    Capybara.register_driver :chrome do |app|
+      #caps = Selenium::WebDriver::Remote::Capabilities.chrome("chromeOptions" => {"excludeSwitches" => [ "ignore-certificate-errors" ]})
+      caps = Selenium::WebDriver::Remote::Capabilities.chrome("chromeOptions" => {"args" => [ "--window-size=200,200" ]})
+      Capybara::Selenium::Driver.new(app, :browser => :chrome, :desired_capabilities => caps)
+    end
+
+    options = {
+      js_errors: false,
+      timeout: 180,
+      inspector: true,
+      phantomjs_options: ['--load-images=no', '--ignore-ssl-errors=yes']
+    }
+    options.merge!({phantomjs_logger: StringIO.new, logger: StringIO.new,}) unless ENV['SHOW_LOGS']
+    Capybara.register_driver :poltergeist do |app|
+      Capybara::Poltergeist::Driver.new(app, options)
+    end
+
+    class Selenium::WebDriver::Firefox::Profile
+
+      def self.firebug_version
+        @firebug_version ||= '2.0.13-fx'
+      end
+
+      def self.firebug_version=(version)
+        @firebug_version = version
+      end
+
+      def frame_position
+        @frame_position ||= 'detached'
+      end
+
+      def frame_position=(position)
+        @frame_position = ["left", "right", "top", "detached"].detect do |side|
+          position && position[0].downcase == side[0]
+        end || "detached"
+      end
+
+      def enable_firebug(version = nil)
+        version ||= Selenium::WebDriver::Firefox::Profile.firebug_version
+        add_extension(File.expand_path("../bin/firebug-#{version}.xpi", __FILE__))
+
+        # For some reason, Firebug seems to trigger the Firefox plugin check
+        # (navigating to https://www.mozilla.org/en-US/plugincheck/ at startup).
+        # This prevents it. See http://code.google.com/p/selenium/issues/detail?id=4619.
+        self["extensions.blocklist.enabled"] = false
+
+        # Prevent "Welcome!" tab
+        self["extensions.firebug.showFirstRunPage"] = false
+
+        # Enable for all sites.
+        self["extensions.firebug.allPagesActivation"] = "on"
+
+        # Enable all features.
+        ['console', 'net', 'script'].each do |feature|
+          self["extensions.firebug.#{feature}.enableSites"] = true
+        end
+
+        # Closed by default, will open detached.
+        self["extensions.firebug.framePosition"] = frame_position
+        self["extensions.firebug.previousPlacement"] = 3
+        self["extensions.firebug.defaultPanelName"] = "console"
+
+        # Disable native "Inspect Element" menu item.
+        self["devtools.inspector.enabled"] = false
+        self["extensions.firebug.hideDefaultInspector"] = true
+      end
+    end
+
+    Capybara.register_driver :selenium_with_firebug do |app|
+      profile = Selenium::WebDriver::Firefox::Profile.new
+      profile.frame_position = ENV['DRIVER'] && ENV['DRIVER'][2]
+      profile.enable_firebug
+      Capybara::Selenium::Driver.new(app, :browser => :firefox, :profile => profile)
+    end
+
+    Capybara.javascript_driver = :poltergeist
+
+    Capybara.register_driver :chrome do |app|
+      Capybara::Selenium::Driver.new(app, :browser => :chrome)
+    end
+
+    if ENV['DRIVER'] =~ /^ff/
+      Capybara.javascript_driver = :selenium_with_firebug
+    elsif ENV['DRIVER'] == 'chrome'
+      Capybara.javascript_driver = :chrome
+    else
+      Capybara.javascript_driver = :poltergeist
+    end
+
+    include ComponentTestHelpers
+
+  end
+
+  FactoryGirl.define do
+
+    sequence :seq_number do |n|
+      " #{n}"
+    end
+
+  end if defined? FactoryGirl
+
+end

data/spec/support/component_helpers.rb

@@ -0,0 +1,351 @@
+# see component_test_helpers_spec.rb for examples
+
+require 'parser/current'
+require 'unparser'
+#require 'pry'
+
+module ComponentTestHelpers
+
+  def self.compile_to_opal(&block)
+    Opal.compile(block.source.split("\n")[1..-2].join("\n"))
+  end
+
+
+  TOP_LEVEL_COMPONENT_PATCH = lambda { |&block| Opal.compile(block.source.split("\n")[1..-2].join("\n"))}.call do #ComponentTestHelpers.compile_to_opal do
+    module React
+      class TopLevelRailsComponent
+
+        class << self
+          attr_accessor :event_history
+
+          def callback_history_for(proc_name)
+            event_history[proc_name]
+          end
+
+          def last_callback_for(proc_name)
+            event_history[proc_name].last
+          end
+
+          def clear_callback_history_for(proc_name)
+            event_history[proc_name] = []
+          end
+
+          def event_history_for(event_name)
+            event_history["_on#{event_name.event_camelize}"]
+          end
+
+          def last_event_for(event_name)
+            event_history["_on#{event_name.event_camelize}"].last
+          end
+
+          def clear_event_history_for(event_name)
+            event_history["_on#{event_name.event_camelize}"] = []
+          end
+
+        end
+
+        def component
+          return @component if @component
+          paths_searched = []
+          if params.component_name.start_with? "::"
+            paths_searched << params.component_name.gsub(/^\:\:/,"")
+            @component = params.component_name.gsub(/^\:\:/,"").split("::").inject(Module) { |scope, next_const| scope.const_get(next_const, false) } rescue nil
+            return @component if @component && @component.method_defined?(:render)
+          else
+            self.class.search_path.each do |path|
+              # try each path + params.controller + params.component_name
+              paths_searched << "#{path.name + '::' unless path == Module}#{params.controller}::#{params.component_name}"
+              @component = "#{params.controller}::#{params.component_name}".split("::").inject(path) { |scope, next_const| scope.const_get(next_const, false) } rescue nil
+              return @component if @component && @component.method_defined?(:render)
+            end
+            self.class.search_path.each do |path|
+              # then try each path + params.component_name
+              paths_searched << "#{path.name + '::' unless path == Module}#{params.component_name}"
+              @component = "#{params.component_name}".split("::").inject(path) { |scope, next_const| scope.const_get(next_const, false) } rescue nil
+              return @component if @component && @component.method_defined?(:render)
+            end
+          end
+          @component = nil
+          raise "Could not find component class '#{params.component_name}' for params.controller '#{params.controller}' in any component directory. Tried [#{paths_searched.join(", ")}]"
+        end
+
+        before_mount do
+          TopLevelRailsComponent.event_history = Hash.new {|h,k| h[k] = [] }
+          component.validator.rules.each do |name, rules|
+            if rules[:type] == Proc
+              TopLevelRailsComponent.event_history[name] = []
+              params.render_params[name] = lambda { |*args|  TopLevelRailsComponent.event_history[name] << args.collect { |arg| Native(arg).to_n } }
+            end
+          end
+        end
+
+        def render
+          present component, params.render_params
+        end
+      end
+    end
+  end
+
+  def build_test_url_for(controller)
+
+    unless controller
+      Object.const_set("ReactTestController", Class.new(ApplicationController)) unless defined?(::ReactTestController)
+      controller = ::ReactTestController
+    end
+
+    route_root = controller.name.gsub(/Controller$/,"").underscore
+
+    unless controller.method_defined? :test
+      controller.class_eval do
+        define_method(:test) do
+          route_root = self.class.name.gsub(/Controller$/,"").underscore
+          test_params = Rails.cache.read("/#{route_root}/#{params[:id]}")
+          @component_name = test_params[0]
+          @component_params = test_params[1]
+          render_params = test_params[2]
+          render_on = render_params.delete(:render_on) || :both
+          mock_time = render_params.delete(:mock_time)
+          style_sheet = render_params.delete(:style_sheet)
+          javascript = render_params.delete(:javascript)
+          code = render_params.delete(:code)
+          page = "<%= react_component @component_name, @component_params, { prerender: false } %>"  # false should be:  "#{render_on != :client_only} } %>" but its not working in the gem testing harness
+          page = "<script type='text/javascript'>\n#{TOP_LEVEL_COMPONENT_PATCH}\n</script>\n#{page}"
+
+          if code
+            page = "<script type='text/javascript'>\n#{code}\n</script>\n"+page
+          end
+
+          #TODO figure out how to auto insert this line????  something like:
+          #page = "<%= javascript_include_tag 'reactrb-router' %>\n#{page}"
+
+          if (render_on != :server_only && !render_params[:layout]) || javascript
+            #page = "<script src='/assets/application.js?ts=#{Time.now.to_f}'></script>\n"+page
+            page = "<%= javascript_include_tag '#{javascript || 'application'}' %>\n"+page
+          end
+          if mock_time || (defined?(Timecop) && Timecop.top_stack_item)
+            puts "********** WARNING LOLEX NOT AVAILABLE TIME ON CLIENT WILL NOT MATCH SERVER **********"
+            # unix_millis = ((mock_time || Time.now).to_f * 1000.0).to_i
+            # page = "<%= javascript_include_tag 'spec/libs/lolex' %>\n"+
+            # "<script type='text/javascript'>\n"+
+            # "  window.original_setInterval = setInterval;\n"+
+            # "  window.lolex_clock = lolex.install(#{unix_millis});\n"+
+            # "  window.original_setInterval(function() {window.lolex_clock.tick(10)}, 10);\n"+
+            # "</script>\n"+page
+          end
+          if !render_params[:layout] || style_sheet
+            page = "<%= stylesheet_link_tag '#{style_sheet || 'application'}' rescue nil %>\n"+page
+          end
+          if render_on == :server_only # so that test helper wait_for_ajax works
+            page = "<script type='text/javascript'>window.jQuery = {'active': 0}</script>\n#{page}"
+          else
+            page = "<%= javascript_include_tag 'jquery' %>\n<%= javascript_include_tag 'jquery_ujs' %>\n#{page}"
+          end
+          page = "<script type='text/javascript'>go = function() {window.hyper_spec_waiting_for_go = false}</script>\n#{page}"
+          title = view_context.escape_javascript(ComponentTestHelpers.current_example.description)
+          title = "#{title}...continued." if ComponentTestHelpers.description_displayed
+          page = "<script type='text/javascript'>console.log(console.log('%c#{title}','color:green; font-weight:bold; font-size: 200%'))</script>\n#{page}"
+          ComponentTestHelpers.description_displayed = true
+          render_params[:inline] = page
+          render render_params
+        end
+      end
+
+      # test_routes = Proc.new do
+      #   get "/#{route_root}/:id", to: "#{route_root}#test"
+      # end
+      # Rails.application.routes.eval_block(test_routes)
+
+      begin
+        routes = Rails.application.routes
+        routes.disable_clear_and_finalize = true
+        routes.clear!
+        routes.draw do
+          get "/#{route_root}/:id", to: "#{route_root}#test"
+        end
+        Rails.application.routes_reloader.paths.each{ |path| load(path) }
+        routes.finalize!
+        ActiveSupport.on_load(:action_controller) { routes.finalize! }
+      ensure
+        routes.disable_clear_and_finalize = false
+      end
+    end
+
+    "/#{route_root}/#{@test_id = (@test_id || 0) + 1}"
+
+  end
+
+  def isomorphic(&block)
+    yield
+    on_client(&block)
+  end
+
+  def evaluate_ruby(str="", opts={}, &block)
+    insure_mount
+    str = "#{str}\n#{Unparser.unparse Parser::CurrentRuby.parse(block.source).children.last}" if block
+    js = Opal.compile(str).gsub("\n","").gsub("(Opal);","(Opal)")
+    JSON.parse(evaluate_script("[#{js}].$to_json()"), opts).first
+  end
+
+  def expect_evaluate_ruby(str = '', opts = {}, &block)
+    insure_mount
+    expect(evaluate_ruby(add_opal_block(str, block), opts))
+  end
+
+  def add_opal_block(str, block)
+    # big assumption here is that we are going to follow this with a .to
+    # hence .children.first followed by .children.last
+    # probably should do some kind of "search" to make this work nicely
+    return str unless block
+    "#{str}\n"\
+    "#{Unparser.unparse Parser::CurrentRuby.parse(block.source).children.first.children.last}"
+  end
+
+  def expect_promise(str = '', opts = {}, &block)
+    insure_mount
+    str = add_opal_block(str, block)
+    str = "#{str}.then { |args| args = [args]; `window.hyper_spec_promise_result = args` }"
+    js = Opal.compile(str).gsub("\n","").gsub("(Opal);","(Opal)")
+    page.evaluate_script("window.hyper_spec_promise_result = false")
+    page.execute_script(js)
+    Timeout.timeout(Capybara.default_max_wait_time) do
+      loop do
+        sleep 0.25
+        break if page.evaluate_script("!!window.hyper_spec_promise_result")
+      end
+    end
+    expect(JSON.parse(page.evaluate_script("window.hyper_spec_promise_result.$to_json()"), opts).first)
+  end
+
+  def ppr(str)
+    js = Opal.compile(str).gsub("\n","").gsub("(Opal);","(Opal)")
+    execute_script("console.log(#{js})")
+  end
+
+
+  def on_client(&block)
+    @client_code = "#{@client_code}#{Unparser.unparse Parser::CurrentRuby.parse(block.source).children.last}\n"
+  end
+
+  def debugger
+    `debugger`
+    nil
+  end
+
+  class << self
+    attr_accessor :current_example
+    attr_accessor :description_displayed
+    def display_example_description
+      "<script type='text/javascript'>console.log(console.log('%c#{current_example.description}','color:green; font-weight:bold; font-size: 200%'))</script>"
+    end
+  end
+
+  def insure_mount
+    # rescue in case page is not defined...
+    mount unless page.instance_variable_get("@hyper_spec_mounted") rescue nil
+  end
+
+  def mount(component_name = nil, params = nil, opts = {}, &block)
+    unless params
+      params = opts
+      opts = {}
+    end
+    test_url = build_test_url_for(opts.delete(:controller))
+    if block || @client_code || component_name.nil?
+      block_with_helpers = <<-code
+        module ComponentHelpers
+          def self.js_eval(s)
+            `eval(s)`
+          end
+          def self.add_class(class_name, styles={})
+            style = styles.collect { |attr, value| "\#{attr.dasherize}:\#{value}"}.join("; ")
+            s = "<style type='text/css'> .\#{class_name}{ \#{style} } </style>"
+            `$(\#{s}).appendTo("head");`
+          end
+        end
+        class React::Component::HyperTestDummy < React::Component::Base
+          def render; end
+        end
+        #{@client_code}
+        #{Unparser.unparse(Parser::CurrentRuby.parse(block.source).children.last) if block}
+      code
+      opts[:code] = Opal.compile(block_with_helpers)
+    end
+    component_name ||= 'React::Component::HyperTestDummy'
+    Rails.cache.write(test_url, [component_name, params, opts])
+    visit test_url
+    wait_for_ajax unless opts[:no_wait]
+    page.instance_variable_set("@hyper_spec_mounted", true)
+    end
+
+  [:callback_history_for, :last_callback_for, :clear_callback_history_for, :event_history_for, :last_event_for, :clear_event_history_for].each do |method|
+    define_method(method) { |event_name| evaluate_script("Opal.React.TopLevelRailsComponent.$#{method}('#{event_name}')") }
+  end
+
+  def run_on_client(&block)
+    script = Opal.compile(Unparser.unparse Parser::CurrentRuby.parse(block.source).children.last)
+    execute_script(script)
+  end
+
+  def open_in_chrome
+    if false && ['linux', 'freebsd'].include?(`uname`.downcase)
+      `google-chrome http://#{page.server.host}:#{page.server.port}#{page.current_path}`
+    else
+      `open http://#{page.server.host}:#{page.server.port}#{page.current_path}`
+    end
+    while true
+      sleep 1.hour
+    end
+  end
+
+  def pause(message = nil)
+    if message
+      puts message
+      page.evaluate_ruby "puts #{message.inspect}.to_s + ' (type go() to continue)'"
+    end
+    page.evaluate_script("window.hyper_spec_waiting_for_go = true")
+    loop do
+      sleep 0.25
+      break unless page.evaluate_script("window.hyper_spec_waiting_for_go")
+    end
+  end
+
+  def size_window(width=nil, height=nil)
+    width, height = width if width.is_a? Array
+    portrait = true if height == :portrait
+    case width
+    when :small
+      width, height = [480, 320]
+    when :mobile
+      width, height = [640, 480]
+    when :tablet
+      width, height = [960, 640]
+    when :large
+      width, height = [1920, 6000]
+    when :default, nil
+      width, height = [1024, 768]
+    end
+    if portrait
+      width, height = [height, width]
+    end
+    if page.driver.browser.respond_to?(:manage)
+      page.driver.browser.manage.window.resize_to(width, height)
+    elsif page.driver.respond_to?(:resize)
+      page.driver.resize(width, height)
+    end
+  end
+
+end
+
+RSpec.configure do |config|
+  config.before(:each) do |example|
+    ComponentTestHelpers.current_example = example
+    ComponentTestHelpers.description_displayed = false
+  end
+  config.before(:all) do
+    ActiveRecord::Base.class_eval do
+      def attributes_on_client(page)
+        page.evaluate_ruby("#{self.class.name}.find(#{id}).attributes", symbolize_names: true)
+      end
+    end
+  end
+end