RubyGems - ress - Versions diffs - 0.0.1 - Mend

ress 0.0.1

Files changed (27) hide show

data/.gitignore +17 -0
data/.rvmrc +1 -0
data/Gemfile +4 -0
data/LICENSE.txt +22 -0
data/README.md +151 -0
data/Rakefile +1 -0
data/lib/generators/ress/install_generator.rb +17 -0
data/lib/generators/ress/templates/README +19 -0
data/lib/generators/ress/templates/ress.rb +4 -0
data/lib/ress.rb +33 -0
data/lib/ress/alternate_version.rb +40 -0
data/lib/ress/canonical_version.rb +38 -0
data/lib/ress/category_collection.rb +23 -0
data/lib/ress/controller_additions.rb +32 -0
data/lib/ress/engine.rb +6 -0
data/lib/ress/version.rb +3 -0
data/lib/ress/view_helpers.rb +21 -0
data/ress.gemspec +23 -0
data/spec/ress/alternate_version_spec.rb +80 -0
data/spec/ress/canonical_version_spec.rb +75 -0
data/spec/ress/category_collection_spec.rb +40 -0
data/spec/ress/controller_additions_spec.rb +72 -0
data/spec/ress/view_helpers_spec.rb +49 -0
data/spec/ress_spec.rb +38 -0
data/vendor/assets/javascripts/modernizr.js +4 -0
data/vendor/assets/javascripts/ress.js +168 -0
metadata +109 -0

data/.gitignore ADDED

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rvmrc ADDED

	@@ -0,0 +1 @@
1	+ rvm gemset use ress

data/Gemfile ADDED

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

data/LICENSE.txt ADDED

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Matthew Robertson
+MIT License
+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 ADDED

@@ -0,0 +1,151 @@
+# Ress
+Ress implements a set of best practices that allow you to progressively
+enhance you Rails application to improve the user experience on mobile
+devices.
+## Background
+Ress is an extension of the [devicejs](https://github.com/borismus/device.js)
+library written by [Boris Smus](http://smus.com/). It adds a back end for
+adapting server responses based on client side feature detection. Ress allows
+you to specify alternate versions of your website, along with media queries
+for which devices should be redirected to which version.
+## How it Works
+### HTML Annotations
+When you register alternate mobile versions of your website, Ress adds annotations
+to the `<head>` of your document that describes where these pages are located and
+which devices should be redirected to them.
+For example, a typical alternate version for a mobile site might include a tag
+like this:
+```html
+<link rel="alternate" media="only screen and (max-width: 640px)" href="http://m.example.com/page-1" >
+```
+The mobile version of the page would then have a link pointing back the canonical
+version:
+```html
+<link rel="canonical" href="http://www.example.com/page-1" >
+```
+These annotations conform to SEO best practices for mobile optimized websites
+as documented by Google
+[here](https://developers.google.com/webmasters/smartphone-sites/details).
+### Feature Detection
+semantic, media query-based device detection
+Device.js will read all of the version links in your markup, and
+redirect you to the appropriate URL that serves the correct version of
+your webapp.
+When a request comes into your site, ress runs a some javascript if there is an
+alternate version available that matches the client. If there is, the user is
+redirected to that site.
+### Server Side Components
+Ress allows you to customize how your Rails application responds to requests in
+two ways:
+1. It adds controller and helper methods to detect which version of your site has
+been requested. This is useful for small tweeks in html or behaviour, eg:
+```erb
+<% if mobile_request? %>
+  <%= image_tag 'low-res.png' %>
+<% else %>
+  <%= image_tag 'high-res.png' %>
+<% end %>
+```
+2. It prepends a view path for each alternate version of your site, so that you can
+override which templates or partials are rendered for certain requests. For example if
+you want to render a different html form for creating users on the mobile version of your
+site you could create `app/mobile_views/users/_form.html.erb` and Ress would have Rails
+select that template over `app/views/users/_form.html.erb` when a request comes in to the
+mobile version.
+## Installation
+Add this line to your application's Gemfile:
+    gem 'ress'
+And then execute:
+    $ bundle install
+Run the installation generator:
+    $ rails g ress:install
+## Usage
+### Version override
+You can manually override the detector and load a particular version of
+the site by passing in the `device` GET parameter with the ID of the
+version you'd like to load. This will look up the `link` tag based on
+the specified ID and load that version. For example, if you are on
+desktop but want the tablet version, visiting
+`http://foo.com/?version=tablet` will redirect to the tablet version at
+`http://tablet.foo.com`.
+Relatedly, you can prevent redirection completely, by specifying the
+`force=1` GET parameter. For example, if you are on desktop and know the
+URL of the tablet site, you can load `http://tablet.foo.com/?force=1`.
+```html
+<!-- Include a way to manually switch between device types -->
+<footer>
+  <ul>
+    <li><a href="?device=desktop">Desktop</a></li>
+    <li><a href="?device=tablet">Tablet</a></li>
+    <li><a href="?device=phone">Phone</a></li>
+  </ul>
+</footer>
+```
+### Dependencies
+TODO: Modernizr
+## Performance considerations
+The javascript included by Ress does some checks and will use client-side
+redirection to point users to the right version of your webapp. Client-side
+redirection can have a performance overhead (though I haven't measured it).
+If you find this is true, you can keep your DOM the same, still using the
+SEO-friendly `<link rel="alternate">` tags, but simply remove the
+device.js script and do your own server-side UA-based pushing.
+## Browser support
+Device.js should work in all browsers that support
+`document.querySelectorAll`. Notably, this excludes IE7. If you want it
+to work in IE7 and below, please include a [polyfill](https://gist.github.com/2724353).
+## Contributing
+The goal of Ress is to provide a SEO-compatible best practice and
+starting point for reliable cross-device, cross-browser redirection.
+Given how many browsers and devices we have these days, there are bound
+to be bugs. If you find them, please report them and (ideally) fix them
+in a pull request.
+1. Fork it
+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 new Pull Request

data/Rakefile ADDED

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

data/lib/generators/ress/install_generator.rb ADDED

@@ -0,0 +1,17 @@
+module Ress
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("../templates", __FILE__)
+      desc "Creates a Ress initializer for your application."
+      def copy_initializer
+        template "ress.rb", "config/initializers/ress.rb"
+      end
+      def show_readme
+        readme "README" if behavior == :invoke
+      end
+    end
+  end
+end

data/lib/generators/ress/templates/README ADDED

@@ -0,0 +1,19 @@
+===============================================================================
+There is some setup you must do manually if you haven't yet:
+  1. Include the Javascript files in your application.js:
+    //= require ress
+  2. Call Ress in the head of your layout to render out the version annotations.
+     For example:
+    <head>
+      <title>My App</title>
+      <%= stylesheet_link_tag "application", :media => "all" %>
+      <%= ress_link_tags %>
+      <%= csrf_meta_tags %>
+    </head>
+===============================================================================

data/lib/generators/ress/templates/ress.rb ADDED

@@ -0,0 +1,4 @@
+Ress.configure do |config|
+end

data/lib/ress.rb ADDED

@@ -0,0 +1,33 @@
+require "action_view"
+require "ress/version"
+require "ress/alternate_version"
+require "ress/canonical_version"
+require "ress/category_collection"
+require "ress/controller_additions"
+require "ress/view_helpers"
+if defined? Rails
+  require "ress/engine"
+end
+module Ress
+  extend self
+  def category_collection
+    @categories ||= CategoryCollection.new
+  end
+  def canonical_version
+    category_collection.canonical_version
+  end
+  def alternate_versions
+    category_collection.alternate_versions
+  end
+  def configure
+    yield(category_collection)
+  end
+end

data/lib/ress/alternate_version.rb ADDED

@@ -0,0 +1,40 @@
+module Ress
+  class AlternateVersion
+    attr_reader :name, :subdomain, :media_query, :view_path
+    def initialize(name, media_query,  options = {})
+      @name        = name
+      @media_query = media_query
+      @subdomain   = options.fetch(:subdomain, name)
+      @view_path   = options.fetch(:view_path, default_view_path)
+    end
+    def matches?(subdomain)
+      self.subdomain == subdomain.split('.').first
+    end
+    # Create a tag of this format:
+    #  `<link rel="alternate" href="http://foo.com" id="desktop" media="only screen and (touch-enabled: 0)">`
+    def link_tag(protocol, base_url, view)
+      view.tag :link, :rel => 'alternate', :href => href(protocol, base_url), :id => id, :media => media_query
+    end
+    private
+      def default_view_path
+        File.join('app', "#{name}_views")
+      end
+      def href(protocol, base_url)
+        "#{protocol}#{subdomain}.#{base_url}"
+      end
+      def id
+        name
+      end
+  end
+end

data/lib/ress/canonical_version.rb ADDED

@@ -0,0 +1,38 @@
+module Ress
+  class CanonicalVersion
+    attr_reader :subdomain
+    def initialize(options = {})
+      @subdomain = options.fetch(:subdomain, false)
+    end
+    def matches?(subdomain)
+      if self.subdomain
+        self.subdomain == subdomain
+      else
+        subdomain.empty?
+      end
+    end
+    # Create a tag of this format:
+    #  `<link rel="canonical" href="http://www.example.com/page-1" >`
+    def link_tag(protocol, fullpath, subdomain, view)
+      view.tag :link, :rel => 'canonical', :href => href(protocol, fullpath, subdomain)
+    end
+    private
+      def href(protocol, fullpath, subdomain)
+        fullpath = fullpath[(subdomain.length + 1)..-1] unless subdomain.empty?
+        if self.subdomain
+          "#{protocol}#{self.subdomain}.#{fullpath}"
+        else
+          "#{protocol}#{fullpath}"
+        end
+      end
+  end
+end

data/lib/ress/category_collection.rb ADDED

@@ -0,0 +1,23 @@
+module Ress
+  class CategoryCollection
+    attr_reader :canonical_version, :alternate_versions
+    def initialize
+      @alternate_versions = []
+      @canonical_version  = CanonicalVersion.new
+    end
+    def set_canonical(options = {})
+      @canonical_version = CanonicalVersion.new(options)
+    end
+    def add_alternate(options)
+      version = AlternateVersion.new(options.delete(:name), options.delete(:media_type), options)
+      alternate_versions << version
+    end
+  end
+end

data/lib/ress/controller_additions.rb ADDED

@@ -0,0 +1,32 @@
+module Ress
+  # This module is automatically included into all controllers.
+  module ControllerAdditions
+    module ClassMethods
+      # class methods go here
+    end
+    def self.included(base)
+      base.extend ClassMethods
+      base.helper_method :canonical_request?
+      base.before_filter :prepend_category_view_path
+    end
+    def prepend_category_view_path
+      Ress.alternate_versions.each do |cat|
+        prepend_view_path(cat.view_path) if cat.matches?(request.subdomain)
+      end
+    end
+    def canonical_request?
+      Ress.canonical_version.matches?(request.subdomain)
+    end
+  end
+end
+if defined? ActionController::Base
+  ActionController::Base.class_eval do
+    include Ress::ControllerAdditions
+  end
+end

data/lib/ress/engine.rb ADDED

@@ -0,0 +1,6 @@
+module Ress
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/ress/version.rb ADDED

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

data/lib/ress/view_helpers.rb ADDED

@@ -0,0 +1,21 @@
+module Ress
+  module ViewHelpers
+    def ress_link_tags
+      path = "#{request.host_with_port}#{request.fullpath}"
+      if canonical_request?
+        Ress.alternate_versions.map do |category|
+          category.link_tag(request.protocol, path, self)
+        end.join.html_safe
+      else
+        Ress.canonical_version.link_tag(request.protocol, path, request.subdomain, self)
+      end
+    end
+  end
+end
+ActionView::Base.send :include, Ress::ViewHelpers

data/ress.gemspec ADDED

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ress/version'
+Gem::Specification.new do |gem|
+  gem.name          = "ress"
+  gem.version       = Ress::VERSION
+  gem.authors       = ["Matthew Robertson"]
+  gem.email         = ["matthewrobertson03@gmail.com"]
+  gem.description   = %q{Progressively enhance the mobile user experience of your Rails application.}
+  gem.summary       = %q{Progressively enhance the mobile user experience of your Rails application.}
+  gem.homepage      = "https://github.com/matthewrobertson/ress"
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  gem.add_dependency("actionpack", "~> 3.0")
+  gem.add_development_dependency("rspec")
+end

data/spec/ress/alternate_version_spec.rb ADDED

@@ -0,0 +1,80 @@
+require_relative '../../lib/ress/alternate_version'
+describe Ress::AlternateVersion do
+  describe '#subdomain' do
+    it 'defaults to the name of the category' do
+      category = Ress::AlternateVersion.new('mobile', 'some media query')
+      category.subdomain.should == 'mobile'
+    end
+    it 'can be overridden by an optional parameter' do
+      category = Ress::AlternateVersion.new('mobile', 'some media query', :subdomain => 'foo')
+      category.subdomain.should == 'foo'
+    end
+  end
+  describe '#view_path' do
+    it 'defaults to app/[NAME]_views' do
+      category = Ress::AlternateVersion.new('mobile', 'some media query')
+      category.view_path.should == 'app/mobile_views'
+    end
+    it 'can be overridden by an optional parameter' do
+      category = Ress::AlternateVersion.new('mobile', 'some media query', :view_path => 'foo')
+      category.view_path.should == 'foo'
+    end
+  end
+  describe '#matches?' do
+    let(:category) { Ress::AlternateVersion.new('mobile', 'some media query', :subdomain => 'foo') }
+    it 'returns true if the subdomain matches' do
+      category.matches?('foo').should be_true
+    end
+    it 'returns false if the subdomain does not match' do
+      category.matches?('bar').should be_false
+    end
+    context 'when there are multiple subdomains' do
+      it 'returns true if the first subdomain matches' do
+        category.matches?('foo.bar').should be_true
+      end
+      it 'returns false if the first subdomain does not match' do
+        category.matches?('bar.baz').should be_false
+      end
+    end
+  end
+  describe '#link_tag' do
+    let(:category) { Ress::AlternateVersion.new('mobile', 'some media query') }
+    let(:view) { stub('view') }
+    def link_tag(base_url, protocol, view)
+      view.tag :link, :rel => 'alternate', :href => href(base_url, protocol), :id => id, :media => media_query
+    end
+    it 'passes args to the view tag helper' do
+      view.should_receive(:tag).with(:link, {
+        :rel   => "alternate",
+        :href  => "http://mobile.foo.com",
+        :id    => "mobile",
+        :media => "some media query"
+      }).and_return('<link>')
+      category.link_tag('http://', 'foo.com', view).should == '<link>'
+    end
+  end
+end

data/spec/ress/canonical_version_spec.rb ADDED

@@ -0,0 +1,75 @@
+require_relative '../../lib/ress/canonical_version'
+describe Ress::CanonicalVersion do
+  describe '#subdomain' do
+    it 'defaults to false' do
+      category = Ress::CanonicalVersion.new
+      category.subdomain.should == false
+    end
+    it 'can be overridden by an optional parameter' do
+      category = Ress::CanonicalVersion.new(:subdomain => 'foo')
+      category.subdomain.should == 'foo'
+    end
+  end
+  describe '#matches?' do
+    context 'with no canonical subdomain' do
+      let(:version) { Ress::CanonicalVersion.new }
+      it 'returns true if there is no subdomain' do
+        version.matches?('').should be_true
+      end
+      it 'returns false if there is a subdomain' do
+        version.matches?('blah').should be_false
+      end
+    end
+    context 'with a canonical subdomain' do
+      let(:version) { Ress::CanonicalVersion.new(:subdomain => 'foo') }
+      it 'returns true if the subdomain matches the configured' do
+        version.matches?('foo').should be_true
+      end
+      it 'returns false if the subdomain does not match' do
+        version.matches?('bar').should be_false
+      end
+    end
+  end
+  describe '#link_tag' do
+    let(:view) { stub('view') }
+    it 'constructs the correct url when there is no canonical subdomain ' do
+      version = Ress::CanonicalVersion.new
+      view.should_receive(:tag).with(:link, {
+        :rel   => "canonical",
+        :href  => "http://foo.com"
+      }).and_return('<link>')
+      version.link_tag('http://', 'm.foo.com', 'm', view).should == '<link>'
+    end
+    it 'constructs the correct url when there is a canonical subdomain ' do
+      version = Ress::CanonicalVersion.new(:subdomain => 'secure')
+      view.should_receive(:tag).with(:link, {
+        :rel   => "canonical",
+        :href  => "http://secure.foo.com"
+      }).and_return('<link>')
+      version.link_tag('http://', 'm.secure.foo.com', 'm.secure', view).should == '<link>'
+    end
+  end
+end

data/spec/ress/category_collection_spec.rb ADDED

@@ -0,0 +1,40 @@
+require_relative '../../lib/ress'
+describe Ress::CategoryCollection do
+  let(:collection) { Ress::CategoryCollection.new }
+  describe '#add_alternate' do
+    it 'adds an item to the alternate_versions' do
+      expect {
+        collection.add_alternate({:name => 'stuff', :media_query => 'foo'})
+      }.to change { collection.alternate_versions.size }.by(1)
+    end
+    it 'sets the name and media_query of the alternate_version' do
+      collection.add_alternate({:name => 'stuff', :media_query => 'foo'})
+      collection.alternate_versions.last.name.should == 'stuff'
+    end
+    it 'passes options to the alternate_version' do
+      collection.add_alternate({:name => 'stuff', :media_query => 'foo', :subdomain => 'm'})
+      collection.alternate_versions.last.subdomain.should == 'm'
+    end
+  end
+  describe 'canonical_version' do
+    it 'defaults to a canonical_version with no subdomain' do
+      collection.canonical_version.subdomain.should be_false
+    end
+    it 'can be altered through set_canonical' do
+      collection.set_canonical :subdomain => 'foo'
+      collection.canonical_version.subdomain.should == 'foo'
+    end
+  end
+end

data/spec/ress/controller_additions_spec.rb ADDED

@@ -0,0 +1,72 @@
+require_relative '../../lib/ress'
+class ActionControllerStub
+  attr_accessor :request
+  def self.before_filter(action)
+    @@action = action
+  end
+  def self.action
+    @@action
+  end
+  def self.helper_method(*splat) ; end
+end
+ActionControllerStub.class_eval do
+  include Ress::ControllerAdditions
+end
+describe Ress::ControllerAdditions do
+  it 'adds a before_filter to all actions when it is included' do
+    ActionControllerStub.action.should == :prepend_category_view_path
+  end
+  describe '#prepend_category_view_path' do
+    let(:controller) { ActionControllerStub.new }
+    before do
+      request = stub('request', :subdomain => 'foo')
+      controller.request = request
+    end
+    it 'prepends view paths of matching alternate_versions' do
+      category = stub('category', :matches? => true, :view_path => 'foo/bar')
+      Ress.stub(:alternate_versions => [category])
+      controller.should_receive(:prepend_view_path).with('foo/bar')
+      controller.prepend_category_view_path
+    end
+    it 'does not prepend view paths of alternate_versions that dont match' do
+      category = stub('category', :matches? => false, :view_path => 'foo/bar')
+      Ress.stub(:alternate_versions => [category])
+      controller.should_not_receive(:prepend_view_path)
+      controller.prepend_category_view_path
+    end
+  end
+  describe '#canonical_request?' do
+    let(:controller) { ActionControllerStub.new }
+    before do
+      request = stub(:subdomain => 'foo')
+      controller.stub(:request => request)
+    end
+    it 'returns true if the request subdomain matches the canonical' do
+      Ress.canonical_version.stub(:matches? => true)
+      controller.canonical_request?.should be_true
+    end
+  end
+end

data/spec/ress/view_helpers_spec.rb ADDED

@@ -0,0 +1,49 @@
+require 'rspec'
+require_relative '../../lib/ress'
+describe ActionView::Base do
+  describe '#ress_link_tags' do
+    let(:view) { ActionView::Base.new }
+    let(:request) { stub('request', :protocol => 'http://', :host_with_port => 'x.foo.com', :fullpath => '/bar', :subdomain => 'x') }
+    let(:category) { Ress::AlternateVersion.new('m', 'stuff') }
+    before do
+      view.stub(:request => request)
+    end
+    context 'alternate request' do
+      before { view.stub(:canonical_request? => false) }
+      it 'returns the canonical link' do
+        view.ress_link_tags.should == "<link href=\"http://foo.com/bar\" rel=\"canonical\" />"
+      end
+    end
+    context 'canonical request' do
+      let(:request) { stub('request', :protocol => 'http://', :host_with_port => 'foo.com', :fullpath => '/bar', :subdomain => '') }
+      before { view.stub(:canonical_request? => true) }
+      it 'returns an empty string if there are no registered categories' do
+        view.ress_link_tags.should == ''
+      end
+      it 'generates the link tags when there is one category' do
+        Ress.configure do |r|
+          r.add_alternate :name => 'm', :media_type => 'stuff'
+        end
+        view.ress_link_tags.should ==
+          "<link href=\"http://m.foo.com/bar\" id=\"m\" media=\"stuff\" rel=\"alternate\" />"
+      end
+    end
+  end
+end

data/spec/ress_spec.rb ADDED

@@ -0,0 +1,38 @@
+require_relative '../lib/ress'
+describe Ress do
+  describe '.configure' do
+    it 'yields the default category collection' do
+      Ress.configure { |r| r.should be_a(Ress::CategoryCollection) }
+    end
+  end
+  describe '.canonical_version' do
+    it 'returns a Ress::CanonicalVersion' do
+      Ress.canonical_version.should be_a(Ress::CanonicalVersion)
+    end
+    it 'can be altered through Ress.configure' do
+      Ress.configure { |r| r.set_canonical :subdomain => 'foo' }
+      Ress.canonical_version.subdomain.should == 'foo'
+    end
+  end
+  describe '.alternate_versions' do
+    it 'can be altered through Ress.configure' do
+      expect {
+        Ress.configure { |r| r.add_alternate :name => 'foo' }
+      }.to change {
+        Ress.alternate_versions.length
+      }.by(1)
+    end
+  end
+end

data/vendor/assets/javascripts/modernizr.js ADDED

@@ -0,0 +1,4 @@
+/* Modernizr 2.5.3 (Custom Build) | MIT & BSD
+ * Build: http://modernizr.com/download/#-touch-mq-teststyles-prefixes
+ */
+;window.Modernizr=function(a,b,c){function w(a){i.cssText=a}function x(a,b){return w(l.join(a+";")+(b||""))}function y(a,b){return typeof a===b}function z(a,b){return!!~(""+a).indexOf(b)}function A(a,b,d){for(var e in a){var f=b[a[e]];if(f!==c)return d===!1?a[e]:y(f,"function")?f.bind(d||b):f}return!1}var d="2.5.3",e={},f=b.documentElement,g="modernizr",h=b.createElement(g),i=h.style,j,k={}.toString,l=" -webkit- -moz- -o- -ms- ".split(" "),m={},n={},o={},p=[],q=p.slice,r,s=function(a,c,d,e){var h,i,j,k=b.createElement("div"),l=b.body,m=l?l:b.createElement("body");if(parseInt(d,10))while(d--)j=b.createElement("div"),j.id=e?e[d]:g+(d+1),k.appendChild(j);return h=["&#173;","<style>",a,"</style>"].join(""),k.id=g,(l?k:m).innerHTML+=h,m.appendChild(k),l||(m.style.background="",f.appendChild(m)),i=c(k,a),l?k.parentNode.removeChild(k):m.parentNode.removeChild(m),!!i},t=function(b){var c=a.matchMedia||a.msMatchMedia;if(c)return c(b).matches;var d;return s("@media "+b+" { #"+g+" { position: absolute; } }",function(b){d=(a.getComputedStyle?getComputedStyle(b,null):b.currentStyle)["position"]=="absolute"}),d},u={}.hasOwnProperty,v;!y(u,"undefined")&&!y(u.call,"undefined")?v=function(a,b){return u.call(a,b)}:v=function(a,b){return b in a&&y(a.constructor.prototype[b],"undefined")},Function.prototype.bind||(Function.prototype.bind=function(b){var c=this;if(typeof c!="function")throw new TypeError;var d=q.call(arguments,1),e=function(){if(this instanceof e){var a=function(){};a.prototype=c.prototype;var f=new a,g=c.apply(f,d.concat(q.call(arguments)));return Object(g)===g?g:f}return c.apply(b,d.concat(q.call(arguments)))};return e});var B=function(c,d){var f=c.join(""),g=d.length;s(f,function(c,d){var f=b.styleSheets[b.styleSheets.length-1],h=f?f.cssRules&&f.cssRules[0]?f.cssRules[0].cssText:f.cssText||"":"",i=c.childNodes,j={};while(g--)j[i[g].id]=i[g];e.touch="ontouchstart"in a||a.DocumentTouch&&b instanceof DocumentTouch||(j.touch&&j.touch.offsetTop)===9},g,d)}([,["@media (",l.join("touch-enabled),("),g,")","{#touch{top:9px;position:absolute}}"].join("")],[,"touch"]);m.touch=function(){return e.touch};for(var C in m)v(m,C)&&(r=C.toLowerCase(),e[r]=m[C](),p.push((e[r]?"":"no-")+r));return w(""),h=j=null,e._version=d,e._prefixes=l,e.mq=t,e.testStyles=s,e}(this,this.document);

data/vendor/assets/javascripts/ress.js ADDED

@@ -0,0 +1,168 @@
+/**
+ *  This file has been adapted from device.js:
+ *    https://github.com/borismus/device.js
+ */
+(function(exports) {
+  var MQ_TOUCH = /\(touch-enabled: (.*?)\)/;
+  var FORCE_COOKIE = 'force-cannonical';
+ /**
+  * Class responsible for deciding which version of the application to
+  * load.
+  */
+  function VersionManager() {
+    // Get a list of all versions.
+    this.versions = this.getVersions();
+  }
+  /**
+   * Parse all of the <link> elements in the <head>.
+   */
+  VersionManager.prototype.getVersions = function() {
+    var versions = [];
+    // Get all of the link rel alternate elements from the head.
+    var links = document.querySelectorAll('head link[rel="alternate"]');
+    // For each link element, get href, media and id.
+    for (var i = 0; i < links.length; i++) {
+      var href = links[i].getAttribute('href');
+      var media = links[i].getAttribute('media');
+      var id = links[i].getAttribute('id');
+      versions.push(new Version(href, media, id));
+    }
+    // Return an array of Version objects.
+    return versions;
+  };
+  /**
+   * Device which version to load.
+   */
+  VersionManager.prototype.redirectIfNeeded = function() {
+    if(this.shouldNotRedirect()) {
+      return;
+    }
+    var version = this.findVersion(Version.prototype.matches);
+    if (version) {
+      version.redirect();
+    }
+  };
+  VersionManager.prototype.shouldNotRedirect = function() {
+    return this.versions.length === 0 ||
+      this.readCookie(FORCE_COOKIE) === 'true';
+  };
+  VersionManager.prototype.readCookie = function() {
+    var nameEQ = name + "=";
+    var ca = document.cookie.split(';');
+    for(var i=0;i < ca.length;i++) {
+      var c = ca[i];
+      while (c.charAt(0)==' ') c = c.substring(1,c.length);
+      if (c.indexOf(nameEQ) === 0) return c.substring(nameEQ.length,c.length);
+    }
+    return null;
+  };
+  VersionManager.prototype.findVersion = function(criteria) {
+    // Go through configured versions.
+    for (var i = 0; i < this.versions.length; i++) {
+      var v = this.versions[i];
+      // Check if this version matches based on criteria.
+      if (criteria.call(v)) {
+        return v;
+      }
+    }
+    return null;
+  };
+  function Version(href, mediaQuery, id) {
+    this.mediaQuery = mediaQuery;
+    this.url = href;
+    this.id = id;
+  }
+  /**
+   * Check if this version matches the current one.
+   */
+  Version.prototype.matches = function() {
+    // Apply a polyfill for the touch-enabled media query (not currently
+    // standardized, only implemented in Firefox: http://goo.gl/LrmIa)
+    var mqParser = new MQParser(this.mediaQuery);
+    return mqParser.evaluate();
+  };
+  /**
+   * Redirect to the current version.
+   */
+  Version.prototype.redirect = function() {
+    // prevent infinite redirect loops
+    if(window.location.href != this.url) {
+      window.location.href = this.url;
+    }
+  };
+  function MQParser(mq) {
+    this.mq = mq;
+    this.segments = [];
+    this.standardSegments = [];
+    this.specialSegments = [];
+    this.parse();
+  }
+  MQParser.prototype.parse = function() {
+    // Split the Media Query into segments separated by 'and'.
+    this.segments = this.mq.split(/\s*and\s*/);
+    // Look for segments that contain touch checks.
+    for (var i = 0; i < this.segments.length; i++) {
+      var seg = this.segments[i];
+      // TODO: replace this check with something that checks generally for
+      // unknown MQ properties.
+      var match = seg.match(MQ_TOUCH);
+      if (match) {
+        this.specialSegments.push(seg);
+      } else {
+        // If there's no touch MQ, we're dealing with something standard.
+        this.standardSegments.push(seg);
+      }
+    }
+  };
+  /**
+   * Check if touch support matches the media query.
+   */
+  MQParser.prototype.evaluateTouch = function() {
+    var out = true;
+    for (var i = 0; i < this.specialSegments.length; i++) {
+      var match = this.specialSegments[i].match(MQ_TOUCH);
+      var touchValue = match[1];
+      if (touchValue !== "0" && touchValue !== "1") {
+        console.error('Invalid value for "touch-enabled" media query.');
+      }
+      var touchExpected = parseInt(touchValue, 10) === 1 ? true : false;
+      out = out && (touchExpected == Modernizr.touch);
+    }
+    return out;
+  };
+  /**
+   * Returns the valid media query (without touch stuff).
+   */
+  MQParser.prototype.getMediaQuery = function() {
+    return this.standardSegments.join(' and ');
+  };
+  /**
+   * Evaluates the media query with matchMedia.
+   */
+  MQParser.prototype.evaluate = function() {
+    return Modernizr.mq(this.getMediaQuery()) &&
+        this.evaluateTouch();
+  };
+  var vermgr = new VersionManager();
+  vermgr.redirectIfNeeded();
+})(window);

metadata ADDED

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: ress
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: 0.0.1
+platform: ruby
+authors:
+- Matthew Robertson
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-01-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    none: false
+  name: actionpack
+  type: :runtime
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    none: false
+- !ruby/object:Gem::Dependency
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+  name: rspec
+  type: :development
+  prerelease: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+    none: false
+description: Progressively enhance the mobile user experience of your Rails application.
+email:
+- matthewrobertson03@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/generators/ress/install_generator.rb
+- lib/generators/ress/templates/README
+- lib/generators/ress/templates/ress.rb
+- lib/ress.rb
+- lib/ress/alternate_version.rb
+- lib/ress/canonical_version.rb
+- lib/ress/category_collection.rb
+- lib/ress/controller_additions.rb
+- lib/ress/engine.rb
+- lib/ress/version.rb
+- lib/ress/view_helpers.rb
+- ress.gemspec
+- spec/ress/alternate_version_spec.rb
+- spec/ress/canonical_version_spec.rb
+- spec/ress/category_collection_spec.rb
+- spec/ress/controller_additions_spec.rb
+- spec/ress/view_helpers_spec.rb
+- spec/ress_spec.rb
+- vendor/assets/javascripts/modernizr.js
+- vendor/assets/javascripts/ress.js
+homepage: https://github.com/matthewrobertson/ress
+licenses: []
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+  none: false
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: Progressively enhance the mobile user experience of your Rails application.
+test_files:
+- spec/ress/alternate_version_spec.rb
+- spec/ress/canonical_version_spec.rb
+- spec/ress/category_collection_spec.rb
+- spec/ress/controller_additions_spec.rb
+- spec/ress/view_helpers_spec.rb
+- spec/ress_spec.rb