Module: Pred

Defined in:
lib/pred.rb,
lib/pred/version.rb

Constant Summary collapse

VERSION = 
"0.1.2"

Class Method Summary collapse

Class Method Details

.count_digit?(ch) ⇒ Boolean

deprecate this … not used anywhere

Returns:

  • (Boolean) 


29
30
31
 
# File 'lib/pred.rb', line 29

def self.count_digit?(ch)  # deprecate this ... not used anywhere
  ('0'..'9').cover? ch
end

.dec(ch) ⇒ Object

def self.inc(ch)

  (ch.ord+1).chr(Encoding::UTF_8)
end



99
100
101
102
103
 
# File 'lib/pred.rb', line 99

def self.dec(ch)
  ii = (ch.ord-1)
  ii = 0 if ii < 0
  (ii).chr(Encoding::UTF_8)
end

.decrement_char(ch) ⇒ Object 



105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/pred.rb', line 105

def self.decrement_char(ch)
  if upper?(ch)
    t = dec(ch)
    return [:done, t] if upper?(t)
    return [:borrow, 'Z', t, :upper? ]
  elsif lower?(ch)
    t = dec(ch)
    return [:done, t] if lower?(t)
    return [:borrow, 'z', t, :lower? ]
  elsif digit?(ch)
    t = dec(ch)
    return [:done, t] if digit?(t)
    return [:borrow, '9', t, :digit? ]
  else
    t = dec(ch)
    return [:ignore, t]
  end
end

.decrement_string(str, ref = {:mode=> :start, :rtn=> "" }) ⇒ Object 



185
186
187
188
189
190
191
192
193
194
195
 
# File 'lib/pred.rb', line 185

def self.decrement_string(str, ref={:mode=> :start, :rtn=> "" })
  return "" if str.empty?
  if str.length==1
    return "" if str.ord==0
  end
  return str[0..-2] + dec(str[-1]) unless decrements?(str)
  if lone_bottom?(str,rtn=[])
    return rtn.first      
  end
  return rcur_decrement_string(str, ref, str.length-1)     
end

.decrementals?(str) ⇒ Boolean

Returns:

  • (Boolean) 


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
 
# File 'lib/pred.rb', line 40

def self.decrementals?(str)
  last = str[-1]
  str = str[0..-2]
  mode = true
  if digit? last
    while !str.empty? do
      if mode
#          if last=='0'
#            if '1'==str[-1]  # we have the weird edge case
#              byebug
#              y = :not   # can't fix it here ... but stop and look around for fix
#            end
#          end
        return true if letter_digit?(str[-1])
        mode = false
      else
        if letter_digit?(str[-1])
          return digit? str[-1]
        end
      end
      str = str[0..-2]
    end
  elsif letter? last
    while !str.empty? do
      if mode
        return true if letter_digit?(str[-1])
        mode = false
      else
        if letter_digit?(str[-1])
          return letter? str[-1]
        end
      end
      str = str[0..-2]
    end
  else
    return decrementals?(str) unless str.empty?
  end
  return false
end

.decrements?(str) ⇒ Boolean

Returns:

  • (Boolean) 


33
34
35
36
37
38
 
# File 'lib/pred.rb', line 33

def self.decrements?(str)
  str.each_char do |ch|
    return true if letter_digit? ch
  end
  return false
end

.digit?(ch) ⇒ Boolean

Returns:

  • (Boolean) 


25
26
27
 
# File 'lib/pred.rb', line 25

def self.digit?(ch)
  ('0'..'9').cover? ch
end

.letter?(ch) ⇒ Boolean

Returns:

  • (Boolean) 


11
12
13
14
15
 
# File 'lib/pred.rb', line 11

def self.letter?(ch)
  return true if ('a'..'z').cover? ch
  return true if ('A'..'Z').cover? ch
  false
end

.letter_digit?(ch) ⇒ Boolean

Returns:

  • (Boolean) 


4
5
6
7
8
9
 
# File 'lib/pred.rb', line 4

def self.letter_digit?(ch)
  return true if ('a'..'z').cover? ch
  return true if ('A'..'Z').cover? ch
  return true if ('0'..'9').cover? ch
  false
end

.lone_bottom?(str, fix = []) ⇒ Boolean

‘a’.pred etc broken

Returns:

  • (Boolean) 


80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/pred.rb', line 80

def self.lone_bottom?(str, fix=[])  # 'a'.pred  etc broken
  fix[0]=str.dup
  while !letter_digit?(str[-1])
    str = str[0..-2]
    return false if str.empty?
  end
  if "aA0".include? str[-1]
    unless decrements?(str[0..-2])
      fix[0][str.length-1] = dec(str[-1])
      return true
    end
  end
  return false
end

.lower?(ch) ⇒ Boolean

Returns:

  • (Boolean) 


21
22
23
 
# File 'lib/pred.rb', line 21

def self.lower?(ch)
  ('a'..'z').cover? ch
end

.rcur_decrement_string(str, ref, pos) ⇒ Object 



124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
 
# File 'lib/pred.rb', line 124

def self.rcur_decrement_string(str, ref, pos)
  if pos < 0  # drop any pending stuff now even if borrow mode active
    return ref[:rtn].reverse
  end
  if ref[:mode] == :start
    rslt = decrement_char(str[pos])
    if rslt.first == :done
      ref[:rtn] += rslt[1]
      ref[:mode] = :done
      return rcur_decrement_string(str, ref, pos-1)
    elsif rslt.first == :borrow
      if decrementals? str[0..pos]
        ref[:mode] = :borrow
        ref[:rtn] += rslt[1]
      else  # drop one of the chars
        ref[:mode] = :done
      end
      return rcur_decrement_string(str, ref, pos-1)
    else
      if decrements? str[0..pos]
        ref[:rtn] += str[pos]
        ref[:mode] = :start
      else
        ref[:rtn] += rslt[1]
        ref[:mode] = :done
      end
      return rcur_decrement_string(str, ref, pos-1) 
    end
  elsif ref[:mode] == :done
    ref[:rtn] += str[pos]
    return rcur_decrement_string(str, ref, pos-1)
  elsif ref[:mode] == :borrow
    if letter_digit? str[pos]
      rslt = decrement_char(str[pos])
      if rslt.first == :done
#          if  (rslt[1]=='0')
#            byebug   # special edge case here ... nothing left to borrow if digit
#            y = :not
#          end          
        ref[:rtn] += rslt[1] unless (rslt[1]=='0')  # added this qualifier ...
        ref[:mode] = :done
        return rcur_decrement_string(str, ref, pos-1)
      elsif rslt.first == :borrow
        if decrementals? str[0..pos]
          ref[:mode] = :borrow
          ref[:rtn] += rslt[1]
        else  # drop one of the chars
          ref[:mode] = :done
        end
        return rcur_decrement_string(str, ref, pos-1)
      end
    else
      ref[:rtn] += str[pos]
    end 
    return rcur_decrement_string(str, ref, pos-1)   
  else
    ref[:rtn] += str[pos]
    return rcur_decrement_string(str, ref, pos-1)
  end
end

.upper?(ch) ⇒ Boolean

Returns:

  • (Boolean) 


17
18
19
 
# File 'lib/pred.rb', line 17

def self.upper?(ch)
  ('A'..'Z').cover? ch
end