hyper-react 0.12.7 → 0.99.0

data/lib/react/callbacks.rb

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

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

@@ -1,168 +0,0 @@
-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(Store::Mixin)
-        base.include(React::Component::API)
-        base.include(React::Component::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
-        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)
-        params["_on#{event_name.to_s.event_camelize}"].call(*args)
-      end
-
-      def component_will_mount
-        React::IsomorphicHelpers.load_context(true) if React::IsomorphicHelpers.on_opal_client?
-        # set_state! initial_state if initial_state
-        # State.initialize_states(self, initial_state)
-        React::State.set_state_context_to(self) { run_callback(:before_mount) }
-      rescue Exception => e
-        self.class.process_exception(e, self)
-      end
-
-      def component_did_mount
-        React::State.set_state_context_to(self) do
-          run_callback(:after_mount)
-          React::State.update_states_to_observe
-        end
-      rescue Exception => e
-        self.class.process_exception(e, self)
-      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, Hash.new(next_props)) }
-      rescue Exception => e
-        self.class.process_exception(e, self)
-      end
-
-      def component_will_update(next_props, next_state)
-        React::State.set_state_context_to(self) { self.run_callback(:before_update, Hash.new(next_props), Hash.new(next_state)) }
-      rescue Exception => e
-        self.class.process_exception(e, self)
-      end
-
-      def component_did_update(prev_props, prev_state)
-        React::State.set_state_context_to(self) do
-          self.run_callback(:after_update, Hash.new(prev_props), Hash.new(prev_state))
-          React::State.update_states_to_observe
-        end
-      rescue Exception => e
-        self.class.process_exception(e, self)
-      end
-
-      def component_will_unmount
-        React::State.set_state_context_to(self) do
-          self.run_callback(:before_unmount)
-          React::State.remove
-        end
-      rescue Exception => e
-        self.class.process_exception(e, self)
-      end
-
-      attr_reader :waiting_on_resources
-
-      def update_react_js_state(object, name, value)
-        if object
-          name = "#{object.class}.#{name}" unless object == self
-          set_state(
-            '***_state_updated_at-***' => Time.now.to_f,
-            name => value
-          )
-        else
-          set_state name => value
-        end
-      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
-      # rubocop:disable Lint/RescueException # we want to catch all exceptions regardless
-      rescue Exception => e
-        # rubocop:enable Lint/RescueException
-        self.class.process_exception(e, self)
-      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

@@ -1,50 +0,0 @@
-module React
-  module Component
-    module API
-      def dom_node
-        if !(`typeof ReactDOM === 'undefined' || typeof ReactDOM.findDOMNode === 'undefined'`)
-          `ReactDOM.findDOMNode(#{self}.native)` # v0.14.0
-        elsif !(`typeof React.findDOMNode === 'undefined'`)
-          `React.findDOMNode(#{self}.native)`    # v0.13.0
-        else
-          `#{self}.native.getDOMNode`            # v0.12.0
-        end
-      end
-
-      def mounted?
-        `#{self}.native.isMounted()`
-      end
-
-      def force_update!
-        `#{self}.native.forceUpdate()`
-      end
-
-      def set_props(prop, &block)
-        set_or_replace_state_or_prop(prop, 'setProps', &block)
-      end
-
-      def set_props!(prop, &block)
-        set_or_replace_state_or_prop(prop, 'replaceProps', &block)
-      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, 'replaceState', &block)
-      end
-
-      private
-
-      def set_or_replace_state_or_prop(state_or_prop, method, &block)
-        raise "No native ReactComponent associated" unless @native
-        %x{
-          #{@native}[#{method}](#{state_or_prop.shallow_to_n}, function(){
-            #{block.call if block}
-          });
-        }
-      end
-    end
-  end
-end

data/lib/react/component/base.rb

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

@@ -1,189 +0,0 @@
-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 process_exception(e, component, reraise = @dont_catch_exceptions)
-        unless @dont_catch_exceptions
-          message = ["Exception raised while rendering #{component}: #{e.message}"]
-          if e.backtrace && e.backtrace.length > 1 && !@backtrace_off
-            append_backtrace(message, e.backtrace)
-          end
-          `console.error(#{message.join("\n")})`
-        end
-        raise e if reraise
-      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`))};
-                var error = new Error(#{"In component `#{name}`\n" + `errors`.join("\n")});
-                return #{`errors`.count > 0 ? `error` : `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
-    end
-  end
-end