bytes 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0a19bb2ea18c1602e43b0a6a7d9b07acc67111ed
-  data.tar.gz: 133e19b5b91c09541ffdf4d9bb8cfe26d33ec521
+SHA256:
+  metadata.gz: 5a8baa99382e45238e96527a5aab45a04daf4b73a2d4e1f64b3bf87530e14a7d
+  data.tar.gz: ec170b28a4efd3d7b0cdf45094831a68a86d60785f313668baa24cbf5a106085
 SHA512:
-  metadata.gz: 5047b0bb6dab48dafb5466bf8026b1803c6f99250ead35e252d9f9319fbc536579983e3b90b6abb1c02526e37ac84c2d7209f694fb396053fc326a72e2900d6d
-  data.tar.gz: 797925e673cb380aa1d0294af8a42ca89b27c303363c027dd5734a3a845d5133f57910d2446c6b8613553ac97b4467f6f7e20ef34012bb3d2c717086dcd46695
+  metadata.gz: 8f62ad42592bfd8e69fb9bf53526ba19e3568b7140f88bfa9bf524ee1ac8af3258dd2d156f6080d08e63ecbcb92cf0e8f531f56f4c3b32faad8477b7efdf8423
+  data.tar.gz: 728487df6ca9ad9cbe4aedcc2ae76c3f7018c195a780a5e4ef7ee487602cf0ac7fadff8b5c31b38a6e18f6a324947a1ae7e51f3c693bb65ae000ce6461a54969

data/CHANGELOG.md

@@ -1,3 +1,3 @@
-### 0.0.1 / 2019-04-16
-
-* Everything is new. First release
+### 0.0.1 / 2019-04-16
+
+* Everything is new. First release

data/Manifest.txt

@@ -1,11 +1,6 @@
 CHANGELOG.md
-LICENSE.md
 Manifest.txt
 README.md
 Rakefile
 lib/bytes.rb
 lib/bytes/version.rb
-test/helper.rb
-test/test_bytes.rb
-test/test_hash.rb
-test/test_string.rb

data/README.md

@@ -1,14 +1,254 @@
-
 # Bytes
 
-bytes gem / library -
+bytes - bits 'n' bytes made easy/easier incl. new buffer helper / wrapper class to help with the string byte vs character dichotomy
 
-* home  :: [github.com/s6ruby/programming-bits-bytes](https://github.com/s6ruby/programming-bits-bytes)
-* bugs  :: [github.com/s6ruby/programming-bits-bytes/issues](https://github.com/s6ruby/programming-bits-bytes/issues)
+* home  :: [github.com/rubycocos/core](https://github.com/rubycocos/core)
+* bugs  :: [github.com/rubycocos/core/issues](https://github.com/rubycocos/core/issues)
 * gem   :: [rubygems.org/gems/bytes](https://rubygems.org/gems/bytes)
 * rdoc  :: [rubydoc.info/gems/bytes](http://rubydoc.info/gems/bytes)
 
 
+## Background -  Programming Bits, Bytes 'n' Blocks Step-by-Step Book / Guide
+
+_Let's start with the three types of strings, that is, bytes, (string) buffers, and (frozen) strings, ..._
+
+
+### Byte vs. Character
+
+
+#### What's a Byte?
+
+A byte is a 8-bit integer number (that is, unsigned from 0 to 255 or
+signed from -128 to 127 using 2's complement).
+Example:
+
+``` ruby
+0b01000001              #=> 65  - base 2  - binary bits
+65                      #=> 65  - base 10 - decimal numbers
+0x41                    #=> 65  - base 16 - hexadecimal numbers
+[0b01000001, 65, 0x41]
+#=> [65, 65, 65]
+```
+
+Or with conversions to 8-bit integer numbers. Example:
+
+``` ruby
+"01000001".to_i(2)     #=> 65
+"65".to_i(10)          #=> 65
+"65".to_i              #=> 65 - same as to_i(10)
+"41".to_i(16)          #=> 65
+"0x41".to_i(16)        #=> 65 - same as "41" - 0x hex prefix gets skipped
+["01000001".to_i(2), "65".to_i(10), "41".to_i(16)]
+#=> [65, 65, 65]
+```
+
+Note:  `String#hex` is a built-in short-cut / alias for `String#to_i(16)`.  Example:
+
+``` ruby
+"41".hex          #=> 65
+"0x41".hex        #=> 65 - same as "41" - 0x hex prefix gets
+```
+
+
+
+#### What's a Character?
+
+A character (or char) used to be a byte
+and, thus, a string (array) of characters
+was also an array of bytes. Example:
+
+``` ruby
+?A.ord        #=> 65 - ASCII character
+"A".ord       #=> 65 - ASCII character
+"\x41".ord    #=> 65 - ASCII character
+[?A.ord, "A".ord, "\x41".ord]
+#=> [65, 65, 65]
+```
+
+
+
+History Nostalgia Corner: ASCII 7-Bit Character Encoding
+
+![](i/us_ascii_code_chart.png)
+
+> ASCII abbreviated from American Standard Code for Information Interchange,
+> is a character encoding standard for electronic communication. ASCII codes
+> represent text in computers, telecommunications equipment, and other devices.
+> Most modern character-encoding schemes are based on ASCII,
+> although they support many additional characters.
+>
+> ASCII is the traditional name for the encoding system; the Internet Assigned
+> Numbers Authority (IANA) prefers the updated name US-ASCII, which clarifies
+> that this system was developed in the US and based on the typographical
+> symbols predominantly in use there.
+>
+> (Source: [ASCII @ Wikipedia](https://en.wikipedia.org/wiki/ASCII))
+
+
+
+Nowadays a character can have one, two or even more bytes.
+Let's try:
+
+``` ruby
+## Latin Capital Letter A (Unicode) - 1 Byte
+"A".bytes          #=> [65]
+"\x41".bytes       #=> [65] - same as "A"
+"\u0041".bytes     #=> [65]
+"\u{41}".bytes     #=> [65] - same as "\u0041" - leading zeros can be dropped
+"A".bytes.size     #=> 1
+"A".chars.size     #=> 1
+
+## Cyrillic Capital Letter A (Unicode) - 2 Bytes
+"А".bytes          #=> [208, 144]
+"\u0410".bytes     #=> [208, 144] - same "А"
+"\u{410}".bytes    #=> [208, 144] - same as "\u0410" - leading zeros can be dropped
+"А".bytes.size     #=> 2
+"А".chars.size     #=> 1
+
+# Old Persian Number One (Unicode) - 4 Bytes
+"𐏑".bytes          #=> [240, 144, 143, 145]
+"\u{103D1}".bytes  #=> [240, 144, 143, 145]
+"\u{103d1}".bytes  #=> [240, 144, 143, 145] same as "\u{103D1}"
+"𐏑".bytes.size     #=> 4
+"𐏑".chars.size     #=> 1
+
+# ...
+```
+
+
+
+### String of Bytes or String of Characters? Yes, Yes, Yes
+
+
+In ruby the String class can morph into three types:
+
+- Bytes
+- Mutable String a.k.a String Buffer
+- Immutable String a.k.a. Frozen String
+
+
+#### Bytes / Binary
+
+
+`String.new` or `"".b` creates new bytes, that is, a new binary string
+buffer with the ASCII_8BIT encoding also known as BINARY.
+Let's try:
+
+``` ruby
+String.new.encoding        #=> <Encoding::ASCII_8BIT>
+String.new("".b).encoding  #=> <Encoding::ASCII_8BIT>
+"".b.encoding              #=> <Encoding::ASCII_8BIT>
+
+Encoding::BINARY == Encoding::ASCII_8BIT  #=> true
+
+# or using the "type-safe" Bytes class
+
+Bytes.new.encoding                  #=> <Encoding::ASCII_8BIT>
+Bytes.new("").encoding              #=> <Encoding::ASCII_8BIT>
+Bytes.new("abc").encoding           #=> <Encoding::ASCII_8BIT>
+Bytes.new("\x61\x62\x63").encoding  #=> <Encoding::ASCII_8BIT>
+```
+
+
+
+#### String Buffer
+
+If you use `String.new("")` (note the `""` passed in) or
+the string literal `""` that creates a new string buffer
+with the default encoding (usually UTF-8).
+Let's try:
+
+``` ruby
+# encoding: utf-8
+String.new("").encoding     #=> <Encoding::UTF_8>
+"".encoding                 #=> <Encoding::UTF_8>
+```
+
+<!--
+
+# or using the StringBuffer c'tor helper (returning a String)
+
+StringBuffer.new.encoding         #=> <Encoding::UTF_8>
+StringBuffer.new("").encoding     #=> <Encoding::UTF_8>
+StringBuffer.new("abc").encoding  #=> <Encoding::UTF_8>
+
+-->
+
+
+#### Frozen String
+
+If you use the recommended `# frozen_string_literal: true` magic comment
+or pragma you can automagically turn all string literals into
+frozen (immutable) strings with the default encoding (usually UTF-8).
+Let's try:
+
+``` ruby
+# frozen_string_literal: true
+"".frozen?                 #=> true
+"Hello, World!".frozen?    #=> true
+String.new.frozen?         #=> false
+String.new("").frozen?     #=> false
+```
+
+
+
+<!--
+
+### Bytes
+
+bytes from hexstring
+
+bytes to hexstring
+
+bytes from string
+
+bytes to string
+
+bytes to array of integers
+
+bytes from array of integers
+
+
+
+#### Bytes to Integer Numbers - Little-Endian vs Big-Endian
+
+4 byte unsigned integer  -
+
+Example - 1
+
+bytes to integer
+
+integer to bytes
+
+Big-End first or Little-End first?
+Least significant bit (lsm) or most significant bit (msb) first?
+
+
+
+
+#### Bytes Helper
+
+
+
+### Buffer
+
+#### Buffer Helper
+
+-->
+
+
+
+
+To be continued ...
+
+---
+
+
+
+
+
+
+
 ## Usage
 
 To be done

data/Rakefile

@@ -1,29 +1,31 @@
-require 'hoe'
-require './lib/bytes/version.rb'
-
-Hoe.spec 'bytes' do
-
-  self.version = Bytes::VERSION
-
-  self.summary = "bytes"
-  self.description = summary
-
-  self.urls    = ['https://github.com/s6ruby/programming-bits-bytes']
-
-  self.author  = 'Gerald Bauer'
-  self.email   = 'wwwmake@googlegroups.com'
-
-  # switch extension to .markdown for gihub formatting
-  self.readme_file  = 'README.md'
-  self.history_file = 'CHANGELOG.md'
-
-  self.extra_deps = [
-  ]
-
-  self.licenses = ['Public Domain']
-
-  self.spec_extras = {
-    required_ruby_version: '>= 2.2.2'
-  }
-
-end
+require 'hoe'
+require './lib/bytes/version.rb'
+
+
+Hoe.spec 'bytes' do
+
+  self.version = Cocos::Module::Bytes::VERSION
+
+  self.summary = "bytes"
+  self.description = summary
+
+
+  self.urls    = { home: 'https://github.com/rubycocos/core' }
+
+  self.author  = 'Gerald Bauer'
+  self.email   = 'wwwmake@googlegroups.com'
+
+  # switch extension to .markdown for gihub formatting
+  self.readme_file  = 'README.md'
+  self.history_file = 'CHANGELOG.md'
+
+  self.extra_deps = [
+  ]
+
+  self.licenses = ['Public Domain']
+
+  self.spec_extras = {
+    required_ruby_version: '>= 2.2.2'
+  }
+
+end

data/lib/bytes/version.rb

@@ -1,24 +1,25 @@
-# encoding: utf-8
-
-
-
-class Bytes
-
-  MAJOR = 0
-  MINOR = 1
-  PATCH = 0
-  VERSION = [MAJOR,MINOR,PATCH].join('.')
-
-  def self.version
-    VERSION
-  end
-
-  def self.banner
-    "bytes/#{VERSION} on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
-  end
-
-  def self.root
-    "#{File.expand_path( File.dirname(File.dirname(File.dirname(__FILE__))) )}"
-  end
-
-end # class Bytes
+
+module Cocos
+module Module
+module Bytes
+
+  MAJOR = 0
+  MINOR = 2
+  PATCH = 0
+  VERSION = [MAJOR,MINOR,PATCH].join('.')
+
+  def self.version
+    VERSION
+  end
+
+  def self.banner
+    "bytes/#{VERSION} on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
+  end
+
+  def self.root
+    "#{File.expand_path( File.dirname(File.dirname(File.dirname(__FILE__))) )}"
+  end
+
+end # module Bytes
+end # module Module
+end # module Cocos

data/lib/bytes.rb

@@ -1,127 +1,140 @@
-# 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
+require 'pp'
+require 'forwardable'
+
+
+## our own code
+require_relative 'bytes/version'    # note: let version always go first
+
+
+module BytesHelper
+  def hex_to_bin( hex )
+    ## todo/fix:  do an argument regex hex check!!!!
+    raise TypeError, "BytesHelper.hex_to_bin - non-hexadecimal digit found in >#{hex}<" unless is_hex?( hex )
+
+    ## note: assume pack always returns string with BINARY/ASCII-8BIT encoding!!!
+    if ['0x', '0X'].include?( hex[0,2] )   ## cut-of leading 0x or 0X if present
+      [hex[2..-1]].pack('H*')
+    else
+      [hex].pack('H*')
+    end
+  end
+  alias_method :hex_to_bytes, :hex_to_bin
+  alias_method :h_to_b,       :hex_to_bin
+  alias_method :htob,         :hex_to_bin
+
+
+  def bin_to_hex( bin )
+    # note: unpack returns string with <Encoding:US-ASCII>
+    # convert to default encoding
+    ##  todo/fix: do NOT hardcode UTF-8 - use default encoding - why? why not?
+    hex = bin.unpack('H*').first
+    ## note: hexdigits/chars (0-9a-f) should be safe, that is, always ASCII-7BIT/UTF_8 with needing to change any char codes
+    hex.encode!( Encoding::UTF_8 )
+    hex
+  end
+  alias_method :bytes_to_hex, :bin_to_hex
+  alias_method :b_to_h,       :bin_to_hex
+  alias_method :btoh,         :bin_to_hex
+
+
+ ########
+  # more helpers
+  ## check if it is a hex (string)
+  ##  - allow optiona 0x or 0X  and allow abcdef and ABCDEF
+  HEX_RE = /\A(?:0x)?[0-9a-f]*\z/i
+  def is_hex?( str )  !HEX_RE.match( str ).nil?; end
+end   # module BytesHelper
+
+
+
+
+class Bytes
+  extend BytesHelper
+  ## e.g. lets you use
+  ##       Bytes.hex_to_bin( hex )
+  ##       Bytes.bin_to_hex( bin )  etc.
+
+
+  def self.from_hex( hex ) new( hex_to_bin( hex ) );  end
+
+  ##  "semantic" constructor for wrapping (binary) strings e.g. same as Bytes.new(bin)
+  def self.wrap( bin ) new( bin );  end
+
+
+  def initialize( bin=String.new )
+    ## note: for now will NOT dup(licate) passed in binary array
+    ##    you only get a new binary array if no arg passed in e.g. Bytes.new
+    @bin  = if bin.encoding != Encoding::ASCII_8BIT
+             puts "!! WARN - Bytes.new - BINARY/ASCII-8BIT encoding expected; got: #{bin.encoding} for string:"
+             pp bin
+
+             bin.b
+            else
+               bin
+            end
+  end
+
+
+  ## add more string methods - why? why not?
+  extend Forwardable
+  def_delegators :@bin, :encoding,
+                        :size, :length
+
+
+  def to_s() Bytes.bin_to_hex( @bin ); end
+  alias_method :to_hex, :to_s
+
+  def b()  @bin; end
+
+  ## add to_a  alias for @bin.bytes() - why? why not?
+
+
+  def ==(other)
+    self.class == other.class && @bin == other.b
+  end
+
+
+
+  def self.convert( arg )
+    ## used by Bytes() in global Kernel converter method
+      if arg.is_a?( Bytes )
+        arg   ## pass-through as is
+      elsif arg.is_a?( String )
+        ## todo/fix: use coerce to_str if arg is NOT a string - why? why not
+        ##
+        if arg.encoding == Encoding::ASCII_8BIT
+          ## assume it's binary data - use as is (no hexstring conversion)
+          Bytes.wrap( arg )   ## todo/check: return str as-is (without new) - why? why not?
+        else    ## assume it's a hexstring
+          Bytes.from_hex( arg )
+        end
+      else
+       ## check for array or such e.g if arg.is_a? Array
+          ## raise TypeError - why? why not?
+         raise ArgumentError, "Bytes() expected String; got #{arg.class.name}"
+      end
+  end
+end
+
+
+
+class String
+  def to_hex()  Bytes.bin_to_hex( self ); end
+  ## add more aliases e.g. bin_to_hex or btoh or b_to_h or such - why? why not?
+
+  ## note: built-in String#hex returns string converted
+  ##                    to Integer  -same as String.to_i(16) !!!!
+end
+
+
+
+
+module Kernel
+  def Bytes( arg )  Bytes.convert( arg ); end
+end
+
+
+
+
+
+puts Cocos::Module::Bytes.banner      ## say hello

metadata

@@ -1,69 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: bytes
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Gerald Bauer
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-04-16 00:00:00.000000000 Z
+date: 2022-12-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '4.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7'
 - !ruby/object:Gem::Dependency
   name: hoe
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.16'
+        version: '3.23'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.16'
+        version: '3.23'
 description: bytes
 email: wwwmake@googlegroups.com
 executables: []
 extensions: []
 extra_rdoc_files:
 - CHANGELOG.md
-- LICENSE.md
 - Manifest.txt
 - README.md
 files:
 - CHANGELOG.md
-- LICENSE.md
 - Manifest.txt
 - README.md
 - Rakefile
 - 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
+homepage: https://github.com/rubycocos/core
 licenses:
 - Public Domain
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--main"
 - README.md
@@ -80,9 +80,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: bytes
 test_files: []

data/LICENSE.md

@@ -1,116 +0,0 @@
-CC0 1.0 Universal
-
-Statement of Purpose
-
-The laws of most jurisdictions throughout the world automatically confer
-exclusive Copyright and Related Rights (defined below) upon the creator and
-subsequent owner(s) (each and all, an "owner") of an original work of
-authorship and/or a database (each, a "Work").
-
-Certain owners wish to permanently relinquish those rights to a Work for the
-purpose of contributing to a commons of creative, cultural and scientific
-works ("Commons") that the public can reliably and without fear of later
-claims of infringement build upon, modify, incorporate in other works, reuse
-and redistribute as freely as possible in any form whatsoever and for any
-purposes, including without limitation commercial purposes. These owners may
-contribute to the Commons to promote the ideal of a free culture and the
-further production of creative, cultural and scientific works, or to gain
-reputation or greater distribution for their Work in part through the use and
-efforts of others.
-
-For these and/or other purposes and motivations, and without any expectation
-of additional consideration or compensation, the person associating CC0 with a
-Work (the "Affirmer"), to the extent that he or she is an owner of Copyright
-and Related Rights in the Work, voluntarily elects to apply CC0 to the Work
-and publicly distribute the Work under its terms, with knowledge of his or her
-Copyright and Related Rights in the Work and the meaning and intended legal
-effect of CC0 on those rights.
-
-1. Copyright and Related Rights. A Work made available under CC0 may be
-protected by copyright and related or neighboring rights ("Copyright and
-Related Rights"). Copyright and Related Rights include, but are not limited
-to, the following:
-
-  i. the right to reproduce, adapt, distribute, perform, display, communicate,
-  and translate a Work;
-
-  ii. moral rights retained by the original author(s) and/or performer(s);
-
-  iii. publicity and privacy rights pertaining to a person's image or likeness
-  depicted in a Work;
-
-  iv. rights protecting against unfair competition in regards to a Work,
-  subject to the limitations in paragraph 4(a), below;
-
-  v. rights protecting the extraction, dissemination, use and reuse of data in
-  a Work;
-
-  vi. database rights (such as those arising under Directive 96/9/EC of the
-  European Parliament and of the Council of 11 March 1996 on the legal
-  protection of databases, and under any national implementation thereof,
-  including any amended or successor version of such directive); and
-
-  vii. other similar, equivalent or corresponding rights throughout the world
-  based on applicable law or treaty, and any national implementations thereof.
-
-2. Waiver. To the greatest extent permitted by, but not in contravention of,
-applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and
-unconditionally waives, abandons, and surrenders all of Affirmer's Copyright
-and Related Rights and associated claims and causes of action, whether now
-known or unknown (including existing as well as future claims and causes of
-action), in the Work (i) in all territories worldwide, (ii) for the maximum
-duration provided by applicable law or treaty (including future time
-extensions), (iii) in any current or future medium and for any number of
-copies, and (iv) for any purpose whatsoever, including without limitation
-commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes
-the Waiver for the benefit of each member of the public at large and to the
-detriment of Affirmer's heirs and successors, fully intending that such Waiver
-shall not be subject to revocation, rescission, cancellation, termination, or
-any other legal or equitable action to disrupt the quiet enjoyment of the Work
-by the public as contemplated by Affirmer's express Statement of Purpose.
-
-3. Public License Fallback. Should any part of the Waiver for any reason be
-judged legally invalid or ineffective under applicable law, then the Waiver
-shall be preserved to the maximum extent permitted taking into account
-Affirmer's express Statement of Purpose. In addition, to the extent the Waiver
-is so judged Affirmer hereby grants to each affected person a royalty-free,
-non transferable, non sublicensable, non exclusive, irrevocable and
-unconditional license to exercise Affirmer's Copyright and Related Rights in
-the Work (i) in all territories worldwide, (ii) for the maximum duration
-provided by applicable law or treaty (including future time extensions), (iii)
-in any current or future medium and for any number of copies, and (iv) for any
-purpose whatsoever, including without limitation commercial, advertising or
-promotional purposes (the "License"). The License shall be deemed effective as
-of the date CC0 was applied by Affirmer to the Work. Should any part of the
-License for any reason be judged legally invalid or ineffective under
-applicable law, such partial invalidity or ineffectiveness shall not
-invalidate the remainder of the License, and in such case Affirmer hereby
-affirms that he or she will not (i) exercise any of his or her remaining
-Copyright and Related Rights in the Work or (ii) assert any associated claims
-and causes of action with respect to the Work, in either case contrary to
-Affirmer's express Statement of Purpose.
-
-4. Limitations and Disclaimers.
-
-  a. No trademark or patent rights held by Affirmer are waived, abandoned,
-  surrendered, licensed or otherwise affected by this document.
-
-  b. Affirmer offers the Work as-is and makes no representations or warranties
-  of any kind concerning the Work, express, implied, statutory or otherwise,
-  including without limitation warranties of title, merchantability, fitness
-  for a particular purpose, non infringement, or the absence of latent or
-  other defects, accuracy, or the present or absence of errors, whether or not
-  discoverable, all to the greatest extent permissible under applicable law.
-
-  c. Affirmer disclaims responsibility for clearing rights of other persons
-  that may apply to the Work or any use thereof, including without limitation
-  any person's Copyright and Related Rights in the Work. Further, Affirmer
-  disclaims responsibility for obtaining any necessary consents, permissions
-  or other rights required for any use of the Work.
-
-  d. Affirmer understands and acknowledges that Creative Commons is not a
-  party to this document and has no duty or obligation with respect to this
-  CC0 or use of the Work.
-
-For more information, please see
-<http://creativecommons.org/publicdomain/zero/1.0/

data/test/helper.rb

@@ -1,8 +0,0 @@
-## minitest setup
-
-require 'minitest/autorun'
-
-
-## our own code
-
-require 'bytes'

data/test/test_bytes.rb

@@ -1,46 +0,0 @@
-# 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

@@ -1,41 +0,0 @@
-# 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

@@ -1,49 +0,0 @@
-# encoding: utf-8
-
-###
-#  to run use
-#     ruby -I ./lib -I ./test test/test_string.rb
-
-
-require 'helper'
-
-
-class TestString < MiniTest::Test
-
-  def test_string
-     ####
-     # note:  1) String.new gets you String with "binary" encoding
-     #        2) String Literal "" and String.new("")
-     #              gets you String with default encoding (utf-8)
-
-     assert Encoding::ASCII_8BIT == String.new.encoding
-     assert Encoding::ASCII_8BIT == String.new("".b).encoding
-     assert Encoding::ASCII_8BIT == "".b.encoding
-
-     assert Encoding::BINARY == Encoding::ASCII_8BIT
-     assert Encoding::BINARY == String.new.encoding
-     assert Encoding::BINARY == String.new("".b).encoding
-     assert Encoding::BINARY == "".b.encoding
-
-     assert Encoding::UTF_8 == "".encoding
-     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