backbone-forms-on-rails 0.10.0 → 0.10.0.1

data/vendor/bundle/gems/i18n-0.6.1/ci/Gemfile.no-rails

@@ -1,5 +0,0 @@
-source :rubygems
-
-gem 'mocha'
-gem 'test_declarative'
-

data/vendor/bundle/gems/i18n-0.6.1/ci/Gemfile.no-rails.lock

@@ -1,14 +0,0 @@
-GEM
-  remote: http://rubygems.org/
-  specs:
-    mocha (0.9.9)
-      rake
-    rake (0.8.7)
-    test_declarative (0.0.4)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  mocha
-  test_declarative

data/vendor/bundle/gems/i18n-0.6.1/ci/Gemfile.rails-2.3.x

@@ -1,9 +0,0 @@
-source :rubygems
-
-gem 'activesupport', '~> 2.3'
-gem 'sqlite3-ruby'
-gem 'mocha'
-gem 'test_declarative'
-gem 'rufus-tokyo'
-gem 'ffi'
-

data/vendor/bundle/gems/i18n-0.6.1/ci/Gemfile.rails-2.3.x.lock

@@ -1,23 +0,0 @@
-GEM
-  remote: http://rubygems.org/
-  specs:
-    activesupport (2.3.10)
-    ffi (0.6.3)
-      rake (>= 0.8.7)
-    mocha (0.9.9)
-      rake
-    rake (0.8.7)
-    rufus-tokyo (1.0.7)
-    sqlite3-ruby (1.3.2)
-    test_declarative (0.0.4)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  activesupport (~> 2.3)
-  ffi
-  mocha
-  rufus-tokyo
-  sqlite3-ruby
-  test_declarative

data/vendor/bundle/gems/i18n-0.6.1/ci/Gemfile.rails-3.x

@@ -1,9 +0,0 @@
-source :rubygems
-
-gem 'activesupport', '~> 3.0.0'
-gem 'sqlite3-ruby'
-gem 'mocha'
-gem 'test_declarative'
-gem 'rufus-tokyo'
-gem 'ffi'
-

data/vendor/bundle/gems/i18n-0.6.1/ci/Gemfile.rails-3.x.lock

@@ -1,23 +0,0 @@
-GEM
-  remote: http://rubygems.org/
-  specs:
-    activesupport (3.0.3)
-    ffi (0.6.3)
-      rake (>= 0.8.7)
-    mocha (0.9.9)
-      rake
-    rake (0.8.7)
-    rufus-tokyo (1.0.7)
-    sqlite3-ruby (1.3.2)
-    test_declarative (0.0.4)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  activesupport (~> 3.0.0)
-  ffi
-  mocha
-  rufus-tokyo
-  sqlite3-ruby
-  test_declarative

data/vendor/bundle/gems/i18n-0.6.1/lib/i18n.rb

@@ -1,332 +0,0 @@
-require 'i18n/version'
-require 'i18n/exceptions'
-require 'i18n/interpolate/ruby'
-
-module I18n
-  autoload :Backend, 'i18n/backend'
-  autoload :Config,  'i18n/config'
-  autoload :Gettext, 'i18n/gettext'
-  autoload :Locale,  'i18n/locale'
-  autoload :Tests,   'i18n/tests'
-
-  RESERVED_KEYS = [:scope, :default, :separator, :resolve, :object, :fallback, :format, :cascade, :throw, :raise, :rescue_format]
-  RESERVED_KEYS_PATTERN = /%\{(#{RESERVED_KEYS.join("|")})\}/
-
-  extend Module.new {
-    # Gets I18n configuration object.
-    def config
-      Thread.current[:i18n_config] ||= I18n::Config.new
-    end
-
-    # Sets I18n configuration object.
-    def config=(value)
-      Thread.current[:i18n_config] = value
-    end
-
-    # Write methods which delegates to the configuration object
-    %w(locale backend default_locale available_locales default_separator
-      exception_handler load_path).each do |method|
-      module_eval <<-DELEGATORS, __FILE__, __LINE__ + 1
-        def #{method}
-          config.#{method}
-        end
-
-        def #{method}=(value)
-          config.#{method} = (value)
-        end
-      DELEGATORS
-    end
-
-    # Tells the backend to reload translations. Used in situations like the
-    # Rails development environment. Backends can implement whatever strategy
-    # is useful.
-    def reload!
-      config.backend.reload!
-    end
-
-    # Translates, pluralizes and interpolates a given key using a given locale,
-    # scope, and default, as well as interpolation values.
-    #
-    # *LOOKUP*
-    #
-    # Translation data is organized as a nested hash using the upper-level keys
-    # as namespaces. <em>E.g.</em>, ActionView ships with the translation:
-    # <tt>:date => {:formats => {:short => "%b %d"}}</tt>.
-    #
-    # Translations can be looked up at any level of this hash using the key argument
-    # and the scope option. <em>E.g.</em>, in this example <tt>I18n.t :date</tt>
-    # returns the whole translations hash <tt>{:formats => {:short => "%b %d"}}</tt>.
-    #
-    # Key can be either a single key or a dot-separated key (both Strings and Symbols
-    # work). <em>E.g.</em>, the short format can be looked up using both:
-    #   I18n.t 'date.formats.short'
-    #   I18n.t :'date.formats.short'
-    #
-    # Scope can be either a single key, a dot-separated key or an array of keys
-    # or dot-separated keys. Keys and scopes can be combined freely. So these
-    # examples will all look up the same short date format:
-    #   I18n.t 'date.formats.short'
-    #   I18n.t 'formats.short', :scope => 'date'
-    #   I18n.t 'short', :scope => 'date.formats'
-    #   I18n.t 'short', :scope => %w(date formats)
-    #
-    # *INTERPOLATION*
-    #
-    # Translations can contain interpolation variables which will be replaced by
-    # values passed to #translate as part of the options hash, with the keys matching
-    # the interpolation variable names.
-    #
-    # <em>E.g.</em>, with a translation <tt>:foo => "foo %{bar}"</tt> the option
-    # value for the key +bar+ will be interpolated into the translation:
-    #   I18n.t :foo, :bar => 'baz' # => 'foo baz'
-    #
-    # *PLURALIZATION*
-    #
-    # Translation data can contain pluralized translations. Pluralized translations
-    # are arrays of singluar/plural versions of translations like <tt>['Foo', 'Foos']</tt>.
-    #
-    # Note that <tt>I18n::Backend::Simple</tt> only supports an algorithm for English
-    # pluralization rules. Other algorithms can be supported by custom backends.
-    #
-    # This returns the singular version of a pluralized translation:
-    #   I18n.t :foo, :count => 1 # => 'Foo'
-    #
-    # These both return the plural version of a pluralized translation:
-    #   I18n.t :foo, :count => 0 # => 'Foos'
-    #   I18n.t :foo, :count => 2 # => 'Foos'
-    #
-    # The <tt>:count</tt> option can be used both for pluralization and interpolation.
-    # <em>E.g.</em>, with the translation
-    # <tt>:foo => ['%{count} foo', '%{count} foos']</tt>, count will
-    # be interpolated to the pluralized translation:
-    #   I18n.t :foo, :count => 1 # => '1 foo'
-    #
-    # *DEFAULTS*
-    #
-    # This returns the translation for <tt>:foo</tt> or <tt>default</tt> if no translation was found:
-    #   I18n.t :foo, :default => 'default'
-    #
-    # This returns the translation for <tt>:foo</tt> or the translation for <tt>:bar</tt> if no
-    # translation for <tt>:foo</tt> was found:
-    #   I18n.t :foo, :default => :bar
-    #
-    # Returns the translation for <tt>:foo</tt> or the translation for <tt>:bar</tt>
-    # or <tt>default</tt> if no translations for <tt>:foo</tt> and <tt>:bar</tt> were found.
-    #   I18n.t :foo, :default => [:bar, 'default']
-    #
-    # *BULK LOOKUP*
-    #
-    # This returns an array with the translations for <tt>:foo</tt> and <tt>:bar</tt>.
-    #   I18n.t [:foo, :bar]
-    #
-    # Can be used with dot-separated nested keys:
-    #   I18n.t [:'baz.foo', :'baz.bar']
-    #
-    # Which is the same as using a scope option:
-    #   I18n.t [:foo, :bar], :scope => :baz
-    #
-    # *LAMBDAS*
-    #
-    # Both translations and defaults can be given as Ruby lambdas. Lambdas will be
-    # called and passed the key and options.
-    #
-    # E.g. assuming the key <tt>:salutation</tt> resolves to:
-    #   lambda { |key, options| options[:gender] == 'm' ? "Mr. %{options[:name]}" : "Mrs. %{options[:name]}" }
-    #
-    # Then <tt>I18n.t(:salutation, :gender => 'w', :name => 'Smith') will result in "Mrs. Smith".
-    #
-    # It is recommended to use/implement lambdas in an "idempotent" way. E.g. when
-    # a cache layer is put in front of I18n.translate it will generate a cache key
-    # from the argument values passed to #translate. Therefor your lambdas should
-    # always return the same translations/values per unique combination of argument
-    # values.
-    def translate(*args)
-      options  = args.last.is_a?(Hash) ? args.pop : {}
-      key      = args.shift
-      backend  = config.backend
-      locale   = options.delete(:locale) || config.locale
-      handling = options.delete(:throw) && :throw || options.delete(:raise) && :raise # TODO deprecate :raise
-
-      raise I18n::ArgumentError if key.is_a?(String) && key.empty?
-
-      result = catch(:exception) do
-        if key.is_a?(Array)
-          key.map { |k| backend.translate(locale, k, options) }
-        else
-          backend.translate(locale, key, options)
-        end
-      end
-      result.is_a?(MissingTranslation) ? handle_exception(handling, result, locale, key, options) : result
-    end
-    alias :t :translate
-
-    # Wrapper for <tt>translate</tt> that adds <tt>:raise => true</tt>. With
-    # this option, if no translation is found, it will raise <tt>I18n::MissingTranslationData</tt>
-    def translate!(key, options={})
-      translate(key, options.merge(:raise => true))
-    end
-    alias :t! :translate!
-
-    # Transliterates UTF-8 characters to ASCII. By default this method will
-    # transliterate only Latin strings to an ASCII approximation:
-    #
-    #    I18n.transliterate("Ærøskøbing")
-    #    # => "AEroskobing"
-    #
-    #    I18n.transliterate("日本語")
-    #    # => "???"
-    #
-    # It's also possible to add support for per-locale transliterations. I18n
-    # expects transliteration rules to be stored at
-    # <tt>i18n.transliterate.rule</tt>.
-    #
-    # Transliteration rules can either be a Hash or a Proc. Procs must accept a
-    # single string argument. Hash rules inherit the default transliteration
-    # rules, while Procs do not.
-    #
-    # *Examples*
-    #
-    # Setting a Hash in <locale>.yml:
-    #
-    #    i18n:
-    #      transliterate:
-    #        rule:
-    #          ü: "ue"
-    #          ö: "oe"
-    #
-    # Setting a Hash using Ruby:
-    #
-    #     store_translations(:de, :i18n => {
-    #       :transliterate => {
-    #         :rule => {
-    #           "ü" => "ue",
-    #           "ö" => "oe"
-    #         }
-    #       }
-    #     )
-    #
-    # Setting a Proc:
-    #
-    #     translit = lambda {|string| MyTransliterator.transliterate(string) }
-    #     store_translations(:xx, :i18n => {:transliterate => {:rule => translit})
-    #
-    # Transliterating strings:
-    #
-    #     I18n.locale = :en
-    #     I18n.transliterate("Jürgen") # => "Jurgen"
-    #     I18n.locale = :de
-    #     I18n.transliterate("Jürgen") # => "Juergen"
-    #     I18n.transliterate("Jürgen", :locale => :en) # => "Jurgen"
-    #     I18n.transliterate("Jürgen", :locale => :de) # => "Juergen"
-    def transliterate(*args)
-      options      = args.pop if args.last.is_a?(Hash)
-      key          = args.shift
-      locale       = options && options.delete(:locale) || config.locale
-      handling     = options && (options.delete(:throw) && :throw || options.delete(:raise) && :raise)
-      replacement  = options && options.delete(:replacement)
-      config.backend.transliterate(locale, key, replacement)
-    rescue I18n::ArgumentError => exception
-      handle_exception(handling, exception, locale, key, options || {})
-    end
-
-    # Localizes certain objects, such as dates and numbers to local formatting.
-    def localize(object, options = {})
-      locale = options.delete(:locale) || config.locale
-      format = options.delete(:format) || :default
-      config.backend.localize(locale, object, format, options)
-    end
-    alias :l :localize
-
-    # Executes block with given I18n.locale set.
-    def with_locale(tmp_locale = nil)
-      if tmp_locale
-        current_locale = self.locale
-        self.locale    = tmp_locale
-      end
-      yield
-    ensure
-      self.locale = current_locale if tmp_locale
-    end
-
-    # Merges the given locale, key and scope into a single array of keys.
-    # Splits keys that contain dots into multiple keys. Makes sure all
-    # keys are Symbols.
-    def normalize_keys(locale, key, scope, separator = nil)
-      separator ||= I18n.default_separator
-
-      keys = []
-      keys.concat normalize_key(locale, separator)
-      keys.concat normalize_key(scope, separator)
-      keys.concat normalize_key(key, separator)
-      keys
-    end
-
-  # making these private until Ruby 1.9.2 can send to protected methods again
-  # see http://redmine.ruby-lang.org/repositories/revision/ruby-19?rev=24280
-  private
-
-    # Any exceptions thrown in translate will be sent to the @@exception_handler
-    # which can be a Symbol, a Proc or any other Object unless they're forced to
-    # be raised or thrown (MissingTranslation).
-    #
-    # If exception_handler is a Symbol then it will simply be sent to I18n as
-    # a method call. A Proc will simply be called. In any other case the
-    # method #call will be called on the exception_handler object.
-    #
-    # Examples:
-    #
-    #   I18n.exception_handler = :default_exception_handler             # this is the default
-    #   I18n.default_exception_handler(exception, locale, key, options) # will be called like this
-    #
-    #   I18n.exception_handler = lambda { |*args| ... }                 # a lambda
-    #   I18n.exception_handler.call(exception, locale, key, options)    # will be called like this
-    #
-    #  I18n.exception_handler = I18nExceptionHandler.new                # an object
-    #  I18n.exception_handler.call(exception, locale, key, options)     # will be called like this
-    def handle_exception(handling, exception, locale, key, options)
-      case handling
-      when :raise
-        raise(exception.respond_to?(:to_exception) ? exception.to_exception : exception)
-      when :throw
-        throw :exception, exception
-      else
-        case handler = options[:exception_handler] || config.exception_handler
-        when Symbol
-          send(handler, exception, locale, key, options)
-        else
-          handler.call(exception, locale, key, options)
-        end
-      end
-    end
-
-    def normalize_key(key, separator)
-      normalized_key_cache[separator][key] ||=
-        case key
-        when Array
-          key.map { |k| normalize_key(k, separator) }.flatten
-        else
-          keys = key.to_s.split(separator)
-          keys.delete('')
-          keys.map! { |k| k.to_sym }
-          keys
-        end
-    end
-
-    def normalized_key_cache
-      @normalized_key_cache ||= Hash.new { |h,k| h[k] = {} }
-    end
-
-    # DEPRECATED. Use I18n.normalize_keys instead.
-    def normalize_translation_keys(locale, key, scope, separator = nil)
-      puts "I18n.normalize_translation_keys is deprecated. Please use the class I18n.normalize_keys instead."
-      normalize_keys(locale, key, scope, separator)
-    end
-
-    # DEPRECATED. Please use the I18n::ExceptionHandler class instead.
-    def default_exception_handler(exception, locale, key, options)
-      puts "I18n.default_exception_handler is deprecated. Please use the class I18n::ExceptionHandler instead " +
-           "(an instance of which is set to I18n.exception_handler by default)."
-      exception.is_a?(MissingTranslation) ? exception.message : raise(exception)
-    end
-  }
-end

data/vendor/bundle/gems/i18n-0.6.1/lib/i18n/backend.rb

@@ -1,18 +0,0 @@
-module I18n
-  module Backend
-    autoload :Base,                  'i18n/backend/base'
-    autoload :InterpolationCompiler, 'i18n/backend/interpolation_compiler'
-    autoload :Cache,                 'i18n/backend/cache'
-    autoload :Cascade,               'i18n/backend/cascade'
-    autoload :Chain,                 'i18n/backend/chain'
-    autoload :Fallbacks,             'i18n/backend/fallbacks'
-    autoload :Flatten,               'i18n/backend/flatten'
-    autoload :Gettext,               'i18n/backend/gettext'
-    autoload :KeyValue,              'i18n/backend/key_value'
-    autoload :Memoize,               'i18n/backend/memoize'
-    autoload :Metadata,              'i18n/backend/metadata'
-    autoload :Pluralization,         'i18n/backend/pluralization'
-    autoload :Simple,                'i18n/backend/simple'
-    autoload :Transliterator,        'i18n/backend/transliterator'
-  end
-end

data/vendor/bundle/gems/i18n-0.6.1/lib/i18n/backend/base.rb

@@ -1,181 +0,0 @@
-require 'yaml'
-require 'i18n/core_ext/hash'
-require 'i18n/core_ext/kernel/surpress_warnings'
-
-module I18n
-  module Backend
-    module Base
-      include I18n::Backend::Transliterator
-
-      # Accepts a list of paths to translation files. Loads translations from
-      # plain Ruby (*.rb) or YAML files (*.yml). See #load_rb and #load_yml
-      # for details.
-      def load_translations(*filenames)
-        filenames = I18n.load_path if filenames.empty?
-        filenames.flatten.each { |filename| load_file(filename) }
-      end
-
-      # This method receives a locale, a data hash and options for storing translations.
-      # Should be implemented
-      def store_translations(locale, data, options = {})
-        raise NotImplementedError
-      end
-
-      def translate(locale, key, options = {})
-        raise InvalidLocale.new(locale) unless locale
-        entry = key && lookup(locale, key, options[:scope], options)
-
-        if options.empty?
-          entry = resolve(locale, key, entry, options)
-        else
-          count, default = options.values_at(:count, :default)
-          values = options.except(*RESERVED_KEYS)
-          entry = entry.nil? && default ?
-            default(locale, key, default, options) : resolve(locale, key, entry, options)
-        end
-
-        throw(:exception, I18n::MissingTranslation.new(locale, key, options)) if entry.nil?
-        entry = entry.dup if entry.is_a?(String)
-
-        entry = pluralize(locale, entry, count) if count
-        entry = interpolate(locale, entry, values) if values
-        entry
-      end
-
-      # Acts the same as +strftime+, but uses a localized version of the
-      # format string. Takes a key from the date/time formats translations as
-      # a format argument (<em>e.g.</em>, <tt>:short</tt> in <tt>:'date.formats'</tt>).
-      def localize(locale, object, format = :default, options = {})
-        raise ArgumentError, "Object must be a Date, DateTime or Time object. #{object.inspect} given." unless object.respond_to?(:strftime)
-
-        if Symbol === format
-          key  = format
-          type = object.respond_to?(:sec) ? 'time' : 'date'
-          options = options.merge(:raise => true, :object => object, :locale => locale)
-          format  = I18n.t(:"#{type}.formats.#{key}", options)
-        end
-
-        # format = resolve(locale, object, format, options)
-        format = format.to_s.gsub(/%[aAbBp]/) do |match|
-          case match
-          when '%a' then I18n.t(:"date.abbr_day_names",                  :locale => locale, :format => format)[object.wday]
-          when '%A' then I18n.t(:"date.day_names",                       :locale => locale, :format => format)[object.wday]
-          when '%b' then I18n.t(:"date.abbr_month_names",                :locale => locale, :format => format)[object.mon]
-          when '%B' then I18n.t(:"date.month_names",                     :locale => locale, :format => format)[object.mon]
-          when '%p' then I18n.t(:"time.#{object.hour < 12 ? :am : :pm}", :locale => locale, :format => format) if object.respond_to? :hour
-          end
-        end
-
-        object.strftime(format)
-      end
-
-      # Returns an array of locales for which translations are available
-      # ignoring the reserved translation meta data key :i18n.
-      def available_locales
-        raise NotImplementedError
-      end
-
-      def reload!
-        @skip_syntax_deprecation = false
-      end
-
-      protected
-
-        # The method which actually looks up for the translation in the store.
-        def lookup(locale, key, scope = [], options = {})
-          raise NotImplementedError
-        end
-
-        # Evaluates defaults.
-        # If given subject is an Array, it walks the array and returns the
-        # first translation that can be resolved. Otherwise it tries to resolve
-        # the translation directly.
-        def default(locale, object, subject, options = {})
-          options = options.dup.reject { |key, value| key == :default }
-          case subject
-          when Array
-            subject.each do |item|
-              result = resolve(locale, object, item, options) and return result
-            end and nil
-          else
-            resolve(locale, object, subject, options)
-          end
-        end
-
-        # Resolves a translation.
-        # If the given subject is a Symbol, it will be translated with the
-        # given options. If it is a Proc then it will be evaluated. All other
-        # subjects will be returned directly.
-        def resolve(locale, object, subject, options = {})
-          return subject if options[:resolve] == false
-          result = catch(:exception) do
-            case subject
-            when Symbol
-              I18n.translate(subject, options.merge(:locale => locale, :throw => true))
-            when Proc
-              date_or_time = options.delete(:object) || object
-              resolve(locale, object, subject.call(date_or_time, options))
-            else
-              subject
-            end
-          end
-          result unless result.is_a?(MissingTranslation)
-        end
-
-        # Picks a translation from an array according to English pluralization
-        # rules. It will pick the first translation if count is not equal to 1
-        # and the second translation if it is equal to 1. Other backends can
-        # implement more flexible or complex pluralization rules.
-        def pluralize(locale, entry, count)
-          return entry unless entry.is_a?(Hash) && count
-
-          key = :zero if count == 0 && entry.has_key?(:zero)
-          key ||= count == 1 ? :one : :other
-          raise InvalidPluralizationData.new(entry, count) unless entry.has_key?(key)
-          entry[key]
-        end
-
-        # Interpolates values into a given string.
-        #
-        #   interpolate "file %{file} opened by %%{user}", :file => 'test.txt', :user => 'Mr. X'
-        #   # => "file test.txt opened by %{user}"
-        def interpolate(locale, string, values = {})
-          if string.is_a?(::String) && !values.empty?
-            I18n.interpolate(string, values)
-          else
-            string
-          end
-        end
-
-        # Loads a single translations file by delegating to #load_rb or
-        # #load_yml depending on the file extension and directly merges the
-        # data to the existing translations. Raises I18n::UnknownFileType
-        # for all other file extensions.
-        def load_file(filename)
-          type = File.extname(filename).tr('.', '').downcase
-          raise UnknownFileType.new(type, filename) unless respond_to?(:"load_#{type}", true)
-          data = send(:"load_#{type}", filename)
-          raise InvalidLocaleData.new(filename) unless data.is_a?(Hash)
-          data.each { |locale, d| store_translations(locale, d || {}) }
-        end
-
-        # Loads a plain Ruby translations file. eval'ing the file must yield
-        # a Hash containing translation data with locales as toplevel keys.
-        def load_rb(filename)
-          eval(IO.read(filename), binding, filename)
-        end
-
-        # Loads a YAML translations file. The data must have locales as
-        # toplevel keys.
-        def load_yml(filename)
-          begin
-            YAML.load_file(filename)
-          rescue TypeError
-            nil
-          rescue SyntaxError
-            nil
-          end
-        end
-    end
-  end
-end