babelfish-ruby 1.0.1

data/lib/babelfish/phrase/compiler.rb

@@ -0,0 +1,70 @@
+# -*- encoding : utf-8 -*-
+require 'babelfish/phrase/literal'
+require 'babelfish/phrase/variable'
+require 'babelfish/phrase/plural_forms'
+
+class Babelfish
+    module Phrase
+        # Babelfish AST Compiler.
+        # Compiles AST to string or to Proc.
+        class Compiler
+            attr_accessor :ast
+
+            def initialize( ast = nil )
+                init( ast )  unless ast.nil?
+            end
+
+            # Initializes compiler. Should not be called directly.
+            def init( ast )
+                self.ast = ast
+            end
+
+            # Throws given message in compiler context.
+            def throw( message )
+                raise "Cannot compile: #{message}";
+            end
+
+            # Compiles AST.
+
+            # Result is string when possible; Proc otherwise.
+            def compile ( ast )
+                init( ast )  unless ast.nil?
+
+                throw("No AST given")  if ast.nil?
+                throw("Empty AST given")  if ast.length == 0;
+
+                if ast.length == 1 && ast.first.kind_of?(Babelfish::Phrase::Literal)
+                    #  просто строка
+                    return ast.first.text
+                end
+
+                ready = ast.map do |node|
+                    case node
+                    when Babelfish::Phrase::Literal
+                        node.text
+                    when Babelfish::Phrase::Variable
+                        node
+                    when Babelfish::Phrase::PluralForms
+                        sub = node.to_ruby_method
+                    else
+                        throw("Unknown AST node: #{node}")
+                    end
+                end
+
+                lambda do |params|
+                    data = ready.map do |what|
+                        case what
+                        when Babelfish::Phrase::Variable
+                            params[what.name.to_s].to_s
+                        when Proc
+                            what = what.call(params)
+                        else
+                            what
+                        end
+                    end.join('')
+                    data
+                end
+            end
+        end
+    end
+end

data/lib/babelfish/phrase/literal.rb

@@ -0,0 +1,12 @@
+# -*- encoding : utf-8 -*-
+require 'babelfish/phrase/node'
+
+class Babelfish
+    module Phrase
+        # Babelfish AST Literal node.
+        class Literal < Node
+
+            attr_accessor :text
+        end
+    end
+end

data/lib/babelfish/phrase/node.rb

@@ -0,0 +1,14 @@
+# -*- encoding : utf-8 -*-
+class Babelfish
+    module Phrase
+        # Babelfish AST abstract node.
+        class Node
+
+            def initialize( args = {} )
+                args.keys.each do |key|
+                    send("#{key}=", args[key])  if respond_to?("#{key}=")
+                end
+            end
+        end
+    end
+end

data/lib/babelfish/phrase/parser.rb

@@ -0,0 +1,173 @@
+# -*- encoding : utf-8 -*-
+require 'babelfish/phrase/parser_base'
+require 'babelfish/phrase/literal'
+require 'babelfish/phrase/variable'
+require 'babelfish/phrase/plural_forms'
+require 'babelfish/phrase/plural_forms_parser'
+
+class Babelfish
+    module Phrase
+        # Babelfish syntax parser.
+        class Parser < ParserBase
+
+            attr_accessor :locale, :mode, :pieces, :escape, :pf0
+
+            LITERAL_MODE  = 'Literal'.freeze
+            VARIABLE_MODE = 'Variable'.freeze
+            PLURALS_MODE  = 'Plurals'.freeze
+            VARIABLE_RE   = /^[a-zA-Z0-9_\.]+$/
+
+            AST_MAP = {
+                LITERAL_MODE  => Babelfish::Phrase::Literal,
+                VARIABLE_MODE => Babelfish::Phrase::Variable,
+                PLURALS_MODE  => Babelfish::Phrase::PluralForms,
+            }
+
+            # Instantiates parser.
+            def initialize( phrase = nil, locale = nil )
+                super( phrase )
+                init( phrase )  unless phrase.nil?
+                self.locale = locale  if locale
+            end
+
+            # Initializes parser. Should not be called directly.
+            def init( phrase )
+                super( phrase )
+                self.mode = LITERAL_MODE
+                self.pieces = []
+                self.pf0 = nil # plural forms without name yet
+            end
+
+            # Finalizes all operations after phrase end.
+            def finalize_mode
+                case mode
+                when LITERAL_MODE
+                    pieces.push( AST_MAP[LITERAL_MODE].new( text: piece ) ) if !piece.empty? || pieces.size == 0;
+                when VARIABLE_MODE
+                    throw( "Variable definition not ended with \"}\": " + piece )
+                when PLURALS_MODE
+                    throw( "Plural forms definition not ended with \"))\": " + piece )  if pf0.nil?
+                    pieces.push( AST_MAP[PLURALS_MODE].new( forms: pf0, name: piece, locale: locale ) )
+                else
+                    throw( "Logic broken, unknown parser mode: " + mode );
+                end
+            end
+
+            class << self
+                attr_accessor :plurals_parser
+            end
+
+            def plurals_parser
+                Parser.plurals_parser ||= Babelfish::Phrase::PluralFormsParser.new
+            end
+
+            def escape?
+                !! self.escape
+            end
+
+            # Parses specified phrase.
+            def parse( phrase = nil, locale = nil )
+                super( phrase )
+                self.locale = locale  unless locale.nil?
+
+                while true
+                    _char = to_next_char
+
+                    if _char.empty?
+                        finalize_mode
+                        return pieces
+                    end
+
+                    case mode
+                    when LITERAL_MODE
+                        if escape?
+                            add_to_piece( _char )
+                            self.escape = false
+                            next
+                        end
+
+                        if _char == "\\"
+                            self.escape = true
+                            next
+                        end
+
+                        if _char == '#' && next_char == '{'
+                            unless piece.empty?
+                                pieces.push( AST_MAP[LITERAL_MODE].new( text: piece ) )
+                                self.piece = ''
+                            end
+                            self.to_next_char # skip "{"
+                            self.mode = VARIABLE_MODE
+                            next
+                        end
+
+                        if _char == '(' && next_char == '('
+                            unless piece.empty?
+                                pieces.push( AST_MAP[LITERAL_MODE].new( text: piece ) )
+                                self.piece = ''
+                            end
+                            to_next_char # skip second "("
+                            self.mode = PLURALS_MODE
+                            next
+                        end
+
+                    when VARIABLE_MODE
+                        if escape?
+                            add_to_piece( _char )
+                            self.escape = false
+                            next
+                        end
+
+                        if _char == "\\"
+                            self.escape = true
+                            next
+                        end
+
+                        if _char == '}'
+                            name = piece.strip
+                            if name.empty?
+                                throw( "No variable name given." );
+                            end
+                            if name !~ VARIABLE_RE
+                                throw( "Variable name doesn't meet conditions: #{name}." );
+                            end
+                            pieces.push( AST_MAP[VARIABLE_MODE].new( name: name ) )
+                            self.piece = ''
+                            self.mode = LITERAL_MODE
+                            next
+                        end
+
+                    when PLURALS_MODE
+                        unless pf0.nil?
+                            if _char =~ VARIABLE_RE && (_char != '.' || next_char =~ VARIABLE_RE)
+                                add_to_piece( _char )
+                                next
+                            else
+                                pieces.push( AST_MAP[PLURALS_MODE].new( forms: pf0, name: piece, locale:locale ) )
+                                self.pf0 = nil
+                                self.mode = LITERAL_MODE
+                                self.piece = ''
+                                backward
+                                next
+                            end
+                        end
+                        if _char == ')' && next_char == ')'
+                            self.pf0 = plurals_parser.parse( piece )
+                            self.piece = ''
+                            to_next_char # skip second ")"
+                            if next_char == ':'
+                                to_next_char # skip ":"
+                                next
+                            end
+                            pieces.push( AST_MAP[PLURALS_MODE].new( forms: pf0, name: 'count', locale: locale ) )
+                            self.pf0 = nil
+                            self.mode = LITERAL_MODE
+                            next
+                        end
+                    end
+                    add_to_piece( _char )
+                end # while ( 1 )
+            end
+        end
+    end
+end

data/lib/babelfish/phrase/parser_base.rb

@@ -0,0 +1,73 @@
+# -*- encoding : utf-8 -*-
+class Babelfish
+    module Phrase
+        # Babelfish abstract parser.
+        class ParserBase
+            attr_accessor :phrase, :index, :length, :prev, :piece, :escape
+
+
+            def initialize(phrase = nil)
+                init(phrase)  if phrase
+            end
+
+            def init(phrase)
+                self.phrase = phrase
+                self.index = -1
+                self.prev = nil
+                self.length = phrase.length
+                self.piece = ''
+                self.escape = false
+            end
+
+            # Gets character on current cursor position.
+            # Will return empty string if no character.
+            def char
+                r = phrase[ index ]
+                r.nil? ? '' : r
+            end
+
+            # Gets character on next cursor position.
+            # Will return empty string if no character.
+            def next_char
+                return ''  if index >= length - 1
+                r = phrase[ index + 1 ]
+                r.nil? ? '' : r
+            end
+
+            # Moves cursor to next position.
+            # Return new current character.
+            def to_next_char
+                self.prev = char  if self.index >= 0
+                self.index =  self.index + 1
+                return ''  if self.index == length
+                char()
+            end
+
+            # Throws given message in phrase context.
+            def throw( message )
+                raise "Cannot parse phrase \""+ ( phrase || 'nil' )+ "\" at ". ( index || '-1' )+ " index: #{message}"
+            end
+
+            # Adds given chars to current piece.
+            def add_to_piece(chars)
+                self.piece += chars
+            end
+
+            # Moves cursor backward.
+            def backward
+                self.index = index - 1
+                if index > 0
+                    r = phrase[ index - 1 ]
+                    self.prev = r.nil? ? '' : r
+                end
+            end
+
+            # Parses specified phrase.
+            def parse( phrase = nil )
+                init(phrase)  unless phrase.nil?
+                throw( "No phrase given" )  if phrase.nil?
+                phrase
+            end
+        end
+    end
+end

data/lib/babelfish/phrase/plural_forms.rb

@@ -0,0 +1,65 @@
+# -*- encoding : utf-8 -*-
+require 'babelfish/phrase/node'
+require 'babelfish/phrase/pluralizer'
+require 'babelfish/phrase/compiler'
+
+class Babelfish
+    module Phrase
+        # Babelfish AST pluralization node.
+        class PluralForms < Node
+
+            class << self
+                attr_accessor :sub_data, :compiler
+
+            end
+
+            PluralForms.sub_data = []
+
+            attr_accessor :forms, :name, :compiled, :locale
+
+            def to_ruby_method
+                unless compiled
+                    PluralForms.compiler ||= Babelfish::Phrase::Compiler.new
+                    forms[:regular].map! do |form|
+                        PluralForms.compiler.compile( form )
+                    end
+                    new_strict = {}
+                    forms[:strict].each_pair do |key, form|
+                        new_strict[key] = PluralForms.compiler.compile( form )
+                    end
+                    forms[:strict].replace(new_strict)
+                    self.compiled = true
+                end
+
+                rule = Babelfish::Phrase::Pluralizer::find_rule( locale )
+
+                PluralForms.sub_data << [
+                    rule,
+                    forms[:strict],
+                    forms[:regular],
+                ]
+
+                return _to_ruby_method( name, PluralForms.sub_data.length - 1 );
+            end
+
+            def _to_ruby_method( name, index )
+                lambda do |params|
+                    value = params[name].to_f
+                    rule, strict_forms, regular_forms = PluralForms.sub_data[index]
+                    r = nil
+                    if value.nan?
+                        warn "#{name} parameter is not numeric"
+                        r = regular_forms[-1]
+                    else
+                        r = strict_forms[value] || regular_forms[rule.call(value)] || regular_forms[-1];
+                    end
+                    return r  if r.kind_of?(String)
+                    return ''  if r.nil?
+                    r.call(params)
+                end
+
+            end
+
+        end
+    end
+end

data/lib/babelfish/phrase/plural_forms_parser.rb

@@ -0,0 +1,64 @@
+# -*- encoding : utf-8 -*-
+require 'babelfish/phrase/plural_forms'
+
+class Babelfish
+    module Phrase
+        # Babelfish plurals syntax parser.
+
+        # Returns { script_forms: {}, regular_forms: [] }
+
+        # Every plural form represented as AST.
+
+        class PluralFormsParser
+            attr_accessor :phrase, :strict_forms, :regular_forms
+
+            class << self
+                attr_accessor :phrase_parser
+            end
+
+            def phrase_parser
+                PluralFormsParser.phrase_parser ||= Babelfish::Phrase::Parser.new
+            end
+
+
+            # Instantiates parser.
+            def initialize( phrase = nil )
+                init( phrase )  unless phrase.nil?
+            end
+
+            # Initializes parser. Should not be called directly.
+            def init( phrase )
+                self.phrase = phrase
+                self.regular_forms = []
+                self.strict_forms = {}
+            end
+
+            # Parses specified phrase.
+            def parse( phrase )
+                init( $phrase )  unless phrase.nil?
+
+                # тут проще регуляркой
+                forms = phrase.split( /(?<!\\)\|/ )
+
+                forms.each do |form|
+                    value = nil
+                    if form =~ /^=([0-9]+)\s*(.+)$/
+                        value, form = $1, $2
+                    end
+                    form = phrase_parser.parse( form )
+
+                    if value.nil?
+                        regular_forms.push form
+                    else
+                        strict_forms[value] = form
+                    end
+                end
+
+                return {
+                    strict:  strict_forms,
+                    regular: regular_forms,
+                }
+            end
+        end
+    end
+end