rasn1 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4eb9957878c25e54a394fee02aab5a42aa1201ad6250f7f6a2a3992128c87d6
-  data.tar.gz: 3b3d3c85d619ee7f78923d7f7c839874f329087b0b1a4094839b059daf94c2ec
+  metadata.gz: b0f5f3f69aaae20cfd16576f565bc52d198bea49921a0db15e3e2a95a4947853
+  data.tar.gz: c3c1f6b2d5019febcbff3812611d624094b7aaefc238bd70109d4c278be3af8c
 SHA512:
-  metadata.gz: 9eb501aacf629355e56a4103dfc3e354bfa035c031a23f2dcc61f8add191a13960cd64ea68db36340694f3b20aba316c0088ebe91943d795405b11489be9342e
-  data.tar.gz: 115cef9248e5251a24ec0bb6d6e977084cfb4ff78118a7f5be31ee8fea05a0c831b935fa72c18bdc08e71bb729a85cff2b394f4a84aafd56245f70908f0a4dc6
+  metadata.gz: 51e54a40d6608074e76ba0d18d51462e82fba109a4258b9082875bafe36476060186d2081cabb4e2d17e1140f53a4700906a053fdb05638ceb060560a337d05b
+  data.tar.gz: 434ca0398606fb411351a2d43b6701b70f9512043abea8768e21832a2a1800be8347efef50b17b01239ce953b49cb21b64860e2d252cc64e9c696a514de564ea

data/README.md

@@ -1,5 +1,4 @@
 [![Gem Version](https://badge.fury.io/rb/rasn1.svg)](https://badge.fury.io/rb/rasn1)
-[![Build Status](https://travis-ci.org/sdaubert/rasn1.svg?branch=master)](https://travis-ci.org/sdaubert/rasn1)
 
 # Rasn1
 

data/lib/rasn1/model.rb

@@ -58,7 +58,10 @@ module RASN1
   # All methods defined by root may be delegated by model, unless model also defines
   # this method.
   # @author Sylvain Daubert
-  class Model
+  class Model # rubocop:disable Metrics/ClassLength
+    # @private
+    Elem = Struct.new(:name, :proc_or_class, :content)
+
     class << self
       # @return [Hash]
       attr_reader :options
@@ -66,8 +69,9 @@ module RASN1
       # Use another model in this model
       # @param [String,Symbol] name
       # @param [Class] model_klass
+      # @return [Elem]
       def model(name, model_klass)
-        @root = [name, model_klass]
+        @root = Elem.new(name, model_klass, nil)
       end
 
       # Update options of root element.
@@ -99,14 +103,17 @@ module RASN1
       # @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" \
@@ -114,9 +121,7 @@ module RASN1
                    "  proc = proc do |opts|\n" \
                    "    Types::#{type.capitalize}.new(options.merge(opts))\n" \
                    "  end\n" \
-                   "  @root = [name, proc]\n" \
-                   "  @root << options[:content] unless options[:content].nil?\n" \
-                   "  @root\n" \
+                   "  @root = Elem.new(name, proc, options[:content])\n" \
                    'end'
       end
 
@@ -124,11 +129,13 @@ module RASN1
       #  @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"
@@ -137,53 +144,64 @@ module RASN1
                    "  proc = proc do |opts|\n" \
                    "    #{klass_name}.new(type, options.merge(opts))\n" \
                    "  end\n" \
-                   "  @root = [name, proc]\n" \
+                   "  @root = Elem.new(name, proc, nil)\n" \
                    'end'
       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
@@ -194,28 +212,30 @@ module RASN1
                    "  proc = proc do |opts|\n" \
                    "    #{prim}.new(options.merge(opts))\n" \
                    "  end\n" \
-                   "  @root = [name, proc]\n" \
+                   "  @root = Elem.new(name, proc, nil)\n" \
                    'end'
       end
 
       # @param [Symbol,String] name name of object in model
       # @param [Hash] options
+      # @return [Elem]
       # @note This method is named +objectid+ and not +object_id+ to not override
       #   +Object#object_id+.
       # @see Types::ObjectId#initialize
       def objectid(name, options={})
         options[:name] = name
         proc = proc { |opts| Types::ObjectId.new(options.merge(opts)) }
-        @root = [name, proc]
+        @root = Elem.new(name, proc, nil)
       end
 
       # @param [Symbol,String] name name of object in model
       # @param [Hash] options
+      # @return [Elem]
       # @see Types::Any#initialize
       def any(name, options={})
         options[:name] = name
         proc = proc { |opts| Types::Any.new(options.merge(opts)) }
-        @root = [name, proc]
+        @root = Elem.new(name, proc, nil)
       end
 
       # Give type name (aka class name)
@@ -233,7 +253,7 @@ module RASN1
       # @raise [ASN1Error] error on parsing
       def parse(str, ber: false)
         model = new
-        model.parse! str, ber: ber
+        model.parse!(str, ber: ber)
         model
       end
     end
@@ -242,8 +262,8 @@ module RASN1
     # @param [Hash] args
     def initialize(args={})
       root = generate_root
-      set_elements(*root)
-      initialize_elements self, args
+      set_elements(root)
+      initialize_elements(self, args)
     end
 
     # Give access to element +name+ in model
@@ -263,10 +283,10 @@ module RASN1
       @elements[name].value = value
     end
 
-    # Get name frm root type
+    # Get name from root type
     # @return [String,Symbol]
     def name
-      @root
+      @root_name
     end
 
     # Get elements names
@@ -281,15 +301,15 @@ module RASN1
       private_to_h
     end
 
-    # @return [String]
-    def to_der
-      @elements[@root].to_der
-    end
-
     # Get root element from model
     # @return [Types::Base,Model]
     def root
-      @elements[@root]
+      @elements[@root_name]
+    end
+
+    # @return [String]
+    def to_der
+      root.to_der
     end
 
     # Give type name (aka class name)
@@ -304,25 +324,37 @@ module RASN1
     # @return [Integer] number of parsed bytes
     # @raise [ASN1Error] error on parsing
     def parse!(str, ber: false)
-      @elements[@root].parse!(str.dup.force_encoding('BINARY'), ber: ber)
+      root.parse!(str.dup.force_encoding('BINARY'), ber: ber)
     end
 
     # @overload value
     #  Get value of root element
     #  @return [Object,nil]
-    # @overload value(name)
+    # @overload value(name, *args)
     #  Direct access to the value of +name+ (nested) element of model.
     #  @param [String,Symbol] name
+    #  @param [Array<Integer,String,Symbol>] args more argument to access element. May be
+    #     used to access content of a SequenceOf or a SetOf
     #  @return [Object,nil]
     # @return [Object,nil]
+    # @example
+    #  class MyModel1 < RASN1::Model
+    #    sequence('seq', content: [boolean('boolean'), integer('int')])
+    #  end
+    #  class MyModel2 < RASN1::Model
+    #    sequence('root', content: [sequence_of('list', MyModel1)])
+    #  end
+    #  model = MyModel2.new
+    #  model.parse!(der)
+    #  # access to 2nd MyModel1.int in list
+    #  model.value('list', 1, 'int')
     def value(name=nil, *args)
       if name.nil?
-        @elements[@root].value
+        root.value
       else
         elt = by_name(name)
 
         unless args.empty?
-          elt = elt.root if elt.is_a?(Model)
           args.each do |arg|
             elt = elt.root if elt.is_a?(Model)
             elt = elt[arg]
@@ -336,8 +368,8 @@ module RASN1
     # Delegate some methods to root element
     # @param [Symbol] meth
     def method_missing(meth, *args)
-      if @elements[@root].respond_to? meth
-        @elements[@root].send meth, *args
+      if root.respond_to? meth
+        root.send meth, *args
       else
         super
       end
@@ -345,7 +377,7 @@ module RASN1
 
     # @return [Boolean]
     def respond_to_missing?(meth, *)
-      @elements[@root].respond_to?(meth) || super
+      root.respond_to?(meth) || super
     end
 
     # @return [String]
@@ -385,6 +417,9 @@ module RASN1
       [Types::Sequence, Types::Set].include? elt.class
     end
 
+    # proc_or_class:
+    # * proc: a Types::Base subclass
+    # * class: a model
     def get_type(proc_or_class, options={})
       case proc_or_class
       when Proc
@@ -395,20 +430,20 @@ module RASN1
     end
 
     def generate_root
-      root = self.class.class_eval { @root }
-      @root = root[0]
+      class_element = self.class.class_eval { @root }
+      @root_name = class_element.name
       @elements = {}
-      @elements[@root] = get_type(root[1], self.class.options || {})
-      root
+      @elements[@root_name] = get_type(class_element.proc_or_class, self.class.options || {})
+      class_element
     end
 
-    def set_elements(name, _elt, content=nil)
-      return unless content.is_a? Array
+    def set_elements(element) # rubocop:disable Naming/AccessorMethodName
+      return unless element.content.is_a? Array
 
-      @elements[name].value = content.map do |name2, proc_or_class, content2|
-        subel = get_type(proc_or_class)
-        @elements[name2] = subel
-        set_elements(name2, proc_or_class, content2) if composed?(subel) && content2.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)
         subel
       end
     end
@@ -423,54 +458,59 @@ module RASN1
 
           initialize_elements obj[name], value
         when Array
-          composed = if obj[name].is_a? Model
-                       obj[name].root
-                     else
-                       obj[name]
-                     end
-          if composed.of_type.is_a? Model
-            value.each do |el|
-              composed << initialize_elements(composed.of_type.class.new, el)
-            end
-          else
-            value.each do |el|
-              obj[name] << el
-            end
-          end
+          initialize_element_from_array(obj[name], value)
         else
           obj[name].value = value
         end
       end
     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 }
+      end
+    end
+
     def private_to_h(element=nil)
-      my_element = element
-      my_element = root if my_element.nil?
+      my_element = element || root
       my_element = my_element.root if my_element.is_a?(Model)
       value = case my_element
               when Types::SequenceOf
-                if my_element.of_type < Model
-                  my_element.value.map { |el| el.to_h.values.first }
-                else
-                  my_element.value.map { |el| private_to_h(el) }
-                end
+                sequence_of_to_h(my_element)
               when Types::Sequence
-                seq = my_element.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)]
-                end
-                seq.compact!
-                Hash[seq]
+                sequence_to_h(my_element)
               else
                 my_element.value
               end
       if element.nil?
-        { @root => value }
+        { @root_name => value }
       else
         value
       end
     end
+
+    def sequence_of_to_h(elt)
+      if elt.of_type < Model
+        elt.value.map { |el| el.to_h.values.first }
+      else
+        elt.value.map { |el| private_to_h(el) }
+      end
+    end
+
+    def sequence_to_h(seq)
+      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)]
+      end
+      ary.compact!
+      ary.to_h
+    end
   end
 end

data/lib/rasn1/types/any.rb

@@ -9,13 +9,15 @@ module RASN1
     class Any < Base
       # @return [String] DER-formated string
       def to_der
-        case @value
-        when Base, Model
-          @value.to_der
-        when nil
-          optional? ? '' : Null.new.to_der
+        if value?
+          case @value
+          when Base, Model
+            @value.to_der
+          else
+            @value.to_s
+          end
         else
-          @value.to_s
+          optional? ? '' : Null.new.to_der
         end
       end
 
@@ -25,7 +27,7 @@ module RASN1
       # @param [Boolean] ber if +true+, accept BER encoding
       # @return [Integer] total number of parsed bytes
       def parse!(der, ber: false)
-        if der.nil? || der.empty?
+        if der.empty?
           return 0 if optional?
 
           raise ASN1Error, 'Expected ANY but get nothing'
@@ -35,25 +37,34 @@ module RASN1
         total_length, = get_data(der[id_size..-1], ber)
         total_length += id_size
 
+        @no_value = false
         @value = der[0, total_length]
 
         total_length
       end
 
       def inspect(level=0)
-        lvl = level >= 0 ? level : 0
-        str = '  ' * lvl
-        str << "#{@name} " unless @name.nil?
-        str << if @value.nil?
-                 '(ANY) NULL'
+        str = common_inspect(level)
+        str << if !value?
+                 'NULL'
                elsif @value.is_a?(OctetString) || @value.is_a?(BitString)
-                 "(ANY) #{@value.type}: #{value.value.inspect}"
+                 "#{@value.type}: #{value.value.inspect}"
                elsif @value.class < Base
-                 "(ANY) #{@value.type}: #{value.value}"
+                 "#{@value.type}: #{value.value}"
                else
-                 "ANY: #{value.to_s.inspect}"
+                 value.to_s.inspect
                end
       end
+
+      def common_inspect(level)
+        lvl = level >= 0 ? level : 0
+        str = '  ' * lvl
+        str << "#{@name} " unless @name.nil?
+        str << asn1_class.to_s.upcase << ' ' unless asn1_class == :universal
+        str << "[#{id}] EXPLICIT " if explicit?
+        str << "[#{id}] IMPLICIT " if implicit?
+        str << '(ANY) '
+      end
     end
   end
 end