hyper-react 0.99.6 → 1.0.0.lap21

data/lib/react/callbacks.rb

@@ -0,0 +1,41 @@
+require 'hyperloop-config'
+Hyperloop::Context
+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)
+        wrapper_name = "_#{callback_name}_callbacks"
+        define_singleton_method(wrapper_name) do
+          Hyperloop::Context.set_var(self, "@#{wrapper_name}", force: true) { [] }
+        end
+        define_singleton_method(callback_name) do |*args, &block|
+          send(wrapper_name).concat(args)
+          send(wrapper_name).push(block) if block_given?
+        end
+      end
+
+      def callbacks_for(callback_name)
+        wrapper_name = "_#{callback_name}_callbacks"
+        if superclass.respond_to? :callbacks_for
+          superclass.callbacks_for(callback_name)
+        else
+          []
+        end + send(wrapper_name)
+      end
+    end
+  end
+end

data/lib/react/children.rb

@@ -0,0 +1,30 @@
+module React
+  class Children
+    include Enumerable
+
+    def initialize(children)
+      @children = children
+    end
+
+    def each(&block)
+      return to_enum(__callee__) { length } unless block_given?
+      return [] unless length > 0
+      collection = []
+      %x{
+        React.Children.forEach(#{@children}, function(context){
+          #{
+            element = React::Element.new(`context`)
+            block.call(element)
+            collection << element
+          }
+        })
+      }
+      collection
+    end
+
+    def length
+      @length ||= `React.Children.count(#{@children})`
+    end
+    alias_method :size, :length
+  end
+end

data/lib/react/component.rb

@@ -0,0 +1,177 @@
+require 'react/ext/string'
+require 'react/ext/hash'
+require 'active_support/core_ext/class/attribute'
+require 'react/callbacks'
+require 'react/rendering_context'
+require 'hyper-store'
+require 'react/state_wrapper'
+require 'react/component/api'
+require 'react/component/class_methods'
+require 'react/component/props_wrapper'
+require 'native'
+
+module Hyperloop
+  class Component
+    module Mixin
+      def self.included(base)
+        base.include(Hyperloop::Store::Mixin)
+        base.include(React::Component::API)
+        base.include(React::Callbacks)
+        base.include(React::Component::Tags)
+        base.include(React::Component::DslInstanceMethods)
+        base.include(React::Component::ShouldComponentUpdate)
+        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
+          define_callback :after_error
+        end
+        base.extend(React::Component::ClassMethods)
+      end
+
+      def self.deprecation_warning(message)
+        React::Component.deprecation_warning(name, message)
+      end
+
+      def deprecation_warning(message)
+        React::Component.deprecation_warning(self.class.name, message)
+      end
+
+      def initialize(native_element)
+        @native = native_element
+        init_store
+      end
+
+      def emit(event_name, *args)
+        if React::Event::BUILT_IN_EVENTS.include?(built_in_event_name = "on#{event_name.to_s.event_camelize}")
+          params[built_in_event_name].call(*args)
+        else
+          params["on_#{event_name}"].call(*args)
+        end
+      end
+
+      def component_will_mount
+        React::IsomorphicHelpers.load_context(true) if React::IsomorphicHelpers.on_opal_client?
+        React::State.set_state_context_to(self) { run_callback(:before_mount) }
+      end
+
+      def component_did_mount
+        React::State.set_state_context_to(self) do
+          run_callback(:after_mount)
+          React::State.update_states_to_observe
+        end
+      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
+        React::State.set_state_context_to(self) { self.run_callback(:before_receive_props, next_props) }
+      end
+
+      def component_will_update(next_props, next_state)
+        React::State.set_state_context_to(self) { self.run_callback(:before_update, next_props, next_state) }
+      end
+
+      def component_did_update(prev_props, prev_state)
+        React::State.set_state_context_to(self) do
+          self.run_callback(:after_update, prev_props, prev_state)
+          React::State.update_states_to_observe
+        end
+      end
+
+      def component_will_unmount
+        React::State.set_state_context_to(self) do
+          self.run_callback(:before_unmount)
+          React::State.remove
+        end
+      end
+
+      def component_did_catch(error, info)
+        React::State.set_state_context_to(self) do
+          if self.class.callbacks_for(:after_error) == []
+            if `typeof error.$backtrace === "function"`
+              `console.error(error.$backtrace().$join("\n"))`
+            else
+              `console.error(error, info)`
+            end
+          else
+            self.run_callback(:after_error, error, info)
+          end
+        end
+      end
+
+      attr_reader :waiting_on_resources
+
+      def update_react_js_state(object, name, value)
+        if object
+          name = "#{object.class}.#{name}" unless object == self
+          # Date.now() has only millisecond precision, if several notifications of 
+          # observer happen within a millisecond, updates may get lost.
+          # to mitigate this the Math.random() appends some random number
+          # this way notifactions will happen as expected by the rest of hyperloop
+          set_state(
+            '***_state_updated_at-***' => `Date.now() + Math.random()`,
+            name => value
+          )
+        else
+          set_state name => value
+        end
+      end
+
+      def set_state_synchronously?
+        @native.JS[:__opalInstanceSyncSetState]
+      end
+      
+      def render
+        raise 'no render defined'
+      end unless method_defined?(:render)
+
+      def _render_wrapper
+        React::State.set_state_context_to(self, true) do
+          element = React::RenderingContext.render(nil) { render || '' }
+          @waiting_on_resources =
+            element.waiting_on_resources if element.respond_to? :waiting_on_resources
+          element
+        end
+      end
+
+      def watch(value, &on_change)
+        Observable.new(value, on_change)
+      end
+
+      def define_state(*args, &block)
+        React::State.initialize_states(self, self.class.define_state(*args, &block))
+      end
+    end
+  end
+end
+
+module React
+  module Component
+    def self.included(base)
+      # note this is turned off during old style testing:  See the spec_helper
+      deprecation_warning base, "The module name React::Component has been deprecated.  Use Hyperloop::Component::Mixin instead."
+      base.include Hyperloop::Component::Mixin
+    end
+    def self.deprecation_warning(name, message)
+      @deprecation_messages ||= []
+      message = "Warning: Deprecated feature used in #{name}. #{message}"
+      unless @deprecation_messages.include? message
+        @deprecation_messages << message
+        React::IsomorphicHelpers.log message, :warning
+      end
+    end
+  end
+  module ComponentNoNotice
+    def self.included(base)
+      base.include Hyperloop::Component::Mixin
+    end
+  end
+end
+
+module React
+end

data/lib/react/component/api.rb

@@ -0,0 +1,69 @@
+module React
+  module Component
+    module API
+      def dom_node
+        `ReactDOM.findDOMNode(#{self}.native)` # react >= v0.15.0
+      end
+
+      def mounted?
+        `(#{self}.is_mounted === undefined) ? false : #{self}.is_mounted`
+      end
+
+      def force_update!
+        `#{self}.native.forceUpdate()`
+      end
+
+      def set_props(prop, &block)
+        raise "set_props: setProps() is no longer supported by react"
+      end
+      alias :set_props! :set_props
+
+      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}.native.forceUpdate()`
+      end
+
+      private
+
+      def set_or_replace_state_or_prop(state_or_prop, method, &block)
+        raise "No native ReactComponent associated" unless @native
+        `var state_prop_n = #{state_or_prop.shallow_to_n}`
+        # the state object is initalized when the ruby component is instanciated
+        # this is detected by self.native.__opalInstanceInitializedState
+        # which is set in the netive component constructor in react/api.rb
+        # the setState update callback is not called when initalizing initial state
+        if block
+          %x{
+            if (#{@native}.__opalInstanceInitializedState === true) {
+              #{@native}[method](state_prop_n, function(){
+                #{block.call}
+              });
+            } else {
+              for (var sp in state_prop_n) {
+                if (state_prop_n.hasOwnProperty(sp)) {
+                  #{@native}.state[sp] = state_prop_n[sp];
+                }
+              }
+            }
+          }
+        else
+          %x{
+            if (#{@native}.__opalInstanceInitializedState === true) {
+              #{@native}[method](state_prop_n);
+            } else {
+              for (var sp in state_prop_n) {
+                if (state_prop_n.hasOwnProperty(sp)) {
+                  #{@native}.state[sp] = state_prop_n[sp];
+                } 
+              }
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/react/component/base.rb

@@ -0,0 +1,13 @@
+module React
+  module Component
+    class Base
+      def self.inherited(child)
+        # note this is turned off during old style testing:  See the spec_helper
+        unless child.to_s == "React::Component::HyperTestDummy"
+          React::Component.deprecation_warning child, "The class name React::Component::Base has been deprecated.  Use Hyperloop::Component instead."
+        end
+        child.include(ComponentNoNotice)
+      end
+    end
+  end
+end

data/lib/react/component/class_methods.rb

@@ -0,0 +1,181 @@
+module React
+  module Component
+    # class level methods (macros) for components
+    module ClassMethods
+
+      def deprecation_warning(message)
+        React::Component.deprecation_warning(self, message)
+      end
+
+      def reactrb_component?
+        true
+      end
+
+      def backtrace(*args)
+        @dont_catch_exceptions = (args[0] == :none)
+        @backtrace_off = @dont_catch_exceptions || (args[0] == :off)
+      end
+
+      def append_backtrace(message_array, backtrace)
+        message_array << "    #{backtrace[0]}"
+        backtrace[1..-1].each { |line| message_array << line }
+      end
+
+      def render(container = nil, params = {}, &block)
+        if container
+          container = container.type if container.is_a? React::Element
+          define_method :render do
+            React::RenderingContext.render(container, params) { instance_eval(&block) if block }
+          end
+        else
+          define_method(:render) { instance_eval(&block) }
+        end
+      end
+
+      # method missing will assume the method is a class name, and will treat this a render of
+      # of the component, i.e. Foo::Bar.baz === Foo::Bar().baz
+
+      def method_missing(name, *args, &children)
+        Object.method_missing(name, *args, &children) unless args.empty?
+        React::RenderingContext.render(
+          self, class: React::Element.haml_class_name(name), &children
+        )
+      end
+
+      def validator
+        @validator ||= Validator.new(props_wrapper)
+      end
+
+      def prop_types
+        if self.validator
+          {
+            _componentValidator: %x{
+              function(props, propName, componentName) {
+                var errors = #{validator.validate(Hash.new(`props`))};
+                return #{`errors`.count > 0 ? `new Error(#{"In component `#{name}`\n" + `errors`.join("\n")})` : `undefined`};
+              }
+            }
+          }
+        else
+          {}
+        end
+      end
+
+      def default_props
+        validator.default_props
+      end
+
+      def params(&block)
+        validator.build(&block)
+      end
+
+      def props_wrapper
+        @props_wrapper ||= Class.new(PropsWrapper)
+      end
+
+      def param(*args)
+        if args[0].is_a? Hash
+          options = args[0]
+          name = options.first[0]
+          default = options.first[1]
+          options.delete(name)
+          options.merge!({default: default})
+        else
+          name = args[0]
+          options = args[1] || {}
+        end
+        if options[:default]
+          validator.optional(name, options)
+        else
+          validator.requires(name, options)
+        end
+      end
+
+      def collect_other_params_as(name)
+        validator.allow_undefined_props = true
+        validator_in_lexical_scope = validator
+        props_wrapper.define_method(name) do
+          @_all_others ||= validator_in_lexical_scope.undefined_props(props)
+        end
+
+        validator_in_lexial_scope = validator
+        props_wrapper.define_method(name) do
+          @_all_others ||= validator_in_lexial_scope.undefined_props(props)
+        end
+      end
+
+      def define_state(*states, &block)
+        deprecation_warning "'define_state' is deprecated. Use the 'state' macro to declare states."
+        default_initial_value = (block && block.arity == 0) ? yield : nil
+        states_hash = (states.last.is_a?(Hash)) ? states.pop : {}
+        states.each { |name| state(name => default_initial_value) } # was states_hash[name] = default_initial_value
+        states_hash.each { |name, value| state(name => value) }
+      end
+
+      def export_state(*states, &block)
+        deprecation_warning "'export_state' is deprecated. Use the 'state' macro to declare states."
+        default_initial_value = (block && block.arity == 0) ? yield : nil
+        states_hash = (states.last.is_a?(Hash)) ? states.pop : {}
+        states.each { |name| states_hash[name] = default_initial_value }
+        states_hash.each do |name, value|
+          state(name => value, scope: :class, reader: true)
+          singleton_class.define_method("#{name}!") do |*args|
+            mutate.__send__(name, *args)
+          end
+        end
+      end
+
+      def native_mixin(item)
+        native_mixins << item
+      end
+
+      def native_mixins
+        @native_mixins ||= []
+      end
+
+      def static_call_back(name, &block)
+        static_call_backs[name] = block
+      end
+
+      def static_call_backs
+        @static_call_backs ||= {}
+      end
+
+      def export_component(opts = {})
+        export_name = (opts[:as] || name).split('::')
+        first_name = export_name.first
+        Native(`Opal.global`)[first_name] = add_item_to_tree(
+          Native(`Opal.global`)[first_name],
+          [React::API.create_native_react_class(self)] + export_name[1..-1].reverse
+        ).to_n
+      end
+
+      def imports(component_name)
+        React::API.import_native_component(
+          self, React::API.eval_native_react_component(component_name)
+        )
+        define_method(:render) {} # define a dummy render method - will never be called...
+      rescue Exception => e # rubocop:disable Lint/RescueException : we need to catch everything!
+        raise "#{self} cannot import '#{component_name}': #{e.message}."
+        # rubocop:enable Lint/RescueException
+      ensure
+        self
+      end
+
+      def add_item_to_tree(current_tree, new_item)
+        if Native(current_tree).class != Native::Object || new_item.length == 1
+          new_item.inject { |a, e| { e => a } }
+        else
+          Native(current_tree)[new_item.last] = add_item_to_tree(
+            Native(current_tree)[new_item.last], new_item[0..-2]
+          )
+          current_tree
+        end
+      end
+
+      def to_n 
+        React::API.class_eval('@@component_classes')[self]
+      end
+    end
+  end
+end