hyper-react 0.12.7 → 0.99.0

data/spec/reactive-ruby/isomorphic_helpers_spec.rb

@@ -1,160 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe React::IsomorphicHelpers do
-  describe 'code execution context' do
-    let(:klass) { Class.send(:include, described_class) }
-
-    describe 'module class methods', :opal do
-      it { expect(described_class).to_not be_on_opal_server }
-      it { expect(described_class).to be_on_opal_client }
-    end
-
-    describe 'included class methods', :opal do
-      it { expect(klass).to_not be_on_opal_server }
-      it { expect(klass).to be_on_opal_client }
-    end
-
-    describe 'included instance methods', :opal do
-      it { expect(klass.new).to_not be_on_opal_server }
-      it { expect(klass.new).to be_on_opal_client }
-    end
-
-    describe 'module class methods', :ruby do
-      it { is_expected.to_not be_on_opal_server }
-      it { is_expected.to_not be_on_opal_client }
-    end
-
-    describe 'included class methods', :ruby do
-      subject { klass }
-      it { is_expected.to_not be_on_opal_server }
-      it { is_expected.to_not be_on_opal_client }
-    end
-
-    describe 'included instance methods', :ruby do
-      subject { klass.new }
-      it { is_expected.to_not be_on_opal_server }
-      it { is_expected.to_not be_on_opal_client }
-    end
-  end
-
-if ruby?
-  describe 'load_context', :ruby do
-    let(:v8_context) { TestV8Context.new }
-    let(:controller) { double('controller') }
-    let(:name) { double('name') }
-
-    it 'creates a context and sets a controller' do
-      context = described_class.load_context(v8_context, controller, name)
-      expect(context.controller).to eq(controller)
-    end
-
-    it 'creates a context and sets a unique_id' do
-      Timecop.freeze do
-        stamp = Time.now.to_i
-        context = described_class.load_context(v8_context, controller, name)
-        expect(context.unique_id).to eq("#{ controller.object_id }-#{ stamp }")
-      end
-    end
-  end
-
-  describe React::IsomorphicHelpers::Context do
-    class TestV8Context < Hash
-      def eval(args)
-        true
-      end
-    end
-
-    # Need to decouple/dry up this...
-    def test_context(files = nil)
-      js = ReactiveRuby::ServerRendering::ContextualRenderer::CONSOLE_POLYFILL.dup
-      js << Opal::Builder.build('opal').to_s
-      Array(files).each do |filename|
-        js << ::Rails.application.assets[filename].to_s
-      end
-      js = "#{React::ServerRendering::ExecJSRenderer::GLOBAL_WRAPPER}#{js}"
-      ctx = ExecJS.compile(js)
-      ctx = ReactiveRuby::ServerRendering.context_instance_for(ctx)
-    end
-
-    def react_context
-      if ::Rails.application.assets['react-server.js'] &&
-         !::Rails.application.assets['react-server.js'].to_s.start_with?("// A placeholder file")
-        test_context(['components', 'react-server.js'])
-      else
-        test_context(['components', 'react.js'])
-      end
-    end
-
-    let(:v8_context) { TestV8Context.new }
-    let(:controller) { double('controller') }
-    let(:name) { double('name') }
-    before do
-      described_class.instance_variable_set :@before_first_mount_blocks, nil
-    end
-
-    describe '#initialize' do
-      it "sets the given V8 context's ServerSideIsomorphicMethods to itself" do
-        context = described_class.new('unique-id', v8_context, controller, name)
-        expect(v8_context['ServerSideIsomorphicMethods']).to eq(context)
-      end
-
-      it 'calls before mount callbacks' do
-        string = instance_double(String)
-        described_class.register_before_first_mount_block do
-          string.inspect
-        end
-        expect(string).to receive(:inspect).once
-        context = described_class.new('unique-id', v8_context, controller, name)
-      end
-    end
-
-    describe '#eval' do
-      it 'delegates to given context' do
-        context = described_class.new('unique-id', v8_context, controller, name)
-        js = 'true;'
-        expect(v8_context).to receive(:eval).with(js).once
-        context.eval(js)
-      end
-    end
-
-    describe '#send_to_opal' do
-      let(:opal_code) { Opal::Builder.new.build_str(ruby_code, __FILE__) }
-      let(:ruby_code) { %Q[
-        module React::IsomorphicHelpers
-          def self.greet(name)
-            "Hello, #\{name}!"
-          end
-
-          def self.valediction
-            'Goodbye'
-          end
-        end
-      ]}
-
-      it 'raises an error when react cannot be loaded' do
-        context = described_class.new('unique-id', v8_context, controller, name)
-        context.instance_variable_set(:@ctx, test_context)
-        expect {
-          context.send_to_opal(:foo)
-        }.to raise_error(/No react.rb components found/)
-      end
-
-      it 'executes method with args inside opal rubyracer context' do
-        ctx = react_context
-        context = described_class.new('unique-id', ctx, controller, name)
-        ctx.eval(opal_code)
-        result = context.send_to_opal(:greet, 'world')
-        expect(result).to eq('Hello, world!')
-      end
-
-      it 'executes the method inside opal rubyracer context' do
-        ctx = react_context
-        context = described_class.new('unique-id', ctx, controller, name)
-        ctx.eval(opal_code)
-        result = context.send_to_opal(:valediction)
-        expect(result).to eq('Goodbye')
-      end
-    end
-  end
-end
-end

data/spec/reactive-ruby/rails/asset_pipeline_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-
-if ruby?
-RSpec.describe 'test_app generator' do
-  it "does not interfer with asset precompilation" do
-    cmd = "cd spec/test_app; BUNDLE_GEMFILE=#{ENV['REAL_BUNDLE_GEMFILE']} bundle exec rake assets:precompile"
-    expect(system(cmd)).to be_truthy
-  end
-end
-end

data/spec/reactive-ruby/rails/component_mount_spec.rb

@@ -1,66 +0,0 @@
-require 'spec_helper'
-
-if ruby?
-RSpec.describe ReactiveRuby::Rails::ComponentMount do
-  let(:helper) { described_class.new }
-
-  before do
-    helper.setup(ActionView::TestCase::TestController.new)
-  end
-
-  describe '#react_component' do
-    it 'renders a div' do
-      html = helper.react_component('Components::HelloWorld')
-      expect(html).to match(/<div.*><\/div>/)
-    end
-
-    it 'accepts a pre-render option' do
-      html = helper.react_component('Components::HelloWorld', {}, prerender: true)
-      expect(html).to match(/<div.*><span.*>Hello, World!<\/span><\/div>/)
-    end
-
-    it 'sets data-react-class to React.TopLevelRailsComponent' do
-      html = helper.react_component('Components::HelloWorld')
-      top_level_class = 'React.TopLevelRailsComponent'
-      expect(attr_value(html, 'data-react-class')).to eq(top_level_class)
-    end
-
-    it 'sets component_name in data-react-props hash' do
-      html = helper.react_component('Components::HelloWorld')
-      props = react_props_for(html)
-
-      expect(props['component_name']).to eq('Components::HelloWorld')
-    end
-
-    it 'sets render_params in data-react-props hash' do
-      html = helper.react_component('Components::HelloWorld', {'foo' => 'bar'})
-      props = react_props_for(html)
-
-      expect(props['render_params']).to include({ 'foo' => 'bar' })
-    end
-
-    it 'sets controller in data-react-props hash' do
-      html = helper.react_component('Components::HelloWorld')
-      props = react_props_for(html)
-
-      expect(props['controller']).to eq('ActionView::TestCase::Test')
-    end
-
-    it 'passes additional options through as html attributes' do
-      html = helper.react_component('Components::HelloWorld', {},
-                                    { 'foo-bar' => 'biz-baz' })
-
-      expect(attr_value(html, 'foo-bar')).to eq('biz-baz')
-    end
-  end
-
-  def attr_value(html, attr)
-    matches = html.match(/#{attr}=["']((?:.(?!["']\s+(?:\S+)=|[>"']))+.)["']?/)
-    matches.captures.first
-  end
-
-  def react_props_for(html)
-    JSON.parse(CGI.unescapeHTML("#{attr_value(html, 'data-react-props')}"))
-  end
-end
-end

data/spec/reactive-ruby/server_rendering/contextual_renderer_spec.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-
-if ruby?
-RSpec.describe ReactiveRuby::ServerRendering::ContextualRenderer do
-  let(:renderer) { described_class.new({}) }
-  let(:init) { Proc.new {} }
-  let(:options) { { context_initializer: init } }
-
-  describe '#render' do
-    it 'pre-renders HTML' do
-      result = renderer.render('Components.Todo',
-                                { todo: 'finish reactive-ruby' },
-                                options)
-      expect(result).to match(/<li.*>finish reactive-ruby<\/li>/)
-      expect(result).to match(/data-react-checksum/)
-    end
-
-    it 'accepts props as a string' do
-      result = renderer.render('Components.Todo',
-                                { todo: 'finish reactive-ruby' }.to_json,
-                                options)
-      expect(result).to match(/<li.*>finish reactive-ruby<\/li>/)
-      expect(result).to match(/data-react-checksum/)
-    end
-
-    it 'pre-renders static content' do
-      result = renderer.render('Components.Todo',
-                                { todo: 'finish reactive-ruby' },
-                                :static)
-      expect(result).to match(/<li.*>finish reactive-ruby<\/li>/)
-      expect(result).to_not match(/data-react-checksum/)
-    end
-  end
-end
-end

data/spec/spec_helper.rb

@@ -1,149 +0,0 @@
-ENV["RAILS_ENV"] ||= 'test'
-
-require 'opal'
-require 'opal-rspec'
-require 'opal-jquery'
-
-def opal?
-  RUBY_ENGINE == 'opal'
-end
-
-def ruby?
-  !opal?
-end
-
-
-if RUBY_ENGINE == 'opal'
-  require File.expand_path('../vendor/jquery-2.2.4.min', __FILE__)
-  require 'hyperloop-config'
-  Hyperloop::Context
-  require 'react/react-source-browser'
-  require 'react/react-source-server'
-  require 'hyper-react'
-  require 'react/test/rspec'
-  require 'react/test/utils'
-  require 'react/top_level_render'
-  require 'react/ref_callback'
-  require 'react/server'
-
-  require File.expand_path('../support/react/spec_helpers', __FILE__)
-
-  # turn off deprecation warnings for old style name spaces during this test
-  module React
-    module Component
-
-      def self.included(base)
-        # deprecation_warning base, "The module name React::Component has been deprecated.  Use Hyperloop::Component::Mixin instead."
-        base.include Hyperloop::Component::Mixin
-      end
-
-      class Base
-        def self.inherited(child)
-          # unless child.to_s == "React::Component::HyperTestDummy"
-          #   React::Component.deprecation_warning child, "The class name React::Component::Base has been deprecated.  Use Hyperloop::Component instead."
-          # end
-          child.include(ComponentNoNotice)
-        end
-      end
-    end
-  end
-
-  module React
-    class State
-      # this messes with lots of tests, these tests will be retested in the new hyper-component gem tests
-      ALWAYS_UPDATE_STATE_AFTER_RENDER = false
-    end
-  end
-
-  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_excluding :ruby
-    if `(React.version.search(/^0\.13/) === -1)`
-      config.filter_run_excluding :v13_only
-    else
-      config.filter_run_excluding :v13_exclude
-    end
-  end
-end
-
-if RUBY_ENGINE != 'opal'
-  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'
-
-  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.before :each do
-      Rails.cache.clear
-    end
-
-    config.filter_run_including focus: true
-    config.filter_run_excluding opal: true
-    config.run_all_when_everything_filtered = true
-  end
-end

data/spec/support/react/spec_helpers.rb

@@ -1,44 +0,0 @@
-if opal?
-module React
-  module SpecHelpers
-    `var ReactTestUtils = React.addons.TestUtils`
-
-    def renderToDocument(type, options = {})
-      element = React.create_element(type, options)
-      React::Test::Utils.render_into_document(element)
-    end
-
-    def build_element(type, options)
-      component = React.create_element(type, options)
-      element = `ReactTestUtils.renderIntoDocument(#{component.to_n})`
-      if `typeof React.findDOMNode === 'undefined'`
-        `$(element.getDOMNode())`          # v0.12
-      else
-        `$(React.findDOMNode(element))`    # v0.13
-      end
-    end
-
-    def expect_component_to_eventually(component_class, opts = {}, &block)
-      # Calls block after each update of a component until it returns true.
-      # When it does set the expectation to true.  Uses the after_update
-      # callback of the component_class, then instantiates an element of that
-      # class The call back is only called on updates, so the call back is
-      # manually called right after the element is created.  Because React.rb
-      # runs the callback inside the components context, we have to setup a
-      # lambda to get back to correct context before executing run_async.
-      # Because run_async can only be run once it is protected by clearing
-      # element once the test passes.
-      element = nil
-      check_block = lambda do
-        context = block.arity > 0 ? self : element
-        run_async do
-          element = nil; expect(true).to be(true)
-        end if element and context.instance_exec(element, &block)
-      end
-      component_class.after_update { check_block.call  }
-      element = build_element component_class, opts
-      check_block.call
-    end
-  end
-end
-end