routable 0.0.1

data/.gitignore

@@ -0,0 +1,9 @@
+.repl_history
+build
+resources/*.nib
+resources/*.momd
+resources/*.storyboardc
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in Routable.gemspec
+gemspec

data/README.md

@@ -0,0 +1,87 @@
+# Routable
+A UIViewController->URL router.
+
+```ruby
+  @router.map("profile/:id", ProfileController)
+
+  # Later on...
+
+  # Pushes a ProfileController with .initWithParams(:id => 189)
+  @router.open("profile/189")
+```
+
+Why is this awesome? Because now you can push any view controller from any part of the app with just a string: buttons, push notifications, anything.
+
+## Installation
+
+```ruby
+gem install routable
+```
+
+And now in your Rakefile, require `routable`:
+
+```ruby
+$:.unshift("/Library/RubyMotion/lib")
+require 'motion/project'
+require 'routable'
+
+Motion::Project::App.setup do |app|
+  ...
+end
+```
+
+## Setup
+
+For every UIViewController you want routable with `:symbolic` params, you need to define `.initWithParams({})`.
+
+```ruby
+class ProfileController < UIViewController
+  attr_accessor :user_id
+
+  def initWithParams(params = {})
+    init()
+    self.user_id = params[:user_id]
+    self
+  end
+end
+```
+
+Here's an example of how you could setup Routable for the entire application:
+
+```ruby
+class AppDelegate
+  def application(application, didFinishLaunchingWithOptions:launchOptions)
+
+    @window = UIWindow.alloc.initWithFrame(UIScreen.mainScreen.bounds)
+    @window.makeKeyAndVisible
+
+    # Make our URLs
+    map_urls
+
+    # .open(url, animated)
+    if User.logged_in_user
+      @router.open("menu", false)
+    else
+      @router.open("login", false)
+    end
+
+    true
+  end
+
+  def map_urls
+    @router = Routable::Router.router
+    @router.navigation_controller = UINavigationController.alloc.init
+
+    # :modal means we push it modally.
+    @router.map("login", LoginController, modal: true)
+    # :shared means it will only keep one instance of this VC in the hierarchy;
+    # if we push it again later, it will pop any covering VCs.
+    @router.map("menu", MenuController, shared: true)
+    @router.map("profile/:id", ProfileController)
+    @router.map("messages", MessagesController)
+    @router.map("message/:id", MessageThreadController)
+
+    @window.rootViewController = @router.navigation_controller
+  end
+end
+```

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/Routable.gemspec

@@ -0,0 +1,16 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/routable/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "routable"
+  s.version     = Routable::VERSION
+  s.authors     = ["Clay Allsopp"]
+  s.email       = ["clay.allsopp@gmail.com"]
+  s.homepage    = "https://github.com/clayallsopp/Routable"
+  s.summary     = "A RubyMotion UIViewController -> URL router"
+  s.description = "A RubyMotion UIViewController -> URL router"
+
+  s.files         = `git ls-files`.split($\)
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+end

data/app/app_delegate.rb

@@ -0,0 +1,15 @@
+class AppDelegate
+  attr_reader :navigation_controller
+
+  def application(application, didFinishLaunchingWithOptions:launchOptions)
+    @window = UIWindow.alloc.initWithFrame(UIScreen.mainScreen.bounds)
+    @window.rootViewController = self.navigation_controller
+    @window.rootViewController.wantsFullScreenLayout = true
+    @window.makeKeyAndVisible
+    true
+  end
+
+  def navigation_controller
+    @navigation_controller ||= UINavigationController.alloc.init
+  end
+end

data/lib/routable/ns_object.rb

@@ -0,0 +1,23 @@
+class NSObject
+  def add_block_method(sym, &block)
+    block_methods[sym] = block
+    nil
+  end
+
+  def method_missing(sym, *args, &block)
+    if block_methods.keys.member? sym
+      return block_methods[sym].call(*args, &block)
+    end
+    raise NoMethodError.new("undefined method `#{sym}' for " + "#{self.inspect}:#{self.class.name}")
+  end
+
+  def methods
+    methods = super
+    methods + block_methods.keys
+  end
+
+  private
+  def block_methods
+    @block_methods ||= {}
+  end
+end

data/lib/routable/router.rb

@@ -0,0 +1,160 @@
+module Routable
+  class Router
+    # Singleton, for practical use (you might not want)
+    # to have more than one router.
+    class << self
+      def router
+        @router ||= Router.new
+      end
+    end
+
+    # The root UINavigationController we use to push/pop view controllers
+    attr_accessor :navigation_controller
+
+    # Hash of URL => UIViewController classes
+    # EX
+    # {"users/:id" => UsersController,
+    #  "users/:id/posts" => PostsController,
+    #  "users/:user_id/posts/:id" => PostController }
+    def routes
+      @routes ||= {}
+    end
+
+    # Map a URL to a UIViewController
+    # EX
+    # router.map "/users/:id", UsersController
+    # OPTIONS
+    #   :modal => true/false
+    #     - We present the VC modally (router is not shared between the new nav VC)
+    #   :shared => true/false
+    #     - If URL is called again, we pop to that VC if it's in memory.
+
+    def map(url, klass, options = {})
+      format = url
+      self.routes[format] = options.merge!(klass: klass)
+    end
+
+    # Push the UIViewController for the given url
+    # EX
+    # router.open("users/3")
+    # => router.navigation_controller pushes a UsersController
+    def open(url, animated = true)
+      controller_options = options_for_url(url)
+      controller = controller_for_url(url)
+      if self.navigation_controller.modalViewController
+        self.navigation_controller.dismissModalViewControllerAnimated(animated)
+      end
+      if controller_options[:modal]
+        if controller.class == UINavigationController
+          self.navigation_controller.presentModalViewController(controller, animated: animated)
+        else
+          tempNavigationController = UINavigationController.alloc.init
+          tempNavigationController.pushViewController(controller, animated: false)
+          self.navigation_controller.presentModalViewController(tempNavigationController, animated: animated)
+        end
+      else
+        if self.navigation_controller.viewControllers.member? controller
+          self.navigation_controller.popToViewController(controller, animated:animated)
+        else
+          self.navigation_controller.pushViewController(controller, animated:animated)
+        end
+      end
+    end
+
+    def options_for_url(url)
+      # map of url => options
+
+      @url_options_cache ||= {}
+      if @url_options_cache[url]
+        return @url_options_cache[url]
+      end
+
+      parts = url.split("/")
+
+      open_options = nil
+      open_params = {}
+
+      self.routes.each { |format, options|
+
+        # If the # of path components isn't the same, then
+        # it for sure isn't a match.
+        format_parts = format.split("/")
+        if format_parts.count != parts.count
+          next
+        end
+
+        matched = true
+        format_params = {}
+        # go through each of the path compoenents and
+        # check if they match up (symbols aside)
+        format_parts.each_with_index {|format_part, index|
+          check_part = parts[index]
+
+          # if we're looking at a symbol (ie :user_id),
+          # then note it and move on.
+          if format_part[0] == ":"
+            format_params[format_part[1..-1].to_sym] = check_part
+            next
+          end
+
+          # if we're looking at normal strings,
+          # check equality.
+          if format_part != check_part
+            matched = false
+            break
+          end
+        }
+
+        if !matched
+          next
+        end
+
+        open_options = options
+        open_params = format_params
+      }
+
+      if open_options == nil
+        raise "No route found for url #{url}"
+      end
+
+      @url_options_cache[url] = open_options.merge(open_params: open_params)
+    end
+
+    # Returns a UIViewController for the given url
+    # EX
+    # router.controller_for_url("users/3")
+    # => #<UsersController @id='3'>
+    def controller_for_url(url)
+      return shared_vc_cache[url] if shared_vc_cache[url]
+
+      open_options = options_for_url(url)
+      open_params = open_options[:open_params]
+      open_klass = open_options[:klass]
+      controller = open_klass.alloc
+      if controller.respond_to? :initWithParams
+        controller = controller.initWithParams(open_params)
+      else
+        controller = controller.init
+      end
+      if open_options[:shared]
+        shared_vc_cache[url] = controller
+        # when controller.viewDidUnload called, remove from cache.
+        controller.add_block_method :new_dealloc do
+          shared_vc_cache.delete url
+        end
+        controller.instance_eval do
+          def viewDidUnload
+            new_dealloc
+            super
+          end
+        end
+      end
+      controller
+    end
+
+    private
+    def shared_vc_cache
+      @shared_vc_cache ||= {}
+    end
+  end
+end

data/lib/routable/version.rb

@@ -0,0 +1,3 @@
+module Routable
+  VERSION = "0.0.1"
+end

data/lib/routable.rb

@@ -0,0 +1,11 @@
+require "routable/version"
+
+unless defined?(Motion::Project::Config)
+  raise "This file must be required within a RubyMotion project Rakefile."
+end
+
+Motion::Project::App.setup do |app|
+  Dir.glob(File.join(File.dirname(__FILE__), 'routable/*.rb')).each do |file|
+    app.files.unshift(file)
+  end
+end

data/spec/main_spec.rb

@@ -0,0 +1,71 @@
+class UsersTestController < UIViewController
+  attr_accessor :user_id
+
+  def initWithParams(params = {})
+    init()
+    self.user_id = params[:user_id]
+    self
+  end
+end
+
+class NoParamsController < UIViewController
+end
+
+describe "the url router" do
+  before do
+    @router = Routable::Router.new
+
+    @nav_controller = UINavigationController.alloc.init
+    @nav_controller.setViewControllers([], animated: false)
+    @nav_controller.viewControllers.count.should == 0
+  end
+
+  def make_test_controller_route
+    format = "users/:user_id"
+    @router.map(format, UsersTestController)
+    @router.routes.should == {format => {:klass => UsersTestController}}
+  end
+
+  it "maps the correct urls" do
+    make_test_controller_route
+
+    user_id = "1001"
+    controller = @router.controller_for_url("users/#{user_id}")
+    controller.class.should == UsersTestController
+    controller.user_id.should == user_id
+  end
+
+  it "opens urls with no params" do
+    @router.navigation_controller = @nav_controller
+    @router.map("url", NoParamsController)
+    @router.open("url")
+    @router.navigation_controller.viewControllers.count.should == 1
+  end
+
+  it "opens nav controller to url" do
+    @router.navigation_controller = @nav_controller
+    make_test_controller_route
+    @router.open("users/3")
+
+    @nav_controller.viewControllers.count.should == 1
+    @nav_controller.viewControllers.last.class.should == UsersTestController    
+  end
+
+  it "uses the shared properties correctly" do
+    shared_format = "users"
+    format= "users/:user_id"
+
+    @router.map(format, UsersTestController)
+    @router.map(shared_format, UsersTestController, shared: true)
+    @router.navigation_controller = @nav_controller
+    @router.open("users/3")
+    @router.open("users/4")
+    @router.open("users")
+    @router.open("users/5")
+
+    @nav_controller.viewControllers.count.should == 4
+
+    @router.open("users")
+    @nav_controller.viewControllers.count.should == 3
+  end
+end

data/spec/ns_object_spec.rb

@@ -0,0 +1,21 @@
+describe "the ns object hack router" do
+  it "alias method trick works" do
+    object = "hello"
+    side_effect = false
+
+    object.add_block_method :new_upcase! do
+      side_effect = true
+    end
+
+    object.instance_eval do
+      def upcase!
+        new_upcase!
+        super
+      end
+    end
+
+    object.upcase!
+    side_effect.should == true
+    object.should == "HELLO"
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: routable
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Clay Allsopp
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-05-23 00:00:00 Z
+dependencies: []
+
+description: A RubyMotion UIViewController -> URL router
+email: 
+- clay.allsopp@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- Routable.gemspec
+- app/app_delegate.rb
+- lib/routable.rb
+- lib/routable/ns_object.rb
+- lib/routable/router.rb
+- lib/routable/version.rb
+- spec/main_spec.rb
+- spec/ns_object_spec.rb
+homepage: https://github.com/clayallsopp/Routable
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: A RubyMotion UIViewController -> URL router
+test_files: 
+- spec/main_spec.rb
+- spec/ns_object_spec.rb