bytemapper 1.0.16 → 1.0.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58da2db82a64cfd1b6eebdb6f61e238a018a9d7722cc28e1a26f0ee9992a8191
-  data.tar.gz: 597ac65da785151a480b7ea756e990d5420e1df8ce7218f6fcb80e1f32f5b5d8
+  metadata.gz: 9383a019c471ccf2979e92c7c2e8a8c7a20f5c63fa74613837c2d38a84632a52
+  data.tar.gz: 903ecf62d057d5ee4f478e022df4129cccf1c9ce545ab60eeef1314bbcbaad67
 SHA512:
-  metadata.gz: 40178210ff809c91e5f4661b7d24f79d565ee1fc7d47d1c3694dcf1db1ff330687c849831ffa495db7111748993e1dcef2e7877787c696b3102eeb3c6d84e7d1
-  data.tar.gz: 8c42f01a701f7bb2a842764efa76f27fef54be61edfff32f100c606851eaecbcea41ab0a10e84b898cffc6efaf30effdaa5c4f4414f166c7a8f4ae3ee3637ec7
+  metadata.gz: 753673f95b723b32f1c0b1aa9dc88418e9e1bc740bc07185a4f5896c05fb388be68f23b5192aeba58bfb3d1c90368687cfda1d7d51471527b1e16e9b0d1b102e
+  data.tar.gz: 21e687cb299ee9aee44a068df8c37cc7a5cca987b7c7175d3677eb3af9ae26a74e5ddc10c1ce8eada691502202a8b5d36dc65e19972e3ac8b70e3e47d2f223c3

data/lib/bytemapper.rb

@@ -1,4 +1,4 @@
-# Bytemapper - Model arbitrary bytestrings as Ruby objects.  
+# Bytemapper - Model arbitrary bytestrings as Ruby objects.
 # Copyright (C) 2020 Jefferson Hudson
 #
 # This program is free software: you can redistribute it and/or modify it under
@@ -16,54 +16,97 @@
 
 module Bytemapper
   require 'bytemapper/registry'
+  require 'bytemapper/shape'
+  require 'bytemapper/type'
   require 'bytemapper/nameable'
-  require 'bytemapper/flattenable'
   require 'bytemapper/chunk'
 
   @@registry = Registry.new
 
-  def self.wrap(obj, name = nil, wrapper = {})
-    if (obj.is_a?(Array) || obj.is_a?(String) || obj.is_a?(Symbol))
-      obj = registry.get(obj, name)
-      raise ArgumentError.new "Object must not be nil" if obj.nil?
-    elsif obj.is_a?(Hash)
-      obj.each do |k, v|
-        wrapper[k] = wrap(v, k)
-        wrapper.define_singleton_method(k) { self.send(:fetch, k) }
+  class << self
+
+    def register(obj, name, fqname = [])
+      return if obj.nil?
+      name = name.downcase.to_sym unless name.nil?
+      fqname << name unless name.nil?
+      if is_a_type?(obj)
+        name = fqname.size > 1 ? fqname.join('.') : fqname.first
+        obj = Type.new(obj)
+        put(obj, name)
+      elsif is_a_name?(obj)
+        register(get(obj), nil, fqname)
+      elsif is_a_shape?(obj)
+        if registered?(obj)
+          obj = get(obj)
+          put(obj, name)
+        else
+          shape = Shape.new
+          obj.each do |k,v|
+            shape[k] = register(v, k, [].concat(fqname))
+          end
+          put(shape, name)
+        end
+      else
+        put(obj, name)
       end
-      wrapper.extend(Flattenable)
-      obj = registry.put(wrapper, name)
-    else
-      raise ArgumentError.new "Invalid object"
     end
-    obj
-  end
+    alias :wrap :register
 
-  def self.map(bytes, shape, name = nil)
-    bytes.force_encoding(Encoding::ASCII_8BIT)
-    bytes = StringIO.new(bytes)
-    wrapper = self.wrap(shape, name)
-    Chunk.new(bytes, wrapper, name)
-  end
+    def is_a_type?(obj)
+      obj.is_a?(Type) ||
+      obj.is_a?(Array) &&
+      obj.size == 2 &&
+      obj.first.is_a?(Integer) &&
+      obj.last.is_a?(String)
+    end
 
-  def self.registry
-    @@registry
-  end
+    def is_a_shape?(obj)
+      obj.is_a?(Hash)
+    end
+
+    def is_a_name?(obj)
+      obj.is_a?(String) || obj.is_a?(Symbol)
+    end
+
+    def map(bytes, shape, name = nil)
+      bytes.force_encoding(Encoding::ASCII_8BIT)
+      bytes = StringIO.new(bytes)
+      if shape.is_a?(Array)
+        chunks = []
+        shape.each { |s| chunks << Chunk.new(bytes.read(s.size), s, name) }
+        chunks
+      else
+        shape = wrap(shape, name)
+        Chunk.new(bytes, shape, name)
+      end
+    end
+
+    def registered?(obj)
+      registry.registered?(obj)
+    end
+
+    def get(obj)
+      registry.get(obj)
+    end
+
+    def put(obj, name)
+      registry.put(obj, name)
+    end
+
+    def names(filter_key = nil)
+      registry.names.keys
+    end
+
+    def print
+      registry.print
+    end
+
+    def registry
+      @@registry
+    end
 
-  def reset(with_basic_types = true)
-    [
-      [:uint8_t, [8,'C']],
-      [:bool, [8,'C']],
-      [:uint16_t, [16,'S']],
-      [:uint32_t, [32,'L']],
-      [:uint64_t, [64,'Q']],
-      [:int8_t, [8,'c']],
-      [:int16_t, [16,'s']],
-      [:int32_t, [32,'l']],
-      [:int64_t, [64,'q']]
-    ].each do |name, type|
-      @@registry.put(type, name)
+    def reset(with_basic_types = true)
+      @@registry = Registry.new(with_basic_types)
     end
-    @@registry
   end
 end

data/lib/bytemapper/chunk.rb

@@ -15,17 +15,25 @@
 # along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 module Bytemapper
-  class Chunk
+  require 'bytemapper/flattenable'
+  class Chunk < Hash
+    include Flattenable
     attr_reader :bytes, :shape, :name
 
     def initialize(bytes, shape, name)
-      @bytes = bytes 
-      @shape = shape
       @name = name
-
-      shape.flatten.each do |k,v|
+      @shape = shape
+      @bytes = bytes.is_a?(StringIO) ? bytes : StringIO.new(bytes)
+      @bytes.truncate(shape.size)
+      replace(shape)
+      each_pair do |k,v|
+        self[k] = if v.is_a?(Hash)
+                    Chunk.new(@bytes.read(v.size), v, k)
+                  else
+                    unpack(v)
+                  end
         singleton_class.instance_eval { attr_reader k }
-        instance_variable_set("@#{k.to_s}", unpack(v))
+        instance_variable_set("@#{k.to_s}", self[k])
       end
     end
 
@@ -42,7 +50,10 @@ module Bytemapper
     end
 
     def size
-      @bytes.size
+      bytes.size
+    end
+
+    def print
     end
 
     def unpack(value, endian = nil)

data/lib/bytemapper/nameable.rb

@@ -5,17 +5,18 @@
 # the terms of the GNU Affero General Public License as published by the Free
 # Software Foundation, either version 3 of the License, or (at your option) any
 # later version.
-
+#
 # This program is distributed in the hope that it will be useful, but WITHOUT
 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 # FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
 # details.
-
+#
 # You should have received a copy of the GNU Affero General Public License
 # along with this program. If not, see <https://www.gnu.org/licenses/>.
+
 module Bytemapper
   module Nameable
+    attr_accessor :name
     attr_accessor :names
-    alias :name :names
   end
 end

data/lib/bytemapper/registry.rb

@@ -1,4 +1,4 @@
-# Bytemapper - Model arbitrary bytestrings as Ruby objects.  
+# Bytemapper - Model arbitrary bytestrings as Ruby objects.
 # Copyright (C) 2020 Jefferson Hudson
 #
 # This program is free software: you can redistribute it and/or modify it under
@@ -37,53 +37,58 @@ module Bytemapper
     end
 
     def registered?(obj)
-      names.key?(obj) || objects.key?(obj.hash)
+      v = registered_name?(obj) if obj.respond_to?(:to_sym)
+      v || registered_obj?(obj)
     end
 
-    def get(obj, name = nil)
-      if (obj.is_a?(String) || obj.is_a?(Symbol))
-        # Object assumed to be a registered name
-        obj = @objects.fetch(@names[obj])
-        register_alias(obj, name) unless name.nil?
-      elsif (obj.is_a?(Array) || obj.is_a?(Hash))
-        obj = put(obj, name)
+    def get(obj)
+      if registered_name?(obj)
+        obj = obj.to_sym.downcase
+        @objects.fetch(@names[obj]) unless obj.nil?
+      elsif registered_obj?(obj)
+        @objects.fetch(obj.hash)
       else
-        raise ArgumentError "Invalid obj"
+        nil
       end
-      obj
     end
 
     def put(obj, name = nil)
       obj = register_obj(obj)
-      register_name(obj, name)
+      register_name(obj, name) unless name.nil?
       obj
     end
 
     def registered_name?(name)
-      @names.key?(name) 
+      if name.respond_to?(:to_sym)
+        name = name.to_sym.downcase
+        @names.key?(name)
+      else
+        false
+      end
     end
 
     def registered_obj?(obj)
-      @objects.key?(obj.hash) 
+      @objects.key?(obj.hash)
     end
 
     def register_obj(obj)
       unless registered_obj?(obj)
-        obj.extend(Nameable)
-        obj.names = Set.new
+        begin
+          obj.extend(Nameable)
+          obj.names = Set.new
+        rescue TypeError
+        end
       end
       @objects[obj.hash] ||= obj
     end
 
     def register_name(obj, name)
-      unless name.nil?
-        if registered_name?(name) && get(name) != obj
-          raise ArgumentError.new 'Name is already registered' 
-        else
-          name = name.to_sym
-          @names[name] ||= obj.hash
-          obj.names << name
-        end
+      if registered_name?(name) && get(name) != obj
+        raise ArgumentError.new 'Name is already registered'
+      else
+        name = name.to_sym.downcase
+        @names[name] ||= obj.hash
+        obj.names << name if obj.respond_to?(:names)
       end
       obj
     end
@@ -99,7 +104,7 @@ module Bytemapper
       # Buffer to build up output.
       buf = StringIO.new
 
-      # Calculate the width of each column.
+      # Calculate the true max width of each column.
       widths = [
         @names.keys.size.zero? ? 0 : @names.keys.map(&:size).max + 1, # add space for the `:`
         7, # length of ID to print
@@ -107,6 +112,10 @@ module Bytemapper
         @objects.values.map { |v| v.to_s.size }.max
       ]
 
+      # Truncate more than `max_width` num chars
+      max_width = 60
+      widths = widths.map { |w| w > max_width ? max_width : w }
+
       # Add an extra space at the beginning and end of each column.
       widths = widths.map { |p| p += 2 }
 
@@ -127,21 +136,29 @@ module Bytemapper
 
           # Fixup the id string so it pads nicely
           idstr = id.positive? ? id.to_s[..5] : id.to_s[..6]
-          idstr = id.positive? ? "  #{idstr}" : " #{idstr}"
+          idstr = id.positive? ? " #{idstr}" : "#{idstr}"
 
-          # Wrap each column value with whitespace.
+          # Generate the column values
           values = [
-          name.empty? ? name : " :#{name} ",
-          idstr,
-          " #{obj.class.to_s} ",
-          " #{obj.to_s} "
+            name.empty? ? name : ":#{name}",
+            idstr,
+            "#{obj.class.to_s}",
+            "#{obj.to_s}"
           ]
 
-          # Calculate padding for each column.
-          pads = widths.zip(values).map { |a,b| a - b.size }
+          # Pad the values to fit in their respective columns, truncating as
+          # needed to stay within `max_width`
+          values = widths.zip(values).map do |w,v|
+            q = w - v.size
+            if q < 2
+              " #{v[..w-7]} ... "
+            else
+              " #{v}#{" "*(q-1)}"
+            end
+          end
 
           values.size.times do |i|
-            buf << "#{values[i]}#{' '*pads[i]}|"
+            buf << "#{values[i]}|"
           end
           buf << "\n"
         end
@@ -164,18 +181,29 @@ module Bytemapper
     private
     def register_basic_types
       [
-        [:char, [8,'c']],
-        [:uchar, [8,'C']],
         [:uint8_t, [8,'C']],
+        [:u8, [8,'C']],
+        [:uchar, [8,'C']],
         [:bool, [8,'C']],
         [:uint16_t, [16,'S']],
+        [:u16, [16,'S']],
         [:uint32_t, [32,'L']],
+        [:u32, [32,'L']],
         [:uint64_t, [64,'Q']],
+        [:u64, [64,'Q']],
         [:int8_t, [8,'c']],
+        [:i8, [8,'c']],
+        [:char, [8,'c']],
         [:int16_t, [16,'s']],
+        [:i16, [16,'s']],
         [:int32_t, [32,'l']],
-        [:int64_t, [64,'q']]
-      ].each { |name, type| put(type, name) }
+        [:i32, [32,'l']],
+        [:int64_t, [64,'q']],
+        [:i64, [64,'q']]
+      ].each do |name, type|
+        type = Type.new(type)
+        put(type, name)
+      end
     end
   end
 end

data/lib/bytemapper/shape.rb

@@ -0,0 +1,34 @@
+# Bytemapper - Model arbitrary bytestrings as Ruby objects.
+# Copyright (C) 2020 Jefferson Hudson
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+module Bytemapper
+  require 'bytemapper/flattenable'
+  require 'bytemapper/nameable'
+  class Shape < Hash
+    include Flattenable
+    include Nameable
+
+    def []=(k,v)
+      super
+      singleton_class.instance_eval { attr_reader k }
+      instance_variable_set("@#{k.to_s}", self[k])
+    end
+
+    def size
+      flatten.values.map(&:size).reduce(:+)
+    end
+  end
+end

data/lib/bytemapper/type.rb

@@ -0,0 +1,26 @@
+# Bytemapper - Model arbitrary bytestrings as Ruby objects.
+# Copyright (C) 2020 Jefferson Hudson
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+module Bytemapper
+  require 'bytemapper/nameable'
+  class Type < Array
+    include Nameable
+
+    def size
+      first / 8
+    end
+  end
+end

data/lib/bytemapper/typeable.rb

@@ -0,0 +1,21 @@
+# Bytemapper - Model arbitrary bytestrings as Ruby objects.  
+# Copyright (C) 2020 Jefferson Hudson
+#
+# This program is free software: you can redistribute it and/or modify it under
+# the terms of the GNU Affero General Public License as published by the Free
+# Software Foundation, either version 3 of the License, or (at your option) any
+# later version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
+# details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+module Bytemapper
+  module Typeable
+    attr_accessor :type
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bytemapper
 version: !ruby/object:Gem::Version
-  version: 1.0.16
+  version: 1.0.22
 platform: ruby
 authors:
 - Jefferson Hudson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-29 00:00:00.000000000 Z
+date: 2020-06-14 00:00:00.000000000 Z
 dependencies: []
 description: Model and interact with bytestrings using Ruby objects.
 email: jefferson.hudson@gmail.com
@@ -21,6 +21,9 @@ files:
 - lib/bytemapper/flattenable.rb
 - lib/bytemapper/nameable.rb
 - lib/bytemapper/registry.rb
+- lib/bytemapper/shape.rb
+- lib/bytemapper/type.rb
+- lib/bytemapper/typeable.rb
 homepage: https://github.com/l4cr0ss/bytemapper
 licenses:
 - AGPL-3.0-or-later