hyper-mesh 0.6.0 → 1.0.0.lap22

data/spec/spec_helper.rb

@@ -1,372 +0,0 @@
-# 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'
-  require 'opal-browser'
-  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 < Hyperloop::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|
-      Hyperloop.class_eval do
-        def self.on_server?
-          true
-        end
-      end
-      #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

@@ -1,351 +0,0 @@
-# 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