hyper-react 0.12.7 → 0.99.0

data/lib/reactive-ruby/component_loader.rb

@@ -1,50 +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 react.rb components found in #{components}.rb" unless loaded?
-    end
-
-    def loaded?
-      !!v8_context.eval('Opal.React')
-    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)
-      if Opal::Processor.respond_to?(:load_asset_code)
-        Opal::Processor.load_asset_code(assets, file)
-      else
-        Opal::Sprockets.load_asset(file, assets)
-      end
-    rescue # What exception is being caught here?
-    end
-
-    def assets
-      ::Rails.application.assets
-    end
-  end
-end

data/lib/reactive-ruby/isomorphic_helpers.rb

@@ -1,212 +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)
-        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?
-           `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.log(message, message_type = :info)
-      message = [message] unless message.is_a? Array
-
-      is_production = React::Config.config[:environment] == 'production'
-
-      if (message_type == :info || message_type == :warning) && is_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.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
-        Hyperloop::Application::Boot.run(context: self)
-        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.$const_get('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
-
-      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) 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(`Opal.global.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, 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

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

@@ -1,46 +0,0 @@
-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).gsub("\n","")
-          .gsub(/(<script>.*<\/script>)<\/div>$/,'</div>\1').html_safe +
-          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

@@ -1,15 +0,0 @@
-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, '\
-                     '{ prerender: !params[:no_prerender] } %>',
-             layout: options.key?(:layout) ? options[:layout].to_s : :default
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-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
-      end
-      config.after_initialize do
-        ::ApplicationController.class_eval do
-          before_action do
-            if params.has_key? 'hyperloop-prerendering'
-              params['hyperloop-prerendering'].to_s == 'on'
-            elsif params.has_key? 'hyperloop_prerendering'
-              params['hyperloop_prerendering'].to_s == 'on'
-            else
-              Hyperloop.prerendering.to_s == 'on'
-            end && next
-            params[:no_prerender] = '1'
-          end
-        end
-        class ::HyperloopController < ::ApplicationController
-          def action_missing(name)
-            render_component
-          end
-        end
-      end
-    end
-  end
-end

data/lib/reactive-ruby/serializers.rb

@@ -1,15 +0,0 @@
-[Bignum, FalseClass, Fixnum, Float, Integer, NilClass, String, Symbol, Time, TrueClass].each do |klass|
-  klass.send(:define_method, :react_serializer) do 
-    as_json
-  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

@@ -1,42 +0,0 @@
-module ReactiveRuby
-  module ServerRendering
-    def self.context_instance_name
-      return '@rhino_context' if RUBY_PLATFORM == 'java'
-      '@v8_context'
-    end
-
-    def self.context_instance_for(context)
-      context.instance_variable_get(context_instance_name)
-    end
-
-    class ContextualRenderer < React::ServerRendering::SprocketsRenderer
-      def initialize(options = {})
-        super(options)
-        ComponentLoader.new(v8_context).load
-      end
-
-      def render(component_name, props, prerender_options)
-        if prerender_options.is_a?(Hash)
-          if v8_runtime? && prerender_options[:context_initializer]
-            raise PrerenderError.new(component_name, props, "you must use 'therubyracer' 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?
-        ["(V8)", "therubyrhino (Rhino)"].include?(ExecJS.runtime.name)
-      end
-
-      def v8_context
-        @v8_context ||= ReactiveRuby::ServerRendering.context_instance_for(@context)
-      end
-    end
-  end
-end

data/lib/reactive-ruby/version.rb

@@ -1,3 +0,0 @@
-module React
-  VERSION = "0.12.7"
-end

data/lib/reactrb/auto-import.rb

@@ -1,27 +0,0 @@
-# rubocop:disable Style/FileName
-# require 'reactrb/auto-import' to automatically
-# import JS libraries and components when they are detected
-if RUBY_ENGINE == 'opal'
-  # modifies const and method_missing so that they will attempt
-  # to auto import native libraries and components using React::NativeLibrary
-  class Object
-    class << self
-      alias _reactrb_original_const_missing const_missing
-      alias _reactrb_original_method_missing method_missing
-
-      def const_missing(const_name)
-        # Opal uses const_missing to initially define things,
-        # so we always call the original, and respond to the exception
-        _reactrb_original_const_missing(const_name)
-      rescue StandardError => e
-        React::NativeLibrary.import_const_from_native(Object, const_name, true) || raise(e)
-      end
-
-      def method_missing(method, *args, &block)
-        component_class = React::NativeLibrary.import_const_from_native(self, method, false)
-        _reactrb_original_method_missing(method, *args, &block) unless component_class
-        React::RenderingContext.render(component_class, *args, &block)
-      end
-    end
-  end
-end