tourguide 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 45a517b7b127f03a7cdfc3f1c2fa8728d83d44b2
+  data.tar.gz: 6c851ebd84ffc0ba380204ed4d38af82712588e2
+SHA512:
+  metadata.gz: 26253c4bc396fc8c31bae0a83fba19be146a3ada47448e9ecd5ad7dc0e9e9bca9b6c85290dee5b6d603263930b500547260256293cba604b34e3dda23dad62c1
+  data.tar.gz: d84396ae8b6bac73c297747f8263a48c4e7fe5ae8a08c0ecb8a30b7a2919322289707da33c05b3be96aab877da06b01f4fd536283ae755f09d5b17bea484190f

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.0

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Adam Carlile
+
+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,39 @@
+# Tourguide
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/tourguide`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tourguide'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tourguide
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, 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` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/tourguide/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

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

data/app/assets/javascripts/tourguide.js

@@ -0,0 +1 @@
+//= require tourguide/tourbus

data/app/assets/stylesheets/tourguide.css.sass

@@ -0,0 +1 @@
+@import 'tourguide/tourbus'

data/app/helpers/tourguide/tourguide_helper.rb

@@ -0,0 +1,11 @@
+module Tourguide
+  module TourguideHelper
+
+    def tourbus id, options={}, &block
+      renderer = Tourguide::Renderers::Tourbus.new(self, id, options)
+      yield(renderer)
+      renderer.render
+    end
+
+  end
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "tourguide"
+
+# 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/tourguide/engine.rb

@@ -0,0 +1,9 @@
+module Tourguide
+  class Engine < ::Rails::Engine
+
+    config.to_prepare do
+      ApplicationController.helper Tourguide::TourguideHelper
+    end
+
+  end
+end

data/lib/tourguide/renderers/connections.rb

@@ -0,0 +1,55 @@
+module Tourguide
+  module Renderers
+    class Connections
+
+      attr_reader :options
+
+      def initialize(context, options={})
+        @context = context
+        @options = options.reverse_merge default_options
+        @connections = []
+      end
+
+      def render
+        xhtml = Builder::XmlMarkup.new target: out=(''), indent: 2
+        xhtml.nav nav_options do |nav|
+          nav << connections.map{ |x| x.render }.join("\n")
+        end
+        out.html_safe
+      end
+
+      def add(label, type)
+        @connections << Tourguide::Renderers::Link.new(@context, label, type)
+      end
+
+      def connections
+        @connections.any? ? @connections : default_connections
+      end
+
+      private
+
+        def nav_options
+          options.merge({class: css_classes})
+        end
+
+        def css_classes
+          out = []
+          out << ("connections-#{connections.count}")
+          out << options[:class]
+          out.compact.join(' ')
+        end
+
+        def default_options
+          {}
+        end
+
+        def default_connections
+          @default_connections ||= [
+            Tourguide::Renderers::Link.new(@context, 'Previous', :prev),
+            Tourguide::Renderers::Link.new(@context, 'Continue', :next)
+          ]
+        end
+
+    end
+  end
+end

data/lib/tourguide/renderers/link.rb

@@ -0,0 +1,40 @@
+module Tourguide
+  module Renderers
+    class Link
+
+      attr_reader :options, :label, :type
+
+      def initialize(context, label, type, options={})
+        @context = context
+        @label   = label
+        @type    = type
+        @options = options.reverse_merge default_options
+      end
+
+      def render
+        @context.link_to label.html_safe, options[:href], html_options
+      end
+
+      private
+
+        def default_options
+          {
+            href:  'javascript:void(0);',
+            class: nil
+          }
+        end
+
+        def html_options
+          options.except(:label, :href).merge({class: css_class})
+        end
+
+        def css_class
+          out = [options[:class]]
+          out << 'tour-link'
+          out << "tourbus-#{type}"
+          out.compact.join(' ')
+        end
+
+    end
+  end
+end

data/lib/tourguide/renderers/stop.rb

@@ -0,0 +1,68 @@
+module Tourguide
+  module Renderers
+    class Stop
+
+      attr_reader :options
+
+      def initialize(context, options={})
+        @context = context
+        @options = options.reverse_merge(default_options[:tour]).reverse_merge(default_options.except(:tour))
+      end
+
+      def content &block
+        raise ArgumentError unless block_given?
+        @content = @context.capture(&block)
+      end
+
+      def connections(options={}, &block)
+        @connections ||= begin 
+          renderer = Tourguide::Renderers::Connections.new(@context, options)
+          yield(renderer) if block_given?
+          renderer
+        end
+      end
+
+      def close
+        @close ||= Tourguide::Renderers::Link.new(@context, options[:close][:label], :stop, options[:close])
+      end
+
+      def render
+        @context.content_tag(:li, [close.render, @content, connections.render].join("\n").html_safe, li_options).html_safe
+      end
+
+      private
+
+        def li_options
+          {
+            data: data_options
+          }.merge(options[:wrapper])
+        end
+
+        def data_options
+          options.except(:wrapper, :close).reject { |k, v| v.blank? }
+        end
+
+        def default_options
+          {
+            wrapper: {},
+            tour: {
+              el: nil,
+              class: nil,
+              orientation: 'centered',
+              algin: 'left',
+              width: nil,
+              margin: nil,
+              top: nil,
+              left: nil,
+              arrow: nil,
+              zindex: nil,
+            },
+            close: {
+              label: "×"
+            }
+          }
+        end
+
+    end
+  end
+end

data/lib/tourguide/renderers/tourbus.rb

@@ -0,0 +1,50 @@
+module Tourguide
+  module Renderers
+    class Tourbus
+
+      attr_reader :id, :options, :stops
+
+      def initialize(context, id, options={})
+        @context = context
+        @id = id
+        @options = options.reverse_merge(default_options)
+        @stops = []
+      end
+
+      def stop(options={}, &block)
+        renderer = Tourguide::Renderers::Stop.new(@context, options)
+        yield(renderer) if block_given?
+        stops << renderer
+      end
+
+      def render
+        xhtml = Builder::XmlMarkup.new target: out=(''), indent: 2
+        xhtml.ul(ul_options) do |ul|
+          ul << stops.map { |x| x.render }.join("\n")
+        end
+        out.html_safe
+      end
+
+      private
+
+        def ul_options
+          {
+            id: id,
+            class: css_classes
+          }.merge(options.except(:class))
+        end
+
+        def css_classes
+          out = []
+          out << 'tourbus-legs'
+          out << options[:class]
+          out.compact.join(' ')
+        end
+
+        def default_options
+          {}
+        end
+
+    end
+  end
+end

data/lib/tourguide/version.rb

@@ -0,0 +1,3 @@
+module Tourguide
+  VERSION = "0.1.0"
+end

data/lib/tourguide.rb

@@ -0,0 +1,15 @@
+require 'sass-rails'
+require 'coffee-rails'
+require 'builder'
+
+require "tourguide/version"
+require "tourguide/engine" if defined? Rails
+
+require "tourguide/renderers/tourbus"
+require "tourguide/renderers/link"
+require "tourguide/renderers/connections"
+require "tourguide/renderers/stop"
+
+module Tourguide
+
+end

data/tourguide.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tourguide/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "tourguide"
+  spec.version       = Tourguide::VERSION
+  spec.authors       = ["Adam Carlile"]
+  spec.email         = ["adam@benchmedia.co.uk"]
+
+  spec.summary       = "Tourbus"
+  spec.description   = "Tourbus"
+  spec.homepage      = "http://www.github.com/boardiq/tourbus"
+  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 "sass-rails", ">= 4"
+  spec.add_runtime_dependency "coffee-rails", ">= 4"
+  spec.add_runtime_dependency "builder"
+
+  spec.add_development_dependency "bundler", "~> 1.8"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/vendor/assets/javascripts/tourguide/tourbus.js

@@ -0,0 +1,593 @@
+(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+//@ sourceMappingURL=jquery-tourbus.map
+(function() {
+  var $, Bus, Leg, methods, tourbus,
+    __slice = [].slice;
+
+  $ = jQuery;
+
+  Bus = require('./modules/bus');
+
+  Leg = require('./modules/leg');
+
+  tourbus = $.tourbus = function() {
+    var args, method;
+    args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+    method = args[0];
+    if (methods.hasOwnProperty(method)) {
+      args = args.slice(1);
+    } else if (method instanceof $) {
+      method = 'build';
+    } else if (typeof method === 'string') {
+      method = 'build';
+      args[0] = $(args[0]);
+    } else {
+      $.error("Unknown method of $.tourbus --", args);
+    }
+    return methods[method].apply(this, args);
+  };
+
+  $.fn.tourbus = function() {
+    var args;
+    args = 1 <= arguments.length ? __slice.call(arguments, 0) : [];
+    return this.each(function() {
+      args.unshift($(this));
+      tourbus.apply(null, ['build'].concat(__slice.call(args)));
+      return this;
+    });
+  };
+
+  methods = {
+    build: function(el, options) {
+      var built;
+      if (options == null) {
+        options = {};
+      }
+      options = $.extend(true, {}, tourbus.defaults, options);
+      built = [];
+      if (!(el instanceof $)) {
+        el = $(el);
+      }
+      el.each(function() {
+        return built.push(new Bus(this, options));
+      });
+      if (built.length === 0) {
+        $.error("" + el.selector + " was not found!");
+      }
+      if (built.length === 1) {
+        return built[0];
+      }
+      return built;
+    },
+    destroyAll: function() {
+      var bus, index, _ref, _results;
+      _ref = Bus._busses;
+      _results = [];
+      for (index in _ref) {
+        bus = _ref[index];
+        _results.push(bus.destroy());
+      }
+      return _results;
+    },
+    expose: function(global) {
+      return global.tourbus = {
+        Bus: Bus,
+        Leg: Leg
+      };
+    }
+  };
+
+  tourbus.defaults = {
+    debug: false,
+    autoDepart: false,
+    container: 'body',
+    "class": null,
+    startAt: 0,
+    onDepart: function() {
+      return null;
+    },
+    onStop: function() {
+      return null;
+    },
+    onLegStart: function() {
+      return null;
+    },
+    onLegEnd: function() {
+      return null;
+    },
+    leg: {
+      "class": null,
+      scrollTo: null,
+      scrollSpeed: 150,
+      scrollContext: 100,
+      orientation: 'bottom',
+      align: 'left',
+      width: 'auto',
+      margin: 10,
+      top: null,
+      left: null,
+      zindex: 9999,
+      arrow: "50%"
+    }
+  };
+
+}).call(this);
+
+},{"./modules/bus":2,"./modules/leg":3}],2:[function(require,module,exports){
+//@ sourceMappingURL=bus.map
+(function() {
+  var $, Bus, Leg, utils,
+    __slice = [].slice;
+
+  $ = jQuery;
+
+  Leg = require('./leg');
+
+  utils = require('./utils');
+
+  module.exports = Bus = (function() {
+    Bus._busses = {};
+
+    Bus._tours = 0;
+
+    Bus.uniqueId = function() {
+      return this._tours++;
+    };
+
+    function Bus(el, options) {
+      this.options = options;
+      this.id = this.constructor.uniqueId();
+      this.elId = "tourbus-" + this.id;
+      this.constructor._busses[this.id] = this;
+      this.$original = $(el);
+      this.rawData = this.$original.data();
+      this.$container = $(utils.dataProp(this.rawData.container, this.options.container));
+      this.$original.data({
+        tourbus: this
+      });
+      this.currentLegIndex = null;
+      this.legs = [];
+      this.legEls = this.$original.children('li');
+      this.totalLegs = this.legEls.length;
+      this._configureElement();
+      this._setupEvents();
+      if (utils.dataProp(this.rawData.autoDepart, this.options.autoDepart)) {
+        this.$original.trigger('depart.tourbus');
+      }
+      this._log('built tourbus with el', el.toString(), 'and options', this.options);
+    }
+
+    Bus.prototype.depart = function() {
+      this.running = true;
+      this.options.onDepart(this);
+      this._log('departing', this);
+      this.currentLegIndex = utils.dataProp(this.rawData.startAt, this.options.startAt);
+      return this.showLeg();
+    };
+
+    Bus.prototype.stop = function() {
+      if (!this.running) {
+        return;
+      }
+      $.each(this.legs, $.proxy(this.hideLeg, this));
+      this.currentLegIndex = null;
+      this.options.onStop(this);
+      return this.running = false;
+    };
+
+    Bus.prototype.on = function(event, selector, fn) {
+      return this.$container.on(event, selector, fn);
+    };
+
+    Bus.prototype.currentLeg = function() {
+      if (this.currentLegIndex === null) {
+        return null;
+      }
+      return this.legs[this.currentLegIndex];
+    };
+
+    Bus.prototype.buildLeg = function(i) {
+      var $legEl, data, leg;
+      $legEl = $(this.legEls[i]);
+      data = $legEl.data();
+      this.legs[i] = leg = new Leg({
+        bus: this,
+        original: $legEl,
+        target: data.el || 'body',
+        index: i,
+        rawData: data
+      });
+      leg.render();
+      this.$el.append(leg.$el);
+      leg._position();
+      leg.hide();
+      return leg;
+    };
+
+    Bus.prototype.showLeg = function(index) {
+      var leg, preventDefault;
+      if (index == null) {
+        index = this.currentLegIndex;
+      }
+      leg = this.legs[index] || this.buildLeg(index);
+      this._log('showLeg:', leg);
+      preventDefault = this.options.onLegStart(leg, this);
+      if (preventDefault !== false) {
+        leg.show();
+      }
+      if (++index < this.totalLegs && !this.legs[index]) {
+        return this.buildLeg(index);
+      }
+    };
+
+    Bus.prototype.hideLeg = function(index) {
+      var leg, preventDefault;
+      if (index == null) {
+        index = this.currentLegIndex;
+      }
+      leg = this.legs[index];
+      if (leg && leg.visible) {
+        this._log('hideLeg:', leg);
+        preventDefault = this.options.onLegEnd(leg, this);
+        if (preventDefault !== false) {
+          leg.hide();
+        }
+      }
+      if (--index > 0 && !this.legs[index]) {
+        return this.buildLeg(index);
+      }
+    };
+
+    Bus.prototype.repositionLegs = function() {
+      return $.each(this.legs, function() {
+        return this.reposition();
+      });
+    };
+
+    Bus.prototype.next = function() {
+      this.hideLeg();
+      this.currentLegIndex++;
+      if (this.currentLegIndex > this.totalLegs - 1) {
+        return this.$original.trigger('stop.tourbus');
+      } else {
+        return this.showLeg();
+      }
+    };
+
+    Bus.prototype.prev = function(cb) {
+      this.hideLeg();
+      this.currentLegIndex--;
+      if (this.currentLegIndex < 0) {
+        return this.$original.trigger('stop.tourbus');
+      } else {
+        return this.showLeg();
+      }
+    };
+
+    Bus.prototype.destroy = function() {
+      $.each(this.legs, function() {
+        return this.destroy();
+      });
+      this.legs = [];
+      delete this.constructor._busses[this.id];
+      this._teardownEvents();
+      this.$original.removeData('tourbus');
+      return this.$el.remove();
+    };
+
+    Bus.prototype._configureElement = function() {
+      this.$el = $("<div class='tourbus-container'></div>");
+      this.el = this.$el[0];
+      this.$el.attr({
+        id: this.elId
+      });
+      this.$el.addClass(utils.dataProp(this.rawData["class"], this.options["class"]));
+      return this.$container.append(this.$el);
+    };
+
+    Bus.prototype._log = function() {
+      if (!utils.dataProp(this.rawData.debug, this.options.debug)) {
+        return;
+      }
+      return console.log.apply(console, ["TOURBUS " + this.id + ":"].concat(__slice.call(arguments)));
+    };
+
+    Bus.prototype._setupEvents = function() {
+      this.$original.on('depart.tourbus', $.proxy(this.depart, this));
+      this.$original.on('stop.tourbus', $.proxy(this.stop, this));
+      this.$original.on('next.tourbus', $.proxy(this.next, this));
+      return this.$original.on('prev.tourbus', $.proxy(this.prev, this));
+    };
+
+    Bus.prototype._teardownEvents = function() {
+      return this.$original.off('.tourbus');
+    };
+
+    return Bus;
+
+  })();
+
+}).call(this);
+
+},{"./leg":3,"./utils":4}],3:[function(require,module,exports){
+//@ sourceMappingURL=leg.map
+(function() {
+  var $, Leg, utils, _addRule;
+
+  $ = jQuery;
+
+  utils = require('./utils');
+
+  module.exports = Leg = (function() {
+    function Leg(options) {
+      this.options = options;
+      this.$original = this.options.original;
+      this.bus = this.options.bus;
+      this.rawData = this.options.rawData;
+      this.index = this.options.index;
+      this.$target = $(this.options.target);
+      this.id = "" + this.bus.id + "-" + this.options.index;
+      this.elId = "tourbus-leg-" + this.id;
+      this.visible = false;
+      if (this.$target.length === 0) {
+        throw "" + this.$target.selector + " is not an element!";
+      }
+      this.content = this.$original.html();
+      this._setupOptions();
+      this._configureElement();
+      this._configureTarget();
+      this._configureScroll();
+      this._setupEvents();
+      this.bus._log("leg " + this.index + " made with options", this.options);
+    }
+
+    Leg.prototype.render = function() {
+      var arrowClass, html;
+      arrowClass = this.options.orientation === 'centered' ? '' : 'tourbus-arrow';
+      this.$el.addClass(" " + arrowClass + " tourbus-arrow-" + this.options.orientation + " ");
+      html = "<div class='tourbus-leg-inner'>\n  " + this.content + "\n</div>";
+      this.$el.css({
+        width: this.options.width,
+        zIndex: this.options.zindex
+      }).html(html);
+      return this;
+    };
+
+    Leg.prototype.destroy = function() {
+      this.$el.remove();
+      return this._teardownEvents();
+    };
+
+    Leg.prototype.reposition = function() {
+      this._configureTarget();
+      return this._position();
+    };
+
+    Leg.prototype._position = function() {
+      var css, keys, rule, selector;
+      if (this.options.orientation !== 'centered') {
+        rule = {};
+        keys = {
+          top: 'left',
+          bottom: 'left',
+          left: 'top',
+          right: 'top'
+        };
+        if (typeof this.options.arrow === 'number') {
+          this.options.arrow += 'px';
+        }
+        rule[keys[this.options.orientation]] = this.options.arrow;
+        selector = "#" + this.elId + ".tourbus-arrow";
+        this.bus._log("adding rule for " + this.elId, rule);
+        _addRule("" + selector + ":before, " + selector + ":after", rule);
+      }
+      css = this._offsets();
+      this.bus._log('setting offsets on leg', css);
+      return this.$el.css(css);
+    };
+
+    Leg.prototype.show = function() {
+      this.visible = true;
+      this.$el.css({
+        visibility: 'visible',
+        opacity: 1.0,
+        zIndex: this.options.zindex
+      });
+      return this.scrollIntoView();
+    };
+
+    Leg.prototype.hide = function() {
+      this.visible = false;
+      if (this.bus.options.debug) {
+        return this.$el.css({
+          visibility: 'visible',
+          opacity: 0.4,
+          zIndex: 0
+        });
+      } else {
+        return this.$el.css({
+          visibility: 'hidden'
+        });
+      }
+    };
+
+    Leg.prototype.scrollIntoView = function() {
+      var scrollTarget;
+      if (!this.willScroll) {
+        return;
+      }
+      scrollTarget = utils.dataProp(this.options.scrollTo, this.$el);
+      this.bus._log('scrolling to', scrollTarget, this.scrollSettings);
+      return $.scrollTo(scrollTarget, this.scrollSettings);
+    };
+
+    Leg.prototype._setupOptions = function() {
+      var dataProps, globalOptions, prop, _i, _len, _results;
+      globalOptions = this.bus.options.leg;
+      dataProps = ['class', 'top', 'left', 'scrollTo', 'scrollSpeed', 'scrollContext', 'margin', 'arrow', 'align', 'width', 'zindex', 'orientation'];
+      _results = [];
+      for (_i = 0, _len = dataProps.length; _i < _len; _i++) {
+        prop = dataProps[_i];
+        _results.push(this.options[prop] = utils.dataProp(this.rawData[prop], globalOptions[prop]));
+      }
+      return _results;
+    };
+
+    Leg.prototype._configureElement = function() {
+      this.$el = $("<div class='tourbus-leg'></div>");
+      this.el = this.$el[0];
+      this.$el.attr({
+        id: this.elId
+      });
+      this.$el.addClass(this.options["class"]);
+      return this.$el.css({
+        zIndex: this.options.zindex
+      });
+    };
+
+    Leg.prototype._setupEvents = function() {
+      this.$el.on('click', '.tourbus-next', $.proxy(this.bus.next, this.bus));
+      this.$el.on('click', '.tourbus-prev', $.proxy(this.bus.prev, this.bus));
+      return this.$el.on('click', '.tourbus-stop', $.proxy(this.bus.stop, this.bus));
+    };
+
+    Leg.prototype._teardownEvents = function() {
+      return this.$el.off('click');
+    };
+
+    Leg.prototype._configureTarget = function() {
+      this.targetOffset = this.$target.offset();
+      if (utils.dataProp(this.options.top, false)) {
+        this.targetOffset.top = this.options.top;
+      }
+      if (utils.dataProp(this.options.left, false)) {
+        this.targetOffset.left = this.options.left;
+      }
+      this.targetWidth = this.$target.outerWidth();
+      return this.targetHeight = this.$target.outerHeight();
+    };
+
+    Leg.prototype._configureScroll = function() {
+      this.willScroll = $.fn.scrollTo && this.options.scrollTo !== false;
+      return this.scrollSettings = {
+        offset: -this.options.scrollContext,
+        easing: 'linear',
+        axis: 'y',
+        duration: this.options.scrollSpeed
+      };
+    };
+
+    Leg.prototype._offsets = function() {
+      var dimension, elHalf, elHeight, elWidth, offsets, targetHalf, targetHeightOverride, validOrientations;
+      elHeight = this.$el.height();
+      elWidth = this.$el.width();
+      offsets = {};
+      switch (this.options.orientation) {
+        case 'centered':
+          targetHeightOverride = $(window).height();
+          offsets.top = this.options.top;
+          if (!utils.dataProp(offsets.top, false)) {
+            offsets.top = (targetHeightOverride / 2) - (elHeight / 2);
+          }
+          offsets.left = (this.targetWidth / 2) - (elWidth / 2);
+          break;
+        case 'left':
+          offsets.top = this.targetOffset.top;
+          offsets.left = this.targetOffset.left - elWidth - this.options.margin;
+          break;
+        case 'right':
+          offsets.top = this.targetOffset.top;
+          offsets.left = this.targetOffset.left + this.targetWidth + this.options.margin;
+          break;
+        case 'top':
+          offsets.top = this.targetOffset.top - elHeight - this.options.margin;
+          offsets.left = this.targetOffset.left;
+          break;
+        case 'bottom':
+          offsets.top = this.targetOffset.top + this.targetHeight + this.options.margin;
+          offsets.left = this.targetOffset.left;
+      }
+      validOrientations = {
+        top: ['left', 'right'],
+        bottom: ['left', 'right'],
+        left: ['top', 'bottom'],
+        right: ['top', 'bottom']
+      };
+      if (utils.include(this.options.orientation, validOrientations[this.options.align])) {
+        switch (this.options.align) {
+          case 'right':
+            offsets.left += this.targetWidth - elWidth;
+            break;
+          case 'bottom':
+            offsets.top += this.targetHeight - elHeight;
+        }
+      } else if (this.options.align === 'center') {
+        if (utils.include(this.options.orientation, validOrientations.left)) {
+          targetHalf = this.targetWidth / 2;
+          elHalf = elWidth / 2;
+          dimension = 'left';
+        } else {
+          targetHalf = this.targetHeight / 2;
+          elHalf = elHeight / 2;
+          dimension = 'top';
+        }
+        if (targetHalf > elHalf) {
+          offsets[dimension] += targetHalf - elHalf;
+        } else {
+          offsets[dimension] -= elHalf - targetHalf;
+        }
+      }
+      return offsets;
+    };
+
+    return Leg;
+
+  })();
+
+  _addRule = (function(styleTag) {
+    var sheet;
+    styleTag.type = 'text/css';
+    document.getElementsByTagName('head')[0].appendChild(styleTag);
+    sheet = document.styleSheets[document.styleSheets.length - 1];
+    return function(selector, css) {
+      var key, propText;
+      propText = $.map((function() {
+        var _results;
+        _results = [];
+        for (key in css) {
+          _results.push(key);
+        }
+        return _results;
+      })(), function(p) {
+        return "" + p + ":" + css[p];
+      }).join(';');
+      try {
+        if (sheet.insertRule) {
+          sheet.insertRule("" + selector + " { " + propText + " }", (sheet.cssRules || sheet.rules).length);
+        } else {
+          sheet.addRule(selector, propText);
+        }
+      } catch (_error) {}
+    };
+  })(document.createElement('style'));
+
+}).call(this);
+
+},{"./utils":4}],4:[function(require,module,exports){
+//@ sourceMappingURL=utils.map
+(function() {
+  module.exports = {
+    dataProp: function(possiblyFalsy, alternative) {
+      if (possiblyFalsy === null || typeof possiblyFalsy === 'undefined') {
+        return alternative;
+      }
+      return possiblyFalsy;
+    },
+    include: function(value, array) {
+      return $.inArray(value, array || []) !== -1;
+    }
+  };
+
+}).call(this);
+
+},{}]},{},[1,2,3,4]);

data/vendor/assets/stylesheets/tourguide/tourbus.css

@@ -0,0 +1,150 @@
+/* Tourbus leg definitions element */
+.tourbus-legs {
+  display: none;
+}
+
+.tour-overlay {
+  display: none;
+  background: #000000;
+  opacity: 0.7;
+  z-index: 9997;
+  min-height: 100%;
+  height: 100%;
+  position: fixed;
+  top: 0; right: 0; bottom: 0; left: 0;
+}
+.tour-highlight {
+  background: white;
+  position: relative;
+  box-shadow: inset 0 0 2px rgba( 0, 0, 0, 0.2 );
+  z-index: 9998;
+}
+
+/* Container for tourbus leg */
+.tourbus-leg {
+  position: absolute;
+  visibility: hidden;
+  top: 0;
+  border: 1px solid #E5E5E5;
+  box-shadow: 0 0 2px rgba(0, 0, 0, 0.15);
+  border-radius: 2px;
+  background: white;
+}
+/* Interior of leg, clearfixed */
+.tourbus-leg-inner {
+  padding: 20px;
+  position: relative;
+  zoom: 1;
+}
+.tourbus-leg-inner:before,
+.tourbus-leg-inner:after {
+  content: "\0020";
+  display: block;
+  height: 0;
+  overflow: hidden;
+}
+.tourbus-leg-inner:after {
+  clear: both;
+}
+/*
+  remove top padding/margin on headings
+  because the interior of the leg has padding
+*/
+.tourbus-leg h1,
+.tourbus-leg h2,
+.tourbus-leg h3,
+.tourbus-leg h4,
+.tourbus-leg h5,
+.tourbus-leg h6 {
+  margin-top: 0;
+  padding-top: 0;
+}
+/* Tourbus leg arrow */
+.tourbus-arrow:before,
+.tourbus-arrow:after {
+  border: solid rgba(0, 0, 0, 0);
+  content: " ";
+  height: 0;
+  width: 0;
+  position: absolute;
+  pointer-events: none;
+  border-color: transparent;
+}
+/* set the :after to be the _interior_ size of the arrow */
+/* set the :before to be the _interior + desired border width_ */
+.tourbus-arrow:after {
+  border-width: 14px;
+}
+.tourbus-arrow:before {
+  border-width: 16px;
+}
+/* Arrow background and border colors */
+/*
+  change margin-top/left values here to
+  match the border width for :after above
+
+  border colors here are for the _interior_ of the arrow
+*/
+.tourbus-arrow-right:after {
+  border-right-color: #ffffff;
+  margin-top: -14px;
+  top: 50%;
+}
+.tourbus-arrow-left:after {
+  border-left-color: #ffffff;
+  margin-top: -14px;
+  top: 50%;
+}
+.tourbus-arrow-bottom:after {
+  border-bottom-color: #ffffff;
+  margin-left: -14px;
+  left: 50%;
+}
+.tourbus-arrow-top:after {
+  border-top-color: #ffffff;
+  margin-left: -14px;
+  left: 50%;
+}
+/*
+  change margin-top/left values here to
+  match the border width for :before above
+
+  border colors here are for the _border_ of the arrow
+*/
+.tourbus-arrow-right:before {
+  border-right-color: #e5e5e5;
+  margin-top: -16px;
+  top: 50%;
+}
+.tourbus-arrow-left:before {
+  border-left-color: #e5e5e5;
+  margin-top: -16px;
+  top: 50%;
+}
+.tourbus-arrow-bottom:before {
+  border-bottom-color: #e5e5e5;
+  margin-left: -16px;
+  left: 50%;
+}
+.tourbus-arrow-top:before {
+  border-top-color: #e5e5e5;
+  margin-left: -16px;
+  left: 50%;
+}
+/* you shouldn't need to change these */
+.tourbus-arrow-right:after,
+.tourbus-arrow-right:before {
+  right: 100%;
+}
+.tourbus-arrow-left:after,
+.tourbus-arrow-left:before {
+  left: 100%;
+}
+.tourbus-arrow-bottom:after,
+.tourbus-arrow-bottom:before {
+  bottom: 100%;
+}
+.tourbus-arrow-top:after,
+.tourbus-arrow-top:before {
+  top: 100%;
+}

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: tourguide
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Adam Carlile
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-02-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sass-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: coffee-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !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: Tourbus
+email:
+- adam@benchmedia.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/assets/javascripts/tourguide.js
+- app/assets/stylesheets/tourguide.css.sass
+- app/helpers/tourguide/tourguide_helper.rb
+- bin/console
+- bin/setup
+- lib/tourguide.rb
+- lib/tourguide/engine.rb
+- lib/tourguide/renderers/connections.rb
+- lib/tourguide/renderers/link.rb
+- lib/tourguide/renderers/stop.rb
+- lib/tourguide/renderers/tourbus.rb
+- lib/tourguide/version.rb
+- tourguide.gemspec
+- vendor/assets/javascripts/tourguide/tourbus.js
+- vendor/assets/stylesheets/tourguide/tourbus.css
+homepage: http://www.github.com/boardiq/tourbus
+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
+signing_key: 
+specification_version: 4
+summary: Tourbus
+test_files: []