hyper-component 0.12.3 → 0.99.0

data/lib/reactive-ruby/component_loader.rb

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,233 @@
+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

data/lib/reactive-ruby/rails.rb

@@ -0,0 +1,8 @@
+require 'action_view'
+require 'react-rails'
+require 'reactive-ruby/server_rendering/hyper_asset_container'
+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,48 @@
+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)
+        if options[:prerender] || [:on, 'on', true].include?(Hyperloop.prerendering)
+          options = context_initializer_options(options, name)
+        end
+        props = serialized_props(props, name, controller)
+        result = super(top_level_name, props, options, &block).gsub("\n","")
+        result = result.gsub(/(<script.*<\/script>)<\/div>$/,'</div>\1').html_safe
+        result + 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(controller)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+require 'action_controller'
+
+module ActionController
+  # adds render_component helper to ActionControllers
+  class Base
+    def render_component(*args)
+      @component_name = (args[0].is_a? Hash) || args.empty? ? params[:action].camelize : args.shift
+      @render_params = args.shift || {}
+      options = args[0] || {}
+      render inline: '<%= react_component @component_name, @render_params %>',
+             layout: options.key?(:layout) ? options[:layout].to_s : :default
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module ReactiveRuby
+  module Rails
+    class Railtie < ::Rails::Railtie
+      config.before_configuration do |app|
+        app.config.assets.enabled = true
+        app.config.assets.paths << ::Rails.root.join('app', 'views').to_s
+        app.config.react.server_renderer = ReactiveRuby::ServerRendering::ContextualRenderer
+        app.config.react.view_helper_implementation = ReactiveRuby::Rails::ComponentMount
+        ReactiveRuby::ServerRendering::ContextualRenderer.asset_container_class = ReactiveRuby::ServerRendering::HyperAssetContainer
+      end
+      config.after_initialize do
+        class ::HyperloopController < ::ApplicationController
+          def action_missing(name)
+            render_component
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reactive-ruby/serializers.rb

@@ -0,0 +1,23 @@
+[FalseClass, Float, Integer, NilClass, String, Symbol, Time, TrueClass].each do |klass|
+  klass.send(:define_method, :react_serializer) do
+    as_json
+  end
+end
+
+if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.4.0')
+  [Bignum, Fixnum].each do |klass|
+    klass.send(:define_method, :react_serializer) do
+      as_json
+    end
+  end
+end
+
+BigDecimal.send(:define_method, :react_serializer) { as_json } rescue nil
+
+Array.send(:define_method, :react_serializer) do
+  self.collect { |e| e.react_serializer }.as_json
+end
+
+Hash.send(:define_method, :react_serializer) do
+  Hash[*self.collect { |key, value| [key, value.react_serializer] }.flatten(1)].as_json
+end

data/lib/reactive-ruby/server_rendering/contextual_renderer.rb

@@ -0,0 +1,46 @@
+module ReactiveRuby
+  module ServerRendering
+    def self.context_instance_name
+      '@context'
+    end
+
+    def self.context_instance_for(context)
+      context.instance_variable_get(context_instance_name)
+    end
+
+    class ContextualRenderer < React::ServerRendering::BundleRenderer
+      def initialize(options = {})
+        super(options)
+        ComponentLoader.new(v8_context).load
+      end
+
+      def before_render(*args)
+        # the base class clears the log history... we don't want that as it is taken
+        # care of in IsomorphicHelpers.load_context
+      end
+
+      def render(component_name, props, prerender_options)
+        if prerender_options.is_a?(Hash)
+          if !v8_runtime? && prerender_options[:context_initializer]
+            raise React::ServerRendering::PrerenderError.new(component_name, props, "you must use 'mini_racer' with the prerender[:context] option") unless v8_runtime?
+          else
+            prerender_options[:context_initializer].call v8_context
+            prerender_options = prerender_options[:static] ? :static : true
+          end
+        end
+
+        super(component_name, props, prerender_options)
+      end
+
+      private
+
+      def v8_runtime?
+        ExecJS.runtime.name == 'mini_racer (V8)'
+      end
+
+      def v8_context
+        @v8_context ||= ReactiveRuby::ServerRendering.context_instance_for(@context)
+      end
+    end
+  end
+end

data/lib/reactive-ruby/server_rendering/hyper_asset_container.rb

@@ -0,0 +1,46 @@
+require 'react/server_rendering/environment_container'
+require 'react/server_rendering/manifest_container'
+require 'react/server_rendering/webpacker_manifest_container'
+
+module ReactiveRuby
+  module ServerRendering
+    class HyperTestAssetContainer
+      def find_asset(logical_path)
+        ::Rails.cache.read(logical_path)
+      end
+    end
+
+    class HyperAssetContainer
+      def initialize
+        @ass_containers = []
+        if assets_precompiled?
+          @ass_containers << React::ServerRendering::ManifestContainer.new if React::ServerRendering::ManifestContainer.compatible?
+        else
+          @ass_containers << React::ServerRendering::EnvironmentContainer.new if ::Rails.application.assets
+        end
+        if React::ServerRendering::WebpackerManifestContainer.compatible?
+          @ass_containers << React::ServerRendering::WebpackerManifestContainer.new
+        end
+        @ass_containers << HyperTestAssetContainer.new  if ::Rails.env.test?
+      end
+
+      def find_asset(logical_path)
+        @ass_containers.each do |ass|
+          begin
+            asset = ass.find_asset(logical_path)
+            return asset if asset && asset != ''
+          rescue
+            next # no asset found, try the next container
+          end
+        end
+        raise "No asset found for #{logical_path}, tried: #{@ass_containers.map { |c| c.class.name }.join(', ')}"
+      end
+
+      private
+
+      def assets_precompiled?
+        !::Rails.application.config.assets.compile
+      end
+    end
+  end
+end