Module: Pred

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

Constant Summary collapse

VERSION = 
"0.1.1"

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



95
96
97
98
99
 
# File 'lib/pred.rb', line 95

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

.decrement_char(ch) ⇒ Object 



101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
 
# File 'lib/pred.rb', line 101

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 



181
182
183
184
185
186
187
188
189
 
# File 'lib/pred.rb', line 181

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)
  return str[0..-2] + dec(str[-1]) if lone_bottom?(str)
  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) ⇒ Boolean

‘a’.pred etc broken

Returns:

  • (Boolean) 


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

def self.lone_bottom?(str)  # 'a'.pred  etc broken
  while !letter_digit?(str[-1])
    str = str[0..-2]
    return false if str.empty?
  end
  if "aA0".include? str[-1]
    return true unless decrements?(str[0..-2])
  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 



120
121
122
123
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
 
# File 'lib/pred.rb', line 120

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