bytes 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bcdcc67a741e1c05bdd45da43251f2db46efe804
-  data.tar.gz: 0ed1603a9adb971ccd2c7b382a43cb34b1274c99
+  metadata.gz: 0a19bb2ea18c1602e43b0a6a7d9b07acc67111ed
+  data.tar.gz: 133e19b5b91c09541ffdf4d9bb8cfe26d33ec521
 SHA512:
-  metadata.gz: 2679e2dc3b63c14c532e869a61c79949dfc06cb0d398c1b7e8297d755d2500728df7bd716c24a7f3eeb28a3812def9b608ed71e431f4c0bf128c32ac9d25a1e4
-  data.tar.gz: ffe4c1db890f1089bee3abcd462b4ead7412644f4a4a2f6a0f80f774f95935dcac4ab9b66093344d3c8913c78969fe6f3147ff0423a14d5edd81dddc40c37182
+  metadata.gz: 5047b0bb6dab48dafb5466bf8026b1803c6f99250ead35e252d9f9319fbc536579983e3b90b6abb1c02526e37ac84c2d7209f694fb396053fc326a72e2900d6d
+  data.tar.gz: 797925e673cb380aa1d0294af8a42ca89b27c303363c027dd5734a3a845d5133f57910d2446c6b8613553ac97b4467f6f7e20ef34012bb3d2c717086dcd46695

data/Manifest.txt

@@ -6,4 +6,6 @@ Rakefile
 lib/bytes.rb
 lib/bytes/version.rb
 test/helper.rb
+test/test_bytes.rb
+test/test_hash.rb
 test/test_string.rb

data/lib/bytes.rb

@@ -1,10 +1,127 @@
 # encoding: utf-8
 
 require 'pp'
+require 'digest'
+
 
 ## our own code
 require 'bytes/version'    # note: let version always go first
 
 
+class Bytes
+  def self.new( *args )
+    String.new( *args ).b
+  end
+
+  def self.from_hex( hexstr )
+    if ['0x', '0X'].include?( hexstr[0...2] )
+      [hexstr[2..-1]].pack('H*')  ## cut-of leading 0x or 0X if present
+    else
+      [hexstr].pack('H*')
+    end
+  end
+
+  def self.to_hex( str )
+    # note: unpack returns string with <Encoding:US-ASCII>
+    # conver to default encoding
+    ##  todo/fix: do NOT hardcode UTF-8 - use default encoding - how?
+    str.unpack('H*').first.encode("UTF-8")
+  end
+
+  def self.convert( *args )
+    ## used by Bytes() in global Kernel converter method
+    if args.size == 1
+      if args[0].is_a? Array
+        ## assume array of bytes
+        ##   to be done
+      else  ## assume String
+        ## todo/fix: use coerce to_str if arg is NOT a string - why? why not?
+        str = args[0]
+        ##
+        if str.encoding == Encoding::ASCII_8BIT
+          ## assume it's binary data - use as is (no hexstring conversion)
+          new( str )   ## todo/check: return str as-is (without new) - why? why not?
+        else    ## assume it's a hexstring
+          from_hex( str )
+        end
+      end
+    else
+      ## todo/fix: throw argument error
+    end
+  end
+end
+
+
+class Buffer
+  def self.new( *args )
+    if args.size == 0
+      ## note: use "" to always use default encoding (and NOT binary)
+      String.new( "" )
+    else
+      String.new( *args )
+    end
+  end
+end
+
+
+module BytesHelper
+  def hex_to_bytes( hexstr ) Bytes.from_hex( hexstr); end
+  alias_method :h_to_b, :hex_to_bytes
+  alias_method :htob,   :hex_to_bytes
+
+  def bytes_to_hex( str ) Bytes.to_hex( str ); end
+  alias_method :b_to_h, :bytes_to_hex
+  alias_method :btoh,   :bytes_to_hex
+end
+
+
+
+class String
+  def h_to_b()  Bytes.from_hex( self ); end
+  alias_method :htob, :h_to_b
+
+  def b_to_h()  Bytes.to_hex( self ); end   ## add .b-like shortcut
+  alias_method :btoh, :b_to_h
+  alias_method :h,    :b_to_h
+end
+
+
+module HashHelper
+  def sha256( bytes )
+    ## todo/fix:  check bytes.encoding - warn if not BINARY!!!!
+    Digest::SHA256.digest( bytes )
+  end
+
+  def ripemd160( bytes )
+    ## todo/fix:  check bytes.encoding - warn if not BINARY!!!!
+    Digest::RMD160.digest( bytes )
+  end
+
+  def hash256( bytes )
+    ## double - uses sha256(sha256())
+    sha256(sha256( bytes ))
+  end
+
+  def hash160( bytes )
+    ## double - uses ripemd160(sha256())
+    ripemd160(sha256( bytes ))
+  end
+
+  ## convenience shortcut helpers
+  def sha256hex( bytes )    Bytes.to_hex(sha256( bytes ));    end
+  def ripemd160hex( bytes ) Bytes.to_hex(ripemd160( bytes )); end
+  def hash256( bytes )      Bytes.to_hex(hash256( bytes ));   end
+  def hash160( bytes )      Bytes.to_hex(hash160( bytes ));   end
+end
+
+## make "global" for now - check if there's a better way (include in Kernel) - why? why ot?
+include HashHelper
+include BytesHelper
+
+
+
+module Kernel
+  def Bytes( *args )  Bytes.convert( *args ); end
+end
 
 puts Bytes.banner    ## say hello

data/lib/bytes/version.rb

@@ -5,8 +5,8 @@
 class Bytes
 
   MAJOR = 0
-  MINOR = 0
-  PATCH = 1
+  MINOR = 1
+  PATCH = 0
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version

data/test/test_bytes.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_bytes.rb
+
+
+require 'helper'
+
+
+class TestBytes < MiniTest::Test
+
+  def test_hex
+    assert String.new( "6162")  == Bytes.to_hex( "ab" )
+    assert String.new( "6162")  == bytes_to_hex( "ab" )
+    assert String.new( "6162")  == "ab".b_to_h
+    assert String.new( "6162")  == "ab".btoh
+    assert String.new( "6162")  == "ab".h
+    assert String.new( "6162")  == Bytes.to_hex( "\x61\x62" )
+    assert String.new( "6162")  == bytes_to_hex( "\x61\x62" )
+    assert String.new( "6162")  == "\x61\x62".b_to_h
+    assert String.new( "6162")  == "\x61\x62".btoh
+    assert String.new( "6162")  == "\x61\x62".h
+    assert Encoding::UTF_8      == Bytes.to_hex( "ab" ).encoding
+
+    assert Bytes.new( "ab" )    == Bytes.from_hex( "6162" )
+    assert Bytes.new( "ab" )    == hex_to_bytes( "6162" )
+    assert Bytes.new( "ab" )    == "6162".h_to_b
+    assert Bytes.new( "ab" )    == "6162".htob
+    assert Bytes.new( "ab" )    == Bytes.from_hex( "0x6162" )
+    assert Bytes.new( "ab" )    == hex_to_bytes( "0x6162" )
+    assert Bytes.new( "ab" )    == "0x6162".h_to_b
+    assert Bytes.new( "ab" )    == "0x6162".htob
+    assert Encoding::ASCII_8BIT == Bytes.from_hex( "6162" ).encoding
+
+    assert Bytes.new( "ab" )    == Bytes( "6162" )
+    assert Bytes.new( "ab" )    == Bytes( "0x6162" )
+    assert Bytes.new( "6162" )  == Bytes( "6162".b )
+    assert Bytes.new( "ab" )    == Bytes( "ab".b )
+    assert Bytes.new( "ab")     == Bytes( "\x61\x62".b )
+    assert Encoding::ASCII_8BIT == Bytes( "6162" ).encoding
+    assert Encoding::ASCII_8BIT == Bytes( "6162".b ).encoding
+    assert Encoding::ASCII_8BIT == Bytes( "ab".b ).encoding
+  end
+
+end  # class TestBytes

data/test/test_hash.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+###
+#  to run use
+#     ruby -I ./lib -I ./test test/test_hash.rb
+
+
+require 'helper'
+
+
+class TestHash < MiniTest::Test
+
+  def test_hash
+    sha256_empty_hex   = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+    sha256_empty_bytes = "\xE3\xB0\xC4B\x98\xFC\x1C\x14\x9A\xFB\xF4\xC8\x99o\xB9$'\xAEA\xE4d\x9B\x93L\xA4\x95\x99\exR\xB8U".b
+
+    assert_equal sha256_empty_bytes, sha256( "" )
+    assert_equal sha256_empty_bytes, sha256( Bytes.new )
+
+    assert_equal sha256_empty_hex, Bytes.to_hex( sha256( "" ) )
+    assert_equal sha256_empty_hex, bytes_to_hex( sha256( "" ) )
+    assert_equal sha256_empty_hex, btoh( sha256( "" ) )
+    assert_equal sha256_empty_hex, sha256( "" ).h
+    assert_equal sha256_empty_hex, sha256hex( "" )
+
+    ripemd160_empty_hex = "9c1185a5c5e9fc54612808977ee8f548b2258d31"
+
+    assert_equal ripemd160_empty_hex, Bytes.to_hex( ripemd160( "" ))
+    assert_equal ripemd160_empty_hex, bytes_to_hex( ripemd160( "" ))
+    assert_equal ripemd160_empty_hex, btoh( ripemd160( "" ))
+    assert_equal ripemd160_empty_hex, ripemd160( "" ).h
+    assert_equal ripemd160_empty_hex, ripemd160hex( "" )
+
+    assert_equal "37f332f68db77bd9d7edd4969571ad671cf9dd3b",
+      ripemd160hex( "The quick brown fox jumps over the lazy dog" )
+
+    assert_equal "132072df690933835eb8b6ad0b77e7b6f14acad7",
+      ripemd160hex( "The quick brown fox jumps over the lazy cog" )
+  end
+
+end  # class TestHash

data/test/test_string.rb

@@ -29,4 +29,21 @@ class TestString < MiniTest::Test
      assert Encoding::UTF_8 == String.new("").encoding
   end
 
+  def test_bytes
+     assert Encoding::ASCII_8BIT == Bytes.new.encoding
+     assert Encoding::ASCII_8BIT == Bytes.new("").encoding
+     assert Encoding::ASCII_8BIT == Bytes.new("ab").encoding
+
+     assert Encoding::BINARY == Encoding::ASCII_8BIT
+     assert Encoding::BINARY == Bytes.new.encoding
+     assert Encoding::BINARY == Bytes.new("").encoding
+     assert Encoding::BINARY == Bytes.new("ab").encoding
+  end
+
+  def test_buffer
+    assert Encoding::UTF_8 == Buffer.new.encoding
+    assert Encoding::UTF_8 == Buffer.new("").encoding
+    assert Encoding::UTF_8 == Buffer.new("ab").encoding
+  end
+
 end  # class TestString

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bytes
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Gerald Bauer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-15 00:00:00.000000000 Z
+date: 2019-04-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -56,6 +56,8 @@ files:
 - lib/bytes.rb
 - lib/bytes/version.rb
 - test/helper.rb
+- test/test_bytes.rb
+- test/test_hash.rb
 - test/test_string.rb
 homepage: https://github.com/s6ruby/programming-bits-bytes
 licenses: