rasn1 0.10.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d38c6038ef58e60eb51d02fc20416188918a736386c4273a713f1be2d2535a1
-  data.tar.gz: fd3b045acdd39707540c3909f24aa8a2e2ae6ed11e46339f90903b7ef96da0df
+  metadata.gz: 552859c3f49caec5374c8db4459ad23e1f9c43e930b0d6511cab8f997c798d20
+  data.tar.gz: 29eaf2fc529b470c9bc6283efbaf82e580d5b4b86d5c46920ee4a882a18b0d72
 SHA512:
-  metadata.gz: f21443bccf45e549a1999bedcef1858ff175ab9e65bdb09f048ad4723d4ac64be80338cbff491ddaf31654aabaa1ad567af4925edf24297e757a42c901684ff2
-  data.tar.gz: ad0a89d6a6d634b83fe89f45f64f327f5740f68be8dfe6ca143bcfcf028e387c9859ec665da82e5f0f8d3576133ef74cf63b24d511da19e2589a53909bcf95ce
+  metadata.gz: 9e5df0e417db7e1f02accae9cc4f17b4a49975d1dc17b716dbf587bb3f5e8ca68ed842d22358d7de037041255c164df5a92c6ada52adba944f0ac635793a64b1
+  data.tar.gz: e193284ea13ca5f80a460b8b390839a0283a8424ca8201f24cbd6113919399fcd5b83a2fc39dd5b26925187e19930a1aceccb1485255de8301435e20a2c82761

data/lib/rasn1/errors.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RASN1
+  # Base error class
+  class Error < StandardError; end
+
+  # ASN.1 encoding/decoding error
+  class ASN1Error < Error; end
+
+  # ASN.1 class error
+  class ClassError < Error
+    # @return [String]
+    def message
+      "Tag class should be a symbol among: #{Types::Base::CLASSES.keys.join(', ')}"
+    end
+  end
+
+  # Enumerated error
+  class EnumeratedError < Error; end
+
+  # CHOICE error: #chosen not set
+  class ChoiceError < RASN1::Error
+    # @param [Types::Base] object
+    def initialize(object)
+      @object = object
+      super()
+    end
+
+    def message
+      "CHOICE #{@object.name}: #chosen not set"
+    end
+  end
+
+  # Exception raised when a constraint is not verified on a constrained type.
+  # @version 0.11.0
+  # @author Sylvain Daubert
+  class ConstraintError < Error
+    # @param [Types::Base] object
+    def initialize(object)
+      @object = object
+      super()
+    end
+
+    # @return [String]
+    def message
+      "Constraint not verified on #{@object.inspect}"
+    end
+  end
+
+  # Exception raised when model validation fails
+  # @since 0.12.0
+  class ModelValidationError < Error
+  end
+end

data/lib/rasn1/model.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'types/constrained'
+
 module RASN1
   # @abstract
   # {Model} class is a base class to define ASN.1 models.
@@ -18,6 +20,8 @@ module RASN1
   #                       integer(:house, explicit: 1, default: 0)])
   #  end
   #
+  # In a model, each element must have a unique name.
+  #
   # === Parse a DER-encoded string
   #  record = Record.parse(der_string)
   #  record[:id]             # => RASN1::Types::Integer
@@ -58,11 +62,38 @@ module RASN1
   # All methods defined by root may be delegated by model, unless model also defines
   # this method.
   # @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)
+    Elem = Struct.new(:name, :proc_or_class, :content) do
+      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
+
+        super
+      end
 
-    class << self
+      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
+    end
+
+    # @private
+    WrapElem = Struct.new(:element, :options) do
+      def name
+        "#{element.name}_wrapper"
+      end
+    end
+
+    module Accel
       # @return [Hash]
       attr_reader :options
 
@@ -74,6 +105,15 @@ module RASN1
         @root = Elem.new(name, model_klass, nil)
       end
 
+      # Use a {Wrapper} around a {Types::Base} or a {Model} object
+      # @param [Types::Base,Model] element
+      # @param [Hash] options
+      # @return [WrapElem]
+      # @since 0.12
+      def wrapper(element, options={})
+        @root = WrapElem.new(element, options)
+      end
+
       # Update options of root element.
       # May be used when subclassing.
       #  class Model1 < RASN1::Model
@@ -87,8 +127,13 @@ module RASN1
       #  end
       # @param [Hash] options
       # @return [void]
+      # @since 0.12.0 may change name through +:name+
       def root_options(options)
         @options = options
+        return unless options.key?(:name)
+
+        @root = @root.dup
+        @root.name = options[:name]
       end
 
       # On inheritance, create +@root+ class variable
@@ -100,120 +145,44 @@ module RASN1
         klass.class_eval { @root = root }
       end
 
-      # @method sequence(name, options)
-      #  @param [Symbol,String] name name of object in model
-      #  @param [Hash] options
-      #  @return [Elem]
-      #  @see Types::Sequence#initialize
-      # @method set(name, options)
-      #  @param [Symbol,String] name name of object in model
-      #  @param [Hash] options
-      #  @return [Elem]
-      #  @see Types::Set#initialize
-      # @method choice(name, options)
-      #  @param [Symbol,String] name name of object in model
-      #  @param [Hash] options
-      #  @return [Elem]
-      #  @see Types::Choice#initialize
-      %w[sequence set choice].each do |type|
-        class_eval "def #{type}(name, options={})\n" \
-                   "  options.merge!(name: name)\n" \
-                   "  proc = proc do |opts|\n" \
-                   "    Types::#{type.capitalize}.new(options.merge(opts))\n" \
-                   "  end\n" \
-                   "  @root = Elem.new(name, proc, options[:content])\n" \
-                   'end'
+      # @since 0.11.0
+      # @since 0.12.0 track source location on error (adfoster-r7)
+      def define_type_accel_base(accel_name, klass)
+        singleton_class.class_eval <<-EVAL, __FILE__, __LINE__ + 1
+          def #{accel_name}(name, options={}) # def sequence(name, type, options)
+            options[:name] = name
+            proc = proc do |opts|
+              #{klass}.new(options.merge(opts)) # Sequence.new(options.merge(opts))
+            end
+            @root = Elem.new(name, proc, options[:content])
+          end
+        EVAL
       end
 
-      # @method sequence_of(name, type, options)
-      #  @param [Symbol,String] name name of object in model
-      #  @param [Model, Types::Base] type type for SEQUENCE OF
-      #  @param [Hash] options
-      #  @return [Elem]
-      #  @see Types::SequenceOf#initialize
-      # @method set_of(name, type, options)
-      #  @param [Symbol,String] name name of object in model
-      #  @param [Model, Types::Base] type type for SET OF
-      #  @param [Hash] options
-      #  @return [Elem]
-      #  @see Types::SetOf#initialize
-      %w[sequence set].each do |type|
-        klass_name = "Types::#{type.capitalize}Of"
-        class_eval "def #{type}_of(name, type, options={})\n" \
-                   "  options.merge!(name: name)\n" \
-                   "  proc = proc do |opts|\n" \
-                   "    #{klass_name}.new(type, options.merge(opts))\n" \
-                   "  end\n" \
-                   "  @root = Elem.new(name, proc, nil)\n" \
-                   'end'
+      # @since 0.11.0
+      # @since 0.12.0 track source location on error (adfoster-r7)
+      def define_type_accel_of(accel_name, klass)
+        singleton_class.class_eval <<-EVAL, __FILE__, __LINE__ + 1
+          def #{accel_name}_of(name, type, options={}) # def sequence_of(name, type, options)
+            options[:name] = name
+            proc = proc do |opts|
+              #{klass}.new(type, options.merge(opts)) # SequenceOf.new(type, options.merge(opts))
+            end
+            @root = Elem.new(name, proc, nil)
+          end
+        EVAL
       end
 
-      # @method boolean(name, options)
-      #  @param [Symbol,String] name name of object in model
-      #  @param [Hash] options
-      #  @return [Elem]
-      #  @see Types::Boolean#initialize
-      # @method integer(name, options)
-      #  @param [Symbol,String] name name of object in model
-      #  @param [Hash] options
-      #  @return [Elem]
-      #  @see Types::Integer#initialize
-      # @method bit_string(name, options)
-      #  @param [Symbol,String] name name of object in model
-      #  @param [Hash] options
-      #  @return [Elem]
-      #  @see Types::BitString#initialize
-      # @method octet_string(name, options)
-      #  @param [Symbol,String] name name of object in model
-      #  @param [Hash] options
-      #  @return [Elem]
-      #  @see Types::OctetString#initialize
-      # @method null(name, options)
-      #  @param [Symbol,String] name name of object in model
-      #  @param [Hash] options
-      #  @return [Elem]
-      #  @see Types::Null#initialize
-      # @method enumerated(name, options)
-      #  @param [Symbol,String] name name of object in model
-      #  @param [Hash] options
-      #  @return [Elem]
-      #  @see Types::Enumerated#initialize
-      # @method utf8_string(name, options)
-      #  @param [Symbol,String] name name of object in model
-      #  @param [Hash] options
-      #  @return [Elem]
-      #  @see Types::Utf8String#initialize
-      # @method numeric_string(name, options)
-      #  @param [Symbol,String] name name of object in model
-      #  @param [Hash] options
-      #  @return [Elem]
-      #  @see Types::NumericString#initialize
-      # @method printable_string(name, options)
-      #  @param [Symbol,String] name name of object in model
-      #  @param [Hash] options
-      #  @return [Elem]
-      #  @see Types::PrintableString#initialize
-      # @method visible_string(name, options)
-      #  @param [Symbol,String] name name of object in model
-      #  @param [Hash] options
-      #  @return [Elem]
-      #  @see Types::VisibleString#initialize
-      # @method ia5_string(name, options)
-      #  @param [Symbol,String] name name of object in model
-      #  @param [Hash] options
-      #  @return [Elem]
-      #  @see Types::IA5String#initialize
-      Types.primitives.each do |prim|
-        next if prim == Types::ObjectId
-
-        method_name = prim.type.gsub(/([a-z0-9])([A-Z])/, '\1_\2').downcase.gsub(/\s+/, '_')
-        class_eval "def #{method_name}(name, options={})\n" \
-                   "  options.merge!(name: name)\n" \
-                   "  proc = proc do |opts|\n" \
-                   "    #{prim}.new(options.merge(opts))\n" \
-                   "  end\n" \
-                   "  @root = Elem.new(name, proc, nil)\n" \
-                   'end'
+      # Define an accelarator to access a type in a model definition
+      # @param [String] accel_name
+      # @param [Class] klass
+      # @since 0.11.0
+      def define_type_accel(accel_name, klass)
+        if klass < Types::SequenceOf
+          define_type_accel_of(accel_name, klass)
+        else
+          define_type_accel_base(accel_name, klass)
+        end
       end
 
       # @param [Symbol,String] name name of object in model
@@ -258,11 +227,126 @@ module RASN1
       end
     end
 
+    extend Accel
+
+    # @!method sequence(name, options)
+    #  @!scope class
+    #  @param [Symbol,String] name name of object in model
+    #  @param [Hash] options
+    #  @return [Elem]
+    #  @see Types::Sequence#initialize
+    # @!method set(name, options)
+    #  @!scope class
+    #  @param [Symbol,String] name name of object in model
+    #  @param [Hash] options
+    #  @return [Elem]
+    #  @see Types::Set#initialize
+    # @!method choice(name, options)
+    #  @!scope class
+    #  @param [Symbol,String] name name of object in model
+    #  @param [Hash] options
+    #  @return [Elem]
+    #  @see Types::Choice#initialize
+    %w[sequence set choice].each do |type|
+      self.define_type_accel_base(type, Types.const_get(type.capitalize))
+    end
+
+    # @!method sequence_of(name, type, options)
+    #  @!scope class
+    #  @param [Symbol,String] name name of object in model
+    #  @param [Model, Types::Base] type type for SEQUENCE OF
+    #  @param [Hash] options
+    #  @return [Elem]
+    #  @see Types::SequenceOf#initialize
+    # @!method set_of(name, type, options)
+    #  @!scope class
+    #  @param [Symbol,String] name name of object in model
+    #  @param [Model, Types::Base] type type for SET OF
+    #  @param [Hash] options
+    #  @return [Elem]
+    #  @see Types::SetOf#initialize
+    %w[sequence set].each do |type|
+      define_type_accel_of(type, Types.const_get("#{type.capitalize}Of"))
+    end
+
+    # @!method boolean(name, options)
+    #  @!scope class
+    #  @param [Symbol,String] name name of object in model
+    #  @param [Hash] options
+    #  @return [Elem]
+    #  @see Types::Boolean#initialize
+    # @!method integer(name, options)
+    #  @!scope class
+    #  @param [Symbol,String] name name of object in model
+    #  @param [Hash] options
+    #  @return [Elem]
+    #  @see Types::Integer#initialize
+    # @!method bit_string(name, options)
+    #  @!scope class
+    #  @param [Symbol,String] name name of object in model
+    #  @param [Hash] options
+    #  @return [Elem]
+    #  @see Types::BitString#initialize
+    # @!method octet_string(name, options)
+    #  @!scope class
+    #  @param [Symbol,String] name name of object in model
+    #  @param [Hash] options
+    #  @return [Elem]
+    #  @see Types::OctetString#initialize
+    # @!method null(name, options)
+    #  @!scope class
+    #  @param [Symbol,String] name name of object in model
+    #  @param [Hash] options
+    #  @return [Elem]
+    #  @see Types::Null#initialize
+    # @!method enumerated(name, options)
+    #  @!scope class
+    #  @param [Symbol,String] name name of object in model
+    #  @param [Hash] options
+    #  @return [Elem]
+    #  @see Types::Enumerated#initialize
+    # @!method utf8_string(name, options)
+    #  @!scope class
+    #  @param [Symbol,String] name name of object in model
+    #  @param [Hash] options
+    #  @return [Elem]
+    #  @see Types::Utf8String#initialize
+    # @!method numeric_string(name, options)
+    #  @!scope class
+    #  @param [Symbol,String] name name of object in model
+    #  @param [Hash] options
+    #  @return [Elem]
+    #  @see Types::NumericString#initialize
+    # @!method printable_string(name, options)
+    #  @!scope class
+    #  @param [Symbol,String] name name of object in model
+    #  @param [Hash] options
+    #  @return [Elem]
+    #  @see Types::PrintableString#initialize
+    # @!method visible_string(name, options)
+    #  @!scope class
+    #  @param [Symbol,String] name name of object in model
+    #  @param [Hash] options
+    #  @return [Elem]
+    #  @see Types::VisibleString#initialize
+    # @!method ia5_string(name, options)
+    #  @!scope class
+    #  @param [Symbol,String] name name of object in model
+    #  @param [Hash] options
+    #  @return [Elem]
+    #  @see Types::IA5String#initialize
+    Types.primitives.each do |prim|
+      next if prim == Types::ObjectId
+
+      method_name = prim.type.gsub(/([a-z0-9])([A-Z])/, '\1_\2').downcase.gsub(/\s+/, '_')
+      self.define_type_accel_base(method_name, prim)
+    end
+
     # Create a new instance of a {Model}
     # @param [Hash] args
     def initialize(args={})
       root = generate_root
-      set_elements(root)
+      generate_elements(root)
       initialize_elements(self, args)
     end
 
@@ -273,7 +357,7 @@ module RASN1
       @elements[name]
     end
 
-    # Set value of element +name+. Element should be a {Base}.
+    # Set value of element +name+. Element should be a {Types::Base}.
     # @param [String,Symbol] name
     # @param [Object] value
     # @return [Object] value
@@ -425,7 +509,7 @@ module RASN1
       when Proc
         proc_or_class.call(options)
       when Class
-        proc_or_class.new
+        proc_or_class.new(options)
       end
     end
 
@@ -437,14 +521,33 @@ module RASN1
       class_element
     end
 
-    def set_elements(element) # rubocop:disable Naming/AccessorMethodName
+    def generate_elements(element)
+      if element.is_a?(WrapElem)
+        generate_wrapper(element)
+        return
+      end
       return unless element.content.is_a? Array
 
       @elements[name].value = element.content.map do |another_element|
-        subel = get_type(another_element.proc_or_class)
-        @elements[another_element.name] = subel
-        set_elements(another_element) if composed?(subel) && another_element.content.is_a?(Array)
+        add_subelement(another_element)
+      end
+    end
+
+    def generate_wrapper(wrap_elem)
+      inner_elem = wrap_elem.element
+      subel = add_subelement(inner_elem)
+      Wrapper.new(subel, wrap_elem.options)
+    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
+      when WrapElem
+        generate_wrapper(subelement)
       end
     end
 
@@ -454,7 +557,7 @@ module RASN1
 
         case value
         when Hash
-          raise ArgumentError, "element #{name}: may only pass a Hash for Model elements" unless obj[name].is_a? Model
+          raise ArgumentError, "element #{name}: may only pass a Hash for Model elements" unless obj[name].is_a?(Model)
 
           initialize_elements obj[name], value
         when Array
@@ -476,7 +579,7 @@ module RASN1
       end
     end
 
-    def private_to_h(element=nil)
+    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
@@ -484,6 +587,13 @@ module RASN1
                 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])
+              when Wrapper
+                wrapper_to_h(my_element)
               else
                 my_element.value
               end
@@ -506,11 +616,29 @@ module RASN1
       ary = seq.value.map do |el|
         next if el.optional? && el.value.nil?
 
-        name = el.is_a?(Model) ? @elements.key(el) : el.name
-        [name, private_to_h(el)]
+        case el
+        when Model
+          hsh = el.to_h
+          hsh = hsh[hsh.keys.first]
+          [@elements.key(el), hsh]
+        when Wrapper
+          [@elements.key(el.element), wrapper_to_h(el)]
+        else
+          [el.name, private_to_h(el)]
+        end
       end
       ary.compact!
       ary.to_h
     end
+
+    def wrapper_to_h(wrap)
+      case wrap.element
+      when Model
+        hsh = wrap.element.to_h
+        hsh[hsh.keys.first]
+      else
+        private_to_h(wrap.element)
+      end
+    end
   end
 end

data/lib/rasn1/types/any.rb

@@ -21,6 +21,10 @@ module RASN1
         end
       end
 
+      def can_build?
+        value? || !optional?
+      end
+
       # Parse a DER string. This method updates object: {#value} will be a DER
       # string.
       # @param [String] der DER string