Class: Cldr::Export::Data::Plurals::Rule

Inherits:
Array
  • Object
show all
Defined in:
lib/cldr/export/data/plurals/rules.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(locales) ⇒ Rule

Returns a new instance of Rule.



96
97
98
 
# File 'lib/cldr/export/data/plurals/rules.rb', line 96

def initialize(locales)
  @locales = locales.map { |locale| locale.gsub('_', '-').to_sym }
end

Instance Attribute Details

#locales ⇒ Object (readonly)

Returns the value of attribute locales.



94
95
96
 
# File 'lib/cldr/export/data/plurals/rules.rb', line 94

def locales
  @locales
end

Class Method Details

.parse(code) ⇒ Object 



59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/cldr/export/data/plurals/rules.rb', line 59

def parse(code)
  code = scrub_code(code)

  code = code.split('@').first.to_s
  operand = /(n|i|f|t|v|w)/i
  expr = /#{operand}(?:\s+(?:mod|%)\s+([\d]+))?/i
  range = /(?:\d+\.\.\d+|\d+)/i
  range_list = /(#{range}(?:\s*,\s*#{range})*)/i
  case code
  when /or/i
    code.split(/or/i).inject(Proposition.new('||')) { |rule, code| rule << parse(code) }
  when /and/i
    code.split(/and/i).inject(Proposition.new('&&')) { |rule, code| rule << parse(code) }
  when /^\s*#{expr}\s+(?:is(\s+not)?|(not\s+)?in|(!)?=)\s+#{range_list}\s*$/i
    list = parse_list($6)
    Expression.new((list.first.count == 1 && list.last.count == 0) ? :is : :in, $2, !($3.nil? && $4.nil? && $5.nil?), (list.first.count == 1 && list.last.count == 0) ? list.first.first : list, $1)
  when /^\s*#{expr}\s+(not\s+)?within\s+#{range_list}\s*$/i
    Expression.new(:within, $2, !($3==nil), parse_list($4).last.first, $1)
  when /^\s*$/
    Expression.new
  else
    raise "can not parse '#{code}'"
  end
end

.parse_list(str) ⇒ Object 



45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/cldr/export/data/plurals/rules.rb', line 45

def parse_list(str)
  values = []
  ranges = []
  str.split(',').each do |value|
    parts = value.split('..')
    if parts.count == 1
      values << value.to_i
    else
      ranges << (parts.first.to_i..parts.last.to_i)
    end
  end
  [values, ranges]
end

Instance Method Details

#keys ⇒ Object 



100
101
102
 
# File 'lib/cldr/export/data/plurals/rules.rb', line 100

def keys
  inject([]) { |keys, (key, code)| keys << key.to_sym }
end

#to_ruby ⇒ Object 



104
105
106
107
108
109
110
111
112
113
 
# File 'lib/cldr/export/data/plurals/rules.rb', line 104

def to_ruby
  @condition ||= 'lambda { |n| n = n.respond_to?(:abs) ? n.abs : ((m = n.to_s)[0] == "-" ? m[1,m.length] : m); ' + reverse.inject(':other') do |result, (key, code)|
    code = self.class.parse(code).to_ruby
    if code
      "#{code} ? :#{key} : #{result}"
    else
      ':' << key.to_s
    end
  end + ' }'
end