hyper-router 1.0.alpha1.8 → 2.4.0

data/lib/hyper-router.rb

@@ -1,29 +1,20 @@
-# rubocop:disable Style/FileName
-
-require 'hyper-component'
-
-Hyperstack.js_import 'hyperstack/router/react-router-source', defines: ['ReactRouter', 'ReactRouterDOM', 'History']
-Hyperstack.import 'hyper-router'
-
 if RUBY_ENGINE == 'opal'
+  # require 'reactrb' # how to require this conditionally????
+  require 'hyper-react'
+  require 'promise'
+  require 'promise_extras'
+  require 'react/router/react-router'
   require 'react/router'
-  require 'react/router/dom'
-  require 'react/router/history'
-
-  require 'hyperstack/internal/router/isomorphic_methods'
-  require 'hyperstack/router/history'
-  require 'hyperstack/router/location'
-  require 'hyperstack/router/match'
-  require 'hyperstack/internal/router/class_methods'
-  require 'hyperstack/internal/router/helpers'
-  require 'hyperstack/internal/router/instance_methods'
-
-  require 'hyperstack/router/helpers'
-  require 'hyperstack/router'
+  require 'react/router/dsl'
+  require 'react/router/dsl/route'
+  require 'react/router/dsl/index'
+  require 'react/router/dsl/transition_context'
+  require 'patches/react'
 else
   require 'opal'
-  require 'hyperstack/internal/router/isomorphic_methods'
-  require 'hyperstack/router/version'
+  require 'hyper-react'
+  require 'react/router/version'
 
   Opal.append_path File.expand_path('../', __FILE__).untaint
+  Opal.append_path File.expand_path('../../vendor', __FILE__).untaint
 end

data/lib/patches/react.rb

@@ -0,0 +1,9 @@
+module React
+  class RenderingContext
+    def self.remove_nodes_from_args(args)
+      args[0].each do |key, value|
+        value.as_node if `value['$is_a?']` && value.is_a?(Element)
+      end if args[0] && args[0].is_a?(Hash)
+    end
+  end
+end

data/lib/promise_extras.rb

@@ -0,0 +1,7 @@
+class Promise
+  def then_build_routes(&block)
+    self.then do |*args|
+      React::Router::DSL.build_routes(*args, &block)
+    end
+  end
+end

data/lib/react/router.rb

@@ -1,5 +1,120 @@
 module React
-  class Router < Hyperstack::Component::NativeLibrary
-    imports 'ReactRouter'
+  class Router
+    include React::Component
+
+    def self.Link(to, opts = {}, &children)
+      opts[:activeClassName] = opts.delete(:active_class).to_n if opts[:active_class]
+      opts[:activeStyle] = opts.delete(:active_style).to_n if opts[:active_style]
+      if opts[:only_active_on_index]
+        opts[:onlyActiveOnIndex] = opts.delete(:only_active_on_index).to_n
+      end
+      opts[:to] = to.to_n
+      Native::Link(opts, &children)
+    end
+
+    def route(*args, &children)
+      DSL::Route.new(*args, &children)
+    end
+
+    def index(opts = {})
+      DSL::Index.new(opts)
+    end
+
+    def redirect(from, opts = {})
+      DSL::Route.new(opts.merge(path: from)).on(:enter) { |c| c.replace(opts[:to]) }
+    end
+
+    def index_redirect(opts = {})
+      DSL::Index.new(opts).on(:enter) { |c| c.replace(opts[:to]) }
+    end
+
+    def build_routes(&block)
+      React::Router::DSL.build_routes(&block)
+    end
+
+    def hash_history
+      `window.ReactRouter.hashHistory`
+    end
+
+    def browser_history
+      `window.ReactRouter.browserHistory`
+    end
+
+    def gather_params
+      params = { routes: React::Router::DSL.children_to_n(build_routes { routes }) }
+      params[:history] = history if respond_to? :history
+      %w(create_element stringify_query parse_query_string on_error on_update).each do |method|
+        params[method.camelcase(false)] = send("#{method}_wrapper") if respond_to? method
+      end
+      params
+    end
+
+    def render
+      Native::Router(gather_params)
+    end
+
+    # private
+
+    class Native < React::NativeLibrary
+      imports "ReactRouter"
+    end
+
+    def stringify_query_wrapper
+      ->(query) { stringify_query(query) }
+    end
+
+    def parse_query_string_wrapper
+      ->(query_string) { parse_query_string(query_string) }
+    end
+
+    def on_update_wrapper
+      -> { on_update(Hash.new(`this.props`), Hash.new(`this.state`)) }
+    end
+
+    def create_element_wrapper
+      lambda do |component, props|
+        comp_classes = React::API.class_eval { @@component_classes }
+        rb_component = comp_classes.detect { |_key, value| value == component }.first
+        # Not sure if this could ever happen,
+        # could not figure out a way to test it so commented it out.
+        # unless rb_component
+        #   rb_component = Class.new(React::Component::Base)
+        #   comp_classes[rb_component] = component
+        # end
+        rb_props = convert_props(props)
+        result = create_element(rb_component, rb_props)
+        convert_or_create_element(result, component, props, rb_component, rb_props)
+      end
+    end
+
+    def on_error_wrapper
+      -> (message) { on_error(message) }
+    end
+
+    private
+
+    def convert_props(props)
+      children_are_null = `props.children == undefined || props.children == null`
+      { children:     children_are_null ? [] : [`props.children`].flatten,
+        history:      `props.history`,
+        location:     `props.location`,
+        params:       `props.params`,
+        route:        `props.route`,
+        route_params: `props.route_params`,
+        routes:       `props.routes` }
+    end
+
+    def convert_or_create_element(result, component, props, rb_component, rb_props)
+      is_result_native_react_element = `!!result._isReactElement`
+      if is_result_native_react_element
+        result
+      elsif !result
+        `React.createElement(component, props)`
+      elsif result.is_a? React::Element
+        result.to_n
+      else
+        React.create_element(rb_component, rb_props).to_n
+      end
+    end
   end
 end

data/lib/react/router/dsl.rb

@@ -0,0 +1,31 @@
+module React
+  class Router
+    class DSL
+      def self.build_routes(*args, &block)
+        evaluate_children(*args, &block)[0]
+      end
+
+      def self.evaluate_children(*args, &children)
+        [[], nil].tap do |new_routes|
+          if children
+            saved_routes, @routes = [@routes, new_routes]
+            @routes << children.call(*args)
+            @routes = saved_routes
+          end
+        end
+      end
+
+      def self.add_element(element)
+        @routes[0] <<  element
+      end
+
+      def self.set_index(index)
+        @routes[1] = index
+      end
+
+      def self.children_to_n(children)
+        children.collect { |e| e.to_json.to_n }
+      end
+    end
+  end
+end

data/lib/react/router/dsl/index.rb

@@ -0,0 +1,11 @@
+module React
+  class Router
+    class DSL
+      class Index < React::Router::DSL::Route
+        def save_element
+          DSL.set_index self
+        end
+      end
+    end
+  end
+end

data/lib/react/router/dsl/route.rb

@@ -0,0 +1,89 @@
+require 'react/router/dsl/route/hooks'
+require 'react/router/dsl/route/wrappers'
+
+module React
+  class Router
+    class DSL
+      class Route
+        def initialize(*args, &children)
+          path =
+            if args[0].is_a? Hash
+              nil
+            else
+              args[0]
+            end
+          opts =
+            if args[0].is_a? Hash
+              args[0]
+            else
+              args[1] || {}
+            end
+          unless opts.is_a? Hash
+            raise 'Route expects an optional path followed by an options hash, '\
+                  "instead we got route(#{'"' + path + '", ' if path} #{opts})"
+          end
+          @children, @index = DSL.evaluate_children do
+            yield if children && children.arity == 0
+            Index.new(mounts: opts[:index]) if opts[:index]
+          end
+          opts.delete(:index)
+          @get_children = children if children && children.arity > 0
+          @path = path
+          if opts[:mounts].is_a? Hash
+            @components = opts[:mounts]
+          else
+            @component = opts[:mounts]
+          end
+          opts.delete(:mounts)
+          @opts = opts
+          save_element
+        end
+
+        def save_element
+          DSL.add_element(self)
+        end
+
+        def to_json
+          hash = {}
+          hash[:path] = @path if @path
+
+          if @get_children
+            hash[:getChildRoutes] = get_child_routes_wrapper
+          else
+            hash[:childRoutes] = @children.map(&:to_json)
+          end
+
+          if @components
+            if @components.detect { |_k, v| v.respond_to? :call }
+              hash[:getComponents] = get_components_wrapper
+            else
+              hash[:components] = @components
+            end
+          elsif @component.respond_to? :call
+            hash[:getComponent] = get_component_wrapper
+          elsif @component
+            hash[:component] = React::API.create_native_react_class(@component)
+          else
+            hash[:component] = DSL.router.lookup_component(@path)
+          end
+
+          %w(enter change leave).each do |hook|
+            hash["on#{hook.camelcase}"] = send("on_#{hook}_wrapper") if @opts["on_#{hook}"]
+          end
+
+          if @index.respond_to? :call
+            hash[:getIndexRoute] = get_index_route_wrapper
+          elsif @index
+            hash[:indexRoute] = @index.to_json
+          end
+
+          @opts.each do |key, value|
+            hash[key] = value unless %w(on_enter on_change on_leave).include?(key)
+          end
+
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/react/router/dsl/route/hooks.rb

@@ -0,0 +1,21 @@
+module React
+  class Router
+    class DSL
+      class Route
+        def on(hook, &block)
+          @opts["on_#{hook}"] = block
+          self
+        end
+
+        def mounts(name = nil, &block)
+          if name
+            @components ||= {}
+            @components[name] = block
+          else
+            @component = block
+          end
+        end
+      end
+    end
+  end
+end

data/lib/react/router/dsl/route/wrappers.rb

@@ -0,0 +1,104 @@
+module React
+  class Router
+    class DSL
+      class Route
+        def get_child_routes_wrapper
+          lambda do |location, callBack|
+            children, index, promise =
+              React::Router::DSL.evaluate_children(TransitionContext.new(location: location),
+                                                   &@get_children)
+            if promise.class < Promise || promise.is_a?(Promise)
+
+              promise.then do |children|
+                callBack.call(nil.to_n, React::Router::DSL.children_to_n(children))
+              end.fail { |err_object| callBack.call(err_object, nil.to_n) }
+            else
+              callBack.call(nil.to_n, DSL.children_to_n(children))
+            end
+          end
+        end
+        def get_components_wrapper
+          lambda do |nextState, callBack|
+            result_hash = {}
+            promises = []
+            @components.each do |name, proc_or_comp|
+              if proc_or_comp.respond_to? :call
+                comp = proc.call(TransitionContext.new(next_state: nextState))
+                if comp.class < Promise || comp.is_a?(Promise)
+                  promises << comp
+                  comp.then do |component|
+                    result_hash[name] = React::API.create_native_react_class(component)
+                  end.fail { |err_object| `callBack(#{err_object}, null)` }
+                else
+                  result_hash[name] = React::API.create_native_react_class(comp)
+                end
+              else
+                result_hash[name] = React::API.create_native_react_class(proc_or_comp)
+              end
+            end
+            Promise.when(*promises).then { `callBack(null, #{result_hash.to_n})` }
+          end.to_n
+        end
+
+        def get_component_wrapper
+          lambda do |nextState, callBack|
+            comp = @component.call(TransitionContext.new(next_state: nextState))
+            if comp.class < Promise || comp.is_a?(Promise)
+              comp.then do |component|
+                component = React::API.create_native_react_class(component)
+                `callBack(null, component)`
+              end.fail { |err_object| `callBack(#{err_object}, null)` }
+            else
+              comp = React::API.create_native_react_class(comp)
+              `callBack(null, comp)`
+            end
+          end.to_n
+        end
+
+        def on_enter_wrapper
+          lambda do |nextState, replace, callBack|
+            comp =
+              @opts[:on_enter].call(TransitionContext.new(next_state: nextState,
+                                                          replace: replace))
+            if comp.class < Promise || comp.is_a?(Promise)
+              comp.then { `callBack()` }
+            else
+              `callBack()`
+            end
+          end.to_n
+        end
+
+        def on_change_wrapper(proc)
+          lambda do |prevState, nextState, replace, callBack|
+            comp = @opts[:on_change].call(TransitionContext.new(prev_state: prevState,
+                                                                next_state: nextState,
+                                                                replace: replace))
+            if comp.class < Promise || comp.is_a?(Promise)
+              comp.then { `callBack()` }
+            else
+              `callBack()`
+            end
+          end.to_n
+        end
+
+        def on_leave_wrapper(proc)
+          lambda do
+            @opts[:on_leave].call(TransitionContext.new)
+          end.to_n
+        end
+
+        def get_index_route_wrapper
+          lambda do |location, callBack|
+            comp = @opts[:index].call(TransitionContext.new(location: location))
+            if comp.class < Promise || comp.is_a?(Promise)
+              comp.then { |component| `callBack(null, {component: #{component}})` }
+                  .fail { |err_object| `callBack(#{err_object}, null)` }
+            else
+              `callBack(null, {component: #{comp}})`
+            end
+          end.to_n
+        end
+      end
+    end
+  end
+end