reactrb 0.7.42

data/lib/react/validator.rb

@@ -0,0 +1,136 @@
+module React
+
+  class Validator
+    attr_accessor :errors
+    private :errors
+
+    def initialize(component_class)
+      @component_class = component_class
+    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 allow_undefined_props=(allow)
+      @allow_undefined_props = allow
+    end
+
+    def undefined_props(props)
+      self.allow_undefined_props = true
+      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)
+      @component_class.define_param(name, options[:type]) unless name == :params
+    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

@@ -0,0 +1,45 @@
+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 react.rb components found in #{components}.rb" unless loaded?
+    end
+
+    def loaded?
+      !!v8_context.eval('Opal.React')
+    end
+
+    private
+
+    def components
+      # Make this configurable at some point
+      'components'
+    end
+
+    def opal(file)
+      Opal::Processor.load_asset_code(assets, file)
+    rescue # What exception is being caught here?
+    end
+
+    def assets
+      ::Rails.application.assets
+    end
+  end
+end

data/lib/reactive-ruby/isomorphic_helpers.rb

@@ -0,0 +1,196 @@
+module React
+  module IsomorphicHelpers
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    if RUBY_ENGINE != 'opal'
+      def self.load_context(ctx, controller, name = nil)
+        puts "************************** React Server Context Initialized #{name} *********************************************"
+        @context = Context.new("#{controller.object_id}-#{Time.now.to_i}", ctx, controller, name)
+      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?
+            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.log(message, message_type = :info)
+      message = [message] unless message.is_a? Array
+      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 window.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
+      footer = Context.prerender_footer_blocks.collect { |block| block.call }.join("\n")
+      if RUBY_ENGINE != 'opal'
+        footer = (footer + "#{@context.send_to_opal(:prerender_footers)}") if @context
+        footer = footer.html_safe
+      end
+      footer
+    end
+
+    class Context
+      attr_reader :controller
+      attr_reader :unique_id
+
+      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, name = nil)
+        @unique_id = unique_id
+        if RUBY_ENGINE != 'opal'
+          @controller = controller
+          @ctx = ctx
+          ctx["ServerSideIsomorphicMethods"] = self
+          send_to_opal(:load_context, @unique_id, name)
+        end
+        self.class.before_first_mount_blocks.each { |block| block.call(self) }
+      end
+
+      def eval(js)
+        @ctx.eval(js) if @ctx
+      end
+
+      def send_to_opal(method, *args)
+        return unless @ctx
+        args = [1] if args.length == 0
+        ::ReactiveRuby::ComponentLoader.new(@ctx).load!
+        @ctx.eval("Opal.React.IsomorphicHelpers.$#{method}(#{args.collect { |arg| "'#{arg}'"}.join(', ')})")
+      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
+      def result
+        @result.first if @result
+      end
+
+      def initialize(name, block, *args)
+        @name = name
+        block.call(self, *args)
+        @result ||= send_to_server(*args) if IsomorphicHelpers.on_opal_server?
+      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?
+          args_as_json = args.to_json
+          @result = [JSON.parse(`window.ServerSideIsomorphicMethods[#{@name}](#{args_as_json})`)]
+        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_method, name) do |args_as_json|
+            React::IsomorphicHelpers::IsomorphicProcCall.new(name, block, *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, *args).result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reactive-ruby/rails.rb

@@ -0,0 +1,7 @@
+require 'action_view'
+require 'react-rails'
+require 'reactive-ruby/server_rendering/contextual_renderer'
+require 'reactive-ruby/rails/component_mount'
+require 'reactive-ruby/rails/railtie'
+require 'reactive-ruby/rails/controller_helper'
+require 'reactive-ruby/component_loader'

data/lib/reactive-ruby/rails/component_mount.rb

@@ -0,0 +1,44 @@
+module ReactiveRuby
+  module Rails
+    class ComponentMount < React::Rails::ComponentMount
+      attr_accessor :controller
+
+      def setup(controller)
+        self.controller = controller
+      end
+
+      def react_component(name, props = {}, options = {}, &block)
+        options = context_initializer_options(options, name) if options[:prerender]
+        props = serialized_props(props, name, controller)
+        super(top_level_name, props, options, &block) + footers
+      end
+
+      private
+
+      def context_initializer_options(options, name)
+        options[:prerender] = {options[:prerender] => true} unless options[:prerender].is_a? Hash
+        existing_context_initializer = options[:prerender][:context_initializer]
+
+        options[:prerender][:context_initializer] = lambda do |ctx|
+          React::IsomorphicHelpers.load_context(ctx, controller, name)
+          existing_context_initializer.call ctx if existing_context_initializer
+        end
+
+        options
+      end
+
+      def serialized_props(props, name, controller)
+        { render_params: props, component_name: name,
+          controller: controller.class.name.gsub(/Controller$/,"") }.react_serializer
+      end
+
+      def top_level_name
+        'React.TopLevelRailsComponent'
+      end
+
+      def footers
+        React::IsomorphicHelpers.prerender_footers #if options[:prerender]
+      end
+    end
+  end
+end

data/lib/reactive-ruby/rails/controller_helper.rb

@@ -0,0 +1,13 @@
+require 'action_controller'
+
+module ReactiveRuby
+  module Rails
+    class ActionController::Base
+      def render_component(*args)
+        @component_name = ((args[0].is_a? Hash) || args.empty?) ? params[:action].camelize : args.shift
+        @render_params = (args[0].is_a? Hash) ? args[0] : {}
+        render inline: "<%= react_component @component_name, @render_params, { prerender: !params[:no_prerender] } %>", layout: 'application'
+      end
+    end
+  end
+end