Class: String::Mask

Inherits:
Object
  • Object
show all
Defined in:
lib/strmask.rb

Overview

Mask

– TODO: Probably need to create a proper #hash method. ++

Constant Summary collapse

VERSION =

Current version.

"0.3.2"
ESC =

Substitue (TODO: rename)

"\032"

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(string, re = nil) ⇒ Mask

Initialize new string mask.

Parameters:

  • string (String) —

    Any regular or masked string.

  • re (String) (defaults to: nil) —

    Single character string used to mark empty slots.



43
44
45
46
47
 
# File 'lib/strmask.rb', line 43

def initialize(string, re=nil)
  @to_str = string.dup
  @re     = re
  mask!(re) if re
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(s, *a, &b) ⇒ Object

Delegate any missing methods to underlying string.



255
256
257
258
259
260
261
 
# File 'lib/strmask.rb', line 255

def method_missing(s, *a, &b)
  begin
    to_str.send(s, *a, &b)
  rescue NoMethodError
    super(s, *a, &b)
  end
end

Class Method Details

.[](string, re = nil) ⇒ Object

New Mask.

Parameters:

  • string (String) —

    Any regular or masked string.

  • re (String) (defaults to: nil) —

    Single character string used to mark empty slots.



31
32
33
 
# File 'lib/strmask.rb', line 31

def self.[](string, re=nil)
  new(string, re)
end

Instance Method Details

#&(other) ⇒ Object

Mask AND. Only where they are then same filters through.

  "abc..123"      "ab..789."
& "ab..789."    | "abc..123"
  ----------      ----------
  "ab......"      "ab......"



169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
# File 'lib/strmask.rb', line 169

def &(other)
  other = convert(other)
  i = 0
  o = ''
  while i < to_str.size
    if (c = to_str[i,1]) == other[i,1]
      o << c
    else
      o << ESC
    end
    i += 1
  end
  self.class.new(o, @re)
end

#*(other) ⇒ Object

Mask XAND. Where the characters are the same, the result is the same, where they differ the result reflects the later.

  "abc..123"      "ab..789."
* "ab..789."    * "abc..123"
  ----------      ----------
  "ab..789."      "abc..123"



146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/strmask.rb', line 146

def *(other)
  other = convert(other)
  i = 0
  o = ''
  while i < to_str.size
    if (c = to_str[i,1]) == other[i,1]
      o << c
    else
      o << other[i,1]
    end
    i += 1
  end
  self.class.new(o, @re)
end

#+(other) ⇒ Object Also known as: |

Mask ADD. As long as there is a value other then empty the character filters though. The last to_str takes precedence.

  "abc..123"      "ab..789."
+ "ab..789."    + "abc..123"
  ----------      ----------
  "abc.7893"      "abc.7123"



119
120
121
122
123
124
125
126
127
128
129
130
131
132
 
# File 'lib/strmask.rb', line 119

def +(other)
  other = convert(other)
  i = 0
  o = ''
  while i < to_str.size
    if other[i,1] == ESC
      o << to_str[i,1]
    else
      o << other[i,1]
    end
    i += 1
  end
  self.class.new(o, @re)
end

#-(other) ⇒ Object

Mask subtraction. Where the characters are the same, the result is “empty”, where they differ the result reflects the last string.

  "abc..123"      "ab..789."
- "ab..789."    - "abc..123"
  ----------      ----------
  "....789."      "..c..123"



95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/strmask.rb', line 95

def -(other)
  other = convert(other)
  i = 0
  o = ''
  while i < to_str.size
    if to_str[i,1] == other[i,1]
      o << ESC
    else
      o << other[i,1]
    end
    i += 1
  end
  self.class.new(o, @re)
end

#==(other) ⇒ Object 



210
211
212
213
214
215
216
217
 
# File 'lib/strmask.rb', line 210

def ==(other)
  case other
  when Mask
    to_str == other.to_str
  else
    to_str == other.to_s
  end
end

#[](*a) ⇒ Object 



67
68
69
 
# File 'lib/strmask.rb', line 67

def [](*a)
  to_str[*a]
end

#^(other) ⇒ Object

Mask XOR operation. Only where there is an empty slot will the value filter.

  "abc..123"      "ab..789."
| "ab..789."    | "abc..123"
  ----------      ----------
  "..c.7..3"      "..c.7..3"



192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
 
# File 'lib/strmask.rb', line 192

def ^(other)
  other = convert(other)
  i = 0
  o = ''
  while i < to_str.size
    if to_str[i,1] == ESC
      o << other[i,1]
    elsif other[i,1] == ESC
      o << to_str[i,1]
    else
      o << ESC
    end
    i += 1
  end
  self.class.new(o, @re)
end

#apply(s = nil, *a, &b) ⇒ Object

Apply a method to the internal string and return a new mask.



221
222
223
224
225
226
227
228
229
 
# File 'lib/strmask.rb', line 221

def apply(s=nil, *a, &b)
  if s
    to_str.send(s,*a,&b).to_mask
  else
    @_self ||= Functor.new do |op, *a|
      to_str.send(op,*a).to_mask
    end
  end
end

#convert(other) ⇒ Object (private) 



265
266
267
268
269
270
271
272
 
# File 'lib/strmask.rb', line 265

def convert(other)
  case other
  when Mask
    other
  else
    self.class.new(other.to_s, @re)
  end
end

#inspect ⇒ Object 



62
63
64
 
# File 'lib/strmask.rb', line 62

def inspect
  @to_str.gsub(ESC, @re).inspect
end

#mask(re) ⇒ Object

Create a new mask with the same underlying string, but using a different empty slot.

Parameters:

  • re (String) —

    Single character string used to mark empty slots.



77
78
79
 
# File 'lib/strmask.rb', line 77

def mask(re)
  self.class.new(to_str,re)
end

#mask!(re) ⇒ Object 



82
83
84
 
# File 'lib/strmask.rb', line 82

def mask!(re)
  to_str.gsub!(re){ |s| ESC * s.size }
end

#replace(string) ⇒ Object 



232
233
234
 
# File 'lib/strmask.rb', line 232

def replace(string)
  @to_str = string.to_s
end

#to_s ⇒ Object

TODO: Should this use the escape character or not?



57
58
59
 
# File 'lib/strmask.rb', line 57

def to_s
  @to_str.gsub(ESC, @re)
end

#to_str ⇒ Object

The underlying string object.



52
53
54
 
# File 'lib/strmask.rb', line 52

def to_str
  @to_str
end