refinerycms 0.9.6.34 → 0.9.7

data/vendor/plugins/i18n/lib/i18n.rb

@@ -0,0 +1,115 @@
+class Refinery::I18n
+  class << self
+
+    attr_accessor :enabled, :current_locale, :locales, :default_locale
+
+    def enabled?
+      # cache this lookup as it gets very expensive.
+      if defined?(@enabled) && !@enabled.nil?
+        @enabled
+      else
+        @enabled = RefinerySetting.find_or_set(:i18n_translation_enabled, false, {
+          :callback_proc_as_string => %q{::Refinery::I18n.setup!},
+          :scoping => 'refinery'
+        })
+      end
+    end
+
+    def current_locale
+      unless enabled?
+        ::Refinery::I18n.current_locale = :en
+      else
+        @current_locale ||= RefinerySetting.find_or_set(:i18n_translation_current_locale, I18n.default_locale, {
+          :scoping => 'refinery',
+          :callback_proc_as_string => %q{::Refinery::I18n.setup!}
+        })
+      end
+    end
+
+    def current_locale=(locale)
+      @current_locale = locale.to_sym
+      RefinerySetting[:i18n_translation_current_locale] = {
+        :value => locale.to_sym,
+        :scoping => 'refinery',
+        :callback_proc_as_string => %q{::Refinery::I18n.setup!}
+      }
+      ::I18n.locale = locale.to_sym
+    end
+
+    def locales
+      @locales ||= RefinerySetting.find_or_set(:i18n_translation_locales, {
+          :en => 'English',
+          :fr => 'Fran&ccedil;ais',
+          :nl => 'Nederlands',
+          :'pt-BR' => 'Portugu&ecirc;s',
+          :da => 'Dansk',
+          :nb => 'Norsk Bokm&aring;l',
+          :sl => 'Slovenian',
+          :es => 'Espa&ntilde;ol',
+          :it => 'Italiano',
+          :de => 'Deutsch'
+        },
+        {
+          :scoping => 'refinery',
+          :callback_proc_as_string => %q{::Refinery::I18n.setup!}
+        }
+      )
+    end
+
+    def has_locale?(locale)
+      locales.has_key?(locale.try(:to_sym))
+    end
+
+    def setup!
+      # Re-initialize variables.
+      @enabled = nil
+      @locales = nil
+
+      self.load_base_locales!
+      self.load_refinery_locales!
+      self.load_app_locales!
+      self.set_default_locale!
+
+      # Mislav trick to fallback to default for missing translations
+      I18n.exception_handler = lambda do |e, locale, key, options|
+        if I18n::MissingTranslationData === e and locale != I18n.default_locale
+          I18n.translate(key, (options || {}).update(:locale => I18n.default_locale, :raise => true))
+        else
+          raise e
+        end
+      end if Rails.env.production?
+    end
+
+    def load_base_locales!
+      load_locales Pathname.new(__FILE__).parent.join "..", "config", "locales", "*.yml"
+    end
+
+    def load_refinery_locales!
+      load_locales Refinery.root.join "vendor", "plugins", "*", "config", "locales", "*.yml"
+    end
+
+    def load_app_locales!
+      load_locales Rails.root.join "config", "locales", "*.yml"
+    end
+
+    def set_default_locale!
+      I18n.default_locale = @default_locale ||= RefinerySetting.find_or_set(:i18n_translation_default_locale, :en, {
+        :callback_proc_as_string => %q{::Refinery::I18n.setup!},
+        :scoping => 'refinery'
+      })
+    end
+
+    def load_locales(locale_files)
+      locale_files = locale_files.to_s if locale_files.is_a? Pathname
+      locale_files = Dir[locale_files] if locale_files.is_a? String
+      locale_files.each do |locale_file|
+        I18n.load_path.unshift locale_file
+      end
+    end
+
+  end
+end
+
+if RefinerySetting.table_exists?
+  Refinery::I18n.setup!
+end

data/vendor/plugins/i18n/lib/i18n_filter.rb

@@ -0,0 +1,48 @@
+module RoutingFilter
+  class Locale < Base
+
+    def around_recognize(path, env, &block)
+      if ::Refinery::I18n.enabled?
+        locale = nil
+        if path =~ %r{^\/#{::Refinery::I18n.locales.keys.join('|')}\/}
+          if path !~ %r{^/(admin|refinery|wymiframe)}
+            path.sub! %r(^/(([a-zA-Z\-_])*)(?=/|$)) do
+              locale = $1
+              ::I18n.locale = locale
+              ''
+            end
+          end
+        else
+          ::I18n.locale = ::Refinery::I18n.current_locale
+        end
+
+        returning yield do |params|
+          unless path =~ %r{^/(admin|refinery|wymiframe)} or ::I18n.locale == ::Refinery::I18n.default_locale
+            params[:locale] = (locale.presence || ::Refinery::I18n.current_locale)
+          end
+        end
+      else
+        returning yield do |result|
+          result
+        end
+      end
+    end
+
+    def around_generate(*args, &block)
+      if ::Refinery::I18n.enabled?
+        locale = args.extract_options!.delete(:locale) || ::I18n.locale
+        returning yield do |result|
+          if (locale != ::Refinery::I18n.default_locale and result !~ %r{^/(refinery|wymiframe)})
+            result.sub!(%r(^(http.?://[^/]*)?(.*))){ "#{$1}/#{locale}#{$2}" }
+          end
+          result
+        end
+      else
+        returning yield do |result|
+          result
+        end
+      end
+    end
+
+  end
+end

data/vendor/plugins/i18n/lib/routing_filter/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Sven Fuchs
+
+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/vendor/plugins/i18n/lib/routing_filter/README.markdown

@@ -0,0 +1,123 @@
+## Routing Filter
+
+This plugin is a wild hack that wraps around the complex beast that the Rails
+routing system is to allow for unseen flexibility and power in Rails URL
+recognition and generation.
+
+As powerful and awesome the Rails' routes are, when you need to design your
+URLs in a manner that only slightly leaves the paved cowpaths of Rails
+conventions, you're usually unable to use all the goodness of helpers and
+convenience that Rails ships with.
+
+## Usage
+
+This plugin comes with a locale routing filter that demonstrates the
+implementation of a custom filter. 
+
+The following would be a sceleton of an empty filter:
+
+    module RoutingFilter
+      class Awesomeness < Base
+        def around_recognize(route, path, env)
+          # Alter the path here before it gets recognized. 
+          # Make sure to yield (calls the next around filter if present and 
+          # eventually `recognize_path` on the routeset):
+          returning yield do |params|
+            # You can additionally modify the params here before they get passed
+            # to the controller.
+          end
+        end
+    
+        def around_generate(controller, *args, &block)
+          # Alter arguments here before they are passed to `url_for`. 
+          # Make sure to yield (calls the next around filter if present and 
+          # eventually `url_for` on the controller):
+          returning yield do |result|
+            # You can change the generated url_or_path here. Make sure to use
+            # one of the "in-place" modifying String methods though (like sub! 
+            # and friends).
+          end
+        end
+      end
+    end
+
+You then have to specify the filter explicitely in your routes.rb:
+
+    ActionController::Routing::Routes.draw do |map|
+      map.filter 'awesomeness'
+    end
+
+(I am not sure if it makes sense to provide more technical information than
+this because the usage of this plugin definitely requires some advanced
+knowledge about Rails internals and especially its routing system. So, I
+figure, anyone who could use this should also be able to read the code and
+figure out what it's doing much better then from any lengthy documentation.
+
+If I'm mistaken on this please drop me an email with your suggestions.)
+
+
+## Rationale: Two example usecases
+
+An early usecase from which this originated was the need to define a locale
+at the beginning of an URL in a way so that 
+
+* the locale can be omitted when it is the default locale
+* all the url\_helpers that are generated by named routes continue to work in 
+a concise manner (i.e. without specifying all parameters again and again)
+* ideally also plays nicely with default route helpers in tests/specs
+
+You can read about this struggle and two possible, yet unsatisfying solutions
+[here](http://www.artweb-design.de/2007/5/13/concise-localized-rails-url-helpers-solved-twice).
+The conclusion so far is that Rails itself does not provide the tools to solve
+this problem in a clean and dry way.
+
+Another usecase that eventually spawned the manifestation of this plugin was 
+the need to map an arbitrary count of path segments to a certain model 
+instance. In an application that I've been working on recently I needed to 
+map URL paths to a nested tree of models like so:
+
+    root
+    + docs
+      + api
+      + wiki
+  
+E.g. the docs section should map to the path `/docs`, the api section to 
+the path `/docs/api` and so on. Furthermore, after these paths there need to be 
+more things to be specified. E.g. the wiki needs to define a whole Rails 
+resource with URLs like `/docs/wiki/pages/1/edit`.
+
+The only way to solve this problem with Rails' routing toolkit is to map
+a big, bold `/*everything` catch-all ("globbing") route and process the whole 
+path in a custom dispatcher.
+
+This, of course, is a really unsatisfying solution because one has to
+reimplement everything that Rails routes are here to help with: regarding both 
+URL recognition (like parameter mappings, resources, ...) and generation 
+(url\_helpers).
+
+## Solution
+
+This plugin offers a solution that takes exactly the opposite route. 
+
+Instead of trying to change things *between* the URL recognition and
+generation stages to achieve the desired result it *wraps around* the whole
+routing system and allows to pre- and post-filter both what goes into it 
+(URL recognition) and what comes out of it (URL generation).
+
+This way we can leave *everything* else completely untouched. 
+
+* We can tinker with the URLs that we receive from the server and feed URLs to 
+Rails that perfectly match the best breed of Rails' conventions. 
+* Inside of the application we can use all the nice helper goodness and 
+conveniences that rely on these conventions being followed. 
+* Finally we can accept URLs that have been generated by the url\_helpers and,
+again, mutate them in the way that matches our requirements.
+
+So, even though the plugin itself is a blatant monkey-patch to one of the
+most complex area of Rails internals, this solution seems to be effectively
+less intrusive and pricey than others are.
+
+## Etc
+
+Authors: [Sven Fuchs](http://www.artweb-design.de) <svenfuchs at artweb-design dot de>  
+License: MIT 

data/vendor/plugins/i18n/lib/routing_filter/VERSION

@@ -0,0 +1 @@
+0.0.2

data/vendor/plugins/i18n/lib/routing_filter/routing_filter.rb

@@ -0,0 +1,96 @@
+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 = {})
+    unless Kernel.const_defined?(name.to_s.camelize) or !options.has_key?(:file)
+      require options.delete(:file) || File.expand_path("../routing_filter/#{name}", __FILE__)
+    end
+    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/vendor/plugins/i18n/lib/routing_filter/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/vendor/plugins/i18n/lib/routing_filter/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