Class: Bukovina::Parsers::NickName

Inherits:
Object
  • Object
show all
Defined in:
lib/bukovina/parsers/nickname.rb

Constant Summary collapse

Parsers = 
Bukovina::Parsers
RE =

RE = /(вид.)?(#STATES.keys.join(‘|’))?(?:UPCHAR”>s*)([#CHARDOWNCHAR”>s]+)?(?:s*()s*)?/

/()?
()?
\s*
([#{Parsers::UPCHAR}][#{Parsers::CHAR}#{Parsers::ACCENT}\s‑]*)?
(?:\s*([,()\/\-])\s*|\z)/x

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#errors ⇒ Object (readonly)

Returns the value of attribute errors.



2
3
4
 
# File 'lib/bukovina/parsers/nickname.rb', line 2

def errors
  @errors
end

Instance Method Details

#parse(name) ⇒ Object

вход: значение поля “имя” включая словарь разных языков выход: обработанный словарь данных



15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/bukovina/parsers/nickname.rb', line 15

def parse name
# TODO skip return if errors found
#
res =
case name
when Hash
   names = name.to_a.map do |(alphabeth_code, nameline)|
      if ! Parsers::MATCH_TABLE.has_key?( alphabeth_code.to_sym )
         raise Parsers::BukovinaInvalidLanguageError,
            "Invalid alphabeth '#{alphabeth_code}' specified" ; end

      if nameline
         parse_line nameline, alphabeth_code
      else
         raise Parsers::BukovinaNullNameLine, "Null name line #{name.inspect}" +
               " for the alphabeth #{alphabeth_code}" ; end ; end


   # remove enumerator error
   @errors.select! { |x| !x.is_a?( Parsers::BukovinaInvalidEnumeratorError ) }

   mn = names[0][ :memory_names ].select do |x|
      !x[ :name ].has_key?( :bond_to )
      end.map.with_index do |x, i|
      x[ :name ].has_key?( :text ) && x ||
         (sel = names[ 1..-1 ].select do |y|
            y[ :memory_names ][ i ]&.[]( :name )&.has_key?( :text ) ; end
         sel.first&.[]( :memory_names )&.[]( i ) || x) ; end

   invalid_index = names[1..-1].any? do |ns|
      size = ns[ :memory_names ].reduce(0) do |s, x|
         x[ :name ].has_key?( :bond_to ) && s || s + 1 ; end
      size != mn.size ; end

   if invalid_index
      raise Parsers::BukovinaIndexError, "#{$!}: for name #{name}" ; end

   names[1..-1].each do |ns|
      ns[ :names ].each.with_index do |n, i|
         has_name =
         names[ 0 ][ :names ].select.with_index do |x, j|
            j % names[ 0 ][ :memory_names ].size == i &&
               x.has_key?( :text ) ; end

         if ! has_name.empty?
            n[ :bind_kind ] = 'переводное'
            n[ :bond_to ] = has_name.first
         elsif mn[ i ] && mn[ i ][ :names ] && mn[ i ][ :names ] != n
            #binding.pry
            n[ :bind_kind ] = 'прилаженое'
            n[ :bond_to ] = mn[ i ][ :names ] ; end
         names[ 0 ][ :names ] << n ; end

      ns[ :memory_names ].each.with_index do |mn, i|
         if mn[ :name ].has_key?( :text )
            if names[ 0 ][ :memory_names ][ i ].present?
               if ! names[ 0 ][ :memory_names ][ i ][ :name ].has_key?( :text )
                  names[ 0 ][ :memory_names ][ i ][ :name ] = mn[ :name ] ;end
               ;end;end;end;end
#         binding.pry
#         rescue TypeError
#            raise BukovinaTypeError, "#{$!}: for name #{name}"
=begin

   names.each do |name_dup|
      dupes = name_dup.map { |n| n[ :text ] }.compact
      name_dup.each do |name|
         name[ :dupes ] = dupes - [ name[ :text] ] ; end ; end

   # detect empty text names
   empty = names.any? { |name_dup| name_dup.all? { |n| n[ :text ] } }
   if empty
      raise BukovinaEmptyRecord, "Empty record found for the names "
            "hash: #{name.inspect}" ; end
=end

   names[ 0 ][ :names ].delete_if { |n| !n[ :text ] }
   names[ 0 ][ :memory_names ].delete_if do |n|
      n[ :name ].has_key?( :bond_to ) ; end
#         binding.pry
   names[ 0 ]

when String
   names = parse_line( name )
   names[ :names ]&.delete_if { |n| !n[ :text ] }
   names[ :memory_names ].delete_if { |n| n[ :name ].has_key?( :bond_to ) }
   names

when NilClass
else
   raise Parsers::BukovinaInvalidClass, "Invalid class #{name.class} " +
         "for Name line '#{name}'" ; end

@errors.empty? && res || nil

   rescue Parsers::BukovinaError => e
@errors << e
nil ; end