react-opal 0.14.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bbee40ce70c05f1c8be8904a0516736a898e0965
+  data.tar.gz: 3cb8fa21df7d35d38041b72ba48354e4f0bdf183
+SHA512:
+  metadata.gz: 9a8506067fcb72df4a5c1b1160229a209bec151a37c3b36e932a1ea27ad27d02d08aafc88d7b8f5ece44e2a8e34cecdc4629500930ed20e2179c58e392206719
+  data.tar.gz: c88db5dc1b1a919992ed9d5aafae113b5ca62c75b00e36687aff4ae72172e2137e4765129263f2a8daf46894cee33292700e5a51afbe9bac1ba1c7a6fea41c3b

data/lib/react-opal.rb

@@ -0,0 +1,15 @@
+if RUBY_ENGINE == 'opal'
+  require 'react/opal/top_level'
+  require 'react/opal/props_children'
+  require 'react/opal/component'
+  require 'react/opal/native_element'
+  require 'react/opal/event'
+  require 'react/opal/component_factory'
+  require 'react/opal/validator'
+else
+  require 'opal'
+  require 'react/opal/version'
+  require 'opal-activesupport'
+
+  Opal.append_path File.expand_path('../', __FILE__).untaint
+end

data/lib/react/opal/callbacks.rb

@@ -0,0 +1,35 @@
+require 'active_support/core_ext/class/attribute'
+
+module React
+  module Callbacks
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def run_callback(name, *args)
+      attribute_name = "_#{name}_callbacks"
+      callbacks = self.class.send(attribute_name)
+      callbacks.each do |callback|
+        if callback.is_a?(Proc)
+          instance_exec(*args, &callback)
+        else
+          send(callback, *args)
+        end
+      end
+    end
+
+    module ClassMethods
+      def define_callback(callback_name)
+        attribute_name = "_#{callback_name}_callbacks"
+        class_attribute(attribute_name)
+        self.send("#{attribute_name}=", [])
+        define_singleton_method(callback_name) do |*args, &block|
+          callbacks = self.send(attribute_name)
+          callbacks.concat(args)
+          callbacks.push(block) if block_given?
+          self.send("#{attribute_name}=", callbacks)
+        end
+      end
+    end
+  end
+end

data/lib/react/opal/component.rb

@@ -0,0 +1,221 @@
+require 'active_support/core_ext/class/attribute'
+require 'react/opal/callbacks'
+require 'react/opal/ext/hash'
+require 'react/opal/component/api'
+
+module React
+  module Component
+    def self.included(base)
+      base.include(API)
+      base.include(React::Callbacks)
+      base.class_eval do
+        class_attribute :init_state, :validator, :context_types, :child_context_types, :child_context_get
+        define_callback :before_mount
+        define_callback :after_mount
+        define_callback :before_receive_props
+        define_callback :before_update
+        define_callback :after_update
+        define_callback :before_unmount
+      end
+      base.extend(ClassMethods)
+    end
+
+    def params
+      Hash.new(`#{self}.props`).inject({}) do |memo, (k, v)|
+        memo[k.underscore] = v
+        memo
+      end
+    end
+
+    def refs
+      Hash.new(`#{self}.refs`)
+    end
+
+    def context
+      Hash.new(`#{self}.context`)
+    end
+
+    def emit(event_name, *args)
+      self.params["on_#{event_name.to_s}"].call(*args)
+    end
+
+    def component_will_mount
+      self.run_callback(:before_mount)
+    end
+
+    def component_did_mount
+      self.run_callback(:after_mount)
+    end
+
+    def component_will_receive_props(next_props)
+      self.run_callback(:before_receive_props, Hash.new(next_props))
+    end
+
+    def should_component_update?(next_props, next_state)
+      self.respond_to?(:needs_update?) ? self.needs_update?(Hash.new(next_props), Hash.new(next_state)) : true
+    end
+
+    def component_will_update(next_props, next_state)
+      self.run_callback(:before_update, Hash.new(next_props), Hash.new(next_state))
+    end
+
+    def component_did_update(prev_props, prev_state)
+      self.run_callback(:after_update, Hash.new(prev_props), Hash.new(prev_state))
+    end
+
+    def component_will_unmount
+      self.run_callback(:before_unmount)
+    end
+
+    def p(*args, &block)
+      if block || args.count == 0 || (args.count == 1 && args.first.is_a?(Hash))
+        _p_tag(*args, &block)
+      else
+        Kernel.p(*args)
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      unless (React::HTML_TAGS.include?(name) || name == 'present' || name == '_p_tag')
+        return super
+      end
+
+      if name == "present"
+        name = args.shift
+      end
+
+      if name == "_p_tag"
+        name = "p"
+      end
+
+      @buffer = [] unless @buffer
+      if block
+        current = @buffer
+        @buffer = []
+        result = block.call
+        element = React.create_element(name, *args) { @buffer.count == 0 ? result : @buffer }
+        @buffer = current
+      else
+        element = React.create_element(name, *args)
+      end
+
+      @buffer << element
+      element
+    end
+
+    def to_n
+      self
+    end
+
+    module ClassMethods
+      def prop_types
+        if self.validator
+          {
+              _componentValidator: %x{
+              function(props, propName, componentName) {
+                var errors = #{validator.validate(Hash.new(`props`))};
+                var error = new Error(#{"In component `" + self.name + "`\n" + `errors`.join("\n")});
+                return #{`errors`.count > 0 ? `error` : `undefined`};
+              }
+            }
+          }
+        else
+          {}
+        end
+      end
+
+      def initial_state
+        self.init_state || {}
+      end
+
+      def default_props
+        self.validator ? self.validator.default_props : {}
+      end
+
+      def params(&block)
+        if self.validator
+          self.validator.evaluate_more_rules(&block)
+        else
+          self.validator = React::Validator.build(&block)
+        end
+      end
+
+      def define_state_prop(prop, &block)
+        define_state prop
+        update_value = lambda do |new_value|
+          new_value = instance_exec(new_value, &block) if block
+          self.send("#{prop}=", new_value)
+        end
+        before_mount do
+          # need to execute in context of each object
+          instance_exec params[prop], &update_value
+        end
+        before_receive_props do |new_props|
+          # need to execute in context of each object
+          instance_exec new_props[prop], &update_value
+        end
+      end
+
+      def get_prop_type(klass)
+        if klass == Proc
+          `React.PropTypes.func`
+        elsif klass.is_a?(Proc)
+          `React.PropTypes.object`
+        elsif klass == Boolean
+          `React.PropTypes.bool`
+        elsif klass.ancestors.include?(Numeric)
+          `React.PropTypes.number`
+        elsif klass == String
+          `React.PropTypes.string`
+        elsif klass == Array
+          `React.PropTypes.array`
+        else
+          `React.PropTypes.object`
+        end
+      end
+
+      def consume_context(item, klass)
+        self.context_types ||= {}
+        self.context_types[item] = get_prop_type(klass)
+      end
+
+      def provide_context(item, klass, &block)
+        self.child_context_types ||= {}
+        self.child_context_types[item] = get_prop_type(klass)
+        self.child_context_get ||= {}
+        self.child_context_get[item] = block
+        unless method_defined?(:get_child_context)
+          define_method(:get_child_context) do
+            Hash[self.child_context_get.map do |item, blk|
+                   [item, instance_eval(&blk)]
+                 end].to_n
+          end
+        end
+      end
+
+      def define_state(*states)
+        raise "Block could be only given when define exactly one state" if block_given? && states.count > 1
+
+        self.init_state = {} unless self.init_state
+
+        if block_given?
+          self.init_state[states[0]] = yield
+        end
+        states.each do |name|
+          # getter
+          define_method("#{name}") do
+            self.state[name]
+          end
+          # setter
+          define_method("#{name}=") do |new_state|
+            hash = {}
+            hash[name] = new_state
+            self.set_state(hash)
+
+            new_state
+          end
+        end
+      end
+    end
+  end
+end

data/lib/react/opal/component/api.rb

@@ -0,0 +1,29 @@
+module React
+  module Component
+    module API
+      def self.included(base)
+        base.include(::React::PropsChildren)
+      end
+
+      def state
+        Hash.new(`#{self}.state`)
+      end
+
+      def force_update!
+        `#{self}.forceUpdate()`
+      end
+
+      def set_state(state, &block)
+        %x{
+        #{self}.setState(#{state.shallow_to_n}, function(){
+            #{block.call if block}
+          });
+        }
+      end
+
+      def dom_node
+        raise "`dom_node` is deprecated in favor of `React.find_dom_node`"
+      end
+    end
+  end
+end

data/lib/react/opal/component_factory.rb

@@ -0,0 +1,78 @@
+module React
+  class ComponentFactory
+    @@component_classes = {}
+
+    def self.clear_component_class_cache
+      @@component_classes = {}
+    end
+
+    def self.native_component_class(klass)
+      @@component_classes[klass.to_s] ||= begin
+        klass.class_eval do
+          include(React::Component::API)
+          # In Opal 0.8, native_alias fails if the method isn't there but we don't want to force all of these to be implemented
+          optional_native_alias = lambda do |js, ruby|
+            not_there = `!(#{self}.$$proto['$' + #{ruby}])`
+            native_alias js, ruby unless not_there
+          end
+          optional_native_alias[:componentWillMount, :component_will_mount]
+          optional_native_alias[:componentDidMount, :component_did_mount]
+          optional_native_alias[:componentWillReceiveProps, :component_will_receive_props]
+          optional_native_alias[:shouldComponentUpdate, :should_component_update?]
+          optional_native_alias[:componentWillUpdate, :component_will_update]
+          optional_native_alias[:componentDidUpdate, :component_did_update]
+          optional_native_alias[:componentWillUnmount, :component_will_unmount]
+          optional_native_alias[:getChildContext, :get_child_context]
+          native_alias :render, :render
+        end
+        %x{
+          if (!Object.assign) {
+            Object.defineProperty(Object, 'assign', {
+              enumerable: false,
+              configurable: true,
+              writable: true,
+              value: function(target, firstSource) {
+                'use strict';
+                if (target === undefined || target === null) {
+                  throw new TypeError('Cannot convert first argument to object');
+                }
+
+                var to = Object(target);
+                for (var i = 1; i < arguments.length; i++) {
+                  var nextSource = arguments[i];
+                  if (nextSource === undefined || nextSource === null) {
+                    continue;
+                  }
+
+                  var keysArray = Object.keys(Object(nextSource));
+                  for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex++) {
+                    var nextKey = keysArray[nextIndex];
+                    var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
+                    if (desc !== undefined && desc.enumerable) {
+                      to[nextKey] = nextSource[nextKey];
+                    }
+                  }
+                }
+                return to;
+              }
+            });
+          }
+          function ctor(props){
+            this.constructor = ctor;
+            this.state = #{klass.respond_to?(:initial_state) ? klass.initial_state.to_n : `{}`};
+            React.Component.apply(this, arguments);
+            #{klass}.$$alloc.prototype.$initialize.call(this, Opal.Hash.$new(props));
+          };
+          ctor.prototype = klass.$$proto;
+          Object.assign(ctor.prototype, React.Component.prototype);
+          ctor.propTypes = #{klass.respond_to?(:prop_types) ? klass.prop_types.to_n : `{}`};
+          ctor.contextTypes = #{klass.respond_to?(:context_types) ? klass.context_types.to_n : `{}`};
+          ctor.childContextTypes = #{klass.respond_to?(:child_context_types) ? klass.child_context_types.to_n : `{}`};
+          ctor.defaultProps = #{klass.respond_to?(:default_props) ? klass.default_props.to_n : `{}`};
+          ctor.displayName = #{klass.to_s};
+        }
+        `ctor`
+      end
+    end
+  end
+end

data/lib/react/opal/event.rb

@@ -0,0 +1,76 @@
+module React
+  class Event
+    include Native
+    alias_native :bubbles, :bubbles
+    alias_native :cancelable, :cancelable
+    alias_native :current_target, :currentTarget
+    alias_native :default_prevented, :defaultPrevented
+    alias_native :event_phase, :eventPhase
+    alias_native :is_trusted?, :isTrusted
+    alias_native :native_event, :nativeEvent
+    alias_native :target, :target
+    alias_native :timestamp, :timeStamp
+    alias_native :event_type, :type
+    alias_native :prevent_default, :preventDefault
+    alias_native :stop_propagation, :stopPropagation
+    # Clipboard
+    alias_native :clipboard_data, :clipboardData
+    # Keyboard
+    alias_native :alt_key, :altKey
+    alias_native :char_code, :charCode
+    alias_native :ctrl_key, :ctrlKey
+    alias_native :get_modifier_state, :getModifierState
+    alias_native :key, :key
+    alias_native :key_code, :keyCode
+    alias_native :locale, :locale
+    alias_native :location, :location
+    alias_native :meta_key, :metaKey
+    alias_native :repeat, :repeat
+    alias_native :shift_key, :shiftKey
+    alias_native :which, :which
+    # Focus
+    alias_native :related_target, :relatedTarget
+    # Mouse
+    alias_native :alt_key, :altKey
+    alias_native :button, :button
+    alias_native :buttons, :buttons
+    alias_native :client_x, :clientX
+    alias_native :client_y, :clientY
+    alias_native :ctrl_key, :ctrlKey
+    alias_native :get_modifier_state, :getModifierState
+    alias_native :meta_key, :metaKey
+    alias_native :page_x, :pageX
+    alias_native :page_y, :pageY
+    alias_native :related_target, :relatedTarget
+    alias_native :screen_x, :screen_x
+    alias_native :screen_y, :screen_y
+    alias_native :shift_key, :shift_key
+    # Touch
+    alias_native :alt_key, :altKey
+    alias_native :changed_touches, :changedTouches
+    alias_native :ctrl_key, :ctrlKey
+    alias_native :get_modifier_state, :getModifierState
+    alias_native :meta_key, :metaKey
+    alias_native :shift_key, :shiftKey
+    alias_native :target_touches, :targetTouches
+    alias_native :touches, :touches
+    # UI
+    alias_native :detail, :detail
+    alias_native :view, :view
+    # Wheel
+    alias_native :delta_mode, :deltaMode
+    alias_native :delta_x, :deltaX
+    alias_native :delta_y, :deltaY
+    alias_native :delta_z, :deltaZ
+
+    BUILT_IN_EVENTS = %w{onCopy onCut onPaste onKeyDown onKeyPress onKeyUp
+      onFocus onBlur onChange onInput onSubmit onClick onDoubleClick onDrag
+      onDragEnd onDragEnter onDragExit onDragLeave onDragOver onDragStart onDrop
+      onMouseDown onMouseEnter onMouseLeave onMouseMove onMouseOut onMouseOver
+      onMouseUp onTouchCancel onTouchEnd onTouchMove onTouchStart onScroll}
+
+    def initialize(native_element)
+      @native = native_element
+    end
+  end
+end

data/lib/react/opal/ext/hash.rb

@@ -0,0 +1,9 @@
+class Hash
+  def shallow_to_n
+    hash = `{}`
+    self.map do |key, value|
+       `hash[#{key}] = #{value}`
+    end
+    hash
+  end
+end

data/lib/react/opal/native_element.rb

@@ -0,0 +1,52 @@
+module React
+  class NativeElement
+    include PropsChildren
+
+    # As of React 0.14, elements are now just plain object literals, so we can't inherit anymore
+    # We can just set each of the properties on our object though
+    # See var ReactElement = function (type, key, ref, self, source, owner, props) in the React source
+    def initialize(native)
+      %x{
+        self.$$typeof = #{native}.$$typeof;
+        self.type = #{native}.type;
+        self.key = #{native}.key;
+        self.ref = #{native}.ref;
+        self.props = #{native}.props;
+        self._owner = #{native}._owner;
+        self._store = #{native}._store;
+        self._self = #{native}._self;
+        self._source = #{native}._source;
+      }
+    end
+
+    def element_type
+      self.JS[:type]
+    end
+
+    def on(event_name)
+      name = event_name.to_s.camelize
+
+      prop_key = "on#{name}"
+
+      if React::Event::BUILT_IN_EVENTS.include?(prop_key)
+        callback =  %x{
+          function(event){
+            #{yield React::Event.new(`event`)}
+          }
+        }
+      else
+        callback = %x{
+          function(){
+            #{yield *Array(`arguments`)}
+          }
+        }
+      end
+
+      new_prop = `{}`
+      `new_prop[prop_key] = #{callback}`
+
+      cloned = `React.cloneElement(#{self}, #{new_prop})`
+      React::NativeElement.new cloned
+    end
+  end
+end

data/lib/react/opal/props_children.rb

@@ -0,0 +1,50 @@
+module React
+  module PropsChildren
+    def props
+      Hash.new(`#{self}.props`)
+    end
+
+    def children
+      nodes = `#{self}.props.children`
+
+      if `React.Children.count(nodes)` == 0
+        `[]`
+      elsif `React.Children.count(nodes)` == 1
+        if `(typeof nodes === 'string') || (typeof nodes === 'number')`
+          [nodes]
+        else
+          `[React.Children.only(nodes)]`
+        end
+      else
+        # Not sure the overhead of doing this..
+        class << nodes
+          include Enumerable
+
+          def to_n
+            self
+          end
+
+          def each(&block)
+            if block_given?
+              %x{
+                React.Children.forEach(#{self.to_n}, function(context){
+                  #{block.call(`context`)}
+                })
+              }
+            else
+              Enumerator.new(`React.Children.count(#{self.to_n})`) do |y|
+                %x{
+                  React.Children.forEach(#{self.to_n}, function(context){
+                    #{y << `context`}
+                  })
+                }
+              end
+            end
+          end
+        end
+
+        nodes
+      end
+    end
+  end
+end

data/lib/react/opal/testing.rb

@@ -0,0 +1,14 @@
+module React
+  module Testing
+    `var ReactTestUtils = React.addons.TestUtils`
+
+    def simulate_event(event_name, dom_element, event_data = {})
+      simulator = Native(`ReactTestUtils.Simulate`)
+      simulator[event_name].call(dom_element, event_data)
+    end
+
+    def render_to_document(element)
+      `ReactTestUtils.renderIntoDocument(#{element})`
+    end
+  end
+end

data/lib/react/opal/top_level.rb

@@ -0,0 +1,101 @@
+require 'native'
+require 'active_support'
+
+module React
+  HTML_TAGS = %w(a abbr address area article aside audio b base bdi bdo big blockquote body br
+                button canvas caption cite code col colgroup data datalist dd del details dfn
+                dialog div dl dt em embed fieldset figcaption figure footer form h1 h2 h3 h4 h5
+                h6 head header hr html i iframe img input ins kbd keygen label legend li link
+                main map mark menu menuitem meta meter nav noscript object ol optgroup option
+                output p param picture pre progress q rp rt ruby s samp script section select
+                small source span strong style sub summary sup table tbody td textarea tfoot th
+                thead time title tr track u ul var video wbr)
+
+  def self.create_element(type, properties = {})
+    params = []
+
+    # Component Spec or Normal DOM
+    native = `(typeof type === 'function')` || HTML_TAGS.include?(type)
+    params << if native
+                type
+              elsif type.kind_of?(Class)
+                raise "Provided class should define `render` method" if !(type.method_defined? :render)
+                React::ComponentFactory.native_component_class(type)
+              else
+                raise "#{type} not implemented"
+              end
+
+    # Passed in properties
+    props = camel_case_hash_keys(properties) do |key, value|
+      if key == "class_name" && value.is_a?(Hash)
+        value.inject([]) { |ary, (k, v)| v ? ary.push(k) : ary }.join(" ")
+      elsif key == 'value_link'
+        process_value_link value
+      else
+        value
+      end
+    end
+
+    params << props.shallow_to_n
+
+    # Children Nodes
+    if block_given?
+      [yield].flatten.each do |ele|
+        params << ele
+      end
+    end
+
+    element = `React.createElement.apply(null, #{params})`
+    React::NativeElement.new(element)
+  end
+
+  def self.lower_camelize(str)
+    camelized = str.camelize
+    camelized[0].downcase + camelized[1..-1]
+  end
+
+  def self.camel_case_hash_keys(input)
+    as_array = input.map do |key, value|
+      new_value = block_given? ? yield(key, value) : value
+      [lower_camelize(key), new_value]
+    end
+    Hash[as_array]
+  end
+
+  def self.process_value_link(arguments)
+    arguments = arguments.call if arguments.is_a? Proc
+    camel_case_hash_keys(arguments).to_n
+  end
+
+  def self.render(element, container)
+    component = Native(`ReactDOM.render(#{element}, container, function(){#{yield if block_given?}})`)
+    component.class.include(React::Component::API)
+    component
+  end
+
+  def self.is_valid_element(element)
+    `React.isValidElement(#{element})`
+  end
+
+  def self.render_to_string(element)
+    `ReactDOMServer.renderToString(#{element})`
+  end
+
+  def self.render_to_static_markup(element)
+    `ReactDOMServer.renderToStaticMarkup(#{element})`
+  end
+
+  def self.unmount_component_at_node(node)
+    `ReactDOM.unmountComponentAtNode(node)`
+  end
+
+  def self.expose_native_class(*args)
+    args.each do |klass|
+      `window[#{klass.to_s}] = #{React::ComponentFactory.native_component_class(klass)}`
+    end
+  end
+
+  def self.find_dom_node(component)
+    `ReactDOM.findDOMNode(#{component})`
+  end
+end

data/lib/react/opal/validator.rb

@@ -0,0 +1,69 @@
+module React
+  class Validator
+    def self.build(&block)
+      validator = self.new
+      validator.instance_eval(&block)
+      validator
+    end
+
+    def initialize
+      @rules = {}
+    end
+    
+    def evaluate_more_rules(&block)
+       self.instance_eval(&block)
+    end
+
+    def requires(prop_name, options = {})
+      rule = options
+      options[:required] = true
+      @rules[prop_name] = options
+    end
+
+    def optional(prop_name, options = {})
+      rule = options
+      options[:required] = false
+      @rules[prop_name] = options
+    end
+
+    def validate(props)
+      errors = []
+      props.keys.each do |prop_name|
+        errors <<  "Provided prop `#{prop_name}` not specified in spec"  if @rules[prop_name] == nil
+      end
+
+      props = props.select {|key| @rules.keys.include?(key) }
+
+      # requires or not
+      (@rules.keys - props.keys).each do |prop_name|
+        errors << "Required prop `#{prop_name}` was not specified" if @rules[prop_name][:required]
+      end
+
+      # type
+      props.each do |prop_name, value|
+        if klass = @rules[prop_name][:type]
+          if klass.is_a?(Array)
+            errors <<  "Provided prop `#{prop_name}` was not an Array of the specified type `#{klass[0]}`" unless value.all?{ |ele| ele.is_a?(klass[0]) }
+          else
+            errors <<  "Provided prop `#{prop_name}` was not the specified type `#{klass}`" unless value.is_a?(klass)
+          end
+        end
+      end
+
+      # values
+      props.each do |prop_name, value|
+        if values = @rules[prop_name][:values]
+          errors << "Value `#{value}` for prop `#{prop_name}` is not an allowed value" unless values.include?(value)
+        end
+      end
+
+      errors
+    end
+
+    def default_props
+      @rules
+      .select {|key, value| value.keys.include?("default") }
+      .inject({}) {|memo, (k,v)| memo[k] = v[:default]; memo}
+    end
+  end
+end

data/lib/react/opal/version.rb

@@ -0,0 +1,3 @@
+module React
+  VERSION = '0.14.1'
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: react-opal
+version: !ruby/object:Gem::Version
+  version: 0.14.1
+platform: ruby
+authors:
+- Brady Wied
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: opal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+- !ruby/object:Gem::Dependency
+  name: opal-activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+description: Write reactive UI component with Ruby's elegancy and compiled to run
+  in Javascript.
+email: brady@bswtechconsulting.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/react-opal.rb
+- lib/react/opal/callbacks.rb
+- lib/react/opal/component.rb
+- lib/react/opal/component/api.rb
+- lib/react/opal/component_factory.rb
+- lib/react/opal/event.rb
+- lib/react/opal/ext/hash.rb
+- lib/react/opal/native_element.rb
+- lib/react/opal/props_children.rb
+- lib/react/opal/testing.rb
+- lib/react/opal/top_level.rb
+- lib/react/opal/validator.rb
+- lib/react/opal/version.rb
+homepage: https://github.com/wied03/react-opal
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.1
+signing_key: 
+specification_version: 4
+summary: Opal Ruby wrapper of React.js library.
+test_files: []