humanized 0.0.1.alpha

data/lib/humanized/humanizer.rb

@@ -0,0 +1,122 @@
+# -*- encoding : utf-8 -*-
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the Affero GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+#    (c) 2011 by Hannes Georg
+#
+require 'facets/array/extract_options.rb'
+require 'facets/hash/deep_merge.rb'
+require 'sync'
+require 'set'
+require 'humanized/compiler.rb'
+require 'humanized/source.rb'
+module Humanized
+# A Humanizer has one simple task: <b>create strings in its language/dialect/locale/whatever!</b>
+#
+# There should be one Humanizer per each configuration, but they can share their three components:
+# * {#source a source} which holds all language data ( mainly strings )
+# * {#compiler a compiler} which compiles the found strings
+# * {#interpolater an interpolater} which holds the methods which can be used in an interpolation
+#
+# The most important method you may use is {#[]}.
+class Humanizer
+  
+  # This is a simple object without public methods. You can use this as a collection for interpolation methods.
+  class PrivatObject
+    public_instance_methods.each do |meth|
+      private meth
+    end
+    
+    public :extend
+    
+  end
+  
+  attr_reader :interpolater, :source, :compiler
+  
+# Creates a new Humanizer
+#
+# @option components [Object] :interpolater This object which has all interpolation methods defined as public methods.
+# @option components [Compiler] :compiler A compiler which can compile strings into procs. (see Compiler)
+# @option components [Source] :source A source which stores translated strings. (see Source)
+  def initialize(components = {})
+    @interpolater = (components[:interpolater] || PrivatObject.new)
+    @compiler = (components[:compiler] || Compiler.new)
+    @source = (components[:source] || Source.new)
+  end
+  
+# Creates a new Humanizer which uses the interpolater, compiler and source of this Humanizer unless other values for them were specified.
+# @see #initialize
+  def renew(components)
+    self.class.new({:interpolater=>@interpolater,:compiler=>@compiler,:source=>@source}.update(components))
+  end
+  
+# Creates a String from the input. This will be the most used method in application code.
+# It expects a {Scope} as argument. Anything that is not a {Scope} will be converted into a {Scope} using the "_"-method.
+# This enables you to pass any object to this method. The result is mainly determined by result of the "_"-method.
+# For 
+#
+# @param [Scope, #_, Object] *args
+# @return [String]
+  def [](*args)
+    it = args._
+    
+    vars = it.variables
+    default = it.default
+    result = @source.get(it, default)
+    result = default unless result.kind_of? String
+    if result.kind_of? String
+      return interpolate(result,vars)
+    elsif default.__id__ != result.__id__
+      warn "[] should be only used for strings. For anything else use get."
+    end
+    return result
+  end
+
+# This is a wrapper for @source.get.
+# The only thing it does additionally is converting all params into a Scope.
+# @see Source#get
+  def get(base,*rest)
+    it = base._(*rest)
+    return @source.get(it, it.default)
+  end
+
+# Stores a translation
+  def []=(it, *rest)
+    last = rest.pop
+    @source.store(it._(*rest).first,last)
+  end
+  
+# This is an alias for @source.package
+# @see Source#package
+  def package(*args,&block)
+    @source.package(*args,&block)
+  end
+  
+# This is an alias for @source.load
+# @see Source#load
+  def load(*args,&block)
+    @source.load(*args,&block)
+  end
+  
+# This is an alias for @source.<<
+# @see Source#<<
+  def <<(x)
+    @source << x
+  end
+  
+  def interpolate(str,vars={})
+    @compiler.compile(str).call(self,@interpolater,vars)
+  end
+  
+end
+end

data/lib/humanized/interpolation/conjunctions.rb

@@ -0,0 +1,34 @@
+# -*- encoding : utf-8 -*-
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the Affero GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+#    (c) 2011 by Hannes Georg
+#
+module Humanized
+  
+module Conjunctions
+  
+  def and(humanizer, *args)
+    args = args.flatten
+    last = args.pop
+    return [args.join(', '), last].join(' '+humanizer[:and]+' ')
+  end
+  
+  def or(humanizer, *args)
+    args = args.flatten
+    last = args.pop
+    return [args.join(', '), last].join(' '+humanizer[:or]+' ')
+  end
+  
+end
+end

data/lib/humanized/interpolation/date.rb

@@ -0,0 +1,36 @@
+# -*- encoding : utf-8 -*-
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the Affero GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+#    (c) 2011 by Hannes Georg
+#
+
+module Humanized
+module Date
+  
+  def date(humanizer, date, format = 'default')
+    if format == 'default'
+      it = date._(:format,:default)
+    else
+      it = date._.format( format._ | :default._ )
+    end
+    f = humanizer.get(it)
+    if f.kind_of? String
+      return date.strftime( f )
+    end
+    warn 'Unable to find Date format: #{it.inspect}.'
+    return ''
+  end
+  
+end
+end

data/lib/humanized/interpolation/english.rb

@@ -0,0 +1,83 @@
+# -*- encoding : utf-8 -*-
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the Affero GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+#    (c) 2011 by Hannes Georg
+#
+require 'humanized/interpolation/kng.rb'
+module Humanized
+module English
+  
+  module Articles
+    
+    def a(humanizer, *args)
+      Wrapper.wrap(args) do |t|
+        fs = first_sound(humanizer, t)
+        s = t.to_s
+        if( fs.nil? )
+          fs = guess_first_sound(s)
+        end
+        (fs == :vowel ? 'an' : 'a' ) + ' ' + s
+      end
+    end
+    
+    def the(humanizer, *args)
+      Wrapper.wrap(args) do |t|
+        'the ' + t.to_s
+      end
+    end
+    
+    def no(humanizer, *args)
+      Wrapper.wrap(args) do |t|
+        'no ' + t.to_s
+      end
+    end
+    
+    def some(humanizer, *args)
+      Wrapper.wrap(args) do |t|
+        'some ' + t.to_s
+      end
+    end
+    
+  protected
+    def first_sound(humanizer, x)
+      return humanizer.get( x._(:first_sound) )
+    end
+    
+    def guess_first_sound(s)
+      return :consonant
+    end
+    
+  end
+  
+  include KNG
+  include Articles
+  
+  KASUS = [
+    'nominativ'.freeze,
+    'genitiv'.freeze
+  ].freeze
+  
+  NUMERUS = [
+    'singular'.freeze,
+    'plural'.freeze
+  ].freeze
+  
+  GENUS = [
+    'neutral'.freeze,
+    'male'.freeze,
+    'female'.freeze
+  ].freeze
+  
+end
+end

data/lib/humanized/interpolation/german.rb

@@ -0,0 +1,74 @@
+# -*- encoding : utf-8 -*-
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the Affero GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+#    (c) 2011 by Hannes Georg
+#
+require 'humanized/interpolation/kng.rb'
+module Humanized
+module German
+  
+  module Articles
+    
+    ArticleScope = Scope::Meta.articles
+    
+    def a(humanizer, *args)
+      Wrapper.wrap(args) do |t|
+        humanizer[ArticleScope.indefinite.optionally(x_to_genus(humanizer, t))._(x_to_numerus(humanizer, t), x_to_kasus(humanizer, t))] + ' ' + t.to_s
+      end
+    end
+    
+    def the(humanizer, *args)
+      Wrapper.wrap(args) do |t|
+        humanizer[ArticleScope.definite.optionally(x_to_genus(humanizer, t))._(x_to_numerus(humanizer, t), x_to_kasus(humanizer, t))] + ' ' + t.to_s
+      end
+    end
+    
+    def some(humanizer, *args)
+      Wrapper.wrap(args) do |t|
+        humanizer[ArticleScope.partitive.optionally(x_to_genus(humanizer, t))._(x_to_numerus(humanizer, t), x_to_kasus(humanizer, t))] + ' ' + t.to_s
+      end
+    end
+    
+    def none(humanizer, *args)
+      Wrapper.wrap(args) do |t|
+        humanizer[ArticleScope.negative.optionally(x_to_genus(humanizer, t))._(x_to_numerus(humanizer, t), x_to_kasus(humanizer, t))] + ' ' + t.to_s
+      end
+    end
+    
+  end
+  
+  include Articles
+  
+  include KNG
+  
+  KASUS = [
+    'nominativ'.freeze,
+    'genitiv'.freeze,
+    'dativ'.freeze,
+    'akkusativ'.freeze
+  ].freeze
+  
+  NUMERUS = [
+    'singular'.freeze,
+    'plural'.freeze
+  ].freeze
+  
+  GENUS = [
+    'neutral'.freeze,
+    'male'.freeze,
+    'female'.freeze
+  ].freeze
+  
+end
+end

data/lib/humanized/interpolation/kng.rb

@@ -0,0 +1,217 @@
+# -*- encoding : utf-8 -*-
+#    This program is free software: you can redistribute it and/or modify
+#    it under the terms of the Affero GNU General Public License as published by
+#    the Free Software Foundation, either version 3 of the License, or
+#    (at your option) any later version.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+#    (c) 2011 by Hannes Georg
+#
+require 'set'
+require 'abbrev'
+require 'facets/kernel/meta_class.rb'
+require "humanized/interpolation/conjunctions"
+require 'humanized/wrapper'
+module Humanized
+  
+module KNG
+  
+  class KNGWrapper < Humanized::Wrapper
+
+    attr_reader :kng_kasus, :kng_numerus, :kng_genus
+
+    def initialize(object, humanizer, kasus, numerus, genus=nil)
+      @kng_kasus = kasus
+      @kng_numerus = numerus
+      @kng_genus = genus
+      @kng_humanizer = humanizer
+      self.__setobj__(object)
+    end
+    
+    def self.wrap(args, *rest)
+      a = args.flatten.map{|o|
+        self.new(o,*rest)
+      }
+      return a.size == 1 ? a[0] : a
+    end
+    
+    def to_s
+      if @kng_genus
+        return @kng_humanizer[__getobj__._.optionally(@kng_genus)._(@kng_numerus, @kng_kasus)]
+      else
+        return @kng_humanizer[__getobj__._(@kng_numerus, @kng_kasus)]
+      end
+    end
+    
+  end
+  
+  def g(humanizer, genus, *args)
+    if args.size == 3
+      # male, female, neutral
+      genus = x_to_genus(humanizer, genus)
+      a = [:male,:female,:neutral].zip(args)
+      if genus.kind_of? Set
+        return genus.map{|g| a.assoc(g)[1] }
+      end
+      return a.assoc(genus)[1]
+    end
+  end
+  
+  def n(humanizer, numerus, *args)
+    if args.size == 2
+      # singular, plural
+      return args[ x_to_numerus(humanizer, numerus) == :singular ? 0 : 1 ]
+    elsif args.size == 1
+      return KNGWrapper.wrap(args, humanizer, meta_class.const_get(:KASUS).first.to_sym, x_to_numerus(humanizer, numerus))
+    end
+  end
+  
+  def kn(humanizer, kasus, numerus, *args)
+    if args.size == 2
+      # singular, plural
+      return args[ x_to_numerus(humanizer, numerus) == :singular ? 0 : 1 ]
+    elsif args.size == 1
+      return KNGWrapper.wrap(args, humanizer, x_to_kasus(humanizer, kasus), x_to_numerus(humanizer, numerus))
+    end
+  end
+  
+  
+  def kng(humanizer, kasus, numerus, genus,*args)
+    if args.size == 2
+      # singular, plural
+      return args[ x_to_numerus(humanizer, numerus) == :singular ? 0 : 1 ]
+    elsif args.size == 1
+      return KNGWrapper.wrap(args, humanizer, x_to_kasus(humanizer, kasus), x_to_numerus(humanizer, numerus), x_to_genus(humanizer, genus))
+    end
+  end
+  
+  def kongruent(humanizer, from, *args)
+    return KNGWrapper.wrap(args, humanizer, x_to_kasus(humanizer, from), x_to_numerus(humanizer, from), x_to_genus(humanizer, from))
+  end
+  
+protected
+
+  def abbrev_kasus
+    return @abbrev_kasus if @abbrev_kasus
+    @abbrev_kasus ||= Hash[*meta_class.const_get(:KASUS).abbrev.map{|(a,b)| [a,b.to_sym]}.flatten(1)]
+    @abbrev_kasus.default = meta_class.const_get(:KASUS).first.to_sym
+    return @abbrev_kasus
+  end
+  
+  def abbrev_numerus
+    return @abbrev_numerus if @abbrev_numerus
+    @abbrev_numerus ||= Hash[*meta_class.const_get(:NUMERUS).abbrev.map{|(a,b)| [a,b.to_sym]}.flatten(1)]
+    @abbrev_numerus.default = meta_class.const_get(:NUMERUS).first.to_sym
+    return @abbrev_numerus
+  end
+  
+  def abbrev_genus
+    return @abbrev_genus if @abbrev_genus
+    @abbrev_genus ||= Hash[*meta_class.const_get(:GENUS).abbrev.map{|(a,b)| [a,b.to_sym]}.flatten(1)]
+    @abbrev_genus.default = meta_class.const_get(:GENUS).first.to_sym
+    return @abbrev_genus
+  end
+  
+  def merge_genus(a,b)
+    if a.kind_of? Set
+      if b.kind_of? Set
+        return a + b
+      else
+        return a + [b]
+      end
+    else
+      if b.kind_of? Set
+        return b + [a]
+      else
+        return Set.new([a,b])
+      end
+    end
+  end
+  
+  def x_to_genus(humanizer, x)
+    if x.respond_to? :kng_genus
+      return x.kng_genus if x.kng_genus
+    end
+    if x.kind_of? HasNaturalGenus
+      return x.genus
+    end
+    if x.kind_of? Array
+      # TODO: this is inefficient...
+      # IDEA 1: plug in something like Array.of(...)
+      s = Set.new
+      x.each do |o|
+        s = merge_genus( s, x_to_genus(humanizer, o) )
+        if s.size == 3
+          break
+        end
+      end
+      return s
+    end
+    if x.kind_of? String
+      return abbrev_genus[x]
+    end
+    genus = humanizer.get(x._(:genus))
+    if genus.kind_of? Symbol
+      return genus
+    else
+      return :neutral
+    end
+  end
+
+  def x_to_kasus(humanizer, x)
+    if x.respond_to? :kng_kasus
+      return x.kng_kasus
+    end
+    i = x.to_i
+    c = meta_class.const_get :KASUS
+    if i > 0 and i <= c.size
+      return c[i-1].to_sym
+    end
+    return abbrev_kasus[x]
+  end
+
+  def x_to_numerus(humanizer, x)
+    if x.respond_to? :kng_numerus
+      return x.kng_numerus
+    end
+    # seriously: this sucks!
+    i = x_to_i(humanizer, x)
+    if i.nil? and x.kind_of? String
+      return abbrev_numerus[x]
+    end
+    if i
+      if i == 1
+        return :singular
+      else
+        return :plural
+      end
+    end
+    numerus = humanizer.get(x._(:numerus))
+    if numerus.kind_of? Symbol
+      return numerus
+    else
+      return :singular
+    end
+  end
+  
+  def x_to_i(humanizer, x)
+    return nil if x.kind_of?(String) and x !~ /\d+/
+    unless x.respond_to? :to_i
+      unless x.respond_to?(:size)
+        return nil
+      end
+      return x.size
+    end
+    return x.to_i
+  end
+  
+end
+  
+end