refinerycms 0.9.7.15 → 0.9.8

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

@@ -1,141 +0,0 @@
-class Refinery::I18n
-  class << self
-
-    attr_accessor :enabled, :current_locale, :locales, :default_locale, :default_frontend_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, true, {
-          :callback_proc_as_string => %q{::Refinery::I18n.setup!},
-          :scoping => 'refinery'
-        })
-      end
-    end
-
-    def current_locale
-      unless enabled?
-        ::Refinery::I18n.current_locale = ::Refinery::I18n.default_locale
-      else
-        @current_locale ||= RefinerySetting.find_or_set(:i18n_translation_current_locale,
-          ::Refinery::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 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 default_frontend_locale
-      @default_frontend_locale ||= RefinerySetting.find_or_set(:i18n_translation_default_frontend_locale,
-      :en, {
-        :scoping => 'refinery',
-        :callback_proc_as_string => %q{::Refinery::I18n.setup!}
-      })
-    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
-      @default_locale = nil
-      @default_frontend_locale = nil
-      @current_locale = nil
-
-      self.load_base_locales!
-      self.load_refinery_locales!
-      self.load_app_locales!
-      self.set_default_locale!
-    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 = ::Refinery::I18n.default_locale
-    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?
-  # override translate, but only in production
-  ::I18n.module_eval do
-    class << self
-      alias_method :original_rails_i18n_translate, :translate
-      def translate(key, options = {})
-        begin
-          original_rails_i18n_translate(key, options.merge!({:raise => true}))
-        rescue ::I18n::MissingTranslationData => e
-          if self.config.locale != ::Refinery::I18n.default_locale
-            self.translate(key, options.update(:locale => ::Refinery::I18n.default_locale))
-          else
-            raise e
-          end
-        end
-      end
-    end
-  end if Rails.env.production?
-
-  ::Refinery::I18n.setup!
-end

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

@@ -1,48 +0,0 @@
-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{^/(sessions?|admin|refinery|wymiframe)}
-            path.sub! %r(^/(([a-zA-Z\-_])*)(?=/|$)) do
-              locale = $1
-              ::I18n.locale = locale
-              ''
-            end
-          end
-        else
-          ::I18n.locale = ::Refinery::I18n.default_frontend_locale
-        end
-
-        yield.tap do |params|
-          unless path =~ %r{^/(admin|refinery|wymiframe)} or ::I18n.locale == ::Refinery::I18n.default_frontend_locale
-            params[:locale] = (locale.presence || ::Refinery::I18n.current_frontend_locale)
-          end
-        end
-      else
-        yield.tap do |result|
-          result
-        end
-      end
-    end
-
-    def around_generate(*args, &block)
-      if ::Refinery::I18n.enabled?
-        locale = args.extract_options!.delete(:locale) || ::I18n.locale
-        yield.tap do |result|
-          if (locale != ::Refinery::I18n.default_frontend_locale and result !~ %r{^/(refinery|wymiframe)})
-            result.sub!(%r(^(http.?://[^/]*)?(.*))){ "#{$1}/#{locale}#{$2}" }
-          end
-          result
-        end
-      else
-        yield.tap do |result|
-          result
-        end
-      end
-    end
-
-  end
-end

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

@@ -1,20 +0,0 @@
-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

@@ -1,123 +0,0 @@
-## 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):
-          yield.tap 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):
-          yield.tap 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

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

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

@@ -1,96 +0,0 @@
-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
-      "#{match[1]}.tap { |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)
-    extract_request_environment_without_host(request).tap 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

@@ -1,31 +0,0 @@
-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