ruta 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6a8777ca0158cf75be951622603e8213369e4d41
+  data.tar.gz: fa3f3d3ce7a1713c25c9928b1493a5a4ed1e7299
+SHA512:
+  metadata.gz: ffcd6159486425e1d7f7d827d30fc5767dab0e5a4d9a1ddb8e151f00cc2f259f503f07568d957690c8970ffaed9a97bc6f49dbc53a92dec366f55825e239214f
+  data.tar.gz: acd9e9a34d23d88e0cb44bbd525c0917ef50773d6c59e07035855d0e4bbe7817e9f4c17293ff367a4524fdf690491f4e8e50f3418c716ee3005823cce69377d6

data/.gitignore

@@ -0,0 +1,61 @@
+# Compiled source #
+###################
+*target
+*.war
+*.ear
+*.com
+*.class
+*.dll
+*.exe
+*.o
+*.so
+
+# Packages #
+############
+# it's better to unpack these files and commit the raw source
+# git has its own built in compression methods
+*.7z
+*.dmg
+*.gz
+*.iso
+*.jar
+*.rar
+*.tar
+*.zip
+*.gem
+
+# Logs and databases #
+######################
+*.log
+*.sql
+*.sqlite
+
+# OS generated files #
+######################
+**/.DS_Store
+**/.DS_Store?
+**/._*
+**/.Spotlight-V100
+**/.Trashes
+**/ehthumbs.db
+**/Thumbs.db
+**/desktop.ini
+
+# text/IDE editor generated files #
+###################################
+**/*~
+**/*#
+**/*.pyo
+**/*.pyc
+**/*.bak
+**/*.swp
+**/.idea
+
+#     misc files     #
+######################
+#any supporting credentials used during testings goes in a .creds file but is loaded like any other ruby file
+**/*.creds
+#sass cache folder
+.sass-cache
+#files generated by git diff
+**/.orig

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.10.6

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    ruta (0.1.0)
+      opal (~> 0.8)
+      opal-browser (~> 0.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    concurrent-ruby (1.0.0)
+    hike (1.2.3)
+    opal (0.8.1)
+      hike (~> 1.2)
+      sourcemap (~> 0.1.0)
+      sprockets (~> 3.1)
+      tilt (>= 1.4)
+    opal-browser (0.2.0)
+      opal
+      paggio
+    paggio (0.2.5)
+    rack (1.6.4)
+    rake (10.4.2)
+    sourcemap (0.1.1)
+    sprockets (3.5.2)
+      concurrent-ruby (~> 1.0)
+      rack (> 1, < 3)
+    tilt (2.0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.10)
+  rake (~> 10.0)
+  ruta!
+
+BUNDLED WITH
+   1.10.6

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Martin Becker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,188 @@
+# Ruta
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ruta'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ruta
+
+## Usage
+
+Making use of this router is pretty simple.
+
+###Contexts
+
+The first thing to do is to define your contexts.
+
+A context is a composition of on screen component containers, routes and handlers.
+
+You can even place another context under a context as a sub-context
+
+`component` is used to define a container, you give it a name and then a block and inside of which you
+place a renderable component.
+
+you can also use `sub_context` to mount a sub-context at this position, first you give it a name then
+a reference to the context you wish to place here.
+
+This initial composition is used to as the default settings for when the context is first rendered
+
+```ruby
+Ruta::Context.define :main do
+  component :header do
+    Header
+  end
+
+  sub_context :info, :info_view
+
+  component :footer do
+    Footer
+  end
+end
+
+
+Ruta::Context.define :info_view do
+  component :hero do
+    Hero_Image
+  end
+
+  component :scroller do
+    Info_Scroller
+  end
+
+  component :buttons do
+    Buttons
+  end
+end
+
+Ruta::Context.define :sign_up do
+  component :sign_up_form do
+    Sign_Up_Form
+  end
+end
+```
+
+###Handlers
+
+Next you should define some handlers, not every component needs a handler but every component has one
+needs to match names with a corresponding handler.
+
+you use the `handle` method to define a handler and you pass into it the name of the element you want this
+handler to drive.
+
+The handler has two variables passed to it:
+
+1. `params` a hash containing the named params of the route
+2. `url` a string containing the url of the route being passed to the handler
+
+The handler must return a renderable component.
+
+```ruby
+Ruta::Handlers.define_for :main do
+
+end
+
+Ruta::Handlers.define_for :info_view do
+  handle :scroller do |params,url|
+    Info_Scroller.render(page: params[:switch_to])
+  end
+
+  handle :buttons do |params,url|
+    Buttons.render(selected: params[:switch_to])
+  end
+end
+
+Ruta::Handlers.define_for :sign_up do
+
+end
+```
+
+###Routes
+
+The last thing to define before your app is ready is the routes that will activate the correct handlers to
+drive onscreen components.
+
+Roots that drive on screen components should always be mounted to a context.
+You can state the context using `for_context` then pass in the context you wish to define routes for.
+whilst you can place context's within each other this doesn't actually do anything beyond aesthetics, but
+it's planned that you can mount contexts to routes
+
+You map a route by using the `map` command then pass a unique reference (to that context) for the route,
+the route you want to match against and then the driver, one or more handlers; remember handlers are
+executed in the order specified. You can also provide a context that the route will activate.
+
+To set the initial context that is presented use `root_to` then provide the context you want to be rendered first
+
+```ruby
+Ruta::Router.define do
+  for_context :main do
+    for_context :info_view do
+      map :i_switch, '/buttons/:switch_to', to: [:scroller,:buttons]
+      map :sign_up, '/sign_up', context: :sign_up
+    end
+  end
+
+  root_to :main
+end
+
+```
+
+###Renderer
+
+The last step is to tell the router how to render your components.
+
+You do this using `Ruta::Context.handle_render` and then creating a macro.
+Passed into the macro is the `component` you wish to render and the `element_id` of the components mounting
+point.
+
+```ruby
+Ruta::Context.handle_render do |component,element_id|
+  element = if component.class == React::Element
+    component
+  else
+    React.create_element(component)
+  end
+  React.render element, `document.getElementById(#{element_id})`
+end
+```
+
+###starting the app
+
+The last step is to start the router and thus your app this can be accomplished by using `Ruta.start_app`;
+it's best to wrap this inside of a `$document.ready` block so that the app will only start when the dom is
+fully ready.
+```ruby
+$document.ready do
+  Ruta.start_app
+end
+```
+
+### Example
+
+Here is an [example app](https://github.com/Thermatix/ruta_with_reactrb_example) where you can see the router in action, remember to `bundle install` first before running with `rackup`
+
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake false` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/ruta. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

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

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ruta"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/ruta/context.rb

@@ -0,0 +1,153 @@
+# stores contexts
+module Ruta
+  class Context
+
+    # @!attribute [r] elements
+    # @return [{ref => { attributes: {},type: Symbol, content: Proc,Symbol}] Hash of all elements defined
+
+    # @!attribute [r] ref
+    # @return [Symbol] this contexts reference in (see #Context#collection)
+
+    # @!attribute [r,w] handlers
+    # @return [{ref => Proc}] list of route handlers attached to this context
+
+    # @!attribute [r,w] routes
+    # @return [{ref => Route}] list of all routes attached to this context
+
+    attr_reader :elements, :ref
+    attr_accessor :handlers, :routes,:sub_contexts
+    DOM = ::Kernel.method(:DOM)
+
+    # @see #Context#handle_render
+    def initialize ref,block
+        @ref = ref
+        @elements = {}
+        @handlers = {}
+        @routes = {}
+        @sub_contexts = []
+        instance_exec &block if block
+    end
+
+    # an element of the composition
+    #
+    # @param [Symbol] id of element to mount element contents to
+    # @param [{Symbol => String,Number,Boolean}] list of attributes to attach to tag
+    # @yield block containing component to be rendered to page
+    # @yieldreturn [Object] a component that will be passed to the renderer to be rendered to the page
+    def component id,attribs={}, &block
+        self.elements[id] = {
+          attributes: attribs,
+          type: :element,
+          content: block
+        }
+    end
+
+    # mount a context as a sub context here
+    #
+    # @param [Symbol] id of component to mount context to
+    # @param [Symbol] ref of context to be mounted
+    # @param [{Symbol => String,Number,Boolean}] list of attributes to attach to tag
+    def sub_context id,ref,attribs={}
+      @sub_contexts << ref
+      self.elements[id] = {
+        attributes: attribs,
+        type: :sub_context,
+        content: ref,
+      }
+    end
+
+
+    class << self
+      # @!attribute [r] collection
+      # @return [{ref => Context}] Hash of all Contexts created
+
+      # @!attribute [r] renderer
+      # @return [Proc] the renderer used to render and or mount components on to the DOM
+
+      # @!attribute [r,w] current_context
+      # @return [Symbol] The reference to the current context being rendered
+
+
+      attr_reader :collection,:renderer
+      attr_accessor :current_context
+
+      # Used to tell the router how to render components to the DOM
+      #
+      # @example render a react.rb component to the dom
+      #   Ruta::Context.handle_render do |object,element_id|
+      #     React.render React.create_element(object), `document.getElementById(#{element_id})`
+      #   end
+      # @yield [object,element_id] A block of code that gets executed to render a given object to a given element id
+      # @yieldparam [Object] object to be rendered
+      # @yieldparam [String] ID of page element object will be mounted to
+      def handle_render &block
+        @renderer = block
+      end
+
+      # used to define a context's page composition
+      #
+      # @example Define a composition for a context called :main
+      #   Ruta::Context.define :main do
+      #     element :header do
+      #       #some code that returns a component
+      #     end
+      #
+      #     sub_context :info, :info_view
+      #
+      #     element :footer do
+      #       #some code that returns a component
+      #     end
+      #   end
+      # @param [Symbol] ref reference to the context being defined
+      # @yield a block that is used to define the composition of a context
+      def define ref, &block
+        @collection[ref] = new(ref,block)
+      end
+
+      # used to wipe clear an elementt's content
+      #
+      # @param [String] id of element to be cleared, if no id is provided will clear body tag of content
+      def wipe id=nil
+        if id
+          $document[id].clear
+        else
+          $document.body.clear
+        end
+      end
+
+      # used to render a composition to the screen
+      #
+      # @param [Symbol] context the context to render
+      # @param  [String] id of element context is to be rendered to, if no id is provided will default to body tagt
+      def render context, id=nil
+        this = id ? $document[id]: $document.body
+        context_to_render = @collection[context]
+        render_context_elements context_to_render,context, this
+        render_element_contents context_to_render,context
+      end
+      private
+      def render_context_elements context_to_render,context,this
+        context_to_render.elements.each do |element_name,details|
+          DOM {
+            div(details[:attributes].merge(id: element_name, "data-context" => context))
+          }.append_to(this)
+        end
+      end
+
+      def render_element_contents context_to_render,context
+        @current_context = context
+        context_to_render.elements.each do |element_name,details|
+          case details[:type]
+          when :sub_context
+            render details[:content],element_name
+          when :element
+            @renderer.call(details[:content].call,element_name,context)
+          end
+        end
+        @current_context = :no_context
+      end
+    end
+    @collection = {}
+    @current_context = :no_context
+  end
+end

data/lib/ruta/handler.rb

@@ -0,0 +1,55 @@
+module Ruta
+  class Handlers
+
+    # create a handle to be excuted when a matching route is hit
+    #
+    # @param [Symbol] handler_name the unique ident of the handler, it should match the id of an element that you want the component to be rendered to
+    # @yield [params,path] a block containing logic for processing any params before passing it to a component to render
+    # @yieldparam [{Symbol => String}] params containing a list of params passed into it from the matching route
+    # @yieldparam [String] path the non processed url
+    # @yieldreturn [Object] a component that will be passed to the renderer to be rendered to the page
+    def handle handler_name,&handler
+        @handler_name = handler_name
+        @context.handlers[@handler_name] = handler
+    end
+
+    # @see #Handlers#define_for
+    def initialize context,block
+      @context = context
+      instance_exec &block
+    end
+
+    # wipe the matching element and render a context
+    #
+    # @param [Symbol] context context to be mounted to matching element of handler
+    # @todo Move these functions to execution context?
+    # @return [Proc] returns a proc to be executed later
+    def mount context
+      handler_name = @handler_name
+      proc {
+        Context.wipe handler_name
+        Context.render context
+      }
+    end
+
+    class << self
+      # define handlers for a context
+      #
+      # @example
+      # Ruta::Handlers.define_for :main do
+      #  handler :header do |params,url|
+      #   some code that process the params and returns a component
+      #  end
+      #  handler :header do |params,url|
+      #   some code that process the params and returns a component
+      #  end
+      # end
+      # @param [Symbol] context to define handlers for
+      # @yield block containing handlers for a context
+      def define_for context, &block
+         new(Context.collection.fetch(context){|c_n|raise"Tried to define handlers for #{c_n} before it exists"},
+         block)
+      end
+    end
+  end
+end

data/lib/ruta/history.rb

@@ -0,0 +1,106 @@
+require 'native'
+module Ruta
+
+  class History
+    class << self
+
+      # push new url to history
+      #
+      # @param [String] url to be added to history
+      # @param [Hash] data to be added to history
+      # @param [String] title to be added to history, defaults to ""
+      def push(url,data,title="")
+        `history.pushState(#{data.to_n}, #{title}, #{url})`
+      end
+
+      # replace current url in history
+      #
+      # @param [String] url to replace current item in history
+      # @param [Hash] data to replace current item in history
+      # @param [String] title to replace current item in history, defaults to ""
+      def replace(url,data,title=nil)
+        `history.replaceState(#{data.to_n}, #{title}, #{url})`
+      end
+
+      # move browser forward
+      #
+      # @param [Integer] by the amount to go forwards by, defaults to 1
+      def forward(by=1)
+        `history.go(#{by.to_i})`
+      end
+
+      # move browser backwards
+      #
+      # @param [Integer] by the amount to go backwards by, defaults to 1
+      def back(by=1)
+        `history.go(#{-by.to_i})`
+      end
+
+      # navigate browser to remote path
+      #
+      # @param [String] path to navigate to
+      def navigate_to_remote path
+        `location.href = #{path}`
+      end
+
+      # get current `thing` from locaction
+      #
+      # current things supported are:
+      #   * query
+      #   * fragment
+      #   * path
+      #   * url
+      #   * uri
+      # @param [Symbol] thing to get the current value of from the current location
+      def current thing
+        case thing
+        when :query
+          `location.query`
+        when :fragment
+        `  location.fragment`
+        when :path
+          `location.pathname`
+        when :url
+          `location.href`
+        when :uri
+          `location.uri`
+        end
+
+      end
+
+      # will turn on a listener for when the forward and backward buttons on the browser are pressed
+      def listen_for_pop
+        `window.onpopstate = function(event) {
+          #{
+              Router.find_and_execute(current :path)
+          }
+        }`
+      end
+
+      # will stop listening for when forward and backward buttons on the browser are pressed
+      def stop_listening_for_pop
+        `window.onpopstate = nil`
+      end
+
+      # will stop listening for when the page move away from the current page(refresh or back), will present user with dialogue box
+      def stop_listening_for_on_before_load
+        `window.onbeforeunload = nil`
+      end
+
+
+      # will turn on a listener for when the page move away from the current page(refresh or back), will present user with dialogue box
+      def listen_for_on_before_load
+        `window.onbeforeunload = function (evt) {
+          var message = 'Are you sure you want to leave?';
+         if (typeof evt == 'undefined') {
+           evt = window.event;
+         }
+         if (evt) {
+           evt.returnValue = message;
+         }
+         return message;
+        }`
+      end
+    end
+  end
+end

data/lib/ruta/route.rb

@@ -0,0 +1,139 @@
+module Ruta
+  # this class was taken from vienna and modified
+  # https://github.com/opal/vienna/blob/master/opal/vienna/router.rb#L42
+  class Route
+    DOM = ::Kernel.method(:DOM)
+    NAMED = /:(\w+)/
+
+    SPLAT = /\\\*(\w+)/
+
+    OPTIONAL = /\\\((.*?)\\\)/
+
+    # @!attribute [r] regexp
+    # @return [Symbol] the regexp used to match against a route
+    # @!attribute [r] named
+    # @return [Symbol] list of all named paramters
+    # @!attribute [r] type
+    # @return [Symbol] the type of the route's handler
+    # @!attribute [r] handlers
+    # @return [Symbol] a list of the handlers this route is suposed to execute
+    # @!attribute [r] url
+    # @return [Symbol] the raw url to match against
+    # @!attribute [r] flags
+    # @return [Symbol] any flags this route possesses
+
+     attr_reader :regexp, :named, :type, :handlers, :url,:flags
+
+    # @param [String] pattern of url to match against
+    # @param [Symbol] context_ref to context route is mounted to
+    # @param [{Symbol => String,Number,Boolean}] flags attached to route
+    def initialize(pattern, context_ref,flags)
+
+     if flags[:to]
+       @type = :handlers
+       @handlers = [flags.delete :to].flatten
+     elsif flags[:context]
+       @type = :context
+       @handlers = flags.delete :context
+     else
+       @type = :ref_only
+     end
+     @context_ref = context_ref
+     @flags = flags
+     @url = pattern
+     @named = []
+
+     pattern = Regexp.escape pattern
+     pattern = pattern.gsub OPTIONAL, "(?:$1)?"
+
+     pattern.gsub(NAMED) { |m| @named << m[1..-1] }
+     pattern.gsub(SPLAT) { |m| @named << m[2..-1] }
+
+     pattern = pattern.gsub NAMED, "([^\\/]*)"
+     pattern = pattern.gsub SPLAT, "(.*?)"
+
+     @regexp = Regexp.new "^#{pattern}$"
+
+    end
+
+    #take in params and return a paramaterized route
+    #
+    # @param [Array<String,Number,Boolean>] params a list of params to replace named params in a route
+    # @return [String] url containing named params replaced
+    def paramaterize params
+     segments = @url.split('/')
+     segments.map { |item| item[0] == ':' ? params.shift : item }.join('/')
+    end
+
+    # get route hash and paramaterize url if needed
+    #
+    # @param [Array<String,Number,Boolean>] params to replace named params in the returned url
+    # @return [Symbol => Number,String,Route] hash specificly formatted:
+    #  {
+    #    url: of the route with named params replaced,
+    #    title: the name of page if the url has one,
+    #    params: a list of all the params used in the route,
+    #    route: the #Route object
+    #  }
+    def get params=nil
+     path = if params
+       paramaterize params.dup
+     else
+       @url
+     end
+     {
+         path: path,
+         title: self.flags.fetch(:title){nil},
+         params: params_hash(params),
+         route: self
+     }
+    end
+
+    # match this route against a given path
+    #
+    # @param [String,Regex] path to match against
+    # @return [Hash,false] (see #get) or false if there is no match
+    def match(path)
+       if match = @regexp.match(path)
+         params = {}
+         @named.each_with_index { |name, i| params[name] = match[i + 1] } if @type == :handlers
+         {
+             path: path,
+             title: self.flags.fetch(:title){nil},
+             params: params,
+             route: self
+         }
+       else
+         false
+       end
+    end
+
+    # execute's route's associated handlers
+    #
+    # @param [Symbol => String] params from the route with there respective keys
+    # @param [String] path containing params placed into there respective named positions
+    def execute_handler params={},path=nil
+     case @type
+     when :handlers
+       @handlers.each do |handler_ident|
+         handler = @context_ref.handlers.fetch(handler_ident) {raise "handler #{handler_ident} doesn't exist in context #{@context_ref.ref}"}
+         component = handler.(params,path||@url,&:call)
+         Context.current_context = @context_ref.ref
+         if component.class == Proc
+           component.call
+         else
+           Context.renderer.call(component,handler_ident)
+         end
+         Context.current_context = :no_context
+       end
+     when :context
+       Context.wipe
+       Context.render handlers
+     end
+    end
+
+    def params_hash(params)
+      Hash[@named.zip(params)]
+    end
+  end
+end

data/lib/ruta/router.rb

@@ -0,0 +1,128 @@
+# matches routes to a handeler
+module Ruta
+
+  class Router
+
+
+    # @todo: ensure sub-context routes are mounted into parent context routes
+
+    # @!attribute [r,w] current_context
+    # @return [Array<Symbol>] current_context a list of contexts, the last being the current
+
+    attr_accessor :current_context
+
+    # @see (see #Router#define)
+    def initialize block
+      @current_context = []
+      Context.define(:no_context)
+      instance_exec &block
+    end
+
+    # set which Context to map the following routes to
+    #
+    # @param [Symbol] context to map routes to
+    def for_context context
+      @current_context << context
+      yield
+      @current_context.pop
+    end
+
+    #  map a route
+    # @param [Symbol] ref to map route to for easy future reference
+    def map ref,route, options={}
+      context = Context.collection[get_context]
+      context.routes[ref]= Route.new(route, context,options)
+    end
+
+    # set the root context, this is the initial context that will be renered by the router
+    #
+    # @note there is only ever one root, calling this multiple times will over right the original root
+    # @param [Symbol] reference to context
+    def root_to reference
+      Router.set_root_to reference
+      context = Context.collection[:no_context]
+      context.routes[:root]= Route.new('/', context,{ context: reference})
+    end
+
+    private
+
+    def get_context
+      @current_context.last || :no_context
+    end
+
+    class << self
+
+      # @!attribute [r] current_context
+      # @return [Array<Symbol>] current_context the current context that the user is in
+
+      # @!attribute [r] history
+      # @return [Array<Symbol>] history
+
+      # @!attribute [r] window
+      # @return [Array<Symbol>] window
+
+      # @!attribute [r] root
+      # @return [Array<Symbol>] root the initial context of the app
+
+      attr_reader :current_context, :root
+
+      # define a router, this can be called multiple times
+      # @example defining routes
+      #   Ruta::Router.define do
+      #     for_context :main do
+      #       for_context :info_view do
+      #         map :i_switch, '/buttons/:switch_to', to: [:scroller,:buttons]
+      #         map :sign_up, '/sign_up', context: :sign_up
+      #       end
+      #     end
+      #
+      #     root_to :main
+      #   end
+      # @note please be aware that placing contexts within other contexts doesn't actully do anything.
+      #   however it is planed to be able to mount sub contexts to a route and re-direct as neccasary
+      #   think mounting engines or sub apps in RoR or Padrino
+      # @yield Use this block to define any routes
+      def define &block
+        new block
+      end
+
+      def set_context_to context
+        @current_context = context
+      end
+
+      def find_and_execute(path)
+        res = find(path)
+        if res
+          navigate_to res
+        else
+          raise "no matching route for #{path}"
+        end
+      end
+
+      def find path
+        Context.collection.each do |con_ref,context|
+          context.routes.each do |r_ref,route|
+            res = route.match(path)
+            return res if res
+          end
+        end
+        false
+      end
+
+      def navigate_to(route)
+        route[:route].execute_handler route[:params],route[:path]
+      end
+
+      def route_for context, ref,params=nil
+        Context.collection[context].routes[ref].get(params)
+      end
+
+      def set_root_to context
+        @root = context
+        Router.set_context_to root
+      end
+
+    end
+
+  end
+end

data/lib/ruta/version.rb

@@ -0,0 +1,3 @@
+module Ruta
+  VERSION = "1.0.0"
+end

data/lib/ruta.rb

@@ -0,0 +1,62 @@
+# @todo: Ensure sub-context routes are mounted into parent context routes
+# @todo: Allow empty components to be exists and ensure they are only rendered when they are not blank
+
+if RUBY_ENGINE == 'opal'
+  require 'browser'
+  require 'browser/history'
+
+  require 'ruta/context'
+  require 'ruta/handler'
+  require 'ruta/history'
+  require 'ruta/route'
+  require 'ruta/router'
+  require 'ruta/version'
+
+
+  module Ruta
+    class << self
+
+
+
+      # used to retrive a stored url
+      #
+      # @param [Symbol] context of the stored url, if this is nil it defaults to the current context
+      # @param [Symbol] reference to the route
+      # @param [Array<String,Number,Boolean>] *params 0 or more params to replace params in the paramterized route
+      # @return [String] string containing url with any params given correctly inserted
+      def get_url_for context, reference, *params
+        Router.route( context || Router.current_context, reference, params)[:path]
+      end
+
+      # used to navigate to a route
+      # @param [Symbol] context that route is mounted to
+      # @param [Symbol] ref to a route that you wish to navigate to
+      # @param [Array<String,Number,Boolean>] *params 0 or more params to replace params in the paramterized route
+      # @note you have to use this function as a proc direcly as in the example, if you place this into a callback block and call it there, you will find that the incorrect context is used for the route
+      # @return [Proc] A proc that can be used as a callback block for an event
+      def navigate_to_ref context, ref,*params
+        route = Router.route_for(context,ref,params)
+        History.push(route[:path],route[:params],route[:title])
+        Router.navigate_to(route)
+      end
+
+      # used to start the app
+      # @example app start command placed inside of $document.ready block
+      #   $document.ready do
+      #     Ruta.start_app
+      #   end
+      def start_app
+        Context.render(Router.current_context)
+        History.listen_for_pop
+      end
+    end
+
+  end
+
+
+else
+  require "ruta/version"
+  require 'opal'
+  lib_path = File.dirname(File.expand_path('.', __FILE__))
+  Opal.append_path lib_path
+end

data/ruta.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruta/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruta"
+  spec.version       = Ruta::VERSION
+  spec.authors       = ["Martin Becker",'Adam Beynon']
+  spec.email         = ["mbeckerwork@gmail.com",'adam.beynon@gmail.com']
+
+  spec.summary       = %q{Front end agnostic router built in opal}
+  spec.homepage      = "https://github.com/Thermatix/ruta"
+  spec.license       = "MIT"
+
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "opal", "~> 0.8"
+  spec.add_runtime_dependency "opal-browser", "~> 0.2"
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,121 @@
+--- !ruby/object:Gem::Specification
+name: ruta
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Martin Becker
+- Adam Beynon
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-12-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: opal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: opal-browser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: 
+email:
+- mbeckerwork@gmail.com
+- adam.beynon@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/ruta.rb
+- lib/ruta/context.rb
+- lib/ruta/handler.rb
+- lib/ruta/history.rb
+- lib/ruta/route.rb
+- lib/ruta/router.rb
+- lib/ruta/version.rb
+- ruta.gemspec
+homepage: https://github.com/Thermatix/ruta
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Front end agnostic router built in opal
+test_files: []
+has_rdoc: