byteman 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 12aa595840a63b8f3737a5f0ed88241d4db1c26d5fdac6a232d2fe2f44fdc1b4
-  data.tar.gz: f6e7c849df1d5194a96a18024aca9210120033b0bde2fb48ef4972c4e4998c72
+  metadata.gz: f97c79daebb65b447178abe2eb39be01d98583d0f813cd60a92cd2b6172d4f31
+  data.tar.gz: a700e4f59a8621fb2c6b9289e42db7ce4715cf897ae487dc2b0ca9021be0d3f5
 SHA512:
-  metadata.gz: f8f5a4caed096e505a08bd44c26bd54f6eef2625018f8c628c7e7010884cde132c9893be2dd928a0922d9126c46aa987d4d2ee4b5e0ce402ae58f2d87ca7c371
-  data.tar.gz: 9f63095dd068bb73b346957450ddbdf776d57c953c60a49d1170543c6f71e6008c622232f2f1cdc7a994840846bb5c47cc568cb27b52c6c56a70afd48b0d3b26
+  metadata.gz: 11117098c87ef66779236692bb2c8dcda4e2225fffe56afbdb606a6467a943e3fab2d77f53cceec083e10878b4913c1b649ef619b2f605d7a1d16f9865e37f9c
+  data.tar.gz: 054cda5e6c527b0ef81032eedb80efd68c50636ffab2fbe68b9153838585b33c55c938fe94cb6e16458d367aa44b2a16302674e30932db55b33c83a670bbc01a

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    byteman (0.1.0)
+    byteman (0.1.1)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,8 +1,6 @@
 # Byteman
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/byteman`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+Simple gem to allow manipulation of data into other forms. Specifically, transform data between byte buffers (integer arrays with every number representing a byte ie an integer from 0-255), hexdigest strings, hex strings, and integers.
 
 ## Installation
 
@@ -22,7 +20,37 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+See spec for most examples. Usage is relatively simple. For example, the `.hex` method can transform hexdigest strings, byte arrays, and integers into its corresponding hex string. For example: 
+
+```ruby
+Byteman.hex(123456) #=> "\x01\xE2@"
+Byteman.hex([92, 123, 1, 209]) #=> "\\{\x01\xD1"
+```
+
+You can pad your numbers to a specific byte length or bit length using the `.pad` method: 
+
+```ruby
+Byteman.pad(num: [43,223], len: 4) #=> [0,0,43, 223]
+Byteman.pad(num: 1234, len: 4) #=> "\x00\x00\x04\xD2"
+Byteman.pad(num: "\xE3\x09", len: 8) #=> "\x00\x00\x00\x00\x00\x00\xE3\x09"
+Byteman.pad(num: 42, len: 8, type: :bits) #=> "00101010"
+Byteman.pad(num: "11001", len: 16, type: :bits) #=> "0000000000011001"
+```
+And there are more methods to facilitate easy manipulation of bytestreams. All are documented with rdoc and are tested in the spec folder. Some of these methods are:
+
+`.digest2buf`, which turns a hexdigest string into a byte buffer:
+```ruby
+Byteman.digest2buf("68656c6c6f20776f726c64") #=> [104, 101, 108, 108, 111, 32, 119, 111, 114, 108, 100]
+```
+
+`.digest2int`, which turns a hexdigest string into an integer:
+```ruby
+Byteman.digest2int("168656c6c6f20776f726c64") #=> 435692254137895873546447972
+
+```
+
+And similar methods such as `.hexdigest`, `.buf2int`, etc. 
+
 
 ## Development
 

data/lib/byteman.rb

@@ -24,16 +24,26 @@ module Byteman
   # Note that this pads 0s to the front of the number, and returns a byte string if an integer or string is the input arg, and returns an array buffer if an array buffer is entered
   #
   # Unexpected results will occur if the number is greater than the number of total padded byte length
-  def self.pad(num: nil, len: , type: :bytes)
+  def self.pad(num: nil, len: , type: :bytes, lsb: false)
     raise ArgumentError.new("Type must be :bytes or :bits") if type != :bytes && type != :bits
     if type == :bytes
       if num.is_a?(Array)
-        overflow = len - (num.length % len)
-        return [0] * overflow + num
+        overflow = len - num.length
+        if overflow == 0
+          return num
+        elsif overflow < 0
+          return num[(num.length - len)..-1]
+        else
+          if lsb
+            return num + ([0] * overflow)
+          else
+            return [0] * overflow + num
+          end
+        end
       elsif num.is_a?(Integer)
-        hex(pad(num: int2buf(num), len: len))
+        hex(pad(num: int2buf(num), len: len, lsb: lsb))
       elsif num.is_a?(String)
-        pad(num: num.unpack("C*"), len: len).pack("C*")
+        pad(num: num.unpack("C*"), len: len, lsb: lsb).pack("C*")
       else
         raise ArgumentError.new("Num must be a Array, Integer, or ByteString")
       end
@@ -45,9 +55,20 @@ module Byteman
       else
         raise ArgumentError("If performing bit padding, the input must be an Integer or a string of bits")
       end
-      overflow = len - (bin_num.length % len)
-      padded = "0" * overflow + bin_num
-      return padded
+      overflow = len - bin_num.length 
+      if overflow == 0
+        return bin_num
+      elsif overflow < 0
+        return bin_num[(bin_num.length - len)..-1]
+      else
+        if lsb
+          padded = bin_num + "0" * overflow 
+          return padded
+        else
+          padded = "0" * overflow + bin_num
+          return padded
+        end
+      end
     end
   end
 

data/lib/byteman/version.rb

@@ -1,3 +1,3 @@
 module Byteman
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: byteman
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - micahshute
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-06-26 00:00:00.000000000 Z
+date: 2020-07-21 00:00:00.000000000 Z
 dependencies: []
 description: Allows simple transformation of data into hex strings, hexdigest strings,
   integer byte arrays, etc. as well as padding your data to a certain byte length