mobvious 0.1.0.pre

data/.gitignore

@@ -0,0 +1,5 @@
+/.bundle
+/.yardoc
+/doc
+/Gemfile.lock
+/vendor/ruby

data/.yardopts

@@ -0,0 +1 @@
+-m markdown

data/Gemfile

@@ -0,0 +1,13 @@
+source :rubygems
+
+gemspec
+
+
+gem 'mobileesp', git: 'git://github.com/jistr/mobileesp'
+
+# == SPECIAL DEVELOPMENT DEPS HANDLING ==
+
+# temporarily switched for this fork, because the current version of guard-minitest has broken notifications
+gem 'guard-minitest', git: 'git://github.com/aspiers/guard-minitest', ref: '4b660261d35'
+gem 'mocha', require: false
+gem 'turn', require: false

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'minitest' do
+  watch(%r|^spec/(.*)_spec\.rb|)
+  watch(%r|^lib/(.*)\.rb|)            { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r|^spec/spec_helper\.rb|)    { "spec" }
+end

data/Rakefile

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

data/lib/mobvious.rb

@@ -0,0 +1,21 @@
+require "mobvious/version"
+
+require "mobvious/config"
+require "mobvious/manager"
+
+# A library (Rack middleware) to detect device types (mobile, tablet, desktop etc.)
+# from requests.
+#
+# See {Mobvious::Manager} for the actual Rack middleware.
+#
+# See {Mobvious::Config} for configuration options (and set them via calling
+# {Mobvious.config Mobvious.config}).
+#
+# See {Mobvious::Strategies} for predefined strategies or roll out your own.
+module Mobvious
+  # An accessor for the global Mobvious configuration object.
+  # See {Config} for configuration options.
+  def self.config
+    @config ||= Mobvious::Config.new
+  end
+end

data/lib/mobvious/config.rb

@@ -0,0 +1,26 @@
+module Mobvious
+  # Class encapsulating Mobvious configuration.
+  #
+  # Set configuration options them via calling {Mobvious.config Mobvious.config}.
+  class Config
+    # Creates a new configuration with no strategies and default device type `:desktop`.
+    def initialize()
+      self.clear
+    end
+
+    # Resets a configuration to no strategies and default device type `:desktop`.
+    def clear
+      @strategies = []
+      @default_device_type = :desktop
+    end
+
+    # Strategies used to determine device type from a request. They are evaluated
+    # in the order they are inserted. Result of the first successful strategy
+    # (returning something else than nil) is used.
+    attr_accessor :strategies
+
+    # Default device type is used when no strategy was successful (all return nil
+    # or none is present).
+    attr_accessor :default_device_type
+  end
+end

data/lib/mobvious/manager.rb

@@ -0,0 +1,57 @@
+require 'rack'
+
+module Mobvious
+  # Rack middleware that enables device type detection for requests.
+  #
+  # Use `Mobvious.config` to set which strategies to use.
+  #
+  # Look into `Mobvious::Strategies` for predefined strategies or write your own.
+  class Manager
+    # Create a new instance of this rack middleware.
+    #
+    # @param app Rack application that can be called.
+    def initialize(app)
+      @app = app
+    end
+
+    # Perform the device type detection and call the inner Rack application.
+    #
+    # @param env Rack environment.
+    # @return rack response `[status, headers, body]`
+    def call(env)
+      request = Rack::Request.new(env)
+      assign_device_type(request)
+
+      status, headers, body = @app.call(env)
+
+      response = Rack::Response.new(body, status, headers)
+      response_callback(request, response)
+
+      [status, headers, body]
+    end
+
+    private
+      def assign_device_type(request)
+        request.env['mobvious.device_type'] =
+            get_device_type_using_strategies(request) || config.default_device_type
+      end
+
+      def response_callback(request, response)
+        config.strategies.each do |strategy|
+          strategy.response_callback(request, response) if strategy.respond_to? :response_callback
+        end
+      end
+
+      def get_device_type_using_strategies(request)
+        config.strategies.each do |strategy|
+          result = strategy.get_device_type(request)
+          return result.to_sym if result
+        end
+        nil
+      end
+
+      def config
+        Mobvious.config
+      end
+  end
+end

data/lib/mobvious/strategies/cookie.rb

@@ -0,0 +1,55 @@
+module Mobvious
+  module Strategies
+    # Mobvious device detection strategy that saves and loads a cookie that precisely
+    # specifies which device type should be used for current client.
+    #
+    # Usually, you will want to set the device type via cookie only when you are absolutely
+    # sure that user wants it this way (e.g. after manual switch between mobile/desktop
+    # interface versions performed by user). Also make sure to use this strategy with high
+    # priority, (e.g. put it before user-agent based detection) so it does not get overriden.
+    #
+    # Use `set_device_type_cookie` method to set the device type and the strategy will then
+    # recognize it on subsequent requests.
+    class Cookie
+      # Creates a new Cookie strategy instance.
+      #
+      # @param cookie_expires [Integer]
+      #   Amount of seconds to hold device type cookie. Defaults to one year (365*24*60*60).
+      def initialize(cookie_expires = (365*24*60*60))
+        @cookie_expires = cookie_expires
+      end
+
+      # Gets device type using a pre-set cookie. Returns nil if the cookie is not set.
+      #
+      # @param request [Rack::Request]
+      # @return [Symbol] device type or nil
+      def get_device_type(request)
+        request.cookies['mobvious.device_type'].to_sym if request.cookies['mobvious.device_type']
+      end
+
+      # Automatically sets the device type cookie again to prolong its expiration date.
+      #
+      # @param request [Rack::Request]
+      # @param response [Rack::Response]
+      def response_callback(request, response)
+        response_cookie_already_set = !!response.headers["Set-Cookie"] &&
+          !!response.headers["Set-Cookie"]["mobvious.device_type"]
+        request_cookie = request.cookies['mobvious.device_type']
+
+        # re-set the cookie to renew the expiration date
+        if request_cookie && !response_cookie_already_set
+          set_device_type_cookie(response, request_cookie)
+        end
+      end
+
+      # Sets the device type cookie.
+      #
+      # @param response [Rack::Response]
+      # @param device_type [Symbol] A device type symbol (or string).
+      def set_device_type_cookie(response, device_type)
+        response.set_cookie('mobvious.device_type',
+                            { value: device_type.to_s, path: '/', expires: Time.now + @cookie_expires })
+      end
+    end
+  end
+end

data/lib/mobvious/strategies/mobileesp.rb

@@ -0,0 +1,43 @@
+require 'mobileesp'
+
+module Mobvious
+  module Strategies
+    # Mobvious device detection strategy that uses user-agent sniffing provided by
+    # the MobileESP library.
+    class Mobileesp
+      # Detection procedure that classifies mobile phones as `:mobile` and anything
+      # else as `:desktop`.
+      DEVICE_TYPES_MOBILE_DESKTOP = lambda {|mobileesp|
+        return :mobile if mobileesp.is_tier_generic_mobile || mobileesp.is_tier_iphone
+        return :desktop
+      }
+
+      # Detection procedure that classifies mobile phones as `:mobile`, tablets as
+      # `:tablet` and anything else as `:desktop`.
+      DEVICE_TYPES_MOBILE_TABLET_DESKTOP = lambda {|mobileesp|
+        return :mobile if mobileesp.is_tier_generic_mobile || mobileesp.is_tier_iphone
+        return :tablet if mobileesp.is_tier_tablet
+        return :desktop
+      }
+
+      # Creates a new instance of MobileESP strategy.
+      #
+      # @param detection_procedure
+      #   A lambda function that gets one parameter (`MobileESP::UserAgentInfo` instance)
+      #   and returns device type symbol or nil.
+      def initialize(detection_procedure = DEVICE_TYPES_MOBILE_DESKTOP)
+        @detection_procedure = detection_procedure
+      end
+
+      # Gets device type using user-agent sniffing. Can return nil if the used
+      # detection procedure does so.
+      #
+      # @param request [Rack::Request]
+      # @return [Symbol] device type or nil
+      def get_device_type(request)
+        mobileesp = MobileESP::UserAgentInfo.new(request.user_agent, request.accept)
+        @detection_procedure.call(mobileesp)
+      end
+    end
+  end
+end

data/lib/mobvious/strategies/url.rb

@@ -0,0 +1,30 @@
+module Mobvious
+  module Strategies
+    # Mobvious device detection strategy that uses URL pattern matching.
+    class URL
+      # Rule set with only one rule for domains that begin with `m.` matching as `:mobile`.
+      MOBILE_PATH_RULES = { /^\w+:\/\/m\./ => :mobile }
+
+      # Creates a new URL strategy instance.
+      #
+      # @param rules
+      #   A hash containing regular expressions mapped to symbols. The regular expression
+      #   is evaluated against the whole URL of the request (including `http://`). If matching,
+      #   the corresponding symbol is returned as the device type.
+      def initialize(rules = MOBILE_PATH_RULE)
+        @rules = rules
+      end
+
+      # Gets device type using URL pattern matching. Returns nil if no match found.
+      #
+      # @param request [Rack::Request]
+      # @return [Symbol] device type or nil
+      def get_device_type(request)
+        @rules.each do |regex, device_type|
+          return device_type if request.url =~ regex
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/mobvious/version.rb

@@ -0,0 +1,3 @@
+module Mobvious
+  VERSION = "0.1.0.pre"
+end

data/mobvious.gemspec

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "mobvious/version"
+
+Gem::Specification.new do |s|
+  s.name        = "mobvious"
+  s.version     = Mobvious::VERSION
+  s.authors     = ["Jiří Stránský"]
+  s.email       = ["jistr@jistr.com"]
+  s.homepage    = "http://github.com/jistr/mobvious"
+  s.summary     = %q{Rack middleware for choosing a version of an interface to render for given request}
+  s.description = %q{Rack middleware for choosing a version of an interface to render for given request}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "rack", ">= 1.2.0"
+  s.add_runtime_dependency "mobileesp"
+
+
+  # == DEVELOPMENT DEPENDENCIES ==
+  # Smart irb
+  s.add_development_dependency 'pry'
+
+  # Specs
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'rack-test'
+
+  # Running tests during development
+  s.add_development_dependency 'guard'
+  s.add_development_dependency 'guard-minitest'
+  # Linux Guard watching
+  s.add_development_dependency 'rb-inotify'
+  # Linux Guard notifications
+  s.add_development_dependency 'libnotify'
+
+  # Pretty printed test output
+  s.add_development_dependency 'turn'
+end

data/spec/mobvious/manager_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+module Mobvious
+  class ManagerSpec < MiniTest::Spec
+  describe Manager do
+    before do
+      @app = mock 'app'
+      @env = mock 'env'
+      @manager = Mobvious::Manager.new(@app)
+      @return_value = [200, ['My-Header'], ['body_part_1']]
+
+      @app.stubs(:call).with(@env).returns(@return_value)
+    end
+
+    after do
+      Mobvious.config.clear
+    end
+
+    it "calls the app and returns what app returns" do
+      @env.stub_everything
+      @app.expects(:call).with(@env).returns(@return_value)
+      @manager.call(@env).must_equal @return_value
+    end
+
+    describe "having strategies" do
+      before do
+        @strategy1 = mock 'strategy1'
+        @strategy2 = mock 'strategy2'
+        @strategy3 = mock 'strategy3'
+        Mobvious.config.strategies << @strategy1
+        Mobvious.config.strategies << @strategy2
+        Mobvious.config.strategies << @strategy3
+      end
+
+      it "uses the result of the first successful strategy" do
+        @app.stub_everything
+        @app.expects(:call).with(@env).returns(@return_value)
+        @strategy1.expects(:get_device_type).returns(nil)
+        @strategy2.expects(:get_device_type).returns(:strategy_2_result)
+        @env.expects('[]=').with('mobvious.device_type', :strategy_2_result)
+        @manager.call(@env)
+      end
+
+      it "calls strategies with a request object" do
+        @app.stub_everything
+        @env.stub_everything
+        @strategy1.expects(:get_device_type).returns(:result).with() {|param|
+          param.must_be_instance_of Rack::Request
+          (param.env == @env).must_equal true
+        }
+        @manager.call(@env)
+      end
+
+      it "uses default value if no strategy is successful" do
+        @app.stub_everything
+        @strategy1.stub_everything
+        @strategy2.stub_everything
+        @strategy3.stub_everything
+        Mobvious.config.default_device_type = :test_default_type
+        @env.expects('[]=').with('mobvious.device_type', :test_default_type)
+        @manager.call(@env)
+      end
+
+      it "calls the response callback on strategies that have it defined" do
+        @env.stub_everything
+        @strategy1.stubs(:get_device_type)
+        @strategy1.stubs(:respond_to?).with(:response_callback).returns(true)
+        @strategy1.expects(:response_callback).with() {|request, response|
+          request.must_be_instance_of Rack::Request
+          (request.env == @env).must_equal true
+          response.must_be_instance_of Rack::Response
+          response.body.must_equal @return_value[2]
+        }
+
+        @strategy2.stub_everything
+        @strategy3.stub_everything
+        @manager.call(@env)
+      end
+    end
+
+    describe "not having strategies" do
+      it "uses default value" do
+        @app.stub_everything
+        Mobvious.config.default_device_type = :test_default_type
+        @env.expects('[]=').with('mobvious.device_type', :test_default_type)
+        @manager.call(@env)
+      end
+    end
+  end
+  end
+end

data/spec/mobvious/strategies/cookie_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+require 'mobvious/strategies/cookie'
+
+module Mobvious::Strategies
+class CookieSpec < MiniTest::Spec
+  describe Cookie do
+    before do
+      @strategy = Cookie.new
+      @app = mock 'app'
+      @uri = URI("http://foo.com/")
+
+      @env = Rack::MockRequest::DEFAULT_ENV
+      @request = Rack::Request.new(@env)
+      @response = Rack::Response.new(['body'], 200, {})
+
+      @mock_session = Rack::MockSession.new(@app)
+      @mock_session.after_request do
+        @strategy.response_callback(@request, @response)
+      end
+    end
+
+    describe "with no device type cookie set" do
+      it "returns nil as device type" do
+        @strategy.get_device_type(@request).must_equal nil
+      end
+
+      describe "when device type set during the app execution" do
+        it "sets the cookie on response" do
+          @app.expects(:call).returns([@response.status, @response.headers, @response.body])
+            .with do |env|
+              @strategy.set_device_type_cookie(@response, :tablet)
+              true
+            end
+          @mock_session.request @uri, @env
+          cookies = Mobvious::CookieParser.new(@response.headers['Set-Cookie'])
+          cookies['mobvious.device_type']['value'].must_equal 'tablet'
+        end
+      end
+    end
+
+    describe "with set device type cookie" do
+      before do
+        @request = Rack::Request.new(@env)
+        @request.cookies['mobvious.device_type'] = 'tablet'
+      end
+
+      it "gets device type from cookie" do
+        @app.expects(:call).returns([@response.status, @response.headers, @response.body])
+          .with do |env|
+            @strategy.get_device_type(@request).must_equal :tablet
+            true
+          end
+        mock_response = @mock_session.request @uri, @env
+      end
+
+      it "refreshes the cookie expiration date with every request" do
+        @app.expects(:call).returns([@response.status, @response.headers, @response.body])
+        mock_response = @mock_session.request @uri, @env
+        cookies = Mobvious::CookieParser.new(@response.headers['Set-Cookie'])
+        cookies['mobvious.device_type'].wont_be_nil
+        cookies['mobvious.device_type']['value'].must_equal 'tablet'
+        cookies['mobvious.device_type']['expires'].wont_be_nil
+      end
+
+      describe "when device type set during the app execution" do
+        it "sets the response cookie to the new value, not the old one" do
+          @app.expects(:call).returns([@response.status, @response.headers, @response.body])
+            .with do |env|
+              @strategy.set_device_type_cookie(@response, :mobile)
+              true
+            end
+          @mock_session.request @uri, @env
+          cookies = Mobvious::CookieParser.new(@response.headers['Set-Cookie'])
+          cookies['mobvious.device_type'].wont_be_nil
+          cookies['mobvious.device_type']['value'].must_equal 'mobile'
+          cookies['mobvious.device_type']['expires'].wont_be_nil
+        end
+      end
+    end
+  end
+end
+end
+

data/spec/mobvious/strategies/mobileesp_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'mobvious/strategies/mobileesp'
+
+module Mobvious::Strategies
+  class MobileespSpec < MiniTest::Spec
+  describe Mobileesp do
+    describe "using mobile_desktop strategy" do
+      before do
+        @strategy = Mobvious::Strategies::Mobileesp.new
+        @request = mock 'request'
+        @request.stubs(:accept).returns('text/html')
+      end
+
+      it "categorizes iPhone as :mobile" do
+        @request.stubs(:user_agent).returns("Mozilla/5.0 (iPhone; U; CPU iPhone OS 4_0 like Mac OS X; en-us) AppleWebKit/532.9 (KHTML, like Gecko) Version/4.0.5 Mobile/8A293 Safari/6531.22.7")
+        @strategy.get_device_type(@request).must_equal :mobile
+      end
+
+      it "categorizes Android tablet as :desktop" do
+        @request.stubs(:user_agent).returns("Mozilla/5.0 (Linux; U; Android 3.0; xx-xx; Xoom Build/HRI39) AppleWebKit/525.10+ (KHTML, like Gecko) Version/3.0.4 Mobile Safari/523.12.2")
+        @strategy.get_device_type(@request).must_equal :desktop
+      end
+
+      it "categorizes Chrome on Linux as :desktop" do
+        @request.stubs(:user_agent).returns("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.46 Safari/535.11")
+        @strategy.get_device_type(@request).must_equal :desktop
+      end
+    end
+
+    describe "using mobile_tablet_desktop strategy" do
+      before do
+        @strategy = Mobvious::Strategies::Mobileesp.new(
+          Mobvious::Strategies::Mobileesp::DEVICE_TYPES_MOBILE_TABLET_DESKTOP)
+        @request = mock 'request'
+        @request.stubs(:accept).returns('text/html')
+      end
+
+      it "categorizes iPhone as :mobile" do
+        @request.stubs(:user_agent).returns("Mozilla/5.0 (iPhone; U; CPU iPhone OS 4_0 like Mac OS X; en-us) AppleWebKit/532.9 (KHTML, like Gecko) Version/4.0.5 Mobile/8A293 Safari/6531.22.7")
+        @strategy.get_device_type(@request).must_equal :mobile
+      end
+
+      it "categorizes Android tablet as :tablet" do
+        @request.stubs(:user_agent).returns("Mozilla/5.0 (Linux; U; Android 3.0; xx-xx; Xoom Build/HRI39) AppleWebKit/525.10+ (KHTML, like Gecko) Version/3.0.4 Mobile Safari/523.12.2")
+        @strategy.get_device_type(@request).must_equal :tablet
+      end
+
+      it "categorizes Chrome on Linux as :desktop" do
+        @request.stubs(:user_agent).returns("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/535.11 (KHTML, like Gecko) Chrome/17.0.963.46 Safari/535.11")
+        @strategy.get_device_type(@request).must_equal :desktop
+      end
+    end
+  end
+  end
+end
+

data/spec/mobvious/strategies/url_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'mobvious/strategies/url'
+
+module Mobvious::Strategies
+class URLSpec < MiniTest::Spec
+  describe URL do
+    before do
+      @env = Rack::MockRequest::DEFAULT_ENV
+      @env.merge!({
+        'rack.url_scheme' => 'http',
+        'HTTP_HOST' => 'm.foo.com',
+        'SERVER_PORT' => 80,
+        'SCRIPT_NAME' => '',
+        'PATH_INFO' => '/some_path'
+      })
+      @request = Rack::Request.new(@env)
+      @strategy = URL.new(URL::MOBILE_PATH_RULES)
+    end
+
+    it "returns the right device type when matching rule found" do
+      puts @request.url
+      @strategy.get_device_type(@request).must_equal :mobile
+    end
+
+    it "returns nil if no matching rule found" do
+      @env['HTTP_HOST'] = 'www.foo.com'
+      @strategy.get_device_type(@request).must_equal nil
+    end
+  end
+end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+begin; require 'turn'; rescue LoadError; end
+require 'mocha'
+require 'rack/test'
+require 'mobvious'
+
+module Mobvious
+  class CookieParser
+    attr_reader :cookies
+
+    def initialize(cookie_header_content)
+      @cookies = {}
+      return unless cookie_header_content
+
+      cookie_header_content.split("\n").each do |cookie_string|
+        cookie_parts = cookie_string.split(';')
+
+        name, cookie_value = cookie_parts.first.split('=')
+        cookie = { 'value' => cookie_value }
+
+        cookie_parts[1..-1].each do |cookie_part|
+          key, value = cookie_part.split('=')
+          cookie[key.strip] = value
+        end
+        @cookies[name.strip] = cookie
+      end
+    end
+
+    def [](*args)
+      @cookies[*args]
+    end
+  end
+end

metadata

@@ -0,0 +1,189 @@
+--- !ruby/object:Gem::Specification
+name: mobvious
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre
+  prerelease: 6
+platform: ruby
+authors:
+- Jiří Stránský
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &12623500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *12623500
+- !ruby/object:Gem::Dependency
+  name: mobileesp
+  requirement: &12623000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *12623000
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: &12622080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12622080
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &12621480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12621480
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &12620840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12620840
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: &12619900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12619900
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: &12619220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12619220
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: &12618320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12618320
+- !ruby/object:Gem::Dependency
+  name: rb-inotify
+  requirement: &12617600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12617600
+- !ruby/object:Gem::Dependency
+  name: libnotify
+  requirement: &12616840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12616840
+- !ruby/object:Gem::Dependency
+  name: turn
+  requirement: &12616080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *12616080
+description: Rack middleware for choosing a version of an interface to render for
+  given request
+email:
+- jistr@jistr.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .yardopts
+- Gemfile
+- Guardfile
+- Rakefile
+- lib/mobvious.rb
+- lib/mobvious/config.rb
+- lib/mobvious/manager.rb
+- lib/mobvious/strategies/cookie.rb
+- lib/mobvious/strategies/mobileesp.rb
+- lib/mobvious/strategies/url.rb
+- lib/mobvious/version.rb
+- mobvious.gemspec
+- spec/mobvious/manager_spec.rb
+- spec/mobvious/strategies/cookie_spec.rb
+- spec/mobvious/strategies/mobileesp_spec.rb
+- spec/mobvious/strategies/url_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/jistr/mobvious
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 816301950663841186
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Rack middleware for choosing a version of an interface to render for given
+  request
+test_files: []