hyper-component 0.99.6 → 1.0.alpha1

data/lib/react/test/rspec.rb

@@ -1,15 +0,0 @@
-require 'react/test/dsl'
-require 'react/test/matchers/render_html_matcher'
-
-RSpec.configure do |config|
-  config.include React::Test::DSL, type: :component
-  config.include React::Test::Matchers, type: :component
-
-  config.after do
-    React::Test.reset_session!
-  end
-
-  config.before do
-    # nothing yet
-  end
-end

data/lib/react/test/session.rb

@@ -1,37 +0,0 @@
-module React
-  module Test
-    class Session
-      DSL_METHODS = %i[mount instance update_params html].freeze
-
-      def mount(component_klass, params = {})
-        @element = React.create_element(component_klass, params)
-        instance
-      end
-
-      def instance
-        unless @instance
-          @container = `document.createElement('div')`
-          @instance = React.render(@element, @container)
-        end
-        @instance
-      end
-
-      def update_params(params, &block)
-        cloned_element = React::Element.new(`React.cloneElement(#{@element.to_n}, #{params.to_n})`)
-        React.render(cloned_element, @container, &block)
-        nil
-      end
-
-      def html
-        html = `#@container.innerHTML`
-        %x{
-            var REGEX_REMOVE_ROOT_IDS = /\s?data-reactroot="[^"]*"/g;
-            var REGEX_REMOVE_IDS = /\s?data-reactid="[^"]+"/g;
-            html = html.replace(REGEX_REMOVE_ROOT_IDS, '');
-            html = html.replace(REGEX_REMOVE_IDS, '');
-        }
-        return html
-      end
-    end
-  end
-end

data/lib/react/test/utils.rb

@@ -1,71 +0,0 @@
-module React
-  module Test
-    class Utils
-      def self.render_component_into_document(component, args = {})
-        element = React.create_element(component, args)
-        render_into_document(element)
-      end
-
-      def self.render_into_document(element)
-        raise "You should pass a valid React::Element" unless React.is_valid_element?(element)
-        dom_el = `document.body.querySelector('div[data-react-class="React.TopLevelRailsComponent"]').appendChild(document.createElement('div'))`
-        React.render(element, dom_el)
-      end
-
-      def self.simulate_click(element)
-        # element must be a component or a dom node or a element
-        el =  if `typeof element.nodeType !== "undefined"`
-                element
-              elsif element.respond_to? :dom_node
-                element.dom_node
-              elsif element.is_a? React::Element
-                `ReactDOM.findDOMNode(#{element.to_n}.native)`
-              else
-                element
-              end
-        %x{
-          var evob = new MouseEvent('click', {
-            view: window,
-            bubbles: true,
-            cancelable: true
-          });
-          el.dispatchEvent(evob);
-        }
-      end
-
-      def self.simulate_keydown(element, key_name = "Enter")
-        # element must be a component or a dom node or a element
-        el =  if `typeof element.nodeType !== "undefined"`
-                element
-              elsif element.respond_to? :dom_node
-                element.dom_node
-              elsif element.is_a? React::Element
-                `ReactDOM.findDOMNode(#{element.to_n}.native)`
-              else
-                element
-              end
-        %x{
-          var evob = new KeyboardEvent('keydown', { key: key_name, bubbles: true, cancelable: true });
-          el.dispatchEvent(evob);
-        }
-      end
-
-      def self.simulate_submit(element)
-        # element must be a component or a dom node or a element
-        el =  if `typeof element.nodeType !== "undefined"`
-                element
-              elsif element.respond_to? :dom_node
-                element.dom_node
-              elsif element.is_a? React::Element
-                `ReactDOM.findDOMNode(#{element.to_n}.native)`
-              else
-                element
-              end
-        %x{
-          var evob = new Event('submit', { bubbles: true, cancelable: true });
-          el.dispatchEvent(evob);
-        }
-      end
-    end
-  end
-end

data/lib/react/top_level.rb

@@ -1,110 +0,0 @@
-require "native"
-require 'active_support/core_ext/object/try'
-require 'react/component/tags'
-require 'react/component/base'
-
-module React
-
-  ATTRIBUTES = %w(accept acceptCharset accessKey action allowFullScreen allowTransparency alt
-                async autoComplete autoPlay cellPadding cellSpacing charSet checked classID
-                className cols colSpan content contentEditable contextMenu controls coords
-                crossOrigin data dateTime defer dir disabled download draggable encType form
-                formAction formEncType formMethod formNoValidate formTarget frameBorder height
-                hidden href hrefLang htmlFor httpEquiv icon id label lang list loop manifest
-                marginHeight marginWidth max maxLength media mediaGroup method min multiple
-                muted name noValidate open pattern placeholder poster preload radioGroup
-                readOnly rel required role rows rowSpan sandbox scope scrolling seamless
-                selected shape size sizes span spellCheck src srcDoc srcSet start step style
-                tabIndex target title type useMap value width wmode dangerouslySetInnerHTML) +
-                #SVG ATTRIBUTES
-                %w(clipPath cx cy d dx dy fill fillOpacity fontFamily
-                fontSize fx fy gradientTransform gradientUnits markerEnd
-                markerMid markerStart offset opacity patternContentUnits
-                patternUnits points preserveAspectRatio r rx ry spreadMethod
-                stopColor stopOpacity stroke  strokeDasharray strokeLinecap
-                strokeOpacity strokeWidth textAnchor transform version
-                viewBox x1 x2 x xlinkActuate xlinkArcrole xlinkHref xlinkRole
-                xlinkShow xlinkTitle xlinkType xmlBase xmlLang xmlSpace y1 y2 y)
-  HASH_ATTRIBUTES = %w(data aria)
-  HTML_TAGS = React::Component::Tags::HTML_TAGS
-
-  def self.html_tag?(name)
-    tags = HTML_TAGS
-    %x{
-      for(var i = 0; i < tags.length; i++) {
-        if(tags[i] === name)
-          return true;
-      }
-      return false;
-    }
-  end
-
-  def self.html_attr?(name)
-    attrs = ATTRIBUTES
-    %x{
-      for(var i = 0; i < attrs.length; i++) {
-        if(attrs[i] === name)
-          return true;
-      }
-      return false;
-    }
-  end
-
-  def self.create_element(type, properties = {}, &block)
-    React::API.create_element(type, properties, &block)
-  end
-
-  def self.render(element, container)
-    %x{
-        console.error(
-          "Warning: Using deprecated behavior of `React.render`,",
-          "require \"react/top_level_render\" to get the correct behavior."
-        );
-    }
-    container = `container.$$class ? container[0] : container`
-    if !(`typeof ReactDOM === 'undefined'`)
-      component = Native(`ReactDOM.render(#{element.to_n}, container, function(){#{yield if block_given?}})`) # v0.15+
-    else
-      raise "render is not defined.  In React >= v15 you must import it with ReactDOM"
-    end
-
-    component.class.include(React::Component::API)
-    component
-  end
-
-  def self.is_valid_element(element)
-    %x{ console.error("Warning: `is_valid_element` is deprecated in favor of `is_valid_element?`."); }
-    element.kind_of?(React::Element) && `React.isValidElement(#{element.to_n})`
-  end
-
-  def self.is_valid_element?(element)
-    element.kind_of?(React::Element) && `React.isValidElement(#{element.to_n})`
-  end
-
-  def self.render_to_string(element)
-    %x{ console.error("Warning: `React.render_to_string` is deprecated in favor of `React::Server.render_to_string`."); }
-    if !(`typeof ReactDOMServer === 'undefined'`)
-      React::RenderingContext.build { `ReactDOMServer.renderToString(#{element.to_n})` } # v0.15+
-    else
-      raise "renderToString is not defined.  In React >= v15 you must import it with ReactDOMServer"
-    end
-  end
-
-  def self.render_to_static_markup(element)
-    %x{ console.error("Warning: `React.render_to_static_markup` is deprecated in favor of `React::Server.render_to_static_markup`."); }
-    if !(`typeof ReactDOMServer === 'undefined'`)
-      React::RenderingContext.build { `ReactDOMServer.renderToStaticMarkup(#{element.to_n})` } # v0.15+
-    else
-      raise "renderToStaticMarkup is not defined.  In React >= v15 you must import it with ReactDOMServer"
-    end
-  end
-
-  def self.unmount_component_at_node(node)
-    if !(`typeof ReactDOM === 'undefined'`)
-      `ReactDOM.unmountComponentAtNode(node.$$class ? node[0] : node)` # v0.15+
-    else
-      raise "unmountComponentAtNode is not defined.  In React >= v15 you must import it with ReactDOM"
-    end
-  end
-
-end

data/lib/react/top_level_render.rb

@@ -1,30 +0,0 @@
-module React
-  def self.render(element, container)
-    raise "ReactDOM.render is not defined.  In React >= v15 you must import it with ReactDOM" if (`typeof ReactDOM === 'undefined'`)
-
-    container = `container.$$class ? container[0] : container`
-
-    if block_given?
-      cb = %x{
-        function(){
-          setTimeout(function(){
-            #{yield}
-          }, 0)
-        }
-      }
-      native = `ReactDOM.render(#{element.to_n}, container, cb)`
-    else
-      native = `ReactDOM.render(#{element.to_n}, container)`
-    end
-
-    return unless `#{native} !== null`
-
-    if `#{native}.__opalInstance !== undefined && #{native}.__opalInstance !== null`
-      `#{native}.__opalInstance`
-    elsif `ReactDOM.findDOMNode !== undefined && #{native}.nodeType === undefined`
-      `ReactDOM.findDOMNode(#{native})`
-    else
-      native
-    end
-  end
-end

data/lib/react/validator.rb

@@ -1,132 +0,0 @@
-module React
-  class Validator
-    attr_accessor :errors
-    attr_reader :props_wrapper
-    private :errors, :props_wrapper
-
-    def initialize(props_wrapper = Class.new(Component::PropsWrapper))
-      @props_wrapper = props_wrapper
-    end
-
-    def self.build(&block)
-      self.new.build(&block)
-    end
-
-    def build(&block)
-      instance_eval(&block)
-      self
-    end
-
-    def requires(name, options = {})
-      options[:required] = true
-      define_rule(name, options)
-    end
-
-    def optional(name, options = {})
-      options[:required] = false
-      define_rule(name, options)
-    end
-
-    def all_other_params(name)
-      @allow_undefined_props = true
-      props_wrapper.define_all_others(name) { |props| props.reject { |name, value| rules[name] } }
-    end
-
-    def validate(props)
-      self.errors = []
-      validate_undefined(props) unless allow_undefined_props?
-      props = coerce_native_hash_values(defined_props(props))
-      validate_required(props)
-      props.each do |name, value|
-        validate_types(name, value)
-        validate_allowed(name, value)
-      end
-      errors
-    end
-
-    def default_props
-      rules
-        .select {|key, value| value.keys.include?("default") }
-        .inject({}) {|memo, (k,v)| memo[k] = v[:default]; memo}
-    end
-
-    private
-
-    def defined_props(props)
-      props.select { |name| rules.keys.include?(name) }
-    end
-
-    def allow_undefined_props?
-      !!@allow_undefined_props
-    end
-
-    def rules
-      @rules ||= { children: { required: false } }
-    end
-
-    def define_rule(name, options = {})
-      rules[name] = coerce_native_hash_values(options)
-      props_wrapper.define_param(name, options[:type])
-    end
-
-    def errors
-      @errors ||= []
-    end
-
-    def validate_types(prop_name, value)
-      return unless klass = rules[prop_name][:type]
-      if !klass.is_a?(Array)
-        allow_nil = !!rules[prop_name][:allow_nil]
-        type_check("`#{prop_name}`", value, klass, allow_nil)
-      elsif klass.length > 0
-        validate_value_array(prop_name, value)
-      else
-        allow_nil = !!rules[prop_name][:allow_nil]
-        type_check("`#{prop_name}`", value, Array, allow_nil)
-      end
-    end
-
-    def type_check(prop_name, value, klass, allow_nil)
-      return if allow_nil && value.nil?
-      return if value.is_a?(klass)
-      return if klass.respond_to?(:_react_param_conversion) &&
-        klass._react_param_conversion(value, :validate_only)
-      errors << "Provided prop #{prop_name} could not be converted to #{klass}"
-    end
-
-    def validate_allowed(prop_name, value)
-      return unless values = rules[prop_name][:values]
-      return if values.include?(value)
-      errors << "Value `#{value}` for prop `#{prop_name}` is not an allowed value"
-    end
-
-    def validate_required(props)
-      (rules.keys - props.keys).each do |name|
-        next unless rules[name][:required]
-        errors << "Required prop `#{name}` was not specified"
-      end
-    end
-
-    def validate_undefined(props)
-      (props.keys - rules.keys).each do |prop_name|
-        errors <<  "Provided prop `#{prop_name}` not specified in spec"
-      end
-    end
-
-    def validate_value_array(name, value)
-      klass = rules[name][:type]
-      allow_nil = !!rules[name][:allow_nil]
-      value.each_with_index do |item, index|
-        type_check("`#{name}`[#{index}]", Native(item), klass[0], allow_nil)
-      end
-    rescue NoMethodError
-      errors << "Provided prop `#{name}` was not an Array"
-    end
-
-    def coerce_native_hash_values(hash)
-      hash.each do |key, value|
-        hash[key] = Native(value)
-      end
-    end
-  end
-end

data/lib/reactive-ruby/component_loader.rb

@@ -1,43 +0,0 @@
-module ReactiveRuby
-  class ComponentLoader
-    attr_reader :v8_context
-    private :v8_context
-
-    def initialize(v8_context)
-      unless v8_context
-        raise ArgumentError.new('Could not obtain ExecJS runtime context')
-      end
-      @v8_context = v8_context
-    end
-
-    def load(file = components)
-      return true if loaded?
-      !!v8_context.eval(opal(file))
-    end
-
-    def load!(file = components)
-      return true if loaded?
-      self.load(file)
-    ensure
-      raise "No HyperReact components found in #{components}" unless loaded?
-    end
-
-    def loaded?
-      !!v8_context.eval('Opal.React !== undefined')
-    rescue ::ExecJS::Error
-      false
-    end
-
-    private
-
-    def components
-      opts = ::Rails.configuration.react.server_renderer_options
-      return opts[:files].first.gsub(/.js$/,'') if opts && opts[:files]
-      'components'
-    end
-
-    def opal(file)
-      Opal::Sprockets.load_asset(file)
-    end
-  end
-end

data/lib/reactive-ruby/isomorphic_helpers.rb

@@ -1,233 +0,0 @@
-require "react/config"
-
-module React
-  module IsomorphicHelpers
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-
-    if RUBY_ENGINE != 'opal'
-      def self.load_context(ctx, controller, name = nil)
-        @context = Context.new("#{controller.object_id}-#{Time.now.to_i}", ctx, controller, name)
-        @context.load_opal_context
-        ::Rails.logger.debug "************************** React Server Context Initialized #{name} #{Time.now.to_f} *********************************************"
-        @context
-      end
-    else
-      def self.load_context(unique_id = nil, name = nil)
-        # can be called on the client to force re-initialization for testing purposes
-        if !unique_id || !@context || @context.unique_id != unique_id
-          if on_opal_server?
-            `console.history = []` rescue nil
-            message = "************************ React Prerendering Context Initialized #{name} ***********************"
-          else
-            message = "************************ React Browser Context Initialized ****************************"
-          end
-          log(message)
-          @context = Context.new(unique_id)
-        end
-        @context
-      end
-    end
-
-    def self.context
-      @context
-    end
-
-    def self.log(message, message_type = :info)
-      message = [message] unless message.is_a? Array
-
-      if (message_type == :info || message_type == :warning) && Hyperloop.env.production?
-        return
-      end
-
-      if message_type == :info
-        if on_opal_server?
-          style = 'background: #00FFFF; color: red'
-        else
-          style = 'background: #222; color: #bada55'
-        end
-        message = ["%c" + message[0], style]+message[1..-1]
-        `console.log.apply(console, message)`
-      elsif message_type == :warning
-        `console.warn.apply(console, message)`
-      else
-        `console.error.apply(console, message)`
-      end
-    end
-
-    if RUBY_ENGINE != 'opal'
-      def self.on_opal_server?
-        false
-      end
-
-      def self.on_opal_client?
-        false
-      end
-    else
-      def self.on_opal_server?
-        `typeof Opal.global.document === 'undefined'`
-      end
-
-      def self.on_opal_client?
-        !on_opal_server?
-      end
-    end
-
-    def log(*args)
-      IsomorphicHelpers.log(*args)
-    end
-
-    def on_opal_server?
-      self.class.on_opal_server?
-    end
-
-    def on_opal_client?
-      self.class.on_opal_client?
-    end
-
-    def self.prerender_footers(controller = nil)
-      footer = Context.prerender_footer_blocks.collect { |block| block.call controller }.join("\n")
-      if RUBY_ENGINE != 'opal'
-        footer = (footer + @context.send_to_opal(:prerender_footers).to_s) if @context
-        footer = footer.html_safe
-      end
-      footer
-    end
-
-    class Context
-      attr_reader :controller
-      attr_reader :unique_id
-
-      def self.define_isomorphic_method(method_name, &block)
-        @@ctx_methods ||= {}
-        @@ctx_methods[method_name] = block
-      end
-
-      def self.before_first_mount_blocks
-        @before_first_mount_blocks ||= []
-      end
-
-      def self.prerender_footer_blocks
-        @prerender_footer_blocks ||= []
-      end
-
-      def initialize(unique_id, ctx = nil, controller = nil, cname = nil)
-        @unique_id = unique_id
-        @cname = cname
-        if RUBY_ENGINE != 'opal'
-          @controller = controller
-          @ctx = ctx
-          if defined? @@ctx_methods
-            @@ctx_methods.each do |method_name, block|
-              @ctx.attach("ServerSideIsomorphicMethod.#{method_name}", proc{|args| block.call(args.to_json)})
-            end
-          end
-        end
-        Hyperloop::Application::Boot.run(context: self)
-        self.class.before_first_mount_blocks.each { |block| block.call(self) }
-      end
-
-      def load_opal_context
-        send_to_opal(:load_context, @unique_id, @cname)
-      end
-
-      def eval(js)
-        @ctx.eval(js) if @ctx
-      end
-
-      def send_to_opal(method_name, *args)
-        return unless @ctx
-        args = [1] if args.length == 0
-        ::ReactiveRuby::ComponentLoader.new(@ctx).load!
-        method_args = args.collect do |arg|
-          quarg = "#{arg}".tr('"', "'")
-          "\"#{quarg}\""
-        end.join(', ')
-        @ctx.eval("Opal.React.$const_get('IsomorphicHelpers').$#{method_name}(#{method_args})")
-      end
-
-      def self.register_before_first_mount_block(&block)
-        before_first_mount_blocks << block
-      end
-
-      def self.register_prerender_footer_block(&block)
-        prerender_footer_blocks << block
-      end
-    end
-
-    class IsomorphicProcCall
-
-      attr_reader :context
-
-      def result
-        @result.first if @result
-      end
-
-      def initialize(name, block, context, *args)
-        @name = name
-        @context = context
-        block.call(self, *args)
-        @result ||= send_to_server(*args)
-      end
-
-      def when_on_client(&block)
-        @result = [block.call] if IsomorphicHelpers.on_opal_client?
-      end
-
-      def send_to_server(*args)
-        if IsomorphicHelpers.on_opal_server?
-          method_string = "ServerSideIsomorphicMethod." + @name + "(" + args.to_json + ")"
-          @result = [JSON.parse(`eval(method_string)`)]
-        end
-      end
-
-      def when_on_server(&block)
-        @result = [block.call.to_json] unless IsomorphicHelpers.on_opal_client? || IsomorphicHelpers.on_opal_server?
-      end
-    end
-
-    module ClassMethods
-      def on_opal_server?
-        IsomorphicHelpers.on_opal_server?
-      end
-
-      def on_opal_client?
-        IsomorphicHelpers.on_opal_client?
-      end
-
-      def log(*args)
-        IsomorphicHelpers.log(*args)
-      end
-
-      def controller
-        IsomorphicHelpers.context.controller
-      end
-
-      def before_first_mount(&block)
-        React::IsomorphicHelpers::Context.register_before_first_mount_block(&block)
-      end
-
-      def prerender_footer(&block)
-        React::IsomorphicHelpers::Context.register_prerender_footer_block(&block)
-      end
-
-      if RUBY_ENGINE != 'opal'
-        def isomorphic_method(name, &block)
-          React::IsomorphicHelpers::Context.send(:define_isomorphic_method, name) do |args_as_json|
-            React::IsomorphicHelpers::IsomorphicProcCall.new(name, block, self, *JSON.parse(args_as_json)).result
-          end
-        end
-      else
-        require 'json'
-
-        def isomorphic_method(name, &block)
-          self.class.send(:define_method, name) do | *args |
-            React::IsomorphicHelpers::IsomorphicProcCall.new(name, block, self, *args).result
-          end
-        end
-      end
-
-    end
-  end
-end