mobylette 1.0.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2011 YOURNAME
+
+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.rdoc

@@ -0,0 +1,83 @@
+http://fd.img.v4.skyrock.net/fd6/mantaur/pics/206915407_small.jpg
+
+= Mobylette http://travis-ci.org/tscolari/mobylette.png
+
+This gem works by adding the 'mobile' format to your rails application. Whenever a request come from a mobile device, if you have your controller mobile enabled, it shall render the view.mobile.erb instead of the view.html.erb (or haml, or whatever).
+
+This gem is based on the mobile_fu plugin (https://github.com/brendanlim/mobile-fu). Also these pages were very usefull for me:
+ * http://stackoverflow.com/questions/5126085/ruby-on-rails-mobile-application
+ * http://www.arctickiwi.com/blog/mobile-enable-your-ruby-on-rails-site-for-small-screens
+ * http://metautonomo.us/2011/01/05/mobile-devices-and-rails-maintaining-your-sanity/
+
+== How does it work?
+
+By adding "respond_to_mobile_requests" in your application_controller (or any other controller), your controllers (or that controller) will understand mobile requests as a new mime type alias "mobile". This will make the controller to search for the .mobile.erb file instead of the .html.erb. Also you will be able to do:
+
+    respond_to do |format|
+      format.html   { ... }
+      format.mobile { ... }
+    end
+
+== Instalation
+
+Add the gem to your gemfile:
+
+    gem 'mobylette', :git => "git://github.com/tscolari/mobylette.git"
+
+And add to your ApplicationController.rb (for enabling it to all your controllers) or to the controllers you want this functionality on:
+
+    respond_to_mobile_requests
+
+After that, you may start adding your .mobile. views.
+
+== Helpers
+
+==== is_mobile_request?
+
+This helper returns true if the request comes from a mobile device, false if it does not.
+
+==== mobylette_stylesheet_link_tag(*sources)
+
+This works like the stylesheet_link_tag helper, but when the request comes from a mobile device, it adds "_mobile" to the stylesheets before calling stylesheet_link_tag
+
+==== mobylette_javascript_include_tag(*soruces)
+
+Same as mobylette_stylesheet_link_tag, but for javascript files and javascript_include_tag
+
+== Fall Backs
+
+By default, when the mobile format is not found, mobylette will fall back to the request original format. For example, if a cell phone makes a request by html, and there is no mobile view, it will render the html. You may force it always to fall back to a especific format, by passing the :fall_back parameter to the respond_to_mobile_requests method:
+
+    respond_to_mobile_requests :fall_back => :html
+
+This would force all views (mobile) to fall back to the html views. You may also disable this behavior, and no fall back will ever occur:
+
+    respond_to_mobile_requests :fall_back => false
+
+== Testing
+
+http://image.tin247.com/kenh14/080918143137-689-665.jpg
+
+Don't drive your mobylette without your Helmet! It's always safer do tests!
+
+For testing, include the Mobylette::Helmet module to your test/test_helpers.rb:
+
+    include Mobylette::Helmet
+
+For RSpec: add to your spec/spec_helpers.rb or create a spec/support/mobylette.rb with the following:
+
+    RSpec.configure do |config|
+      config.include Mobylette::Helmet, :type => :controller
+    end
+
+This will add 2 methods to your test scope:
+
+    force_mobile_request_agent(device = "Android")
+
+this one will force your user_agent to the one specified, allowing you to test mobile requests.
+
+    reset_test_request_agent
+
+and this one will reset your user_agent to the test default "Rails Testing". You don't need to call this everytime, all your requests by default are "Rails Testing" in your test env.
+
+Friendly note: on your tests, call these functions BEFORE you make the request, otherwise they are useless =p

data/Rakefile

@@ -0,0 +1,37 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Mobylette'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/lib/mobylette.rb

@@ -0,0 +1,12 @@
+module Mobylette
+  module Controllers
+    autoload "RespondToMobileRequests", "mobylette/controllers/respond_to_mobile_requests"
+    autoload "Helpers"                , "mobylette/controllers/helpers"
+  end
+
+  autoload "Helmet"                   , "mobylette/helmet"
+  require 'mobylette/railtie'
+end
+
+require 'action_controller'
+Mime::Type.register_alias "text/html", :mobile

data/lib/mobylette/controllers/helpers.rb

@@ -0,0 +1,52 @@
+module Mobylette
+  module Controllers
+
+    #
+    # Mobylette::Controllers::Helpers include few methods to
+    # include different css/js files for the mobile and for
+    # the normal version of your layout
+    #
+    # Personal note: I'm rethinking and I guess that, since you
+    # may have (and probably will) a different layout file for the
+    # "normal" and mobile version, you probably wont use this at all
+    module Helpers
+      extend ActiveSupport::Concern
+
+      # Adds a "_mobile" sulfix to the files you include (when the request is mobile)
+      def mobylette_stylesheet_link_tag(*sources)
+        options = sources.extract_options!
+        if is_mobile_request?
+          stylesheet_link_tag(*sulfix_mobile_assets(sources, :css).insert(-1, options))
+        else
+          stylesheet_link_tag(*sources.insert(-1, options))
+        end
+      end
+
+      # Adds a "_mobile" sulfix to the files you include (when the request is mobile)
+      def mobylette_javascript_include_tag(*sources)
+        options = sources.extract_options!
+        if is_mobile_request?
+          javascript_include_tag(*sulfix_mobile_assets(sources, :js).insert(-1, options))
+        else
+          javascript_include_tag(*sources.insert(-1, options))
+        end
+      end
+
+      private
+
+      #
+      # Anex the "_mobile" sulfix to each string in the array,
+      # before the .#{extension}, if it exists
+      def sulfix_mobile_assets(sources, extension)
+        sources.map do |source|
+          if source =~ /.#{extension}/
+            "#{source.split(/.#{extension}$/)[0]}_mobile.#{extension}"
+          else
+            "#{source}_mobile"
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/mobylette/controllers/respond_to_mobile_requests.rb

@@ -0,0 +1,86 @@
+module Mobylette
+  module Controllers
+
+    # Mobylette::Controllers::RespondToMobileRequests includes the respond_to_mobile_requests
+    # to your ActionController::Base.
+    #
+    # The respond_to_mobile_requests method enables the controller mobile handling
+    module RespondToMobileRequests
+      extend ActiveSupport::Concern
+
+      included do
+        helper_method :is_mobile_request?
+
+        # List of mobile agents, from mobile_fu (https://github.com/brendanlim/mobile-fu)
+        MOBILE_USER_AGENTS =  'palm|blackberry|nokia|phone|midp|mobi|symbian|chtml|ericsson|minimo|' +
+                              'audiovox|motorola|samsung|telit|upg1|windows ce|ucweb|astel|plucker|' +
+                              'x320|x240|j2me|sgh|portable|sprint|docomo|kddi|softbank|android|mmp|' +
+                              'pdxgw|netfront|xiino|vodafone|portalmmm|sagem|mot-|sie-|ipod|up\\.b|' +
+                              'webos|amoi|novarra|cdm|alcatel|pocket|ipad|iphone|mobileexplorer|'    +
+                              'mobile'
+      end
+
+      module ClassMethods
+
+        # This method enables the controller do handle mobile requests
+        # You must add this to every controller you want to respond differently to mobile devices,
+        # or make it application wide calling it from the ApplicationController
+        #
+        # Options:
+        # * :fall_back => :html
+        #     You may pass a fall_back option to the method, it will force the render
+        #     to look for that other format, in case there is not a .mobile file for the view.
+        #     By default, it will fall back to the format of the original request.
+        #     If you don't want fall back at all, pass :fall_back => false
+        #
+        def respond_to_mobile_requests(options = {})
+          return if self.included_modules.include?(Mobylette::Controllers::RespondToMobileRequestsMethods)
+
+          cattr_accessor :fall_back_format
+          self.fall_back_format   = options[:fall_back]
+
+          self.send(:include, Mobylette::Controllers::RespondToMobileRequestsMethods)
+        end
+      end
+
+      module InstanceMethods
+
+        private
+
+        # helper method to check if the current request if from a mobile device or not
+        def is_mobile_request?
+          return true if (request.format.to_s == "mobile") or (params[:format] == "mobile")
+          request.user_agent.to_s.downcase =~ /#{MOBILE_USER_AGENTS}/
+        end
+      end
+
+    end
+
+    # RespondToMobileRequestsMethods is included by respond_to_mobile_requests
+    # This will check if the request is from a mobile device and change
+    # the request format to :mobile
+    module RespondToMobileRequestsMethods
+      extend ActiveSupport::Concern
+
+      included do
+        before_filter :handle_mobile
+      end
+
+      module InstanceMethods
+        private
+
+        # Changes the request.form to :mobile, when the request is from
+        # a mobile device
+        def handle_mobile
+          if is_mobile_request?
+            original_format   = request.format.to_sym
+            request.format    = :mobile
+            if self.fall_back_format != false
+              request.formats << Mime::Type.new((self.fall_back_format if self.fall_back_format) || original_format)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mobylette/helmet.rb

@@ -0,0 +1,41 @@
+module Mobylette
+  # Mobylette::Helmet provides helper methods to help you when testing your controllers
+  # for a mobile request.
+  #
+  # You must include Mobylette::Helmet into your test case, in the README there is more
+  # documentation about how to make this test wide.
+  module Helmet
+    extend ActiveSupport::Concern
+    autoload "Helpers", "mobylette/helmet/helpers"
+    autoload "Faker"  , "mobylette/helmet/faker"
+
+    # Force the request for the user_agent
+    # Remember to add it BEFORE the request
+    #
+    # Example:
+    #
+    #   it "should render the mobile_device view on mobile request" do
+    #     force_mobile_request_agent("Android")
+    #     get :index
+    #     response.should render_template(:mobile_device)
+    #   end
+    def force_mobile_request_agent(user_agent = "Android")
+      request.user_agent = user_agent
+    end
+
+    # Reset the user_aget to the default ("Rails Testing")
+    # Remember to add it BEFORE the request
+    #
+    # Example:
+    #
+    #   it "should render the normal_view view on mobile request" do
+    #     reset_test_request_agent
+    #     get :index
+    #     response.should render_template(:normal_view)
+    #   end
+    def reset_test_request_agent
+      request.user_agent = "Rails Testing"
+    end
+
+  end
+end

data/lib/mobylette/helmet/faker.rb

@@ -0,0 +1,19 @@
+module Mobylette
+  module Helmet
+
+    # Forces the helper to think that all requests come
+    # from a mobile device
+    module Faker
+      extend ActiveSupport::Concern
+
+      included do
+        cattr_accessor :is_mobile_request
+      end
+
+      def is_mobile_request?
+        is_mobile_request
+      end
+
+    end
+  end
+end

data/lib/mobylette/helmet/helpers.rb

@@ -0,0 +1,34 @@
+module Mobylette
+  module Helmet
+    # This module is only for testing the view's helpers of the module
+    # it simulates the Helmet helpers and the controller methods
+    # that are necessary for the tests
+    module Helpers
+      extend ActiveSupport::Concern
+
+      included do
+        cattr_accessor :user_agent
+      end
+
+
+      def force_mobile_request_agent
+        insert_faker
+        ActionController::Base.is_mobile_request = true
+      end
+
+      def reset_test_request_agent
+        insert_faker
+        ActionController::Base.is_mobile_request = false
+      end
+
+      private
+
+      def insert_faker
+        return if ActionController::Base.included_modules.include?(Mobylette::Helmet::Faker)
+        ActionController::Base.send(:include, Mobylette::Helmet::Faker)
+      end
+
+
+    end
+  end
+end

data/lib/mobylette/railtie.rb

@@ -0,0 +1,10 @@
+module Mobylette
+  class Railtie < ::Rails::Railtie
+    initializer :mobylette do
+      ActiveSupport.on_load(:action_controller) do
+        ::ActionController::Base.send(:include, Mobylette::Controllers::RespondToMobileRequests)
+        ::ActionController::Base.helper Mobylette::Controllers::Helpers
+      end
+    end
+  end
+end

data/lib/mobylette/version.rb

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

data/lib/tasks/mobylette_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :mobylette do
+#   # Task goes here
+# end

data/spec/controllers/actioncontroller_base_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe ActionController::Base do
+
+  it "ActionController::Base class should respond to the respond_to_mobile_requests" do
+    ActionController::Base.respond_to?(:respond_to_mobile_requests).should be_true
+  end
+
+  it "should have the :is_mobile_request? method" do
+    # works on ruby 1.9.2, but not on 1.8.7:
+    #@controller.private_methods.include?(:is_mobile_request?).should be_true
+
+    @controller.send(:is_mobile_request?).should be_nil
+  end
+
+end

data/spec/controllers/default_fallback_controller_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe DefaultFallbackController do
+  render_views
+
+  it "should find the correct view when it exists" do
+    force_mobile_request_agent
+    get :index
+    response.should render_template(:index)
+    response.body.should contain("MOBILE VIEW")
+  end
+
+  it "should find the correct view when it exists" do
+    reset_test_request_agent
+    get :index
+    response.should render_template(:index)
+    response.body.should contain("HTML VIEW")
+  end
+
+
+  it "should fall back to the default request format when it doesnt" do
+    force_mobile_request_agent
+    get :test
+    response.should render_template(:test)
+    response.body.should contain("HTML VIEW")
+  end
+
+  it "should fall back to the default request format when it doesnt (js)" do
+    force_mobile_request_agent
+    get :test, :format => :js
+    response.should render_template(:test)
+    response.body.should contain("JS VIEW")
+  end
+
+
+end