kingpong-bitwise_string_ops 0.1.3 → 0.1.4

data/CHANGELOG

@@ -1,3 +1,57 @@
+commit 678935a5904007ccd44178f961c5ab525dba4811
+Author: kingpong <philip@pastemagazine.com>
+Date:   Sun Aug 23 04:18:23 2009 -0400
+
+    updated documentation
+
+commit 6d5bf6876529fc5c515d3ba108b2e1b6b4fd6184
+Author: kingpong <philip@pastemagazine.com>
+Date:   Sun Aug 23 03:12:56 2009 -0400
+
+    expanded tabs
+
+commit a3d7746d9f09d42593fa9446c4fb2bead2894d29
+Author: kingpong <philip@pastemagazine.com>
+Date:   Sun Aug 23 03:02:40 2009 -0400
+
+    handle non-strings
+
+commit 200fcb33e1479246c6229998de42ad3c27cdf00e
+Author: kingpong <philip@pastemagazine.com>
+Date:   Sun Aug 23 01:42:07 2009 -0400
+
+    added test cases
+
+commit 3f03b37a4deb5a578fe991b1e09f74143f74fc45
+Author: kingpong <philip@pastemagazine.com>
+Date:   Sat Aug 22 23:34:32 2009 -0400
+
+    removed intermediate method names for the operators
+
+commit 383ce0eca96503c6729eab72d63aad2ae84eee85
+Author: kingpong <philip@pastemagazine.com>
+Date:   Sat Aug 22 23:27:25 2009 -0400
+
+    ignore doc dir
+
+commit 3f94a2438be1c3da43478900d4fa2a07b50181e9
+Author: kingpong <philip@pastemagazine.com>
+Date:   Sat Aug 22 23:27:03 2009 -0400
+
+    fixed unicode issue
+
+commit 33ea54dfb0624905bc94ea384b58b9fe87e08cc6
+Author: kingpong <philip@pastemagazine.com>
+Date:   Sat Aug 22 20:42:14 2009 -0400
+
+    increment version num for github gem builder
+
+commit 33f1b27e41bc395637645b89ea37f7362094c8ab
+Author: kingpong <philip@pastemagazine.com>
+Date:   Sat Aug 22 19:41:33 2009 -0400
+
+    include changelog and manifest in version control
+
 commit 074c9142a5b66b146e70e185566931e285867d06
 Author: kingpong <philip@pastemagazine.com>
 Date:   Sat Aug 22 19:28:48 2009 -0400

data/Manifest

@@ -5,14 +5,15 @@ ext/bitwise_string_ops.c
 ext/bitwise_string_ops.h
 ext/extconf.rb
 init.rb
-lib/bitwise_string_ops.rb
 Manifest
 Rakefile
 README.rdoc
 setup.rb
 test/test.rb
 test/test_helper.rb
+test/test_perl_equivalence.rb
 test/test_string_and.rb
 test/test_string_not.rb
 test/test_string_or.rb
 test/test_string_xor.rb
+test/testcases.pl

data/README.rdoc

@@ -33,41 +33,41 @@ For strings of the same length, nothing unexpected:
 
   "r b " ^ " u y"   # "RUBY"
   #
-  # 01110010 00100000 01100010 00100000 ^    # "r b " ^
-  # 00100000 01110101 00100000 01111001      # " u y"
-  # ======== ======== ======== ========
-  # 01010010 01010101 01000010 01011001      # "RUBY"
+  #   01110010 00100000 01100010 00100000  # "r b "
+  # ^ 00100000 01110101 00100000 01111001  # " u y"
+  #   ======== ======== ======== ========
+  #   01010010 01010101 01000010 01011001  # "RUBY"
 
 OR operation expands to the larger of the two strings:
 
   "RU" | "  by"     # "ruby"
   #
-  # 01010010 01010101                   |    # "RU"
-  # 00100000 00100000 01100010 01111001      # "  by"
-  # ======== ======== ======== ========
-  # 01110010 01110101 01100010 01111001      # "ruby"
+  #   01010010 01010101                    # "RU"
+  # | 00100000 00100000 01100010 01111001  # "  by"
+  #   ======== ======== ======== ========
+  #   01110010 01110101 01100010 01111001  # "ruby"
 
 XOR expands also:
 
   "%:--!" ^ "woot"  # "RUBY!"
   #
-  # 00100101 00111010 00101101 00101101 00100001 ^    # "%:--!"
-  # 01110111 01101111 01101111 01110100               # "woot"
-  # ======== ======== ======== ========
-  # 01010010 01010101 01000010 01011001 00100001"     # "RUBY!"
+  #   00100101 00111010 00101101 00101101 00100001  # "%:--!"
+  # ^ 01110111 01101111 01101111 01110100           # "woot"
+  #   ======== ======== ======== ========
+  #   01010010 01010101 01000010 01011001 00100001  # "RUBY!"
 
 AND truncates to the shorter of the two:
 
   "ruby!" & '____'  # "ruby"
   #
-  # 01110010 01110101 01100010 01111001 00100001 &    # "ruby!"
-  # 01011111 01011111 01011111 01011111               # "____"
-  # ======== ======== ======== ========
-  # 01110010 01110101 01100010 01111001               # "ruby"
+  #   01110010 01110101 01100010 01111001 00100001  # "ruby!"
+  # & 01011111 01011111 01011111 01011111           # "____"
+  #   ======== ======== ======== ========
+  #   01110010 01110101 01100010 01111001           # "ruby"
 
 = Known Issues
 
-* Completely untested with non-string rhs operands
+No known issues.  If you find any bugs, please let the author know.
 
 = Author
 

data/Rakefile

@@ -3,7 +3,7 @@ require 'rake'
 require 'echoe'
 
 project = "bitwise_string_ops"
-version = "0.1.3"
+version = "0.1.4"
 
 Echoe.new(project, version) do |p|
   p.description = "Bitwise operations for Ruby strings"

data/bitwise_string_ops.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{bitwise_string_ops}
-  s.version = "0.1.3"
+  s.version = "0.1.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Philip Garrett"]
@@ -10,14 +10,14 @@ Gem::Specification.new do |s|
   s.description = %q{Bitwise operations for Ruby strings}
   s.email = %q{philip@pastemagazine.com}
   s.extensions = ["ext/extconf.rb"]
-  s.extra_rdoc_files = ["CHANGELOG", "ext/bitwise.c", "ext/bitwise_string_ops.c", "ext/bitwise_string_ops.h", "ext/extconf.rb", "lib/bitwise_string_ops.rb", "README.rdoc"]
-  s.files = ["bitwise_string_ops.gemspec", "CHANGELOG", "ext/bitwise.c", "ext/bitwise_string_ops.c", "ext/bitwise_string_ops.h", "ext/extconf.rb", "init.rb", "lib/bitwise_string_ops.rb", "Manifest", "Rakefile", "README.rdoc", "setup.rb", "test/test.rb", "test/test_helper.rb", "test/test_string_and.rb", "test/test_string_not.rb", "test/test_string_or.rb", "test/test_string_xor.rb", "test/test_perl_equivalence.rb"]
+  s.extra_rdoc_files = ["CHANGELOG", "ext/bitwise.c", "ext/bitwise_string_ops.c", "ext/bitwise_string_ops.h", "ext/extconf.rb", "README.rdoc"]
+  s.files = ["bitwise_string_ops.gemspec", "CHANGELOG", "ext/bitwise.c", "ext/bitwise_string_ops.c", "ext/bitwise_string_ops.h", "ext/extconf.rb", "init.rb", "Manifest", "Rakefile", "README.rdoc", "setup.rb", "test/test.rb", "test/test_helper.rb", "test/test_perl_equivalence.rb", "test/test_string_and.rb", "test/test_string_not.rb", "test/test_string_or.rb", "test/test_string_xor.rb", "test/testcases.pl"]
   s.homepage = %q{http://github.com/kingpong/bitwise_string_ops}
   s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Bitwise_string_ops", "--main", "README.rdoc"]
   s.require_paths = ["lib", "ext"]
   s.rubyforge_project = %q{bitwise_string_ops}
   s.rubygems_version = %q{1.3.3}
-  s.summary = %q{bitwise_string_ops 0.1.3}
+  s.summary = %q{bitwise_string_ops 0.1.4}
   s.test_files = ["test/test_helper.rb", "test/test_perl_equivalence.rb", "test/test_string_and.rb", "test/test_string_not.rb", "test/test_string_or.rb", "test/test_string_xor.rb"]
 
   if s.respond_to? :specification_version then

data/ext/bitwise_string_ops.c

@@ -2,7 +2,7 @@
  * bitwise_string_ops.c
  *
  * Copyright (c) 2009 Philip Garrett.
- * 
+ *
  * 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
@@ -10,10 +10,10 @@
  * 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.
@@ -23,48 +23,62 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-// Include the Ruby headers and goodies
 #include "ruby.h"
 #include "bitwise_string_ops.h"
 
-// Defining a space for information and references about the module to be stored internally
-VALUE BitwiseStringOps = Qnil;
 static ID ToString;
+static VALUE to_s(VALUE o);
 
-// Prototype for the initialization method - Ruby calls this, not you
+/* callback for module init */
 void Init_bitwise_string_ops();
 
-// Prototypes for our methods
 VALUE method_bit_or(VALUE self, VALUE other);
 VALUE method_bit_xor(VALUE self, VALUE other);
 VALUE method_bit_and(VALUE self, VALUE other);
 VALUE method_bit_not(VALUE self);
 
-static VALUE to_s(VALUE o);
-
-// The initialization method for this module
 void Init_bitwise_string_ops()
 {
-    BitwiseStringOps = rb_define_module("BitwiseStringOps");
-	ToString = rb_intern("to_s");
-    rb_define_method(BitwiseStringOps, "|", method_bit_or,  1);
-    rb_define_method(BitwiseStringOps, "^", method_bit_xor, 1);
-    rb_define_method(BitwiseStringOps, "&", method_bit_and, 1);
-    rb_define_method(BitwiseStringOps, "~", method_bit_not, 0);
+    ToString = rb_intern("to_s");
+    rb_define_method(rb_cString, "|", method_bit_or,  1);
+    rb_define_method(rb_cString, "^", method_bit_xor, 1);
+    rb_define_method(rb_cString, "&", method_bit_and, 1);
+    rb_define_method(rb_cString, "~", method_bit_not, 0);
 }
 
 static VALUE to_s(VALUE o)
 {
-	return rb_obj_is_kind_of(o,rb_cString)
-		? o : rb_funcall(o, ToString, 0);
+    return rb_obj_is_kind_of(o,rb_cString)
+        ? o : rb_funcall(o, ToString, 0);
 }
 
+/*
+ * call-seq:
+ *  |(other)
+ *
+ * Performs a byte-by-byte bitwise OR on +self+ (a String) and +other+
+ * (anything that responds to +to_s+) and returns the result.  If one
+ * operand is longer than the other, the effect is as if the shorter
+ * operand were padded with zero bits on the right.  The result is as
+ * long as the <b>longer</b> operand.
+ *
+ * Example:
+ *
+ *   "RU" | "  by"     # "ruby"
+ *   #
+ *   #   01010010 01010101                    # "RU"
+ *   # | 00100000 00100000 01100010 01111001  # "  by"
+ *   #   ======== ======== ======== ========
+ *   #   01110010 01110101 01100010 01111001  # "ruby"
+ *
+ *
+ */
 VALUE method_bit_or(VALUE self, VALUE other)
 {
-	VALUE left, right, right_s, dest;
-	left = StringValue(self);
-	right_s = to_s(other);
-	right = StringValue(right_s);
+    VALUE left, right, right_s, dest;
+    left = StringValue(self);
+    right_s = to_s(other);
+    right = StringValue(right_s);
     dest = rb_str_new(NULL, string_bitwise_or_result_len(RSTRING(left)->len,
                                                          RSTRING(right)->len));
     string_bitwise_or(RSTRING(left)->ptr, RSTRING(left)->len,
@@ -73,12 +87,32 @@ VALUE method_bit_or(VALUE self, VALUE other)
     return dest;
 }
 
+/*
+ * call-seq:
+ *  ^(other)
+ *
+ * Performs a byte-by-byte bitwise XOR on +self+ (a String) and +other+
+ * (anything that responds to +to_s+) and returns the result.  If one
+ * operand is longer than the other, the effect is as if the shorter
+ * operand were padded with zero bits on the right.  The result is as
+ * long as the <b>longer</b> operand.
+ *
+ * Example:
+ *
+ *   "%:--!" ^ "woot"  # "RUBY!"
+ *   #
+ *   #   00100101 00111010 00101101 00101101 00100001  # "%:--!"
+ *   # ^ 01110111 01101111 01101111 01110100           # "woot"
+ *   #   ======== ======== ======== ========
+ *   #   01010010 01010101 01000010 01011001 00100001  # "RUBY!"
+ *
+ */
 VALUE method_bit_xor(VALUE self, VALUE other)
 {
-	VALUE left, right, right_s, dest;
-	left = StringValue(self);
-	right_s = to_s(other);
-	right = StringValue(right_s);
+    VALUE left, right, right_s, dest;
+    left = StringValue(self);
+    right_s = to_s(other);
+    right = StringValue(right_s);
     dest = rb_str_new(NULL, string_bitwise_xor_result_len(RSTRING(left)->len,
                                                           RSTRING(right)->len));
     string_bitwise_xor(RSTRING(left)->ptr, RSTRING(left)->len,
@@ -87,12 +121,32 @@ VALUE method_bit_xor(VALUE self, VALUE other)
     return dest;
 }
 
+/*
+ * call-seq:
+ *  &(other)
+ *
+ * Performs a byte-by-byte bitwise AND on +self+ (a String) and +other+
+ * (anything that responds to +to_s+) and returns the result.  If one
+ * operand is longer than the other, the effect is as if the longer
+ * operand were truncated to the length of the shorter.  The result is
+ * as long as the <b>shorter</b> operand.
+ *
+ * Example:
+ *
+ *   "ruby!" & '____'  # "ruby"
+ *
+ *   #   01110010 01110101 01100010 01111001 00100001  # "ruby!"
+ *   # & 01011111 01011111 01011111 01011111           # "____"
+ *   #   ======== ======== ======== ========
+ *   #   01110010 01110101 01100010 01111001           # "ruby"
+ *
+ */
 VALUE method_bit_and(VALUE self, VALUE other)
 {
-	VALUE left, right, right_s, dest;
-	left = StringValue(self);
-	right_s = to_s(other);
-	right = StringValue(right_s);
+    VALUE left, right, right_s, dest;
+    left = StringValue(self);
+    right_s = to_s(other);
+    right = StringValue(right_s);
     dest = rb_str_new(NULL, string_bitwise_and_result_len(RSTRING(left)->len,
                                                           RSTRING(right)->len));
     string_bitwise_and(RSTRING(left)->ptr, RSTRING(left)->len,
@@ -101,6 +155,21 @@ VALUE method_bit_and(VALUE self, VALUE other)
     return dest;
 }
 
+/*
+ * call-seq:
+ *  ~()
+ *
+ * Performs a byte-by-byte bitwise NOT on +self+ (a String) * and returns the result.
+ *
+ * Example:
+ *
+ *   ~"ruby" # "\215\212\235\206"
+ *
+ *   # ~ 01110010 01110101 01100010 01111001 # "ruby"
+ *   #   ======== ======== ======== ========
+ *   #   10001101 10001010 10011101 10000110 # "\215\212\235\206"
+ *
+ */
 VALUE method_bit_not(VALUE self)
 {
     VALUE str = StringValue(self);

data/test/testcases.pl

@@ -0,0 +1,42 @@
+#!/usr/bin/env perl
+use strict;
+use warnings;
+
+=head1 NAME
+
+testcases.pl
+
+=head1 DESCRIPTION
+
+Generates a data set to test the ruby bitwise string operations against
+Perl's implementation in a brute force manner.
+
+This doesn't really prove anything, it just a little confidence booster.
+
+=cut
+
+sub OPERAND_MAX()  { 32  }
+sub TESTS_PER_OP() { 256 }
+
+for my $i (1..TESTS_PER_OP) {
+    my ($left,$right) = (gen_operand(),gen_operand());
+    dump_testcase('|', $left | $right, $left, $right);
+    dump_testcase('&', $left & $right, $left, $right);
+    dump_testcase('^', $left ^ $right, $left, $right);
+    dump_testcase('~', ~$left, $left);
+}
+
+sub gen_operand {
+    join('', map { chr(rand(256)) } (0..rand(OPERAND_MAX)));
+}
+
+sub dump_testcase {
+    my ($op,$out,@args) = @_;
+    print map { str2bin($_) } ($op,$out,@args);
+}
+
+sub str2bin {
+    my ($str) = @_;
+    pack('N', length($str)) . $str;
+}
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: kingpong-bitwise_string_ops
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors: 
 - Philip Garrett
@@ -25,7 +25,6 @@ extra_rdoc_files:
 - ext/bitwise_string_ops.c
 - ext/bitwise_string_ops.h
 - ext/extconf.rb
-- lib/bitwise_string_ops.rb
 - README.rdoc
 files: 
 - bitwise_string_ops.gemspec
@@ -35,18 +34,18 @@ files:
 - ext/bitwise_string_ops.h
 - ext/extconf.rb
 - init.rb
-- lib/bitwise_string_ops.rb
 - Manifest
 - Rakefile
 - README.rdoc
 - setup.rb
 - test/test.rb
 - test/test_helper.rb
+- test/test_perl_equivalence.rb
 - test/test_string_and.rb
 - test/test_string_not.rb
 - test/test_string_or.rb
 - test/test_string_xor.rb
-- test/test_perl_equivalence.rb
+- test/testcases.pl
 has_rdoc: false
 homepage: http://github.com/kingpong/bitwise_string_ops
 licenses: 
@@ -79,7 +78,7 @@ rubyforge_project: bitwise_string_ops
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: bitwise_string_ops 0.1.3
+summary: bitwise_string_ops 0.1.4
 test_files: 
 - test/test_helper.rb
 - test/test_perl_equivalence.rb

data/lib/bitwise_string_ops.rb

@@ -1,16 +0,0 @@
-#
-# bitwise_string_ops.rb
-#
-# BitwiseStringOps provides bitwise operators for the String class that
-# mimic Perl's bitwise string operators.
-# See http://perldoc.perl.org/perlop.html#Bitwise-String-Operators.
-#
-# Author:: Philip Garrett
-# Copyright:: Copyright (c) 2009 Philip Garrett.
-# License:: MIT License (http://www.opensource.org/licenses/mit-license.php)
-#
-#
-require 'bitwise_string_ops.so'
-class String
-  include BitwiseStringOps
-end