strmask 0.2.1

data/HISTORY

@@ -0,0 +1,10 @@
+= HISTORY
+
+== 1.0.0 / 2009-07-19
+
+This is the initial release of Mask.
+
+* 1 Major Enhancment
+
+    * Happy Birthday!
+

data/LICENSE

@@ -0,0 +1,23 @@
+The MIT License
+
+Copyright (c) 2009 Peter Vanbroekhoven & Thomas Sawyer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+

data/README.rdoc

@@ -0,0 +1,47 @@
+= String::Mask
+
+* home: http://rubyworks.github.com/strmask
+* work: http://github.com/rubyworks/strmask
+
+
+== DESCRIPTION
+
+Mask provides a string utility to manipulate strings
+in logicomathematical manner, ie. add, subtract, xor,
+etc.
+
+== SYNOPSIS
+
+Mask objects can be created explicitly via #new.
+
+  m1 = String::Mask.new("abc..123", '.')
+  m2 = String::Mask.new("ab..789.", '.')
+  m1 - m2                             #=> "....789."
+
+But the String#mask extension is much easier to use.
+
+  m1 = "abc..123".mask('.')
+  m2 = "ab..789.".mask('.')
+  m1 * m2                             #=> "ab..789."
+
+The second operand can be a normal String. Mask will assume
+it repesents another mask akin to the first.
+
+  "abc..123".mask('.') + "ab..789."   #=> "abc.7893"
+
+
+== HOW TO INSTALL
+
+To install with RubyGems simply open a console and type:
+
+  gem install mask
+
+
+== COPYRIGHT
+
+Copyright (c) 2009 Thomas Sawyer
+
+This program is ditributed unser the terms of the LGPL license.
+
+See the LICENSE or COPYING file for details.
+

data/lib/strmask.rb

@@ -0,0 +1,241 @@
+#require 'facets/functor'
+
+class String
+
+  # Create a mask.
+  def mask(re=nil)
+    Mask.new(self,re)
+  end
+
+  # = Mask
+  #
+  class Mask
+
+    ESC = "\032" # ASCII SUBSTITUTE
+
+    def self.[](string, re=nil)
+      new(string, re)
+    end
+
+  private
+
+    def initialize(string, re=nil)
+      @to_str = string.dup
+      mask!(re) if re
+    end
+
+    def convert(other)
+      case other
+      when Mask
+        other
+      else
+        self.class.new(other.to_s, re)
+      end
+    end
+
+  public
+
+    # The underlying string object.
+    def to_str
+      @to_str
+    end
+
+    #
+    def to_s
+      to_str
+    end
+
+    #
+    def inspect
+      to_str.inspect
+    end
+
+    #
+    def [](*a)
+      to_str[*a]
+    end
+
+    def mask(re)
+      self.class.new(to_str,re)
+    end
+
+    def mask!(re)
+      to_str.gsub!(re){ |s| ESC * s.size }
+    end
+
+    # 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"
+    #
+    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)
+    end
+
+    # 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"
+    #
+    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)
+    end
+
+    # Mask OR is the same as ADD.
+    alias_method :|, :+
+
+    # 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"
+    #
+    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)
+    end
+
+    # Mask AND. Only where they are
+    # then same filters through.
+    #
+    #     "abc..123"      "ab..789."
+    #   & "ab..789."    | "abc..123"
+    #     ----------      ----------
+    #     "ab......"      "ab......"
+    #
+    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)
+    end
+
+    # 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"
+    #
+    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)
+    end
+
+    #
+    def ==(other)
+      case other
+      when Mask
+        to_str == other.to_str
+      else
+        to_str == other.to_s
+      end
+    end
+
+    # Apply a method to the internal string and return
+    # a new mask.
+    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
+
+    #
+    def replace(string)
+      @to_str = string.to_s
+    end
+
+    #
+    #def instance_delegate
+    #  @to_str
+    #end
+
+    # Functor on the interal string.
+    #def self
+    #  @_self ||= Functor.new do |op, *a|
+    #    @to_str = @to_str.send(op, *a)
+    #  end
+    #end
+
+    # Delegate any missing methods to underlying string.
+    #
+    def method_missing(s, *a, &b)
+      begin
+        to_str.send(s, *a, &b)
+      rescue NoMethodError
+        super(s, *a, &b)
+      end
+    end
+
+  end
+
+end
+

data/meta/authors

@@ -0,0 +1 @@
+Thomas Sawyer

data/meta/collection

@@ -0,0 +1 @@
+rubyworks

data/meta/contact

@@ -0,0 +1 @@
+rubyworks-mailinglist@googlegroups.com

data/meta/created

@@ -0,0 +1 @@
+2009-07-19

data/meta/description

@@ -0,0 +1,3 @@
+String::Mask provides a kind-of string algebra
+useful for manipulating strings in in comparitive
+ways, eg. add, subtract, xor, etc.

data/meta/homepage

@@ -0,0 +1 @@
+http://rubyworks.github.com/strmask

data/meta/license

@@ -0,0 +1 @@
+MIT

data/meta/name

@@ -0,0 +1 @@
+strmask

data/meta/released

@@ -0,0 +1 @@
+2010-02-24

data/meta/repository

@@ -0,0 +1 @@
+git://github.com/rubyworks/strmask.git

data/meta/title

@@ -0,0 +1 @@
+String::Mask

data/meta/version

@@ -0,0 +1 @@
+0.2.1

data/test/test_strmask.rb

@@ -0,0 +1,63 @@
+require 'test/unit'
+require 'strmask'
+
+class TestStringMask < Test::Unit::TestCase
+
+  def setup
+    @x1 = String::Mask["abc..123", '.']
+    @x2 = String::Mask["ab..789.", '.']
+  end
+
+  def test_sub
+    r = @x1 - @x2
+    a = String::Mask["....789.", '.']
+    assert_equal(a, r)
+
+    r = @x2 - @x1
+    a = String::Mask["..c..123", '.']
+    assert_equal(a, r)
+  end
+
+  def test_add
+    r = @x1 + @x2
+    a = String::Mask["abc.7893", '.']
+    assert_equal(a, r)
+
+    r = @x2 + @x1
+    a = String::Mask["abc.7123", '.']
+    assert_equal(a, r)
+  end
+
+  def test_xand
+    r = @x1 * @x2
+    a = String::Mask["ab..789.", '.']
+    assert_equal(a, r)
+
+    r = @x2 * @x1
+    a = String::Mask["abc..123", '.']
+    assert_equal(a, r)
+  end
+
+  def test_and
+    r = @x1 & @x2
+    a = String::Mask["ab......", '.']
+    assert_equal(a, r)
+
+    r = @x2 & @x1
+    a = String::Mask["ab......", '.']
+    assert_equal(a, r)
+  end
+
+  def test_xor
+    r = @x1 ^ @x2
+    a = String::Mask["..c.7..3", '.']
+    assert_equal(a, r)
+
+    r = @x2 ^ @x1
+    a = String::Mask["..c.7..3", '.']
+    assert_equal(a, r)
+  end
+
+end
+
+

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: strmask
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 1
+  version: 0.2.1
+platform: ruby
+authors: 
+- Thomas Sawyer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-23 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: |-
+  String::Mask provides a kind-of string algebra
+  useful for manipulating strings in in comparitive
+  ways, eg. add, subtract, xor, etc.
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/strmask.rb
+- meta/authors
+- meta/collection
+- meta/contact
+- meta/created
+- meta/description
+- meta/homepage
+- meta/license
+- meta/name
+- meta/released
+- meta/repository
+- meta/title
+- meta/version
+- test/test_strmask.rb
+- LICENSE
+- README.rdoc
+- HISTORY
+has_rdoc: true
+homepage: http://rubyworks.github.com/strmask
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- String::Mask API
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: strmask
+rubygems_version: 1.3.6.pre.3
+signing_key: 
+specification_version: 3
+summary: String::Mask provides a kind-of string algebra
+test_files: 
+- test/test_strmask.rb