reactrb 0.7.42

data/lib/generators/reactive_ruby/test_app/templates/views/components/hello_world.rb

@@ -0,0 +1,11 @@
+module Components
+  class HelloWorld
+    include React::Component
+
+    def render
+      div do
+        "Hello, World!".span
+      end
+    end
+  end
+end

data/lib/generators/reactive_ruby/test_app/templates/views/components/todo.rb

@@ -0,0 +1,14 @@
+module Components
+  class Todo
+    include React::Component
+    export_component
+
+    params do
+      requires :todo
+    end
+
+    def render
+      li { "#{params[:todo]}" }
+    end
+  end
+end

data/lib/generators/reactive_ruby/test_app/test_app_generator.rb

@@ -0,0 +1,105 @@
+require 'rails/generators/rails/app/app_generator'
+
+module ReactiveRuby
+  class TestAppGenerator < ::Rails::Generators::Base
+    def self.source_paths
+      paths = self.superclass.source_paths
+      paths << File.expand_path('../templates', __FILE__)
+      paths.flatten
+    end
+
+    def remove_existing_app
+      remove_dir(test_app_path) if File.directory?(test_app_path)
+    end
+
+    def generate_test_app
+      opts = options.dup
+      opts[:database] = 'sqlite3' if opts[:database].blank?
+      opts[:force] = true
+      opts[:skip_bundle] = true
+
+      puts "Generating Test Rails Application..."
+      invoke ::Rails::Generators::AppGenerator,
+        [ File.expand_path(test_app_path, destination_root) ], opts
+    end
+
+    def configure_test_app
+      template 'boot.rb.erb', "#{test_app_path}/config/boot.rb", force: true
+      template 'test_application.rb.erb', "#{test_app_path}/config/application.rb", force: true
+      template 'assets/javascripts/test_application.rb',
+        "#{test_app_path}/app/assets/javascripts/application.rb", force: true
+      template 'assets/javascripts/components.rb',
+        "#{test_app_path}/app/views/components.rb", force: true
+      template 'views/components/hello_world.rb',
+        "#{test_app_path}/app/views/components/hello_world.rb", force: true
+      template 'views/components/todo.rb',
+        "#{test_app_path}/app/views/components/todo.rb", force: true
+    end
+
+    def clean_superfluous_files
+      inside test_app_path do
+        remove_file '.gitignore'
+        remove_file 'doc'
+        remove_file 'Gemfile'
+        remove_file 'lib/tasks'
+        remove_file 'app/assets/images/rails.png'
+        remove_file 'app/assets/javascripts/application.js'
+        remove_file 'public/index.html'
+        remove_file 'public/robots.txt'
+        remove_file 'README.rdoc'
+        remove_file 'test'
+        remove_file 'vendor'
+        remove_file 'spec'
+      end
+    end
+
+    def configure_opal_rspec
+      inject_into_file "#{test_app_path}/config/application.rb",
+        after: /class Application < Rails::Application/, verbose: true do
+        %Q[
+    config.opal.method_missing = true
+    config.opal.optimized_operators = true
+    config.opal.arity_check = false
+    config.opal.const_missing = true
+    config.opal.dynamic_require_severity = :ignore
+    config.opal.enable_specs = true
+    config.opal.spec_location = 'spec-opal'
+]
+      end
+    end
+
+    protected
+
+    def application_definition
+      @application_definition ||= begin
+                                    test_application_contents
+                                  end
+    end
+    alias :store_application_definition! :application_definition
+
+    private
+
+    def test_app_path
+      'spec/test_app'
+    end
+
+    def test_application_path
+      File.expand_path("#{test_app_path}/config/application.rb",
+                       destination_root)
+    end
+
+    def test_application_contents
+      return unless File.exists?(test_application_path) && !options[:pretend]
+      contents = File.read(test_application_path)
+      contents[(contents.index("module #{module_name}"))..-1]
+    end
+
+    def module_name
+      'TestApp'
+    end
+
+    def gemfile_path
+      '../../../../Gemfile'
+    end
+  end
+end

data/lib/rails-helpers/top_level_rails_component.rb

@@ -0,0 +1,54 @@
+module React
+  class TopLevelRailsComponent
+    include React::Component
+
+    def self.search_path
+      @search_path ||= [Module]
+    end
+
+    export_component
+
+    param :component_name
+    param :controller
+    param :render_params
+
+    backtrace :on
+
+    def render
+      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 present component, params.render_params 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 present component, params.render_params 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 present component, params.render_params if component && component.method_defined?(:render)
+        end
+      end
+      raise "Could not find component class '#{params.component_name}' for params.controller '#{params.controller}' in any component directory. Tried [#{paths_searched.join(", ")}]"
+    end
+  end
+end
+
+class Module
+  def add_to_react_search_path(replace_search_path = nil)
+    if replace_search_path
+      React::TopLevelRailsComponent.search_path = [self]
+    elsif !React::TopLevelRailsComponent.search_path.include? self
+      React::TopLevelRailsComponent.search_path << self
+    end
+  end
+end
+
+module Components
+  add_to_react_search_path
+end

data/lib/react/api.rb

@@ -0,0 +1,127 @@
+require 'react/native_library'
+
+module React
+  class API
+    @@component_classes = {}
+
+    def self.import_native_component(opal_class, native_class)
+      @@component_classes[opal_class.to_s] = native_class
+    end
+
+    def self.create_native_react_class(type)
+      raise "Provided class should define `render` method"  if !(type.method_defined? :render)
+      render_fn = (type.method_defined? :_render_wrapper) ? :_render_wrapper : :render
+      # this was hashing type.to_s, not sure why but .to_s does not work as it Foo::Bar::View.to_s just returns "View"
+      @@component_classes[type] ||= %x{
+        React.createClass({
+          displayName: #{type.name},
+          propTypes: #{type.respond_to?(:prop_types) ? type.prop_types.to_n : `{}`},
+          getDefaultProps: function(){
+            return #{type.respond_to?(:default_props) ? type.default_props.to_n : `{}`};
+          },
+          mixins: #{type.respond_to?(:native_mixins) ? type.native_mixins : `[]`},
+          statics: #{type.respond_to?(:static_call_backs) ? type.static_call_backs.to_n : `{}`},
+          componentWillMount: function() {
+            var instance = this._getOpalInstance.apply(this);
+            return #{`instance`.component_will_mount if type.method_defined? :component_will_mount};
+          },
+          componentDidMount: function() {
+            var instance = this._getOpalInstance.apply(this);
+            return #{`instance`.component_did_mount if type.method_defined? :component_did_mount};
+          },
+          componentWillReceiveProps: function(next_props) {
+            var instance = this._getOpalInstance.apply(this);
+            return #{`instance`.component_will_receive_props(`next_props`) if type.method_defined? :component_will_receive_props};
+          },
+          shouldComponentUpdate: function(next_props, next_state) {
+            var instance = this._getOpalInstance.apply(this);
+            return #{`instance`.should_component_update?(`next_props`, `next_state`) if type.method_defined? :should_component_update?};
+          },
+          componentWillUpdate: function(next_props, next_state) {
+            var instance = this._getOpalInstance.apply(this);
+            return #{`instance`.component_will_update(`next_props`, `next_state`) if type.method_defined? :component_will_update};
+          },
+          componentDidUpdate: function(prev_props, prev_state) {
+            var instance = this._getOpalInstance.apply(this);
+            return #{`instance`.component_did_update(`prev_props`, `prev_state`) if type.method_defined? :component_did_update};
+          },
+          componentWillUnmount: function() {
+            var instance = this._getOpalInstance.apply(this);
+            return #{`instance`.component_will_unmount if type.method_defined? :component_will_unmount};
+          },
+          _getOpalInstance: function() {
+            if (this.__opalInstance == undefined) {
+              var instance = #{type.new(`this`)};
+            } else {
+              var instance = this.__opalInstance;
+            }
+            this.__opalInstance = instance;
+            return instance;
+          },
+          render: function() {
+            var instance = this._getOpalInstance.apply(this);
+            return #{`instance`.send(render_fn).to_n};
+          }
+        })
+      }
+    end
+
+    def self.create_element(type, properties = {}, &block)
+      params = []
+
+      # Component Spec, Normal DOM, String or Native Component
+      if @@component_classes[type]
+        params << @@component_classes[type]
+      elsif type.kind_of?(Class)
+        params << create_native_react_class(type)
+      elsif HTML_TAGS.include?(type)
+        params << type
+      elsif type.is_a? String
+        return React::Element.new(type)
+      else
+        raise "#{type} not implemented"
+      end
+
+      # Passed in properties
+      params << convert_props(properties)
+
+      # Children Nodes
+      if block_given?
+        children = [yield].flatten.each do |ele|
+          params << ele.to_n
+        end
+      end
+      return React::Element.new(`React.createElement.apply(null, #{params})`, type, properties, block)
+    end
+
+    def self.clear_component_class_cache
+      @@component_classes = {}
+    end
+
+    def self.convert_props(properties)
+      raise "Component parameters must be a hash. Instead you sent #{properties}" unless properties.is_a? Hash
+      props = {}
+      properties.map do |key, value|
+        if key == "class_name" && value.is_a?(Hash)
+          props[lower_camelize(key)] = `React.addons.classSet(#{value.to_n})`
+        elsif key == "class"
+          props["className"] = value
+        elsif ["style", "dangerously_set_inner_HTML"].include? key
+          props[lower_camelize(key)] = value.to_n
+        else
+          props[React::ATTRIBUTES.include?(lower_camelize(key)) ? lower_camelize(key) : key] = value
+        end
+      end
+      props.shallow_to_n
+    end
+
+    private
+
+    def self.lower_camelize(snake_cased_word)
+      words = snake_cased_word.split("_")
+      result = [words.first]
+      result.concat(words[1..-1].map {|word| word[0].upcase + word[1..-1] })
+      result.join("")
+    end
+  end
+end

data/lib/react/callbacks.rb

@@ -0,0 +1,42 @@
+require 'active_support/core_ext/class/attribute'
+
+module React
+  module Callbacks
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def run_callback(name, *args)
+      self.class.callbacks_for(name).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
+
+      def callbacks_for(callback_name)
+        attribute_name = "_#{callback_name}_callbacks"
+        if superclass.respond_to? :callbacks_for
+          superclass.callbacks_for(callback_name)
+        else
+          []
+        end + self.send(attribute_name)
+      end
+    end
+  end
+end

data/lib/react/component.rb

@@ -0,0 +1,269 @@
+require 'react/ext/string'
+require 'react/ext/hash'
+require 'active_support/core_ext/class/attribute'
+require 'react/callbacks'
+require 'react/rendering_context'
+require 'react/observable'
+require 'react/state'
+require 'react/component/api'
+require 'react/component/class_methods'
+require 'react/component/props_wrapper'
+require 'native'
+
+module React
+  module Component
+    def self.included(base)
+      base.include(API)
+      base.include(Callbacks)
+      base.class_eval do
+        class_attribute :initial_state
+        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)
+
+      if base.name
+        parent = base.name.split("::").inject([Module]) { |nesting, next_const| nesting + [nesting.last.const_get(next_const)] }[-2]
+
+        class << parent
+          def method_missing(n, *args, &block)
+            name = n
+            if name =~ /_as_node$/
+              node_only = true
+              name = name.gsub(/_as_node$/, "")
+            end
+            begin
+              name = const_get(name)
+            rescue Exception
+              name = nil
+            end
+            unless name && name.method_defined?(:render)
+              return super
+            end
+            React::RenderingContext.build_or_render(node_only, name, *args, &block)
+          end
+        end
+      end
+    end
+
+    def initialize(native_element)
+      @native = native_element
+    end
+
+    def render
+      raise "no render defined"
+    end unless method_defined?(:render)
+
+    def deprecated_params_method(name, *args, &block)
+      self.class.deprecation_warning "Direct access to param `#{name}`.  Use `params.#{name}` instead."
+      params.send(name, *args, &block)
+    end
+
+    def children
+      nodes = if `#{@native}.props.children==undefined`
+        []
+      else
+        [`#{@native}.props.children`].flatten
+      end
+      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(React::Element.new(`context`))}
+                  })
+            }
+            nil
+          else
+            Enumerator.new(`React.Children.count(#{self.to_n})`) do |y|
+              %x{
+                    React.Children.forEach(#{self.to_n}, function(context){
+              #{y << React::Element.new(`context`)}
+                    })
+              }
+            end
+          end
+        end
+      end
+
+      nodes
+    end
+
+    def params
+      @props_wrapper
+    end
+
+    def props
+      Hash.new(`#{@native}.props`)
+    end
+
+    def refs
+      Hash.new(`#{@native}.refs`)
+    end
+
+    def state
+      #raise "No native ReactComponent associated" unless @native
+      @state_wrapper ||= StateWrapper.new(@native, self)
+    end
+
+    def update_react_js_state(object, name, value)
+      if object
+        set_state({"***_state_updated_at-***" => Time.now.to_f, "#{object.class.to_s+'.' unless object == self}#{name}" => value})
+      else
+        set_state({name => value})
+      end rescue nil
+    end
+
+    def emit(event_name, *args)
+      self.params["_on#{event_name.to_s.event_camelize}"].call(*args)
+    end
+
+    def component_will_mount
+      IsomorphicHelpers.load_context(true) if IsomorphicHelpers.on_opal_client?
+      @props_wrapper = self.class.props_wrapper.new(Hash.new(`#{@native}.props`))
+      set_state! initial_state if initial_state
+      State.initialize_states(self, initial_state)
+      State.set_state_context_to(self) { self.run_callback(:before_mount) }
+    rescue Exception => e
+      self.class.process_exception(e, self)
+    end
+
+    def component_did_mount
+      State.set_state_context_to(self) do
+        self.run_callback(:after_mount)
+        State.update_states_to_observe
+      end
+    rescue Exception => e
+      self.class.process_exception(e, self)
+    end
+
+    def component_will_receive_props(next_props)
+      # need to rethink how this works in opal-react, or if its actually that useful within the react.rb environment
+      # for now we are just using it to clear processed_params
+      State.set_state_context_to(self) { self.run_callback(:before_receive_props, Hash.new(next_props)) }
+    rescue Exception => e
+      self.class.process_exception(e, self)
+    end
+
+    def props_changed?(next_props)
+      return true unless props.keys.sort == next_props.keys.sort
+      props.detect { |k, v| `#{next_props[k]} != #{params[k]}`}
+    end
+
+    def should_component_update?(next_props, next_state)
+      State.set_state_context_to(self) do
+        next_props = Hash.new(next_props)
+        if self.respond_to?(:needs_update?)
+          !!self.needs_update?(next_props, Hash.new(next_state))
+        elsif false # switch to true to force updates per standard react
+          true
+        elsif props_changed? next_props
+          true
+        elsif `!next_state != !#{@native}.state`
+          true
+        elsif `!next_state && !#{@native}.state`
+          false
+        elsif `next_state["***_state_updated_at-***"] != #{@native}.state["***_state_updated_at-***"]`
+          true
+        else
+          false
+        end.to_n
+      end
+    end
+
+    def component_will_update(next_props, next_state)
+      State.set_state_context_to(self) { self.run_callback(:before_update, Hash.new(next_props), Hash.new(next_state)) }
+      @props_wrapper = self.class.props_wrapper.new(Hash.new(next_props), @props_wrapper)
+    rescue Exception => e
+      self.class.process_exception(e, self)
+    end
+
+    def component_did_update(prev_props, prev_state)
+      State.set_state_context_to(self) do
+        self.run_callback(:after_update, Hash.new(prev_props), Hash.new(prev_state))
+        State.update_states_to_observe
+      end
+    rescue Exception => e
+      self.class.process_exception(e, self)
+    end
+
+    def component_will_unmount
+      State.set_state_context_to(self) do
+        self.run_callback(:before_unmount)
+        State.remove
+      end
+    rescue Exception => e
+      self.class.process_exception(e, self)
+    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 component?(name)
+      name_list = name.split("::")
+      scope_list = self.class.name.split("::").inject([Module]) { |nesting, next_const| nesting + [nesting.last.const_get(next_const)] }.reverse
+      scope_list.each do |scope|
+        component = name_list.inject(scope) do |scope, class_name|
+          scope.const_get(class_name)
+        end rescue nil
+        return component if component && component.method_defined?(:render)
+      end
+      nil
+    end
+
+    def method_missing(n, *args, &block)
+      return props[n] if props.key? n # TODO deprecate and remove - done so that params shadow tags, no longer needed
+      name = n
+      if name =~ /_as_node$/
+        node_only = true
+        name = name.gsub(/_as_node$/, "")
+      end
+      unless (HTML_TAGS.include?(name) || name == 'present'  || name == '_p_tag' || (name = component?(name, self)))
+        return super
+      end
+
+      if name == "present"
+        name = args.shift
+      end
+
+      if name == "_p_tag"
+        name = "p"
+      end
+
+      React::RenderingContext.build_or_render(node_only, name, *args, &block)
+    end
+
+    def watch(value, &on_change)
+      Observable.new(value, on_change)
+    end
+
+    def define_state(*args, &block)
+      State.initialize_states(self, self.class.define_state(*args, &block))
+    end
+
+    attr_reader :waiting_on_resources
+
+    def _render_wrapper
+      State.set_state_context_to(self) do
+        React::RenderingContext.render(nil) {render || ""}.tap { |element| @waiting_on_resources = element.waiting_on_resources if element.respond_to? :waiting_on_resources }
+      end
+    rescue Exception => e
+      self.class.process_exception(e, self)
+    end
+  end
+end