Class: Bukovina::Parsers::Name

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

Constant Summary collapse

Parsers = 
Bukovina::Parsers
STATES = 
{
   'в наречении' => :
RE =

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

/(вид\.)?
(#{STATES.keys.join('|').gsub(/\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/name.rb', line 2

def errors
  @errors
end

Instance Method Details

#parse(name) ⇒ Object

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



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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
 
# File 'lib/bukovina/parsers/name.rb', line 28

def parse name
# TODO skip return if errors found
#
res =
case name
when Hash
   name_list = 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 = name_list[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 = name_list[ 1..-1 ].select do |y|
            y[ :memory_names ][ i ]&.[]( :name )&.has_key?( :text ) ; end
         sel.first&.[]( :memory_names )&.[]( i ) || x) ; end

   invalid_index = name_list[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

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

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

      ns[ :memory_names ].each.with_index do |mn, i|
#            binding.pry
         if mn[ :name ].has_key?( :text )
            if name_list[ 0 ][ :memory_names ][ i ].present?
               if ! name_list[ 0 ][ :memory_names ][ i ][ :name ].has_key?( :text )
#            binding.pry
#                  Kernel.puts "*"*80
#                  Kernel.puts names[ 0 ].inspect
#                  Kernel.puts names[ 0 ][ :memory_names ].inspect
#                  Kernel.puts names[ 0 ][ :memory_names ][ i ].inspect
#                  Kernel.puts names[ 0 ][ :memory_names ][ i ]&.[]( :name ).inspect
#                  Kernel.puts names[ 0 ][ :memory_names ][ i ]&.[]( :name )&.has_key?( :text ).inspect
                  name_list[ 0 ][ :memory_names ][ i ][ :name ] = mn[ :name ] ;end
#                  else
#                     if 
#                     raise
               ;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

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

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

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