hyper-component 0.99.6 → 1.0.alpha1

data/lib/hyperstack/internal/component/haml.rb

@@ -0,0 +1,56 @@
+require 'hyperstack/ext/component/string'
+# see hyperstack/component/haml for this is to be included.
+module Hyperstack
+  module Internal
+    module Component
+      module HAMLTagInstanceMethods
+        def self.included(base)
+          base.const_get('HTML_TAGS').each do |tag|
+            if tag == 'p'
+              base.define_method(tag) do |*params, &children|
+                if children || params.count == 0 || (params.count == 1 && params.first.is_a?(Hash))
+                  RenderingContext.render(tag, *params, &children)
+                else
+                  Kernel.p(*params)
+                end
+              end
+            else
+              base.alias_method tag, tag.upcase
+            end
+          end
+        end
+      end
+
+      module HAMLElementInstanceMethods
+        def method_missing(class_name, args = {}, &new_block)
+          return dup.render.method_missing(class_name, args, &new_block) unless rendered?
+          Hyperstack::Internal::Component::RenderingContext.replace(
+            self,
+            Hyperstack::Internal::Component::RenderingContext.build do
+              Hyperstack::Internal::Component::RenderingContext.render(type, build_new_properties(class_name, args), &new_block)
+            end
+          )
+        end
+
+        def rendered?
+          Hyperstack::Internal::Component::RenderingContext.rendered? self
+        end
+
+        def haml_class_name(class_name)
+          class_name.gsub(/__|_/, '__' => '_', '_' => '-')
+        end
+
+        private
+
+        def build_new_properties(class_name, args)
+          class_name = haml_class_name(class_name)
+          new_props = @properties.dup
+          new_props[:className] = "\
+            #{class_name} #{new_props[:className]} #{args.delete(:class)} #{args.delete(:className)}\
+          ".split(' ').uniq.join(' ')
+          new_props.merge! args
+        end
+      end
+    end
+  end
+end

data/lib/hyperstack/internal/component/instance_methods.rb

@@ -0,0 +1,92 @@
+require "hyperstack/component/children"
+
+module Hyperstack
+  module Internal
+    module Component
+      module InstanceMethods
+        def children
+          Hyperstack::Component::Children.new(`#{@__hyperstack_component_native}.props.children`)
+        end
+
+        def params
+          if @__hyperstack_component_params_wrapper.param_accessor_style == :hyperstack
+            raise "params are now directly accessible via instance variables.\n"\
+                  '  to access the legacy behavior add `param_accessor_style = :legacy` '\
+                    "to your component class\n"\
+                  '  to access both behaviors add `param_accessor_style = :both` '\
+                    'to your component class'
+          end
+          @__hyperstack_component_params_wrapper
+        end
+
+        def props
+          Hash.new(`#{@__hyperstack_component_native}.props`)
+        end
+
+        def refs
+          Hash.new(`#{@__hyperstack_component_native}.refs`)
+        end
+
+        def dom_node
+          `ReactDOM.findDOMNode(#{self}.__hyperstack_component_native)` # react >= v0.15.0
+        end
+
+        def mounted?
+          `(#{self}.__hyperstack_component_is_mounted === undefined) ? false : #{self}.__hyperstack_component_is_mounted`
+        end
+
+        def force_update!
+          `#{self}.__hyperstack_component_native.forceUpdate()`
+          self
+        end
+
+        def set_state(state, &block)
+          set_or_replace_state_or_prop(state, 'setState', &block)
+        end
+
+        def set_state!(state, &block)
+          set_or_replace_state_or_prop(state, 'setState', &block)
+          `#{self}.__hyperstack_component_native.forceUpdate()`
+        end
+
+        private
+
+        def set_or_replace_state_or_prop(state_or_prop, method, &block)
+          raise "No native ReactComponent associated" unless @__hyperstack_component_native
+          `var state_prop_n = #{state_or_prop.shallow_to_n}`
+          # the state object is initalized when the ruby component is instantiated
+          # this is detected by self.__hyperstack_component_native.__opalInstanceInitializedState
+          # which is set in the native component constructor in ReactWrapper
+          # the setState update callback is not called when initalizing initial state
+          if block
+            %x{
+              if (#{@__hyperstack_component_native}.__opalInstanceInitializedState === true) {
+                #{@__hyperstack_component_native}[method](state_prop_n, function(){
+                  block.$call();
+                });
+              } else {
+                for (var sp in state_prop_n) {
+                  if (state_prop_n.hasOwnProperty(sp)) {
+                    #{@__hyperstack_component_native}.state[sp] = state_prop_n[sp];
+                  }
+                }
+              }
+            }
+          else
+            %x{
+              if (#{@__hyperstack_component_native}.__opalInstanceInitializedState === true) {
+                #{@__hyperstack_component_native}[method](state_prop_n);
+              } else {
+                for (var sp in state_prop_n) {
+                  if (state_prop_n.hasOwnProperty(sp)) {
+                    #{@__hyperstack_component_native}.state[sp] = state_prop_n[sp];
+                  }
+                }
+              }
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hyperstack/internal/component/props_wrapper.rb

@@ -0,0 +1,125 @@
+require 'active_support/core_ext/string'
+module Hyperstack
+  module Internal
+    module Component
+      class PropsWrapper
+        attr_reader :component
+
+        class << self
+          def instance_var_name_for(name)
+            case Hyperstack.naming_convention
+            when :camelize_params
+              name.camelize
+            when :prefix_params
+              "_#{name}"
+            else
+              name
+            end
+          end
+
+          def param_accessor_style(style = nil)
+            @param_accessor_style = style if style
+            @param_accessor_style ||=
+              if superclass.respond_to? :param_accessor_style
+                superclass.param_accessor_style
+              else
+                :hyperstack
+              end
+          end
+
+          def param_definitions
+            @param_definitions ||=
+              if superclass.respond_to? :param_definitions
+                superclass.param_definitions.dup
+              else
+                Hash.new
+              end
+          end
+
+          def define_param(name, param_type, aka = nil)
+            meth_name = aka || name
+            var_name = aka || instance_var_name_for(name)
+            param_definitions[name] = lambda do |props|
+              @component.instance_variable_set :"@#{var_name}", fetch_from_cache(name, param_type, props)
+            end
+            if param_type == Proc
+              define_method(meth_name.to_sym) do |*args, &block|
+                props[name].call(*args, &block) if props[name]
+              end
+            else
+              define_method(meth_name.to_sym) do
+                fetch_from_cache(name, param_type, props)
+              end
+            end
+          end
+
+          def define_all_others(name)
+            var_name = instance_var_name_for(name)
+            param_definitions[name] = lambda do |props|
+              @component.instance_variable_set :"@#{var_name}", yield(props)
+            end
+            define_method(name.to_sym) do
+              @_all_others_cache ||= yield(props)
+            end
+          end
+        end
+
+        def param_accessor_style
+          self.class.param_accessor_style
+        end
+
+        def initialize(component, incoming = nil)
+          @component = component
+          return if param_accessor_style == :legacy
+          self.class.param_definitions.each_value do |initializer|
+            instance_exec(incoming || props, &initializer)
+          end
+        end
+
+        def reload(next_props)
+          @_all_others_cache = nil # needed for legacy params wrapper
+          initialize(@component, next_props)
+        end
+
+        def [](prop)
+          props[prop]
+        end
+
+        private
+
+        def fetch_from_cache(name, param_type, props)
+          last, cached_value = cache[name]
+          return cached_value if last.equal?(props[name])
+          convert_param(name, param_type, props).tap do |value|
+            cache[name] = [props[name], value]
+          end
+        end
+
+        def convert_param(name, param_type, props)
+          if param_type.respond_to? :_react_param_conversion
+            param_type._react_param_conversion props[name], nil
+          elsif param_type.is_a?(Array) &&
+                param_type[0].respond_to?(:_react_param_conversion)
+            props[name].collect do |param|
+              param_type[0]._react_param_conversion param, nil
+            end
+          else
+            props[name]
+          end
+        end
+
+        def cache
+          @cache ||= Hash.new { |h, k| h[k] = [] }
+        end
+
+        def props
+          component.props
+        end
+
+        def value_for(name)
+          self[name].instance_variable_get('@value') if self[name]
+        end
+      end
+    end
+  end
+end

data/lib/hyperstack/internal/component/rails.rb

@@ -0,0 +1,11 @@
+if defined?(Rails)
+  require 'action_view'
+  require 'react-rails'
+  require 'hyperstack/internal/component/rails'
+  require 'hyperstack/internal/component/rails/server_rendering/hyper_asset_container'
+  require 'hyperstack/internal/component/rails/server_rendering/contextual_renderer'
+  require 'hyperstack/internal/component/rails/component_mount'
+  require 'hyperstack/internal/component/rails/railtie'
+  require 'hyperstack/internal/component/rails/controller_helper'
+  require 'hyperstack/internal/component/rails/component_loader'
+end

data/lib/hyperstack/internal/component/rails/component_loader.rb

@@ -0,0 +1,49 @@
+module Hyperstack
+  module Internal
+    module Component
+      module Rails
+        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 Hyperstack components found in #{components}" unless loaded?
+          end
+
+          def loaded?
+            !!v8_context.eval('Opal.Hyperstack !== 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
+    end
+  end
+end

data/lib/hyperstack/internal/component/rails/component_mount.rb

@@ -0,0 +1,52 @@
+module Hyperstack
+  module Internal
+    module Component
+      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?(Hyperstack.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|
+              Hyperstack::Component::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
+            'Hyperstack.Internal.Component.TopLevelRailsComponent'
+          end
+
+          def footers
+            Hyperstack::Component::IsomorphicHelpers.prerender_footers(controller)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hyperstack/internal/component/rails/railtie.rb

@@ -0,0 +1,24 @@
+module Hyperstack
+  module Internal
+    module Component
+      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 = ServerRendering::ContextualRenderer
+            app.config.react.view_helper_implementation = ComponentMount
+            ServerRendering::ContextualRenderer.asset_container_class = ServerRendering::HyperAssetContainer
+          end
+          config.after_initialize do
+            class ::HyperstackController < ::ApplicationController
+              def action_missing(_name)
+                render_component
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hyperstack/internal/component/rails/server_rendering/contextual_renderer.rb

@@ -0,0 +1,52 @@
+module Hyperstack
+  module Internal
+    module Component
+      module Rails
+        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 ||= ServerRendering.context_instance_for(@context)
+            end
+          end
+        end
+      end
+    end
+  end
+end