i18n-inflector-3 3.0.0

data/lib/i18n-inflector/lazy_enum.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+#
+# Author::    Paweł Wilk (mailto:pw@gnu.org)
+# Copyright:: (c) 2011,2012,2013 by Paweł Wilk
+# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:docs/COPYING Ruby License}.
+#
+# This file contains lazy enumerators.
+
+module I18n
+  module Inflector
+    if RUBY_VERSION.gsub(/\D/, '')[0..1].to_i < 19
+
+      class LazyEnumerator < Object.const_defined?(:Enumerator) ? Enumerator : Enumerable::Enumerator
+        # This class allows to initialize the Enumerator with a block
+        class Yielder
+          def initialize(&block)
+            @main_block = block
+          end
+
+          def each(&block)
+            @final_block = block
+            @main_block.call(self)
+          end
+
+          if Proc.method_defined?(:yield)
+            def yield(*arg)
+              @final_block.yield(*arg)
+            end
+          else
+            def yield(*arg)
+              @final_block.call(*arg)
+            end
+          end
+
+          alias_method :<<, :yield if method_defined?(:yield) && !method_defined?(:<<)
+        end
+
+        unless begin
+          new {}
+        rescue StandardError
+          false
+        end
+          def initialize(*args, &)
+            args.empty? ? super(Yielder.new(&)) : super
+          end
+        end
+
+        if method_defined?(:with_object) && !method_defined?(:each_with_object)
+          alias_method :each_with_object,
+            :with_object
+        end
+      end
+
+    else # if RUBY_VERSION >= 1.9.0
+
+      class LazyEnumerator < Enumerator
+      end
+
+    end
+
+    # This class adds some lazy operations for collections
+    class LazyEnumerator
+      # Create a new instance that iterates over the passed Enumerable
+      # @return [I18n::Inflector::LazyEnumerator] the enumerator
+      def self.for(enumerable)
+        new do |y|
+          enumerable.each do |e|
+            y << e
+          end
+        end
+      end
+
+      # Addition operator for collections
+      # @return [I18n::Inflector::LazyEnumerator] the enumerator
+      def +(other)
+        self.class.new do |yielder|
+          each do |v|
+            yielder << v
+          end
+          other.each do |v|
+            yielder << v
+          end
+        end
+      end
+
+      # Insertion operator for collections
+      # @return [I18n::Inflector::LazyEnumerator] the enumerator
+      def insert(value)
+        self.class.new do |yielder|
+          yielder << value
+          each do |v|
+            yielder << v
+          end
+        end
+      end
+
+      # Appending operator for collections
+      # @return [I18n::Inflector::LazyEnumerator] the enumerator
+      def append(value)
+        self.class.new do |yielder|
+          each do |v|
+            yielder << v
+          end
+          yielder << value
+        end
+      end
+
+      # Mapping enumerator
+      # @return [I18n::Inflector::LazyEnumerator] the enumerator
+      def map(&block)
+        self.class.new do |yielder|
+          each do |v|
+            yielder << block[v]
+          end
+        end
+      end
+
+      # Selecting enumerator
+      # @return [I18n::Inflector::LazyEnumerator] the enumerator
+      def select(&block)
+        self.class.new do |yielder|
+          each do |v|
+            yielder << v if block[v]
+          end
+        end
+      end
+
+      # Rejecting enumerator
+      # @return [I18n::Inflector::LazyEnumerator] the enumerator
+      def reject(&block)
+        self.class.new do |yielder|
+          each do |v|
+            yielder << v unless block[v]
+          end
+        end
+      end
+
+      # Checks if a collection is empty
+      # @return [Boolean] +true+ if collection is empty, +false+ otherwise
+      def empty?
+        self.class.new do |_yielder|
+          each do |_k, _v|
+            return false
+          end
+        end
+        true
+      end
+    end
+
+    # This class implements simple enumerators for arrays
+    # that allow to do lazy operations on them.
+    class LazyArrayEnumerator < LazyEnumerator
+    end
+
+    # This class implements simple enumerators for hashes
+    # that allow to do lazy operations on them.
+    class LazyHashEnumerator < LazyEnumerator
+      # Creates a Hash kind of object by collecting all
+      # data from enumerated collection.
+      # @return [Hash] the resulting hash
+      def to_h
+        h = {}
+        each { |k, v| h[k] = v }
+        h
+      end
+
+      # Insertion operator for Hash enumerators
+      # @return [I18n::Inflector::LazyHashEnumerator] the enumerator
+      def insert(key, value)
+        self.class.new do |yielder|
+          yielder.yield(key, value)
+          each do |k, v|
+            yielder.yield(k, v)
+          end
+        end
+      end
+
+      # Appending operator for Hash enumerators
+      # @return [I18n::Inflector::LazyHashEnumerator] the enumerator
+      def append(key, value)
+        self.class.new do |yielder|
+          each do |k, v|
+            yielder.yield(k, v)
+          end
+          yielder.yield(key, value)
+        end
+      end
+
+      # Hash mapping enumerator
+      # @return [I18n::Inflector::LazyHashEnumerator] the enumerator
+      def map(&block)
+        LazyHashEnumerator.new do |yielder|
+          each do |k, v|
+            yielder.yield(k, block[k, v])
+          end
+        end
+      end
+
+      # Hash to Array mapping enumerator
+      # @return [I18n::Inflector::LazyHashEnumerator] the enumerator
+      def ary_map(&block)
+        LazyHashEnumerator.new do |yielder|
+          each do |value|
+            yielder << block[value]
+          end
+        end
+      end
+
+      # This method converts resulting keys
+      # to an array.
+      def keys
+        ary = []
+        each { |k, _v| ary << k }
+        ary
+      end
+
+      # This method converts resulting values
+      # to an array.
+      def values
+        ary = []
+        each { |_k, v| ary << v }
+        ary
+      end
+
+      # Keys enumerator
+      # @return [I18n::Inflector::LazyArrayEnumerator.new] the enumerator
+      def each_key
+        LazyArrayEnumerator.new do |yielder|
+          each do |k, _v|
+            yielder << k
+          end
+        end
+      end
+
+      # Values enumerator
+      # @return [I18n::Inflector::LazyArrayEnumerator.new] the enumerator
+      def each_value
+        LazyArrayEnumerator.new do |yielder|
+          each do |_k, v|
+            yielder << v
+          end
+        end
+      end
+
+      # Hash selecting enumerator
+      # @return [I18n::Inflector::LazyHashEnumerator] the enumerator
+      def select(&block)
+        self.class.new do |yielder|
+          each do |k, v|
+            yielder.yield(k, v) if block[k, v]
+          end
+        end
+      end
+
+      # Hash rejecting enumerator
+      # @return [I18n::Inflector::LazyHashEnumerator] the enumerator
+      def reject(&block)
+        self.class.new do |yielder|
+          each do |k, v|
+            yielder.yield(k, v) unless block[k, v]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/i18n-inflector/long_comments.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+#
+# Author::    Paweł Wilk (mailto:pw@gnu.org)
+# Copyright:: (c) 2011,2012,2013 by Paweł Wilk
+# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:docs/COPYING Ruby License}.
+#
+# This file contains inline documentation data
+# that would make the file with code less readable
+# if placed there. Code from this file is not used
+# by the library, it's just for documentation.
+
+module I18n
+  module Inflector
+    class API
+      # This reader allows to reach a reference of the
+      # object that is a kind of {I18n::Inflector::API_Strict}
+      # and handles inflections for named patterns (strict kinds).
+      #
+      # @api public
+      # @return [I18n::Inflector::API_Strict] the object containing
+      #   database and operations for named patterns (strict kinds)
+      attr_reader :strict
+
+      # This reader allows to reach internal configuration
+      # of the engine. It is shared among all instances of
+      # the Inflector and also available as
+      # {I18n::Inflector::Config I18n::Inflector::Config}.
+      attr_reader :config
+
+      # Gets known regular inflection kinds.
+      #
+      # @api public
+      # @note To get all inflection kinds (regular and strict) for default inflector
+      #   use: <tt>I18n.inflector.kinds + I18n.inflector.strict.kinds</tt>
+      # @return [Array<Symbol>] the array containing known inflection kinds
+      # @raise [I18n::InvalidLocale] if there is no proper locale name
+      # @overload kinds
+      #   Gets known inflection kinds for the current locale.
+      #   @return [Array<Symbol>] the array containing known inflection kinds
+      # @overload kinds(locale)
+      #   Gets known inflection kinds for the given +locale+.
+      #   @param [Symbol] locale the locale for which operation has to be done
+      #   @return [Array<Symbol>] the array containing known inflection kinds
+      def kinds(locale = nil) = super
+      alias_method :inflection_kinds, :kinds
+    end
+  end
+
+  # @abstract This exception class is defined in package I18n. It is raised when
+  #   the given and/or processed locale parameter is invalid.
+  class InvalidLocale; end
+
+  # @abstract This exception class is defined in package I18n. It is raised when
+  #   the given and/or processed translation data or parameter are invalid.
+  class ArgumentError; end
+end

data/lib/i18n-inflector/options.rb

@@ -0,0 +1,329 @@
+# frozen_string_literal: true
+
+#
+# Author::    Paweł Wilk (mailto:pw@gnu.org)
+# Copyright:: (c) 2011,2012,2013 by Paweł Wilk
+# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:docs/COPYING Ruby License}.
+#
+# This file contains a class used to set up some options,
+# for engine.
+
+module I18n
+  module Inflector
+    # This class contains structures for keeping parsed translation data
+    # and basic operations.
+    #
+    # All global options are available for current backend's inflector by
+    # calling:
+    #   I18n.backend.inflector.options.<option_name>
+    # or just:
+    #   I18n.inflector.options.<option_name>
+    # A global option may be overriden by passing a proper option to
+    # the translation method. Such option should have the name of a
+    # global option but prefixed with +inflector_+:
+    #   translate('welcome', :inflector_<option_name> => value)
+    # @note This class uses modified version of +attr_accessor+ that
+    #   memorizes any added method name as an option name. These options
+    #   (with +inflector_+ prefix added) are accessible through
+    #   {#known} method. The last method is used by options preparing
+    #   routine when the interpolation is performed.
+    class InflectionOptions
+      # Prefix used to mark option as a controlling option.
+      OPTION_PREFIX = 'inflector_'
+
+      class << self
+        # @private
+        attr_reader :known
+
+        # @private
+        alias_method :old_attr_accessor, :attr_accessor
+        def attr_accessor(*args)
+          r = old_attr_accessor(*args)
+          @known ||= {}
+          args.each do |arg|
+            key = "@#{arg}"
+            @known[key.to_sym] = (OPTION_PREFIX + arg.to_s).to_sym
+          end
+          r
+        end
+      end
+
+      # This switch enables cache-aware mode. In that mode inflection
+      # options and flags are evaluated before calling original translate
+      # method and all options are passed to that method. Because options
+      # preparation for inflection methods is explicit (any missing switches
+      # and their default values are added to options) then original
+      # translate (or proxy caching method) will receive even those options
+      # that might have been changed globally.
+      #
+      # Caching modules for I18n may use options passed to the translate
+      # method (if they are plugged in before inflector) for key
+      # transformation since the inflection options may influence
+      # the interpolation process and therefore the resulting string.
+      #
+      # If however, the caching variant of the translate method is
+      # positioned before inflected variant in methods chain, then
+      # the only way of knowing all the settings by caching routine is to call
+      # <tt>options.options.prepare_options!(options)</tt> on the used backend,
+      # for example:
+      #   I18n.backend.inflector.options.prepare(options)
+      # That will alter the +options+ data so they will contain all switches
+      # and values.
+      #
+      # @api public
+      # @return [Boolean] state of the switch
+      # @param [Boolean] state +true+ enables, +false+ disables this switch
+      attr_accessor :cache_aware
+
+      # This is a switch that enables extended error reporting. When it's enabled then
+      # errors are raised in case of unknown or empty tokens present in a pattern
+      # or in options. This switch is by default set to +false+.
+      #
+      # @note Local option +:inflector_raises+ passed
+      #   to the {I18n::Backend::Inflector#translate} overrides this setting.
+      #
+      # @api public
+      # @return [Boolean] state of the switch
+      # @param [Boolean] state +true+ enables, +false+ disables this switch
+      attr_accessor :raises
+
+      # This is a switch that enables you to use aliases in patterns. When it's enabled then
+      # aliases may be used in inflection patterns, not only true tokens. This operation
+      # may make your translation data a bit messy if you're not alert.
+      # That's why this switch is by default set to +false+.
+      #
+      # @note Local option +:inflector_aliased_patterns+ passed to the
+      #   {I18n::Backend::Inflector#translate} overrides this setting.
+      #
+      # @api public
+      # @return [Boolean] state of the switch
+      # @param [Boolean] state +true+ enables, +false+ disables this switch
+      attr_accessor :aliased_patterns
+
+      # This is a switch that enables you to interpolate patterns contained
+      # in resulting nested Hashes. It is used when the original translation
+      # method returns a subtree of translation data because the given key
+      # is not pointing to a leaf of the data but to some collection.
+      #
+      # This switch is by default set to +true+. When you turn it off then
+      # the Inflector won't touch nested results and will return them as they are.
+      #
+      # @note Local option +:inflector_traverses+ passed to the
+      #   {I18n::Backend::Inflector#translate} overrides this setting.
+      #
+      # @api public
+      # @return [Boolean] state of the switch
+      # @param [Boolean] state +true+ enables, +false+ disables this switch
+      attr_accessor :traverses
+
+      # This is a switch that enables interpolation of symbols. Whenever
+      # interpolation method will receive a collection of symbols as a result
+      # of calling underlying translation method
+      # it won't process them, returning as they are, unless
+      # this switch is enabled.
+      #
+      # Note that using symbols as values in translation data creates
+      # I18n aliases. This option is intended to work with arrays of
+      # symbols or hashes with symbols as values, if the original translation
+      # method returns such structures.
+      #
+      # This switch is by default set to +false+.
+      #
+      # @note Local option +:inflector_interpolate_symbols+ passed to the
+      #   {I18n::Backend::Inflector#translate} overrides this setting.
+      #
+      # @api public
+      # @return [Boolean] state of the switch
+      # @param [Boolean] state +true+ enables, +false+ disables this switch
+      attr_accessor :interpolate_symbols
+
+      # When this switch is set to +true+ then inflector falls back to the default
+      # token for a kind if an inflection option passed to the
+      # {I18n::Backend::Inflector#translate} is unknown or +nil+.
+      # Note that the value of the default token will be
+      # interpolated only when this token is present in a pattern. This switch
+      # is by default set to +true+.
+      #
+      # @note Local option +:inflector_unknown_defaults+ passed
+      #   to the {I18n::Backend::Inflector#translate} overrides this setting.
+      #
+      # @api public
+      # @return [Boolean] state of the switch
+      # @param [Boolean] state +true+ enables, +false+ disables this switch
+      #
+      # @example YAML:
+      #    en:
+      #     i18n:
+      #       inflections:
+      #         gender:
+      #           n:       'neuter'
+      #           o:       'other'
+      #           default:  n
+      #
+      #     welcome:         "Dear @{n:You|o:Other}"
+      #     welcome_free:    "Dear @{n:You|o:Other|Free}"
+      #
+      # @example Example 1
+      #
+      #   # :gender option is not present,
+      #   # unknown tokens in options are falling back to default
+      #
+      #   I18n.t('welcome')
+      #   # => "Dear You"
+      #
+      #   # :gender option is not present,
+      #   # unknown tokens from options are not falling back to default
+      #
+      #   I18n.t('welcome', inflector_unknown_defaults: false)
+      #   # => "Dear You"
+      #
+      #   # other way of setting an option – globally
+      #
+      #   I18n.inflector.options.unknown_defaults = false
+      #   I18n.t('welcome')
+      #   # => "Dear You"
+      #
+      #   # :gender option is not present, free text is present,
+      #   # unknown tokens from options are not falling back to default
+      #
+      #   I18n.t('welcome_free', inflector_unknown_defaults: false)
+      #   # => "Dear You"
+      #
+      # @example Example 2
+      #
+      #   # :gender option is nil,
+      #   # unknown tokens from options are falling back to default token for a kind
+      #
+      #   I18n.t('welcome', gender: nil)
+      #   # => "Dear You"
+      #
+      #   # :gender option is nil
+      #   # unknown tokens from options are not falling back to default token for a kind
+      #
+      #   I18n.t('welcome', gender: nil, inflector_unknown_defaults: false)
+      #   # => "Dear "
+      #
+      #   # :gender option is nil, free text is present
+      #   # unknown tokens from options are not falling back to default token for a kind
+      #
+      #   I18n.t('welcome_free', gender: nil, inflector_unknown_defaults: false)
+      #   # => "Dear Free"
+      #
+      # @example Example 3
+      #
+      #   # :gender option is unknown,
+      #   # unknown tokens from options are falling back to default token for a kind
+      #
+      #   I18n.t('welcome', gender: :unknown_blabla)
+      #   # => "Dear You"
+      #
+      #   # :gender option is unknown,
+      #   # unknown tokens from options are not falling back to default token for a kind
+      #
+      #   I18n.t('welcome', gender: :unknown_blabla, inflector_unknown_defaults: false)
+      #   # => "Dear "
+      #
+      #   # :gender option is unknown, free text is present
+      #   # unknown tokens from options are not falling back to default token for a kind
+      #
+      #   I18n.t('welcome_free', gender: :unknown_blabla, inflector_unknown_defaults: false)
+      #   # => "Dear Free"
+      attr_accessor :unknown_defaults
+
+      # When this switch is set to +true+ then inflector falls back to the default
+      # token for a kind if the given inflection option is correct but doesn't exist
+      # in a pattern.
+      #
+      # There might happen that the inflection option
+      # given to {#translate} method will contain some proper token, but that token
+      # will not be present in a processed pattern. Normally an empty string will
+      # be generated from such a pattern or a free text (if a local fallback is present
+      # in a pattern). You can change that behavior and tell interpolating routine to
+      # use the default token for a processed kind in such cases.
+      #
+      # This switch is by default set to +false+.
+      #
+      # @note Local option +:inflector_excluded_defaults+ passed to the {I18n::Backend::Inflector#translate}
+      #   overrides this setting.
+      #
+      # @api public
+      # @return [Boolean] state of the switch
+      # @param [Boolean] state +true+ enables, +false+ disables this switch
+      #
+      # @example YAML:
+      #   en:
+      #     i18n:
+      #       inflections:
+      #         gender:
+      #           o:      "other"
+      #           m:      "male"
+      #           n:      "neuter"
+      #           default: n
+      #
+      #     welcome:  'Dear @{n:You|m:Sir}'
+      # @example Usage of +:inflector_excluded_defaults+ option
+      #   I18n.t('welcome', gender: :o)
+      #   # => "Dear "
+      #
+      #   I18n.t('welcome', gender: :o, inflector_excluded_defaults: true)
+      #   # => "Dear You"
+      attr_accessor :excluded_defaults
+
+      # This method initializes all internal structures.
+      def initialize
+        reset
+      end
+
+      # This method resets all options to their default values.
+      #
+      # @return [void]
+      def reset
+        @unknown_defaults   = true
+        @traverses          = true
+        @interpolate_symbols = false
+        @excluded_defaults  = false
+        @aliased_patterns   = false
+        @cache_aware        = false
+        @raises             = false
+        nil
+      end
+
+      # This method processes the given argument
+      # in a way that it will use default values
+      # for options that are missing.
+      #
+      # @api public
+      # @note It modifies the given object.
+      # @param [Hash] options the options
+      # @return [Hash] the given options
+      def prepare_options!(options)
+        self.class.known
+          .reject { |_name, long| options.key?(long) }
+          .each   { |name, long| options[long] = instance_variable_get(name) }
+        options
+      end
+
+      # This method prepares options for translate method.
+      # That means removal of all kind-related options
+      # and all options that are flags.
+      #
+      # @api public
+      # @note It modifies the given object.
+      # @param [Hash] options the given options
+      # @return [Hash] the given options
+      def clean_for_translate!(options)
+        self.class.known.each_value { |long| options.delete long }
+        options
+      end
+
+      # Lists all known options in a long format
+      # (each name preceeded by <tt>inflector_</tt>).
+      #
+      # @api public
+      # @return [Array<Symbol>] the known options
+      def known
+        self.class.known.values
+      end
+    end
+  end
+end

data/lib/i18n-inflector/version.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+#
+# Author::    Paweł Wilk (mailto:pw@gnu.org)
+# Copyright:: (c) 2011,2012,2013 by Paweł Wilk
+# License::   This program is licensed under the terms of {file:docs/LGPL GNU Lesser General Public License} or {file:docs/COPYING Ruby License}.
+#
+# This file contains version information.
+
+module I18n
+  module Inflector
+    # @private
+    DEVELOPER   = 'Paweł Wilk'
+    # @private
+    EMAIL       = 'pw@gnu.org'
+    # @private
+    VERSION     = '3.0.0'
+    # @private
+    NAME        = 'i18n-inflector'
+    # @private
+    SUMMARY     = 'Inflection module for I18n'
+    # @private
+    URL         = 'https://rubygems.org/gems/i18n-inflector/'
+    # @private
+    DESCRIPTION = 'Enhances simple I18n backend in a way that it inflects translation data using pattern interpolation.'
+  end
+end

data/lib/i18n-inflector.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'i18n'
+
+require 'i18n-inflector/version'
+require 'i18n-inflector/hset'
+require 'i18n-inflector/lazy_enum'
+require 'i18n-inflector/inflection_data_strict'
+require 'i18n-inflector/inflection_data'
+require 'i18n-inflector/options'
+require 'i18n-inflector/inflector'
+require 'i18n-inflector/config'
+require 'i18n-inflector/backend'
+require 'i18n-inflector/errors'
+require 'i18n-inflector/interpolate'
+require 'i18n-inflector/api_strict'
+require 'i18n-inflector/api'
+
+I18n::Backend::Simple.include I18n::Backend::Inflector