oembed_provider 0.1.0

data/test/full_2_3_5_app_with_tests/test/unit/oembed_provider_test.rb

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+require 'test_helper'
+
+class OembedProviderTest < ActiveSupport::TestCase
+  context "The OembedProvider object" do
+    should "be able to set and return its provider name" do
+      name = "Media Conglomerate International"
+      OembedProvider.provider_name = name
+      assert_equal OembedProvider.provider_name, name
+    end
+
+    should "be able to set and return its provider url" do
+      url = "http://example.com"
+      OembedProvider.provider_url = url
+      assert_equal OembedProvider.provider_url, url
+    end
+
+    should "be able to set and return its cache age" do
+      age = "1440"
+      OembedProvider.cache_age = age
+      assert_equal OembedProvider.cache_age, age
+    end
+
+    should "return version as 1.0 of oEmbed spec" do
+      assert_equal "1.0", OembedProvider.version
+    end
+
+    should "have an array of base attribute keys" do
+      base_attributes = [:provider_url,
+                         :provider_name,
+                         :cache_age,
+                         :version]
+
+      assert_equal OembedProvider.base_attributes, base_attributes
+    end
+
+    should "have an array of optional attribute keys" do
+      optional_attributes = [:title,
+                             :author_name,
+                             :author_url,
+                             :thumbnail_url,
+                             :thumbnail_width,
+                             :thumbnail_height]
+
+      assert_equal OembedProvider.optional_attributes, optional_attributes
+    end
+
+    should "have a hash of keyed by oembed type with required attribute keys" do
+      required_attributes = {
+        :photo => [:url, :width, :height], 
+        :video => [:html, :width, :height],
+        :link => [],
+        :rich => [:html, :width, :height] }
+      
+      assert_equal OembedProvider.required_attributes, required_attributes
+    end
+
+    should "have a hash of keyed by oembed type photo with required attribute keys" do
+      requires = [:url, :width, :height]
+      assert_equal OembedProvider.required_attributes[:photo], requires
+    end
+
+    should "have a hash of keyed by oembed type video with required attribute keys" do
+      requires = [:html, :width, :height]
+      assert_equal OembedProvider.required_attributes[:video], requires
+    end
+
+    should "have a hash of keyed by oembed type link with required attribute keys" do
+      requires = []
+      assert_equal OembedProvider.required_attributes[:link], requires
+    end
+
+    should "have a hash of keyed by oembed type rich with required attribute keys" do
+      requires = [:html, :width, :height]
+      assert_equal OembedProvider.required_attributes[:rich], requires
+    end
+
+    context "have an cattr accessor for mapping controllers that aren't tableized version of models, to their corresponding models" do
+      should "be able to set and read controller_model_maps" do
+        assert OembedProvider.respond_to?(:controller_model_maps)
+        assert_equal Hash.new, OembedProvider.controller_model_maps
+        test_hash = { :images => 'StillImage' }
+        OembedProvider.controller_model_maps = test_hash
+        assert_equal test_hash, OembedProvider.controller_model_maps
+        test_hash[:audio] = 'AudioRecording'
+        OembedProvider.controller_model_maps[:audio] = 'AudioRecording'
+        assert_equal test_hash, OembedProvider.controller_model_maps
+      end
+    end
+
+    should "be able to answer find_provided_from with provided object based on passed in url" do
+      @photo = Factory.create(:photo)
+      url = "http://example.com/photos/#{@photo.id}"
+      assert_equal @photo, OembedProvider.find_provided_from(url)
+    end
+  end
+end

data/test/full_2_3_5_app_with_tests/vendor/plugins/routing-filter/init.rb

@@ -0,0 +1 @@
+require 'routing_filter'

data/test/full_2_3_5_app_with_tests/vendor/plugins/routing-filter/lib/routing_filter/base.rb

@@ -0,0 +1,31 @@
+module RoutingFilter
+  class Base
+    class_inheritable_accessor :active
+    self.active = true
+
+    attr_accessor :chain, :options
+
+    def initialize(options = {})
+      @options = options
+      options.each { |name, value| instance_variable_set :"@#{name}", value }
+    end
+
+    def run(method, *args, &block)
+      _next = successor ? lambda { successor.run(method, *args, &block) } : block
+      active ? send(method, *args, &_next) : _next.call(*args)
+    end
+
+    def run_reverse(method, *args, &block)
+      _prev = predecessor ? lambda { predecessor.run(method, *args, &block) } : block
+      active ? send(method, *args, &_prev) : _prev.call(*args)
+    end
+
+    def predecessor
+      @chain.predecessor(self)
+    end
+
+    def successor
+      @chain.successor(self)
+    end
+  end
+end

data/test/full_2_3_5_app_with_tests/vendor/plugins/routing-filter/lib/routing_filter/force_extension.rb

@@ -0,0 +1,57 @@
+require 'routing_filter/base'
+
+module RoutingFilter
+  class ForceExtension < Base
+    attr_reader :extension, :exclude
+
+    def initialize(*args)
+      super
+      @extension ||= 'html'
+      @exclude = %r(^(http.?://[^/]+)?\/?$) if @exclude.nil?
+    end
+
+    def around_recognize(path, env, &block)
+      extract_extension!(path) unless excluded?(path)
+      yield(path, env)
+    end
+
+    def around_generate(*args, &block)
+      returning yield do |result|
+        url = result.is_a?(Array) ? result.first : result
+        append_extension!(url) if append_extension?(url)
+      end
+    end
+
+    protected
+
+      def extract_extension!(path)
+        path.sub! /\.#{extension}$/, ''
+        $1
+      end
+      
+      def append_extension?(url)
+        !(url.blank? || excluded?(url) || mime_extension?(url))
+      end
+      
+      def excluded?(url)
+        case exclude
+        when Regexp
+          url =~ exclude
+        when Proc
+          exclude.call(url)
+        end
+      end
+      
+      def mime_extension?(url)
+        url =~ /\.#{Mime::EXTENSION_LOOKUP.keys.join('|')}(\?|$)/
+      end
+      
+      def append_extension!(url)
+        url.replace url.sub(/(\?|$)/, ".#{extension}\\1")
+      end
+
+      def append_page!(url, page)
+        url.replace "#{url}/pages/#{page}"
+      end
+  end
+end

data/test/full_2_3_5_app_with_tests/vendor/plugins/routing-filter/lib/routing_filter/locale.rb

@@ -0,0 +1,70 @@
+require 'i18n'
+require 'routing_filter/base'
+
+module RoutingFilter
+  class Locale < Base
+    @@include_default_locale = true
+    cattr_writer :include_default_locale
+
+    class << self
+      def include_default_locale?
+        @@include_default_locale
+      end
+
+      def locales
+        @@locales ||= I18n.available_locales.map(&:to_sym)
+      end
+
+      def locales=(locales)
+        @@locales = locales.map(&:to_sym)
+      end
+
+      def locales_pattern
+        @@locales_pattern ||= %r(^/(#{self.locales.map { |l| Regexp.escape(l.to_s) }.join('|')})(?=/|$))
+      end
+    end
+
+    def around_recognize(path, env, &block)
+      locale = extract_locale!(path)                 # remove the locale from the beginning of the path
+      returning yield do |params|                    # invoke the given block (calls more filters and finally routing)
+        params[:locale] = locale if locale           # set recognized locale to the resulting params hash
+      end
+    end
+
+    def around_generate(*args, &block)
+      locale = args.extract_options!.delete(:locale) # extract the passed :locale option
+      locale = I18n.locale if locale.nil?            # default to I18n.locale when locale is nil (could also be false)
+      locale = nil unless valid_locale?(locale)      # reset to no locale when locale is not valid
+
+      returning yield do |result|
+        if locale && prepend_locale?(locale)
+          url = result.is_a?(Array) ? result.first : result
+          prepend_locale!(url, locale)
+        end
+      end
+    end
+
+    protected
+
+      def extract_locale!(path)
+        path.sub! self.class.locales_pattern, ''
+        $1
+      end
+
+      def prepend_locale?(locale)
+        self.class.include_default_locale? || !default_locale?(locale)
+      end
+
+      def valid_locale?(locale)
+        locale && self.class.locales.include?(locale.to_sym)
+      end
+
+      def default_locale?(locale)
+        locale && locale.to_sym == I18n.default_locale.to_sym
+      end
+
+      def prepend_locale!(url, locale)
+        url.sub!(%r(^(http.?://[^/]*)?(.*))) { "#{$1}/#{locale}#{$2}" }
+      end
+  end
+end

data/test/full_2_3_5_app_with_tests/vendor/plugins/routing-filter/lib/routing_filter/pagination.rb

@@ -0,0 +1,33 @@
+require 'routing_filter/base'
+
+module RoutingFilter
+  class Pagination < Base
+    def around_recognize(path, env, &block)
+      page = extract_page!(path)
+      returning yield(path, env) do |params|
+        params[:page] = page.to_i if page
+      end
+    end
+
+    def around_generate(*args, &block)
+      page = args.extract_options!.delete(:page)
+      returning yield do |result|
+        if page && page != 1
+          url = result.is_a?(Array) ? result.first : result
+          append_page!(url, page)
+        end
+      end
+    end
+
+    protected
+
+      def extract_page!(path)
+        path.sub! %r(/pages/([\d]+)/?$), ''
+        $1
+      end
+
+      def append_page!(url, page)
+        url.sub!(/($|\?)/) { "/pages/#{page}#{$1}" }
+      end
+  end
+end

data/test/full_2_3_5_app_with_tests/vendor/plugins/routing-filter/lib/routing_filter/uuid_token.rb

@@ -0,0 +1,78 @@
+# This is a routing filter that extracts UUIDs from urls and exposes them via
+# params[:uuid_token]
+#
+# URL scheme: http://example.com/d00fbbd1-82b6-4c1a-a57d-098d529d6854/your_route
+#
+# To enable this filter add map.filter :uuid_token to your routes.rb
+# 
+# To make your restful path helpers use this :uuid_token use:
+# new_post_path(:uuid_token => params[:uuid_token])
+#
+# If don't want to pass the :uuid_token manually you can add a custom module
+# like this to your RAILS_ROOT/lib directory:
+#
+#   module AccessToken
+#     
+#     class << self
+#       def current=(token)
+#         Thread.current[:uuid_token] = token
+#       end
+#       
+#       def current
+#         Thread.current[:uuid_token] ||= ""
+#       end
+#     end
+#     
+#   end
+#
+# Now in your application_controller you can set a before_filter which sets that
+# token for every request:
+# 
+#   before_filter :set_token
+#   
+#   protected
+#   
+#     def set_token
+#       AccessToken.current = params[:uuid_token] if params[:uuid_token]
+#     end
+#
+# As you can see below in the around_generate method, if you don't provide a 
+# :uuid_token argument for your restful path helpers it will try to get the
+# current :uuid_token from the AccessToken module.
+
+require 'routing_filter/base'
+
+module RoutingFilter
+  class UuidToken < Base
+
+    def around_recognize(path, env, &block)
+      token = extract_token!(path)                              # remove the token from the beginning of the path
+      returning yield do |params|                               # invoke the given block (calls more filters and finally routing)
+        params[:uuid_token] = token if token                    # set recognized token to the resulting params hash
+      end
+    end
+
+    def around_generate(*args, &block)
+      token = args.extract_options!.delete(:uuid_token)         # extract the passed :token option
+      token = AccessToken.current if AccessToken && token.nil?  # default to AccessToken.current when token is nil (could also be false)
+
+      returning yield do |result|
+        if token
+          url = result.is_a?(Array) ? result.first : result
+          prepend_token!(url, token)
+        end
+      end
+    end
+
+    protected
+
+      def extract_token!(path)
+        path.sub! /([a-z\d]{8}\-[a-z\d]{4}\-[a-z\d]{4}\-[a-z\d]{4}\-[a-z\d]{12})\//, ''
+        $1
+      end
+
+      def prepend_token!(url, token)
+        url.sub!(%r(^(http.?://[^/]*)?(.*))) { "#{$1}/#{token}#{$2}" }
+      end
+  end
+end

data/test/full_2_3_5_app_with_tests/vendor/plugins/routing-filter/lib/routing_filter.rb

@@ -0,0 +1,94 @@
+module RoutingFilter
+  mattr_accessor :active
+  @@active = true
+
+  class Chain < Array
+    def << (filter)
+      filter.chain = self
+      super
+    end
+
+    def run(method, *args, &final)
+      RoutingFilter.active && !first.nil? ? first.run(method, *args, &final) : final.call
+    end
+
+    def run_reverse(method, *args, &final)
+      RoutingFilter.active && !last.nil? ? last.run_reverse(method, *args, &final) : final.call
+    end
+
+    def predecessor(filter)
+      ix = index(filter)
+      ix > 0 ? self[ix - 1] : nil
+    end
+
+    def successor(filter)
+      ix = index(filter)
+      ix < length - 1 ? self[ix + 1] : nil
+    end
+  end
+end
+
+# allows to install a filter to the route set by calling: map.filter 'locale'
+ActionController::Routing::RouteSet::Mapper.class_eval do
+  def filter(name, options = {})
+    require options.delete(:file) || "routing_filter/#{name}"
+    klass = RoutingFilter.const_get(name.to_s.camelize)
+    @set.filters << klass.new(options)
+  end
+end
+
+# same here for the optimized url generation in named routes
+ActionController::Routing::RouteSet::NamedRouteCollection.class_eval do
+  # gosh. monkey engineering optimization code
+  def generate_optimisation_block_with_filtering(*args)
+    code = generate_optimisation_block_without_filtering(*args)
+    if match = code.match(%r(^return (.*) if (.*)))
+      # returned string must not contain newlines, or we'll spill out of inline code comments in
+      # ActionController::Routing::RouteSet::NamedRouteCollection#define_url_helper
+      "returning(#{match[1]}) { |result|" +
+      "  ActionController::Routing::Routes.filters.run_reverse(:around_generate, *args, &lambda{ result }) " +
+      "} if #{match[2]}"
+    end
+  end
+  alias_method_chain :generate_optimisation_block, :filtering
+end
+
+ActionController::Routing::RouteSet.class_eval do
+  def clear_with_filtering!
+    @filters.clear if @filters
+    clear_without_filtering!
+  end
+  alias_method_chain :clear!, :filtering
+
+  attr_writer :filters
+
+  def filters
+    @filters ||= RoutingFilter::Chain.new
+  end
+
+  def recognize_path_with_filtering(path, env = {})
+    path = ::URI.unescape(path.dup) # string is frozen due to memoize
+    filters.run(:around_recognize, path, env, &lambda{ recognize_path_without_filtering(path, env) })
+  end
+  alias_method_chain :recognize_path, :filtering
+
+  def generate_with_filtering(*args)
+    filters.run_reverse(:around_generate, args.first, &lambda{ generate_without_filtering(*args) })
+  end
+  alias_method_chain :generate, :filtering
+
+  # add some useful information to the request environment
+  # right, this is from jamis buck's excellent article about routes internals
+  # http://weblog.jamisbuck.org/2006/10/26/monkey-patching-rails-extending-routes-2
+  # TODO move this ... where?
+  alias_method :extract_request_environment_without_host, :extract_request_environment unless method_defined? :extract_request_environment_without_host
+  def extract_request_environment(request)
+    returning extract_request_environment_without_host(request) do |env|
+      env.merge! :host => request.host,
+                 :port => request.port,
+                 :host_with_port => request.host_with_port,
+                 :domain => request.domain,
+                 :subdomain => request.subdomains.first
+    end
+  end
+end

data/test/full_2_3_5_app_with_tests/vendor/plugins/routing-filter/spec/force_extension_spec.rb

@@ -0,0 +1,65 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe 'RoutingFilter::ForceExtension' do
+  include RoutingFilterHelpers
+
+  before :each do
+    setup_environment(:force_extension)
+  end
+
+  describe 'url recognition' do
+    it 'recognizes the path /sections/1.html' do
+      should_recognize_path '/sections/1.html', @section_params
+    end
+
+    it 'recognizes the path /sections/1/articles/1.html' do
+      should_recognize_path '/sections/1/articles/1.html', @article_params
+    end
+
+    it 'does not recognize the path /sections/1/articles/1.foobar' do
+      lambda { @set.recognize_path('/sections/1/articles/1.foobar', {}) }.should raise_error(ActionController::RoutingError)
+    end
+  end
+
+  describe 'url generation' do
+    it 'appends the .html extension to generated paths (section_path)' do
+      section_path(:id => 1).should == '/sections/1.html'
+    end
+
+    it 'appends the .html extension to generated paths (section_article_path)' do
+      section_article_path(:section_id => 1, :id => 1).should == '/sections/1/articles/1.html'
+    end
+
+    it 'appends the .html extension to generated paths (admin_articles_path)' do
+      admin_articles_path.should == '/admin/articles.html'
+    end
+
+    it 'does not replace or add on an existing extension' do
+      section_path(:id => 1, :format => 'xml').should == '/sections/1.xml'
+    end
+
+    it 'works with url query params' do
+      section_path(:id => 1, :foo => 'bar').should == '/sections/1.html?foo=bar'
+    end
+    
+    it 'excludes / by default' do
+      home_path.should == '/'
+    end
+    
+    it 'excludes http://test.host/ by default' do
+      home_url.should == 'http://test.host/'
+    end
+    
+    it 'excludes with custom regexp' do
+      setup_environment { |map| map.filter :force_extension, :exclude => %r(^/(admin|$)) }
+      home_path.should == '/'
+      admin_articles_path.should == '/admin/articles'
+      section_path(:id => 1).should == '/sections/1.html'
+    end
+
+    it 'does not exclude / when :exclude => false was passed' do
+      setup_environment { |map| map.filter :force_extension, :exclude => false }
+      home_path.should == '/.html'
+    end
+  end
+end