bytemapper 1.0.18 → 1.0.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ac5e3c1befb8f914bd5a4f84d6ce7cb9a41a3f0b451153bc797ab9e6ed848cd
-  data.tar.gz: bba2cd9d3cd7b2361ace18ff87c20783e3545ad1bda12338ae3dc757a6f186f8
+  metadata.gz: dce11df6e4ad42a1c8a81853d2e9188fd9a3caaa02692ef12a58dedcae33e296
+  data.tar.gz: f95e339d989e6346651cc45d07ca0ae1ffd55e2b0a8bd0071b0014b28aa9868c
 SHA512:
-  metadata.gz: 4b13d9d92f750f0354ee3c60be0ac549c132ab071cfc9aed010cb42365ec40416056e1ccde03a9cda8b705b798e47d6d24c2bf90e5933ee202a8ba1337037659
-  data.tar.gz: a6b93b9463f1b0b4335587e3f33566547ec750dfb88906c5054bcb2862a7835f0e62387827ee0a6de76443dd78c28ae9c2dec6875d29bcf559aa1ba15f845ab9
+  metadata.gz: 56c5919a1f298fe359eb3931e941965ac43d003ddf2691c2b93394ca8b0dbdba88ef9b64c55cdda5d0902ac148776bfcc6f6aa7c45d43d6320d5a5f028c0cbfd
+  data.tar.gz: '0698b1a5cc71653eb4044f920f4e4428244c88a8cc08ec22c72324e9943efdbbf0e1c7ec7da91bd319c61fdd3c4a3f9e9271889098f503fbb4f3ad52f112d03c'

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,58 +16,118 @@
 
 module Bytemapper
   require 'bytemapper/registry'
+  require 'bytemapper/shape'
+  require 'bytemapper/type'
   require 'bytemapper/nameable'
-  require 'bytemapper/flattenable'
   require 'bytemapper/chunk'
+  require 'bytemapper/table'
 
   @@registry = Registry.new
 
-  def self.wrap(obj, name = nil, wrapper = {})
-    _wrap(obj, name, wrapper)
-  end
+  class << self
 
-  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) }
+    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 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 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 repeat(obj, times = nil)
+      Table.new(obj, times)
+    end
+
+    def registered?(obj)
+      registry.registered?(obj)
+    end
+
+    def get(obj)
+      registry.get(obj)
     end
-    @@registry
+
+    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)
+      @@registry = Registry.new(with_basic_types)
+    end
+
+    def reverse_lookup(prefix, value = nil)
+      @@rl_cache ||= {}
+      prefix = "#{prefix.to_s}_"
+      lookup = @@rl_cache[prefix]
+
+      if lookup.nil?
+        labels = names.filter { |n| n.start_with?(prefix) } 
+        values = labels.map { |l| get(l) }
+        lookup = Hash[values.zip(labels)]
+        @@rl_cache[prefix] = lookup
+      end
+
+      value.nil? ? lookup : lookup[value]
+    end
+
   end
 end

data/lib/bytemapper/chunk.rb

@@ -15,20 +15,32 @@
 # along with this program. If not, see <https://www.gnu.org/licenses/>.
 
 module Bytemapper
-  class Chunk
-    attr_reader :bytes, :shape, :name
+  require 'bytemapper/flattenable'
+  class Chunk < Hash
+    include Nameable
+    include Flattenable
+    attr_reader :bytes, :shape
 
     def initialize(bytes, shape, name)
       @name = name
       @shape = shape
-      @bytes = bytes
-      bytes.truncate(shape.size)
-
-      shape.flatten.each do |k,v|
+      @bytes = bytes.is_a?(StringIO) ? bytes : StringIO.new(bytes)
+      replace(shape)
+      each_pair do |k,v|
+        self[k] = if v.is_a?(Hash)
+                    Chunk.new(@bytes.read(v.size), v, k)
+                  elsif v.is_a?(Bytemapper::Table)
+                    if v.unbounded?
+                      v.populate(@bytes.read(@bytes.size-@bytes.pos))
+                    else
+                      v.populate(@bytes.read(v.capacity))
+                    end
+                  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
 
     def string
@@ -43,10 +55,22 @@ module Bytemapper
       bytes.string.split(//).map(&:chr)
     end
 
+    def capacity
+      shape.size
+    end
+
     def size
       bytes.size
     end
 
+    def consumed
+      size
+    end
+
+    def remaining
+      capacity - consumed
+    end
+
     def unpack(value, endian = nil)
       num_bytes, flag = value
       _bytes = bytes.read(num_bytes >> 3)

data/lib/bytemapper/flattenable.rb

@@ -21,6 +21,8 @@ module Bytemapper
         k = prefix.nil? ?  k : "#{prefix}_#{k}".to_sym
         if v.is_a?(Hash)
           v.flatten(flattened, k)
+        elsif v.is_a?(Bytemapper::Table)
+          v.each_with_index { |e,i| e.flatten(flattened, i) }
         else
           flattened[k] = v
         end

data/lib/bytemapper/nameable.rb

@@ -5,17 +5,22 @@
 # 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_reader :name
     attr_accessor :names
-    alias :name :names
+
+    def name=(val)
+      @name ||= val.to_sym
+    end
   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/table.rb

@@ -0,0 +1,44 @@
+module Bytemapper
+  module NilTimes
+    refine NilClass do
+      def times
+        0
+      end
+    end
+  end
+
+  class Table < Array
+    include Flattenable
+    include Nameable
+    attr_reader :shape, :rows, :bytes
+    using NilTimes
+
+    def initialize(shape, rows = nil)
+      @shape = Bytemapper.get(shape)
+      rows.times { self << @shape  }
+    end
+
+    def populate(bytes)
+      bytes = bytes.nil? ? '' : bytes
+      @bytes = bytes.is_a?(StringIO) ? bytes : StringIO.new(bytes)
+      @bytes.string.force_encoding(Encoding::ASCII_8BIT)
+      if unbounded?
+        (bytes.size / shape.size).times { self << @shape } 
+      end
+
+      table = Table.new(shape) 
+      table.clear
+      (bytes.size / shape.size).times { table << Chunk.new(@bytes.read(shape.size), shape, shape.name) }
+      table
+    end
+
+    def unbounded?
+      empty?
+    end
+
+    def size
+      empty? ? 0 : 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.18
+  version: 1.0.25
 platform: ruby
 authors:
 - Jefferson Hudson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-30 00:00:00.000000000 Z
+date: 2020-08-14 00:00:00.000000000 Z
 dependencies: []
 description: Model and interact with bytestrings using Ruby objects.
 email: jefferson.hudson@gmail.com
@@ -21,6 +21,10 @@ files:
 - lib/bytemapper/flattenable.rb
 - lib/bytemapper/nameable.rb
 - lib/bytemapper/registry.rb
+- lib/bytemapper/shape.rb
+- lib/bytemapper/table.rb
+- lib/bytemapper/type.rb
+- lib/bytemapper/typeable.rb
 homepage: https://github.com/l4cr0ss/bytemapper
 licenses:
 - AGPL-3.0-or-later