reactive-router 0.7.3 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 73020402b77bb3c9e6fd7b7ecb6e5473a1909629
-  data.tar.gz: 83324993db70d197472abb0f6e54d45b87fb40f0
+  metadata.gz: 4a37cfefc5d18c03f42d0302fd1e56360ab0acdf
+  data.tar.gz: c367a01366dca24fed30dfa4bbf332d7b6e83163
 SHA512:
-  metadata.gz: c13b7252cf9d88f0bae57f3abbf1d549a8ed972c145688eea7e866556a15cba181293caffbe16fcd19cd38a588d5ee39d53e34de4c135d1e89721e7e58d79e43
-  data.tar.gz: 84d07d8faf68375b6360fedf326415d8f586e886caf44e9ec1d326d90d8a7404cc55e3da894fe0ddc1a1d02de31f038b77e26823f77f16366bb5e571ff2aede5
+  metadata.gz: 84257330b586a80d5d958207e31f2797bf95e4ee8538c4ffd4fd1bc80f8c47b93302ef1b1eb9c10da86e6500ad5a34d90c7e2b9c60eb107cf6f523359528f157
+  data.tar.gz: 5d130e422da66bcbc0ed5f3bd7c89f69c312349de727086fe26ab41fdae9019c27203794cf4ccd997cc16b18ab65bb76556e3f084de4e55de8bc7c0e6c7d6b69

data/lib/reactive-router.rb

@@ -1,6 +1,7 @@
 if RUBY_ENGINE == 'opal'
   require 'reactive-ruby'
   require 'reactive-router/component'
+  require 'reactive-router/history'
   require 'reactive-router/router'
   require 'reactive-router/version'
 else

data/lib/reactive-router/component.rb

@@ -2,27 +2,39 @@ module React
   module Component
 
     module ClassMethods
-
+      
+      def url_param_evaluators
+        @url_param_evaluators ||= {}
+      end
+      
+      attr_accessor :evaluated_url_params
+      
       def router_param(name, &block)
-        define_state name
-        before_mount do
-          send("#{name}!", yield(params[:params][name]))
+        
+        url_param_evaluators[name] = block
+        
+        class << self
+          define_method name do
+            evaluated_url_params[name]
+          end
         end
-        before_receive_props do |new_params|
-          send("#{name}!", yield(new_params[:params][name]))
+        
+        define_method name do
+          self.class.send(name)
         end
+        
       end
-
+      
     end
 
-    def route_handler
-      Router::RR::RouteHandler()
+    def route_handler(*args)
+      Router::RR::RouteHandler(*args)
     end
 
     def link(opts = {}, &block)
       opts[:params] = opts[:params].to_n if opts[:params]
       Router::RR::Link(opts, &block)
     end
-
+    
   end
 end

data/lib/reactive-router/history.rb

@@ -0,0 +1,134 @@
+class History
+
+  class << self
+
+    def setup_handler
+      unless @handlers_setup
+        %x{
+          if (window.addEventListener) {
+            window.addEventListener('popstate', #{method(:window_history_pop_handler).to_n}, false);
+          } else {
+            window.attachEvent('onpopstate', #{method(:window_history_pop_handler).to_n});
+          }
+        }
+      end
+      @handlers_setup = true
+    end
+
+    def current_path
+      @current_path ||= `decodeURI(window.location.pathname + window.location.search)`
+    end
+
+    attr_accessor :history
+
+    def [](name)
+      (@histories ||= {})[name]
+    end
+
+    def []=(name, value)
+      (@histories ||= {})[name] = value
+    end
+
+    def window_history_pop_handler(event)
+      return if `event.state === undefined`
+      if `event.state == null` # happens when popping off outer dialog
+        puts "pop handler pops off last value"
+        old_history = @history
+        @current_path = ""
+        @history = nil
+        `ReactRouter.History.length = 0`
+        old_history.on_state_change.call(:inactive) if old_history.on_state_change
+      else
+        puts "pop handler #{`event.state.history_id`}, #{`ReactRouter.History.length`} -> #{`event.state.history_length`}, #{`event.state.path`}"
+        old_history = @history
+        old_history_length = `ReactRouter.History.length`
+        @current_path = `event.state.path`
+        @history= History[`event.state.history_id`]
+        `ReactRouter.History.length = event.state.history_length`
+        if old_history != @history
+          if `ReactRouter.History.length` > old_history_length
+            puts "activating "
+            @history.on_state_change.call(:active) if @history.on_state_change
+          else
+            puts "deactivating"
+            old_history.on_state_change.call(:inactive) if old_history.on_state_change
+          end
+        end
+        @history.notify_listeners(:pop)
+      end
+    end
+
+    def push_path(path)
+      puts "pushing path #{path}"
+      `window.history.pushState({ path: path, history_id: #{@history.name}, history_length: (ReactRouter.History.length += 1)}, '', path);`
+      @current_path = path
+      @history.notify_listeners(:push)
+    end
+
+    def replace_path(path)
+      puts "replacing path #{path}"
+      `window.history.replaceState({ path: path, history_id: #{@history.name}, history_length: ReactRouter.History.length}, '', path);`
+      @current_path = path
+      @history.notify_listeners(:replace)
+    end
+
+    def pop_path
+      `window.history.go(-1)`
+    end
+  end
+
+  attr_reader :location
+  attr_reader :on_state_change
+  attr_reader :name
+
+  def to_s
+    "History<#{@name}>"
+  end
+
+  def initialize(name, preactivate_path = nil, &on_state_change)
+    @name = name
+    if History[@name]
+      raise "a history location named #{@name} already exists"
+    else
+      History[@name] = self
+    end
+    @on_state_change = on_state_change
+    @initial_path = @preactivate_path = preactivate_path
+    self.class.setup_handler
+    @listeners = []
+    @location = {
+      addChangeListener: lambda { |listener| @listeners << listener unless @listeners.include? listener} ,
+      removeChangeListener: lambda { |listener| @listeners.delete(listener) },
+      push: lambda { |path| self.class.push_path(path) },
+      pop: lambda { self.class.pop_path },
+      replace: lambda { |path| self.class.replace_path path },
+      getCurrentPath: lambda { (@preactivate_path || self.class.current_path)},
+      toString: lambda { '<HistoryLocation>'}
+    }.to_n
+  end
+
+  def activate(initial_path = nil)
+    puts "activating #{self}"
+    @preactivate_path = nil
+    initial_path ||= @initial_path || self.class.current_path
+    current_history = self.class.history
+    self.class.history = self
+    @starting_history_length = `ReactRouter.History.length` if current_history != self
+    self.class.push_path initial_path
+    @on_state_change.call(:active) if @on_state_change and current_history != self
+    self
+  end
+
+  def deactivate
+    puts "deactivate go(#{@starting_history_length-`ReactRouter.History.length`})"
+    `window.history.go(#{@starting_history_length}-ReactRouter.History.length)`
+    self
+  end
+
+  def notify_listeners(type)
+    puts "#{self}.notify_listeners(#{type}) listeners_count: #{@listeners.count}, path: #{self.class.current_path}"
+    @listeners.each { |listener| `listener.call(#{@location}, {path: #{self.class.current_path}, type: type})` }
+  end
+
+
+end

data/lib/reactive-router/router.rb

@@ -3,6 +3,9 @@ module React
 
   module Router
 
+    class AbortTransition < Exception
+    end
+
     class RR < React::NativeLibrary
       imports ReactRouter
     end
@@ -12,9 +15,56 @@ module React
 
         include React::Component
         include React::IsomorphicHelpers
-        
+
+        native_mixin `ReactRouter.Navigation`
+        native_mixin `ReactRouter.State`
+
+        def get_path
+          path = `self.native.getPath()`
+          path = nil if `typeof path === 'undefined'`
+          path
+        end
+
+        def replace_with(route_or_path, params = nil, query = nil)
+          `self.native.replaceWith.apply(self.native, #{[route_or_path, params].compact})`
+        end
+
+        def transition_to(route_or_path, params = nil, query = nil)
+          `self.native.transitionTo.apply(self.native, #{[route_or_path, params].compact})`
+        end
+
+        static_call_back "willTransitionTo" do |transition, params, query, callback|
+          params = Hash.new(params)
+          query = Hash.new(query)
+          transition = `transition.path`
+          puts "willTransitionTo(#{transition}, #{params}, #{query})"
+          begin
+            params.each do |param, value|
+              if evaluator = url_param_evaluators[param]
+                evaluated_url_params[param] = evaluator.call(value)
+              end
+            end
+            if self.respond_to? :will_transition_to
+              result = will_transition_to transition, params, query if self.respond_to? :will_transition_to
+              if result.is_a? Promise
+                result.then { |r| callback(r) }
+              else
+                callback.call()
+              end
+            else
+              callback.call()
+            end
+          rescue AbortTransition
+            raise "transition aborted"
+          end
+        end
+
         before_first_mount do |context|
-          if `typeof ReactRouter === 'undefined'`
+
+          @evaluated_url_params = {}
+          if !self.instance_methods.include?(:show)  # if there is no show method this is NOT a top level router so we assume routing will begin elsewhere
+            @routing = true
+          elsif `typeof ReactRouter === 'undefined'`
             if on_opal_client?
               message = "ReactRouter not defined in browser assets - you must manually include it in your assets"
             else
@@ -29,14 +79,24 @@ module React
 
         export_component
 
+        optional_param :router_state # optional because it is not initially passed in but we add it when running the router
+        optional_param :query
+        optional_param :params
+
+        def url_params(params)
+          params[:params] || (params[:router_state] && params[:router_state][:params]) || {}
+        end
+
+
         def render
           if self.class.routing?
             show
           elsif on_opal_server?
             self.class.routing!
-            routes = self.class.build_routes
+            routes = self.class.build_routes(true)
             %x{
-              ReactRouter.run(#{routes}, window.reactive_router_static_location, function(root) {
+              ReactRouter.run(#{routes}, window.reactive_router_static_location, function(root, state) {
+                self.native.props.router_state = state
                 self.root = React.createElement(root, self.native.props);
               });
             }
@@ -54,6 +114,12 @@ module React
           was_routing
         end
 
+        # override self.location to provide application specific location handlers
+
+        def location
+          (@location ||= History.new("MainApp")).activate.location
+        end
+
         after_mount do
           unless self.class.routing!
             dom_node = if `typeof React.findDOMNode === 'undefined'`
@@ -61,9 +127,10 @@ module React
             else
               `React.findDOMNode(#{self}.native)`    # v0.13.0
             end
-            routes = self.class.build_routes
+            routes = self.class.build_routes(true)
             %x{
-              ReactRouter.run(#{routes}, ReactRouter.HistoryLocation, function(root) {
+              ReactRouter.run(#{routes}, #{location}, function(root, state) {
+                self.native.props.router_state = state
                 React.render(React.createElement(root, self.native.props), #{dom_node});
               });
             }
@@ -74,17 +141,23 @@ module React
           @routes_opts = opts
           @routes_block = block
         end
-        
-        def self.build_routes
+
+        def self.routes_block
+          @routes_block
+        end
+
+        def self.build_routes(generate_node = nil)
+          #raise "You must define a routes block in a router component" unless @routes_block
           routes_opts = @routes_opts.dup
-          routes_opts[:handler] ||= self 
-          route(routes_opts, generate_node = true, &@routes_block)
+          routes_opts[:handler] ||= self
+          route(routes_opts, generate_node, &@routes_block)
         end
 
         def self.route(opts = {}, generate_node = nil, &block)
+          block ||= opts[:handler].routes_block if opts[:handler].respond_to? :routes_block
           opts = opts.dup
           opts[:handler] = React::API.create_native_react_class(opts[:handler])
-          (generate_node ? RR::Route_as_node(opts, &block) : RR::Route(opts, &block)) 
+          (generate_node ? RR::Route_as_node(opts, &block) : RR::Route(opts, &block))
         end
 
         def self.default_route(ops = {}, &block)
@@ -95,6 +168,11 @@ module React
           RR::Redirect(opts, &block)
         end
 
+        def self.not_found(opts={}, &block)
+          opts[:handler] = React::API.create_native_react_class(opts[:handler])
+          RR::NotFoundRoute(opts, &block)
+        end
+
       end
     end
 

data/lib/reactive-router/version.rb

@@ -1,3 +1,3 @@
 module ReactiveRouter
-  VERSION = "0.7.3"
+  VERSION = "0.7.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reactive-router
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.7.4
 platform: ruby
 authors:
 - Adam George
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-07 00:00:00.000000000 Z
+date: 2015-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -64,6 +64,7 @@ files:
 - Rakefile
 - lib/reactive-router.rb
 - lib/reactive-router/component.rb
+- lib/reactive-router/history.rb
 - lib/reactive-router/router.rb
 - lib/reactive-router/version.rb
 - lib/reactive-router/window_location.rb