nelumba-i18n 0.0.2

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ostatus.gemspec
+gemspec
+
+group :test do
+  gem "rake"              # rakefile
+  gem "minitest", "4.7.0" # test framework (specified here for prior rubies)
+  gem "ansi"              # minitest colors
+  gem "turn"              # minitest output
+  gem "mocha"             # stubs
+
+  gem "awesome_print"
+  gem "debugger"
+end

data/Gemfile.lock

@@ -0,0 +1,49 @@
+PATH
+  remote: .
+  specs:
+    lotus-i18n (0.0.1)
+      i18n
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ansi (1.4.3)
+    awesome_print (1.1.0)
+    columnize (0.3.6)
+    debugger (1.6.0)
+      columnize (>= 0.3.1)
+      debugger-linecache (~> 1.2.0)
+      debugger-ruby_core_source (~> 1.2.1)
+    debugger-linecache (1.2.0)
+    debugger-ruby_core_source (1.2.3)
+    diff-lcs (1.1.3)
+    i18n (0.6.4)
+    metaclass (0.0.1)
+    minitest (4.7.0)
+    mocha (0.14.0)
+      metaclass (~> 0.0.1)
+    rake (10.1.0)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+    turn (0.9.6)
+      ansi
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ansi
+  awesome_print
+  debugger
+  lotus-i18n!
+  minitest (= 4.7.0)
+  mocha
+  rake
+  rspec (~> 2.10.0)
+  turn

data/LICENSE

@@ -0,0 +1,127 @@
+nelumba-i18n
+
+To the extent possible under law, the author(s) have dedicated all
+copyright and related and neighboring rights to this software to the
+public domain worldwide. This software is distributed without any warranty.
+
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = "spec/**/*_spec.rb"
+end

data/lib/nelumba-i18n.rb

@@ -0,0 +1,11 @@
+# The main module for all Nelumba related functionality.
+module Nelumba
+end
+
+require 'nelumba-i18n/i18n'
+require 'nelumba-i18n/locales'
+
+# Add nelumba locales to the I18n load path
+I18n.load_path += Dir[File.expand_path("../nelumba-i18n/locales/**/lexicon.{yml}", __FILE__)]
+
+Dir[File.join(File.dirname(__FILE__), "nelumba-i18n", "locales", "*.rb")].each {|file| require file }

data/lib/nelumba-i18n/i18n.rb

@@ -0,0 +1,166 @@
+# The main module for all Nelumba related functionality.
+module Nelumba
+  # The internationalization and localization module.
+  module I18n
+    require 'i18n'
+
+    # Translate the given token to the locale's translation.
+    def self.translate(*args)
+      ::I18n.t(*args)
+    end
+
+    # Translates the given verb for the current locale.
+    def self.verb(*args)
+      token = args.shift
+      self.translate("verb.#{token}", *args)
+    end
+
+    # Translates the given object as a singular for the current locale.
+    def self.single_object(*args)
+      token = args.shift
+      options = args.last if args.last.is_a? Hash
+      self.translate("object.singular_#{token}", *args)
+    end
+
+    # Translates the given object as a plural for the current locale.
+    def self.plural_object(*args)
+      token = args.shift
+      options = args.last if args.last.is_a? Hash
+      self.translate("object.plural_#{token}", *args)
+    end
+
+    # Translates the given object for the current locale.
+    def self.object(*args)
+      token = args.shift
+      self.translate("object.#{token}", *args)
+    end
+
+    # Translates the given pronoun for the current locale.
+    def self.pronoun(*args)
+      token = args.shift
+      self.translate("pronoun.#{token}", *args)
+    end
+
+    # Translates the given possessive pronoun for the current locale.
+    def self.possessive_pronoun(*args)
+      token = args.shift
+      self.translate("possessive_pronoun.#{token}", *args)
+    end
+
+    # Translates the given action for the current locale.
+    def self.action(*args)
+      token = args.shift
+      self.translate("action.#{token}", *args)
+    end
+
+    # Translates the given category for the current locale.
+    def self.category(*args)
+      token = args.shift
+      self.translate("category.#{token}", *args)
+    end
+
+    # Translates the given field for the current locale.
+    def self.field(*args)
+      token = args.shift
+      self.translate("field.#{token}", *args)
+    end
+
+    # Localize the given object for the current locale.
+    def self.localize(*args)
+      ::I18n.l(*args)
+    end
+
+    # Produces a sentence describing the given Nelumba::Activity.
+    def self.sentence(options = {})
+      options ||= {}
+
+      components = {}
+
+      if options[:actor].is_a? Symbol
+        components[:actor_pronoun] = options[:actor]
+      else
+        components[:actor] = options[:actor]
+      end
+
+      if options[:actors].is_a? Symbol
+        components[:actors_pronoun] = options[:actors]
+      else
+        components[:actors] = options[:actors]
+      end
+
+      if options[:object_owner].is_a? Symbol
+        components[:object_owner_pronoun] = options[:object_owner]
+      else
+        components[:object_owner] = options[:object_owner]
+      end
+
+      if options[:object_owners].is_a? Symbol
+        components[:object_owners_pronoun] = options[:object_owners]
+      else
+        components[:object_owners] = options[:object_owners]
+      end
+
+      if options[:target_owner].is_a? Symbol
+        components[:target_owner_pronoun] = options[:target_owner]
+      else
+        components[:target_owner] = options[:target_owner]
+      end
+
+      if options[:target_owners].is_a? Symbol
+        components[:target_owners_pronoun] = options[:target_owners]
+      else
+        components[:target_owners] = options[:target_owners]
+      end
+
+      components[:target]  = options[:target]
+      components[:targets] = options[:targets]
+      components[:object]  = options[:object]
+      components[:objects] = options[:objects]
+      components[:verb]    = options[:verb]
+      components[:action]  = options[:action]
+      components[:field]   = options[:field]
+
+      components.keys.each do |key|
+        if components[key].nil?
+          components.delete key
+        end
+      end
+
+      rules = Nelumba::Locales.rules(options)
+      result = ""
+
+      rules.each do |hash|
+        if components.keys.select{|e| !hash["for"].include?(e.to_s)}.empty? &&
+           components.keys.count == hash["for"].count
+          if hash["match"] && hash["match"].count > 0
+            matches = hash["match"]
+
+            violations = matches.select do |rule|
+              if rule[0] && components[rule[0].intern]
+                !components[rule[0].intern].match(Regexp.new(rule[1]))
+              else
+                false
+              end
+            end
+
+            next unless violations.empty?
+          end
+
+          result = hash["do"]
+          components.each do |component, value|
+            if value.is_a? Symbol
+              result = result.gsub /[\.a-zA-Z_]*%#{Regexp.escape(component.to_s)}%[\.a-zA-Z_]*/ do |match|
+                self.translate(match.gsub("%#{component.to_s}%", value.to_s).strip, options)
+              end
+            else
+              result = result.gsub("%#{component.to_s}%", value.to_s)
+            end
+          end
+          break
+        end
+      end
+
+      result
+    end
+  end
+end

data/lib/nelumba-i18n/locales.rb

@@ -0,0 +1,122 @@
+module Nelumba
+  # Modules that will generate sentences dependent on the locale.
+  module Locales
+    # Returns the metadata used to build grammatical structures for the given
+    #   locale.
+    #
+    # options:
+    #   :locale => The locale to use. Defaults to :en (English).
+    #
+    # Returns: an array of grammar rules. Each rule is a hash described below:
+    # "for"   => gives an array of strings for components that must be available
+    #            in order to generate this sentence.
+    # "do"    => gives the string that serves as the grammatical structure.
+    # "match" => an array of patterns to match against component values. if
+    #            the component does not match, then this rule is not used.
+    #            For instance, a rule that looks for an 's' at the end of
+    #            a word so as to decide between a rule that add "'s" or "'"
+    #            to the end of a word to make it possessive. You would have
+    #            a rule that matches that component against "s$". The patterns
+    #            are regular expression strings.
+    def self.grammar(options = {})
+      filename = self.grammar_path(options)
+
+      @@grammar ||= {}
+      @@grammar[filename] ||= YAML.load_file(filename)[self.locale(options)]
+      @@grammar[filename]
+    end
+
+    # Returns the default locale for the system.
+    def self.default_locale
+      default = ::I18n.default_locale.to_s
+    end
+
+    # Returns the locale passed through options if that locale exists, otherwise
+    # it returns the default locale.
+    def self.locale(options = {})
+      options ||= {}
+
+      locale = options[:locale].to_s || ::I18n.locale.to_s
+
+      default = ::I18n.default_locale.to_s
+
+      # Use the system default locale and then English as fallback
+      filename = ::File.join(::File.dirname(__FILE__), 'locales', locale, 'grammar.yml')
+      unless ::File.exist? filename
+        locale = default
+        filename = ::File.join(::File.dirname(__FILE__), 'locales', locale, 'grammar.yml')
+        unless ::File.exist? filename
+          locale = "en"
+        end
+      end
+
+      locale
+    end
+
+    # Returns the path to the grammar descriptions for the given locale or the
+    # default locale if none is given or the given locale cannot be found.
+    def self.grammar_path(options = {})
+      ::File.join(::File.dirname(__FILE__), 'locales', self.locale(options), 'grammar.yml')
+    end
+
+    # Returns the full list of rules for the given locale.
+    def self.rules(options = {})
+      locale  = self.locale(options)
+
+      @@rules ||= {}
+      return @@rules[locale] if @@rules[locale]
+
+      grammar = self.grammar(options)
+
+      rules = []
+      grammar["rules"].each do |rule|
+        if rule["match"] && rule["match"].count > 0 &&
+                            !rule["match"][0].is_a?(Array)
+          rule["match"] = [rule["match"]]
+        end
+
+        if rule["do"].match /\$([^\$]+)\$/
+          patterns = rule["do"].split('$')
+          patterns << "" if patterns.length.even?
+          number_of_subrules = (patterns.length - 1)/2
+          subrules = patterns.select.each_with_index { |_,i| i.odd? }
+
+          subrules.map! do |subrule|
+            grammar["subrules"][subrule]
+          end
+
+          subrules = subrules[0].product(*subrules[1..-1])
+
+          subrules.each do |set|
+            new_rule = {}
+            new_rule["for"] = set.map{|subrule|(subrule["for"] || []).dup}.concat(rule["for"]||[]).flatten.uniq
+
+            new_rule["match"] = set.map do |subrule|
+              if subrule["match"] && subrule["match"].count > 0 &&
+                                     !subrule["match"][0].is_a?(Array)
+                subrule["match"] = [subrule["match"]]
+              end
+              (subrule["match"] || [[]]).dup
+            end.inject(&:concat).concat(rule["match"]||[[]]).uniq.select{|e|!e.empty?}
+
+            new_rule["do"] = ""
+            patterns.each_with_index do |pattern, i|
+              if i.even?
+                new_rule["do"] << pattern
+              else
+                new_rule["do"] << set[(i-1)/2]["do"]
+              end
+            end
+            rules << new_rule
+          end
+        else
+          rule["for"] ||= []
+          rule["match"] ||= [[]]
+          rules << rule
+        end
+      end
+
+      @@rules[locale] = rules
+    end
+  end
+end