rasn1 0.14.0 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fca7c9a3f54b4fb4aea0ab91f4a7e243a4b5874eae10540a04390dcaff340218
-  data.tar.gz: 77e0ef0cd540c787781bb9aae0aada5a3f7770e6060d1ace5c902afb4b212bcb
+  metadata.gz: f4b0dda0fa6e06b6371e74782ecc5b5cc5f9d30dab886a759aa5b9345bd80908
+  data.tar.gz: cfad20040d45598fffda3132bb9c417cdf4fca9dd78dda9616a4b7a0a6a98b97
 SHA512:
-  metadata.gz: 410feb2673c7667bd1efbab93e7e78e8cca4e0f9a815d6cd768a26acea42afe6bce2bbfa4b090c36f411753a77dec08671e0463600c94e12f21081ecc631a13d
-  data.tar.gz: f373028c96806e3034471bd5833345303b572842215a02d7d3612c7614557894c8cf3029783af6b09120ce31db81ac8d84414eca28d5ec76991f39d749a7b801
+  metadata.gz: a99c4ee238423b561470182c3ac415d9a9ff8f11d626af843d203d5c6aedff6969ec0e4b47f68844e4c62153dd238ba4d852f3855e63a091e8c2cf0643d39d89
+  data.tar.gz: 9614d3434f7b05fe01e80bb36cbd82914b565a6e5087e48bc5e44aa7f47d70076ac3b1f542062bf9bc203d8101f4afd21f2ad5b9865011cdff1359e8178c8b19

data/README.md

@@ -1,5 +1,5 @@
 [![Gem Version](https://badge.fury.io/rb/rasn1.svg)](https://badge.fury.io/rb/rasn1)
-[![Action status](https://github.com/lemontree55/rasn1/workflows/ci/badge.svg?branch=master)](https://github.com/lemontree55/rasn1/actions?query=workflow%3Aci)
+[![Action status](https://github.com/lemontree55/rasn1/actions/workflows/ci.yml/badge.svg)](https://github.com/lemontree55/rasn1/actions/workflows/ci.yml)
 
 # Rasn1
 
@@ -15,11 +15,15 @@ gem 'rasn1'
 
 And then execute:
 
-    $ bundle install
+```bash
+bundle install
+```
 
 Or install it yourself as:
 
-    $ gem install rasn1
+```bash
+gem install rasn1
+```
 
 ## Simple usage
 
@@ -31,9 +35,10 @@ decoded_ber = RASN1.parse(ber_string, ber: true)
 ```
 
 ## Advanced usage
+
 All examples below will be based on:
 
-```
+```text
 Record ::= SEQUENCE {
   id        INTEGER,
   room  [0] INTEGER OPTIONAL,
@@ -70,6 +75,7 @@ end
 ```
 
 ### Parse a DER-encoded string
+
 ```ruby
 record = Record.parse(der_string)
 record[:id]             # => RASN1::Types::Integer
@@ -92,6 +98,7 @@ cplx_record[:a_record]        # => Record
 ```
 
 ### Generate a DER-encoded string
+
 ```ruby
 record = Record.new(id: 12)
 record[:id].to_i      # => 12
@@ -110,8 +117,8 @@ record.to_der         # => String
 
 ### More information
 
-see https://github.com/sdaubert/rasn1/wiki
+see <https://github.com/sdaubert/rasn1/wiki>
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/sdaubert/rasn1.
+Bug reports and pull requests are welcome on GitHub at <https://github.com/sdaubert/rasn1>.

data/lib/rasn1/model.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'types/constrained'
-
 module RASN1
   # @abstract
   # {Model} class is a base class to define ASN.1 models.
@@ -64,39 +62,45 @@ module RASN1
   # @author Sylvain Daubert
   # @author adfoster-r7 ModelValidationError, track source location for dynamic class methods
   class Model # rubocop:disable Metrics/ClassLength
-    # @private
-    Elem = Struct.new(:name, :proc_or_class, :content) do
+    # @private Base Element
+    BaseElem = Struct.new(:name, :proc, :content) do
       # @param [String,Symbol] name
-      # @param [Proc,Class] proc_or_class
+      # @param [Proc] proc
       # @param [Array,nil] content
-      def initialize(name, proc_or_class, content)
-        if content.is_a?(Array)
-          duplicate_names = find_all_duplicate_names(content.map(&:name) + [name])
-          raise ModelValidationError, "Duplicate name #{duplicate_names.first} found" if duplicate_names.any?
-        end
-
+      def initialize(name, proc, content)
+        check_duplicates(content.map(&:name) + [name]) unless content.nil?
         super
       end
 
       private
 
-      # @param [Array<String>] names
       # @return [Array<String>] The duplicate names found in the array
       def find_all_duplicate_names(names)
         names.group_by { |name| name }
              .select { |_name, values| values.length > 1 }
              .keys
       end
+
+      def check_duplicates(names)
+        duplicates = find_all_duplicate_names(names)
+        raise ModelValidationError, "Duplicate name #{duplicates.first} found" if duplicates.any?
+      end
     end
 
-    # @private
+    # @private Model Element
+    ModelElem = Struct.new(:name, :klass)
+
+    # @private Wrapper Element
     WrapElem = Struct.new(:element, :options) do
-      # @return [String]
+      # @return [Symbol]
       def name
-        "#{element.name}_wrapper"
+        :"#{element.name}_wrapper"
       end
     end
 
+    # @private Sequence types
+    SEQUENCE_TYPES = [Types::Sequence, Types::SequenceOf, Types::Set, Types::SetOf].freeze
+
     # Define helper methods to define models
     module Accel
       # @return [Hash]
@@ -107,7 +111,7 @@ module RASN1
       # @param [Class] model_klass
       # @return [Elem]
       def model(name, model_klass)
-        @root = Elem.new(name, model_klass, nil)
+        @root = ModelElem.new(name, model_klass)
       end
 
       # Use a {Wrapper} around a {Types::Base} or a {Model} object
@@ -162,7 +166,7 @@ module RASN1
             proc = proc do |opts|
               #{klass}.new(options.merge(opts)) # Sequence.new(options.merge(opts))
             end
-            @root = Elem.new(name, proc, options[:content])
+            @root = BaseElem.new(name, proc, options[:content])
           end
         EVAL
       end
@@ -179,7 +183,7 @@ module RASN1
             proc = proc do |opts|
               #{klass}.new(type, options.merge(opts)) # SequenceOf.new(type, options.merge(opts))
             end
-            @root = Elem.new(name, proc, nil)
+            @root = BaseElem.new(name, proc, nil)
           end
         EVAL
       end
@@ -206,7 +210,7 @@ module RASN1
       def objectid(name, options={})
         options[:name] = name
         proc = proc { |opts| Types::ObjectId.new(options.merge(opts)) }
-        @root = Elem.new(name, proc, nil)
+        @root = BaseElem.new(name, proc, nil)
       end
 
       # @param [Symbol,String] name name of object in model
@@ -216,7 +220,7 @@ module RASN1
       def any(name, options={})
         options[:name] = name
         proc = proc { |opts| Types::Any.new(options.merge(opts)) }
-        @root = Elem.new(name, proc, nil)
+        @root = BaseElem.new(name, proc, nil)
       end
 
       # Give type name (aka class name)
@@ -366,19 +370,35 @@ module RASN1
       self.define_type_accel_base(method_name, prim)
     end
 
+    # @return [Model, Wrapper, Types::Base]
+    attr_reader :root
+
     # Create a new instance of a {Model}
     # @param [Hash] args
     def initialize(args={})
-      root = generate_root
-      generate_elements(root)
-      initialize_elements(self, args)
-    end
-
-    # Give access to element +name+ in model
-    # @param [String,Symbol] name
-    # @return [Types::Base]
-    def [](name)
-      @elements[name]
+      @elements = {}
+      generate_root(args)
+      lazy_initialize(args) unless args.empty?
+    end
+
+    # @overload [](name)
+    #  Access an element of the model by its name
+    #  @param [Symbol] name
+    #  @return [Model, Types::Base, Wrapper]
+    # @overload [](idx)
+    #  Access an element of root element by its index. Root element must be a {Sequence} or {SequenceOf}.
+    #  @param [Integer] idx
+    #  @return [Model, Types::Base, Wrapper]
+    def [](name_or_idx)
+      case name_or_idx
+      when Symbol
+        elt = @elements[name_or_idx]
+        return elt unless elt.is_a?(Proc)
+
+        @elements[name_or_idx] = elt.call
+      when Integer
+        root[name_or_idx]
+      end
     end
 
     # Set value of element +name+. Element should be a {Types::Base}.
@@ -386,13 +406,20 @@ module RASN1
     # @param [Object] value
     # @return [Object] value
     def []=(name, value)
-      raise Error, 'cannot set value for a Model' if @elements[name].is_a? Model
+      # Here, use #[] to force generation for lazy elements
+      raise Error, 'cannot set value for a Model' if self[name].is_a?(Model)
+
+      self[name].value = value
+    end
 
-      @elements[name].value = value
+    # clone @elements and initialize @root from this new @element.
+    def initialize_copy(_other)
+      @elements = @elements.clone
+      @root = @elements[@root_name]
     end
 
-    # Get name from root type
-    # @return [String,Symbol]
+    # Give model name (a.k.a root name)
+    # @return [String]
     def name
       @root_name
     end
@@ -409,12 +436,6 @@ module RASN1
       private_to_h
     end
 
-    # Get root element from model
-    # @return [Types::Base,Model]
-    def root
-      @elements[@root_name]
-    end
-
     # @return [String]
     def to_der
       root.to_der
@@ -427,12 +448,18 @@ module RASN1
     end
 
     # Parse a DER/BER encoded string, and modify object in-place.
-    # @param [String] str
+    # @param [String] der
     # @param [Boolean] ber accept BER encoding or not
     # @return [Integer] number of parsed bytes
     # @raise [ASN1Error] error on parsing
-    def parse!(str, ber: false)
-      root.parse!(str.dup.force_encoding('BINARY'), ber: ber)
+    def parse!(der, ber: false)
+      root.parse!(der, ber: ber)
+    end
+
+    # @private
+    # @see Types::Base#do_parse
+    def do_parse(der, ber: false)
+      root.do_parse(der, ber: ber)
     end
 
     # @overload value
@@ -474,11 +501,13 @@ module RASN1
       end
     end
 
+    # Return a hash image of model
+    # @return [Hash]
     # Delegate some methods to root element
     # @param [Symbol] meth
-    def method_missing(meth, *args)
-      if root.respond_to? meth
-        root.send meth, *args
+    def method_missing(meth, *args, **kwargs)
+      if root.respond_to?(meth)
+        root.send(meth, *args, **kwargs)
       else
         super
       end
@@ -491,7 +520,7 @@ module RASN1
 
     # @return [String]
     def inspect(level=0)
-      '  ' * level + "(#{type}) #{root.inspect(-level)}"
+      "#{'  ' * level}(#{type}) #{root.inspect(-level)}"
     end
 
     # Objects are equal if they have same class AND same DER
@@ -503,127 +532,121 @@ module RASN1
 
     protected
 
-    # Give a (nested) element from its name
-    # @param [String, Symbol] name
-    # @return [Model, Types::Base, nil]
-    def by_name(name)
-      elt = self[name]
-      return elt unless elt.nil?
+    # Initialize model elements from +args+
+    # @param [Hash,Array] args
+    # @return [void]
+    def lazy_initialize(args)
+      case args
+      when Hash
+        lazy_initialize_hash(args)
+      when Array
+        lazy_initialize_array(args)
+      end
+    end
 
-      @elements.each_key do |subelt_name|
-        subelt = self[subelt_name]
-        if subelt.is_a?(Model)
-          elt = subelt[name]
-          return elt unless elt.nil?
+    # Initialize an element from a hash
+    # @param [Hash] args
+    # @return [void]
+    def lazy_initialize_hash(args)
+      args.each do |name, value|
+        element = self[name]
+        case element
+        when Model
+          element.lazy_initialize(value)
+        when nil
+        else
+          element.value = value
         end
       end
-
-      nil
     end
 
-    private
-
-    def composed?(elt)
-      [Types::Sequence, Types::Set].include? elt.class
-    end
+    # Initialize an sequence element from an array
+    # @param [Array] args
+    # @return [void]
+    def lazy_initialize_array(ary)
+      raise Error, 'Only sequence types may be initialized with an array' unless SEQUENCE_TYPES.any? { |klass| root.is_a?(klass) }
 
-    # proc_or_class:
-    # * proc: a Types::Base subclass
-    # * class: a model
-    def get_type(proc_or_class, options={})
-      case proc_or_class
-      when Proc
-        proc_or_class.call(options)
-      when Class
-        proc_or_class.new(options)
+      ary.each do |initializer|
+        root << initializer
       end
     end
 
-    def generate_root
-      class_element = self.class.class_eval { @root }
-      @root_name = class_element.name
-      @elements = {}
-      @elements[@root_name] = case class_element
-                              when WrapElem
-                                generate_wrapper(class_element)
-                              else
-                                get_type(class_element.proc_or_class, self.class.options || {})
-                              end
-      class_element
-    end
-
-    def generate_elements(element)
-      if element.is_a?(WrapElem)
-        generate_wrapper(element)
-        return
-      end
-      return unless element.content.is_a? Array
+    # Give a (nested) element from its name
+    # @param [String, Symbol] name
+    # @return [Model, Types::Base, nil]
+    def by_name(name)
+      elt = self[name]
+      return elt unless elt.nil?
 
-      @elements[name].value = element.content.map do |another_element|
-        add_subelement(another_element)
+      @elements.each_value do |subelt|
+        next unless subelt.is_a?(Model)
+
+        value = subelt.by_name(name)
+        return value unless value.nil?
       end
-    end
 
-    def generate_wrapper(wrap_elem)
-      inner_elem = wrap_elem.element
-      subel = add_subelement(inner_elem)
-      Wrapper.new(subel, wrap_elem.options)
+      nil
     end
 
-    def add_subelement(subelement)
-      case subelement
-      when Elem
-        subel = get_type(subelement.proc_or_class)
-        @elements[subelement.name] = subel
-        generate_elements(subelement) if composed?(subel) && subelement.content.is_a?(Array)
-        subel
+    private
+
+    def generate_root(args)
+      opts = args.slice(:name, :explicit, :implicit, :optional, :class, :default, :constructed, :tag_value)
+      root = self.class.class_eval { @root }
+      root_options = self.class.options || {}
+      root_options.merge!(opts)
+      @root_name = args[:name] || root.name
+      @root = generate_element(root, root_options)
+      @elements[@root_name] = @root
+    end
+
+    def generate_element(elt, opts={})
+      case elt
+      when BaseElem
+        generate_base_element(elt, opts)
+      when ModelElem
+        opts[:name] ||= elt.name
+        elt.klass.new(opts)
       when WrapElem
-        generate_wrapper(subelement)
+        generate_wrapper_element(elt, opts)
       end
     end
 
-    def initialize_elements(obj, args)
-      args.each do |name, value|
-        subobj = obj[name]
-        next unless subobj
-
-        case value
-        when Hash
-          raise ArgumentError, "element #{name}: may only pass a Hash for Model elements" unless subobj.is_a?(Model)
-
-          initialize_elements(subobj, value)
-        when Array
-          initialize_element_from_array(subobj, value)
-        else
-          subobj.value = value
-        end
-      end
+    def generate_wrapper_element(elt, opts)
+      wrapped = elt.element.is_a?(ModelElem) ? elt.element.klass : generate_element(elt.element)
+      options = elt.options.merge(opts)
+      options[:name] = elt.element.name if elt.element.is_a?(ModelElem)
+      wrapper = Wrapper.new(wrapped, options)
+      # Use a proc as wrapper may be lazy
+      @elements[elt.element.name] = proc { wrapper.element }
+      wrapper
     end
 
-    def initialize_element_from_array(obj, value)
-      composed = obj.is_a?(Model) ? obj.root : obj
-      if composed.of_type.is_a?(Model)
-        value.each do |el|
-          composed << initialize_elements(composed.of_type.class.new, el)
-        end
-      else
-        value.each { |el| composed << el }
+    def generate_base_element(elt, opts)
+      element = elt.proc.call(opts)
+      return element if elt.content.nil?
+
+      element.value = elt.content.map do |subel|
+        generated = generate_element(subel)
+        @elements[subel.name] = generated
       end
+      element
     end
 
+    # @author sdaubert
+    # @author lemontree55
+    # @author adfoster-r7
     def private_to_h(element=nil) # rubocop:disable Metrics/CyclomaticComplexity
       my_element = element || root
-      my_element = my_element.root if my_element.is_a?(Model)
       value = case my_element
+              when Model
+                model_to_h(my_element)
               when Types::SequenceOf
                 sequence_of_to_h(my_element)
               when Types::Sequence
                 sequence_to_h(my_element)
-              # @author adfoster-r7
               when Types::Choice
-                raise ChoiceError.new(my_element) if my_element.chosen.nil?
-
-                private_to_h(my_element.value[my_element.chosen])
+                choice_to_h(my_element)
               when Wrapper
                 wrapper_to_h(my_element)
               else
@@ -636,31 +659,48 @@ module RASN1
       end
     end
 
+    def model_to_h(elt)
+      hsh = elt.to_h
+      if root.is_a?(Types::Choice)
+        hsh[hsh.keys.first]
+      else
+        { @elements.key(elt) => hsh[hsh.keys.first] }
+      end
+    end
+
     def sequence_of_to_h(elt)
       if elt.of_type < Model
-        elt.value.map { |el| el.to_h.values.first }
+        elt.value&.map { |el| el.to_h.values.first }
       else
-        elt.value.map { |el| private_to_h(el) }
+        elt.value&.map { |el| private_to_h(el) }
       end
     end
 
     def sequence_to_h(seq)
-      ary = seq.value.map do |el|
+      ary = seq.value&.map do |el|
         next if el.optional? && el.value.nil?
 
         case el
         when Model
-          hsh = el.to_h
-          hsh = hsh[hsh.keys.first]
-          [@elements.key(el), hsh]
+          model_to_h(el).to_a[0]
         when Wrapper
-          [@elements.key(el.element), wrapper_to_h(el)]
+          [unwrap_keyname(@elements.key(el)), wrapper_to_h(el)]
         else
           [el.name, private_to_h(el)]
         end
       end
-      ary.compact!
-      ary.to_h
+      ary.compact.to_h
+    end
+
+    def choice_to_h(elt)
+      raise ChoiceError.new(elt) if elt.chosen.nil?
+
+      chosen = elt.value[elt.chosen]
+      { chosen.name => private_to_h(chosen) }
+    end
+
+    def unwrap_keyname(key)
+      key.to_s.delete_suffix('_wrapper').to_sym
     end
 
     def wrapper_to_h(wrap)

data/lib/rasn1/tracer.rb

@@ -83,8 +83,8 @@ module RASN1
       # @private
       # Parse +der+ with tracing abillity
       # @see #parse!
-      def do_parse_with_tracing(der, ber)
-        ret = do_parse_without_tracing(der, ber)
+      def do_parse_with_tracing(der, ber:)
+        ret = do_parse_without_tracing(der, ber: ber)
         RASN1.tracer.trace(self.trace)
         ret
       end
@@ -131,7 +131,7 @@ module RASN1
         end
 
         # @private
-        # Unpatch {#der_to_value!} to remove tracing ability
+        # Unpatch {#der_to_value} to remove tracing ability
         def stop_tracing
           alias_method :der_to_value, :der_to_value_without_tracing
         end
@@ -156,7 +156,7 @@ module RASN1
         end
 
         # @private
-        # Unpatch {#der_to_value!} to remove tracing ability
+        # Unpatch {#der_to_value} to remove tracing ability
         def stop_tracing
           alias_method :der_to_value, :der_to_value_without_tracing
         end

data/lib/rasn1/types/any.rb

@@ -31,7 +31,7 @@ module RASN1
       # @param [Boolean] ber if +true+, accept BER encoding
       # @return [Integer] total number of parsed bytes
       def parse!(der, ber: false)
-        total_length, _data = do_parse(der, ber)
+        total_length, _data = do_parse(der, ber: ber)
         total_length
       end
 
@@ -70,7 +70,9 @@ module RASN1
         str << '(ANY) '
       end
 
-      def do_parse(der, ber)
+      # @private
+      # @see Types::Base#do_parse
+      def do_parse(der, ber: false)
         if der.empty?
           return [0, ''] if optional?
 
@@ -78,7 +80,7 @@ module RASN1
         end
 
         id_size = Types.decode_identifier_octets(der).last
-        total_length, = get_data(der[id_size..-1], ber)
+        total_length, = get_data(der[id_size..], ber)
         total_length += id_size
 
         @no_value = false