rasn1 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e9f8ffeb57fd641930cbe2e820c903102ed404e6
-  data.tar.gz: 8d214577ea3085f99a96926e9e26a81f3148e262
+  metadata.gz: 38f025ab48cabca987b7e0813332e9228ab1933a
+  data.tar.gz: 84ed306ccd84238b89ea1e02f2b73a9bf8558f41
 SHA512:
-  metadata.gz: c6a96e1e65a1fccaa036b984933fda1b3f5c43d03c0a6b05fb262b3b2a3a1cf6aebb4de0e87bf38455ea726f1a21ec793e307dfe24dd94b202ef0428b7db79dd
-  data.tar.gz: cbad3dcc907ef35b8bb6689fa4d35b04797c2374f7e9a7f9b26349b0da3bdb99ec71b7262c3018104175d64b9d3922bd0d8564b194f2616f3a02c60415ea631b
+  metadata.gz: a3b4edc322d49eb3e68ecccada5e5022c7f0d08e183a71b991faf62b488c6e70753e531e0a7b5d7bce6bf0a9f4a41da74162f476631097abfd42631962856529
+  data.tar.gz: 6144b8db2f536adc0f8d0f61727724b556058fadd14f02666d5f91df8dfd7f0b92a93a2e30c4a51526a61d6997f3b102e8a2b876d2fc74556190e8cf512854cf

data/.travis.yml

@@ -4,6 +4,6 @@ rvm:
   - 2.3.4
   - 2.4.1
 install:
-  - bundler install --path vendor/bundle --jobs=3 --retry=3
+  - bundle install --path vendor/bundle --jobs=3 --retry=3
 script:
-  - bundler exec rake
+  - bundle exec rake

data/lib/rasn1.rb

@@ -29,4 +29,35 @@ module RASN1
       "CHOICE #@name: #chosen not set"
     end
   end
+  
+  # Parse a DER/BER string without checking a model
+  # @note If you want to check ASN.1 grammary, you should define a {Model}
+  #       and use {Model#parse}.
+  # @note This method will never decode SEQUENCE OF or SET OF objects, as these
+  #       ones use the same encoding as SEQUENCE and SET, respectively.
+  # @note Real type of tagged value cannot be guessed. So, such tag will
+  #       generate {Types::Base} objects.
+  # @param [String] der binary string to parse
+  # @param [Boolean] ber if +true+, decode a BER string, else a DER one
+  # @return [Types::Base]
+  def self.parse(der, ber: false)
+    root = nil
+    while der.size > 0
+      type = Types.tag2type(der[0].ord)
+      type.parse!(der, ber: ber)
+      root = type if root.nil?
+
+      if [Types::Sequence, Types::Set].include? type.class
+        subder = type.value
+        ary = []
+        while subder.size > 0
+          ary << self.parse(subder)
+          subder = subder[ary.last.to_der.size..-1]
+        end
+        type.value = ary
+      end
+      der = der[type.to_der.size..-1]
+    end
+    root
+  end
 end

data/lib/rasn1/model.rb

@@ -95,15 +95,22 @@ module RASN1
       end
 
       # @method sequence(name, options)
+      #  @param [Symbol,String] name name of object in model
+      #  @param [Hash] options
       #  @see Types::Sequence#initialize
       # @method set(name, options)
+      #  @param [Symbol,String] name name of object in model
+      #  @param [Hash] options
       #  @see Types::Set#initialize
       # @method choice(name, options)
+      #  @param [Symbol,String] name name of object in model
+      #  @param [Hash] options
       #  @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.new do |opts|\n" \
-                   "    Types::#{type.capitalize}.new(name, options.merge(opts))\n" \
+                   "    Types::#{type.capitalize}.new(options.merge(opts))\n" \
                    "  end\n" \
                    "  @root = [name, proc]\n" \
                    "  @root << options[:content] unless options[:content].nil?\n" \
@@ -112,54 +119,82 @@ module RASN1
       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
       #  @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
       #  @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.new do |opts|\n" \
-                   "    #{klass_name}.new(name, type, options.merge(opts))\n" \
+                   "    #{klass_name}.new(type, options.merge(opts))\n" \
                    "  end\n" \
                    "  @root = [name, proc]\n" \
                    "end"
       end
 
       # @method boolean(name, options)
+      #  @param [Symbol,String] name name of object in model
+      #  @param [Hash] options
       #  @see Types::Boolean#initialize
       # @method integer(name, options)
+      #  @param [Symbol,String] name name of object in model
+      #  @param [Hash] options
       #  @see Types::Integer#initialize
       # @method bit_string(name, options)
+      #  @param [Symbol,String] name name of object in model
+      #  @param [Hash] options
       #  @see Types::BitString#initialize
       # @method octet_string(name, options)
+      #  @param [Symbol,String] name name of object in model
+      #  @param [Hash] options
       #  @see Types::OctetString#initialize
       # @method null(name, options)
+      #  @param [Symbol,String] name name of object in model
+      #  @param [Hash] options
       #  @see Types::Null#initialize
       # @method enumerated(name, options)
+      #  @param [Symbol,String] name name of object in model
+      #  @param [Hash] options
       #  @see Types::Enumerated#initialize
       # @method utf8_string(name, options)
+      #  @param [Symbol,String] name name of object in model
+      #  @param [Hash] options
       #  @see Types::Utf8String#initialize
       Types.primitives.each do |prim|
         next if prim == Types::ObjectId
         class_eval "def #{prim.type.downcase.gsub(/\s+/, '_')}(name, options={})\n" \
+                   "  options.merge!(name: name)\n" \
                    "  proc = Proc.new do |opts|\n" \
-                   "    #{prim.to_s}.new(name, options.merge(opts))\n" \
+                   "    #{prim.to_s}.new(options.merge(opts))\n" \
                    "  end\n" \
                    "  @root = [name, proc]\n" \
                    "end"
       end
 
+      # @param [Symbol,String] name name of object in model
+      # @param [Hash] options
       # @note This method is named +objectid+ and not +object_id+ to not override
       #   +Object#object_id+.
       # @see Types::ObjectId#initialize
       def objectid(name, options={})
-        proc = Proc.new { |opts| Types::ObjectId.new(name, options.merge(opts)) }
+        options.merge!(name: name)
+        proc = Proc.new { |opts| Types::ObjectId.new(options.merge(opts)) }
         @root = [name, proc]
       end
 
+      # @param [Symbol,String] name name of object in model
+      # @param [Hash] options
       # @see Types::Any#initialize
       def any(name, options={})
-        proc = Proc.new { |opts| Types::Any.new(name, options.merge(opts)) }
+        options.merge!(name: name)
+        proc = Proc.new { |opts| Types::Any.new(options.merge(opts)) }
         @root = [name, proc]
       end
 
@@ -186,7 +221,7 @@ module RASN1
     # @param [Hash] args
     def initialize(args={})
       root = generate_root
-      set_elements *root
+      set_elements(*root)
       initialize_elements self, args
     end
 
@@ -209,7 +244,7 @@ module RASN1
     # Get name frm root type
     # @return [String,Symbol]
     def name
-      @elements[@root].name
+      @root
     end
 
     # Get elements names
@@ -221,7 +256,7 @@ module RASN1
     # Return a hash image of model
     # @return [Hash]
     def to_h
-      { @root => private_to_h(@elements[@root]) }
+      private_to_h
     end
 
     # @return [String]
@@ -328,27 +363,32 @@ module RASN1
       end
     end
 
-    def private_to_h(element)
-      if element.is_a?(Types::SequenceOf) or
-         (element.is_a?(Model) and element.root.is_a?(Types::SequenceOf))
-        element.value.map { |el| private_to_h(el) }
-      elsif element.value.is_a? Array
-        h = {}
-        element.value.each do |subel|
-          case subel
-          when Types::Sequence, Types::Set
-            h[subel.name] = private_to_h(subel)
-          when Model
-            this_name = @elements.key(subel) || element.name
-            h[this_name] = subel.to_h[subel.name]
-          else
-            next if subel.value.nil? and subel.optional?
-            h[subel.name] = subel.value
-          end
-        end
-        h
+    def private_to_h(element=nil)
+      my_element = element
+      my_element = root if my_element.nil?
+      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
+              when Types::Sequence
+                seq = my_element.value.map do |el|
+                        next if el.optional? and el.value.nil?
+                        name = el.is_a?(Model) ? @elements.key(el) : el.name
+                        [name, private_to_h(el)]
+                      end
+                seq.compact!
+                Hash[seq]
+              else
+                my_element.value
+              end
+      if element.nil?
+        { @root => value }
       else
-        element.value
+        value
       end
     end
   end

data/lib/rasn1/types.rb

@@ -6,15 +6,42 @@ module RASN1
     # Give all primitive types
     # @return [Array<Types::Primitive>]
     def self.primitives
-      self.constants.map { |c| Types.const_get(c) }.
-          select { |klass| klass < Primitive }
+      @primitives ||= self.constants.map { |c| Types.const_get(c) }.
+                           select { |klass| klass < Primitive }
     end
 
     # Give all constructed types
     # @return [Array<Types::Constructed>]
     def self.constructed
-      self.constants.map { |c| Types.const_get(c) }.
-          select { |klass| klass < Constructed }
+      @constructed ||= self.constants.map { |c| Types.const_get(c) }.
+                            select { |klass| klass < Constructed }
+    end
+
+    # Give ASN.1 type from an integer. If +tag+ is unknown, return a {Types::Base}
+    # object.
+    # @param [Integer] tag
+    # @return [Types::Base]
+    # @raise [ASN1Error] +tag+ is out of range
+    def self.tag2type(tag)
+      raise ASN1Error, "tag is out of range" if tag > 0xff
+
+      if !defined? @tag2types
+        constructed = self.constructed - [Types::SequenceOf, Types::SetOf]
+        primitives = self.primitives - [Types::Enumerated]
+        ary = [primitives, constructed].flatten.map do |type|
+          next unless type.const_defined? :TAG
+          [type::TAG, type]
+        end
+        @tag2types = Hash[ary]
+        @tag2types.default = Types::Base
+      end
+
+      klass = @tag2types[tag & 0xdf] # Remove CONSTRUCTED bit
+      is_constructed = (tag & 0x20) == 0x20
+      asn1class = Types::Base::CLASSES.key(tag & 0xc0)
+      options = { class: asn1class, constructed: is_constructed }
+      options[:tag_value] = (tag & 0x1f) if klass == Types::Base
+      klass.new(options)
     end
   end
 end

data/lib/rasn1/types/any.rb

@@ -13,7 +13,7 @@ module RASN1
         when Base, Model
           @value.to_der
         when nil
-          Null.new(@name).to_der
+          Null.new.to_der
         else
           @value.to_s
         end
@@ -33,14 +33,15 @@ module RASN1
       def inspect(level=0)
         str = ''
         str << '  ' * level if level > 0
+        str << "#{@name} " unless @name.nil?
         if @value.nil?
-          str << "#{name} (ANY) NULL"
+          str << "(ANY) NULL"
         elsif @value.is_a?(OctetString)
-          str << "#{name} (ANY) #{@value.type}: #{value.value.inspect}"
+          str << "(ANY) #{@value.type}: #{value.value.inspect}"
         elsif @value.class < Base
-          str << "#{name} (ANY) #{@value.type}: #{value.value}"
+          str << "(ANY) #{@value.type}: #{value.value}"
         else
-          str << "#{name} (ANY) #{value.to_s.inspect}"
+          str << "(ANY) #{value.to_s.inspect}"
         end
       end
     end

data/lib/rasn1/types/base.rb

@@ -33,15 +33,15 @@ module RASN1
     #  -- private tag
     #  PType ::= [PRIVATE 2] EXPLICIT INTEGER
     # These types may be defined as:
-    #  ctype = RASN1::Types::Integer.new(:ctype, explicit: 0)                      # with explicit, default #asn1_class is :context
-    #  atype = RASN1::Types::Integer.new(:atype, explicit: 1, class: :application)
-    #  ptype = RASN1::Types::Integer.new(:ptype, explicit: 2, class: :private)
+    #  ctype = RASN1::Types::Integer.new(explicit: 0)                      # with explicit, default #asn1_class is :context
+    #  atype = RASN1::Types::Integer.new(explicit: 1, class: :application)
+    #  ptype = RASN1::Types::Integer.new(explicit: 2, class: :private)
     # Sometimes, an EXPLICIT type should be CONSTRUCTED. To do that, use +:constructed+
     # option:
-    #  ptype = RASN1::Types::Integer.new(:ptype, explicit: 2, class: :private, constructed: true)
+    #  ptype = RASN1::Types::Integer.new(explicit: 2, class: :private, constructed: true)
     #
     # Implicit tagged values may also be defined:
-    #  ctype_implicit = RASN1::Types::Integer.new(:ctype, implicit: 0)
+    #  ctype_implicit = RASN1::Types::Integer.new(implicit: 0)
     # @author Sylvain Daubert
     class Base
       # Allowed ASN.1 tag classes
@@ -58,8 +58,8 @@ module RASN1
       # Length value for indefinite length
       INDEFINITE_LENGTH = 0x80
 
-      # @return [Symbol, String]
-      attr_accessor :name
+      # @return [String,nil]
+      attr_reader :name
       # @return [Symbol]
       attr_reader :asn1_class
       # @return [Object,nil] default value, if defined
@@ -75,23 +75,40 @@ module RASN1
       end
 
 
-      # @param [Symbol, String] name name for this tag in grammar
-      # @param [Hash] options
-      # @option options [Symbol] :class ASN.1 tag class. Default value is +:universal+.
-      #  If +:explicit+ or +:implicit:+ is defined, default value is +:context+.
-      # @option options [::Boolean] :optional define this tag as optional. Default
-      #   is +false+
-      # @option options [Object] :default default value for DEFAULT tag
-      # @option options [Object] :value value to set
-      # @option options [::Integer] :implicit define an IMPLICIT tagged type
-      # @option options [::Integer] :explicit define an EXPLICIT tagged type
-      # @option options [::Boolean] :constructed if +true+, set type as constructed.
-      #  May only be used when +:explicit+ is defined, else it is discarded.
-      def initialize(name, options={})
-        @name = name
+      # @overload initialize(options={})
+      #   @param [Hash] options
+      #   @option options [Symbol] :class ASN.1 tag class. Default value is +:universal+.
+      #    If +:explicit+ or +:implicit:+ is defined, default value is +:context+.
+      #   @option options [::Boolean] :optional define this tag as optional. Default
+      #     is +false+
+      #   @option options [Object] :default default value for DEFAULT tag
+      #   @option options [Object] :value value to set
+      #   @option options [::Integer] :implicit define an IMPLICIT tagged type
+      #   @option options [::Integer] :explicit define an EXPLICIT tagged type
+      #   @option options [::Boolean] :constructed if +true+, set type as constructed.
+      #    May only be used when +:explicit+ is defined, else it is discarded.
+      #   @option options [::String] :name name for this node
+      # @overload initialize(value, options={})
+      #   @param [Object] value value to set for this ASN.1 object
+      #   @param [Hash] options
+      #   @option options [Symbol] :class ASN.1 tag class. Default value is +:universal+.
+      #    If +:explicit+ or +:implicit:+ is defined, default value is +:context+.
+      #   @option options [::Boolean] :optional define this tag as optional. Default
+      #     is +false+
+      #   @option options [Object] :default default value for DEFAULT tag
+      #   @option options [::Integer] :implicit define an IMPLICIT tagged type
+      #   @option options [::Integer] :explicit define an EXPLICIT tagged type
+      #   @option options [::Boolean] :constructed if +true+, set type as constructed.
+      #    May only be used when +:explicit+ is defined, else it is discarded.
+      #   @option options [::String] :name name for this node
+      def initialize(value_or_options={}, options={})
         @constructed = nil
-
-        set_options options
+        if value_or_options.is_a? Hash
+          set_options value_or_options
+        else
+          set_options options
+          @value = value_or_options
+        end
       end
 
       # Used by +#dup+ and +#clone+. Deep copy @value.
@@ -142,11 +159,7 @@ module RASN1
       #   SHOULD respond to +#value_to_der+.
       # @return [String] DER-formated string
       def to_der
-        if self.class.const_defined?('TAG')
-          build_tag
-        else
-          raise NotImplementedError, 'should be implemented by subclasses'
-        end
+        build_tag
       end
 
       # @return [::Boolean] +true+ if this is a primitive type
@@ -168,10 +181,12 @@ module RASN1
       # Get tag value
       # @return [Integer]
       def tag
-        pc = if  @constructed.nil?
+        pc = if @constructed.nil?
                self.class::ASN1_PC
-             else
+             elsif @constructed   # true
                Constructed::ASN1_PC
+             else    # false
+               0
              end
         (@tag_value || self.class::TAG) | CLASSES[@asn1_class] | pc
       end
@@ -208,7 +223,17 @@ module RASN1
       def inspect(level=0)
         str = ''
         str << '  ' * level if level > 0
-        str << "#{name} #{type}: #{value}"
+        str << "#{@name} " unless @name.nil?
+        if self.class == Base
+          str << "#{type} (0x#{'%02x' % tag}): "
+          if @value.is_a?(Base)
+            str << value.inspect(level+1)
+          else
+            str << value.inspect
+          end
+        else
+          str << "#{type}: #{value.inspect}"
+        end
       end
 
       # Objects are equal if they have same class AND same DER
@@ -220,12 +245,26 @@ module RASN1
 
       private
 
+      def value_to_der
+        case @value
+        when Base
+          @value.to_der
+        else
+          @value.to_s
+        end
+      end
+
+      def der_to_value(der, ber:false)
+        @value = der
+      end
+
       def set_options(options)
         set_class options[:class]
         set_optional options[:optional]
         set_default options[:default]
         set_tag options
         @value = options[:value]
+        @name = options[:name]
       end
 
       def set_class(asn1_class)
@@ -251,6 +290,8 @@ module RASN1
         @default = default
       end
 
+      # handle undocumented option +:tag_value+, used internally by
+      # {RASN1.parse} to parse non-universal class tags.
       def set_tag(options)
         if options[:explicit]
           @tag = :explicit
@@ -259,6 +300,10 @@ module RASN1
         elsif options[:implicit]
           @tag = :implicit
           @tag_value = options[:implicit]
+          @constructed = options[:constructed]
+        elsif options[:tag_value]
+          @tag_value = options[:tag_value]
+          @constructed = options[:constructed]
         end
 
         @asn1_class = :context if @tag and @asn1_class == :universal
@@ -330,14 +375,14 @@ module RASN1
 
         if length == INDEFINITE_LENGTH
           if primitive?
-            raise ASN1Error, "malformed #{type} TAG (#@name): indefinite length " \
+            raise ASN1Error, "malformed #{type} TAG: indefinite length " \
               "forbidden for primitive types"
           else
             if ber
-              raise NotImplementedError, "TAG #@name: indefinite length not " \
+              raise NotImplementedError, "TAG: indefinite length not " \
                 "supported yet"
             else
-              raise ASN1Error, "TAG #@name: indefinite length forbidden in DER " \
+              raise ASN1Error, "TAG: indefinite length forbidden in DER " \
                 "encoding"
             end
           end
@@ -357,12 +402,11 @@ module RASN1
       end
 
       def explicit_type
-        self.class.new(@name)
+        self.class.new
       end
 
       def raise_tag_error(expected_tag, tag)
         msg = "Expected #{tag2name(expected_tag)} but get #{tag2name(tag)}"
-        msg << " for #@name"
         raise ASN1Error, msg
       end
 

data/lib/rasn1/types/bit_string.rb

@@ -9,28 +9,32 @@ module RASN1
       # @return [Integer] bit length of bit string
       attr_accessor :bit_length
 
-      # @param [Symbol, String] name name for this tag in grammar
-      # @param [Hash] options
-      # @option options [Symbol] :class ASN.1 tag class. Default value is +:universal+
-      # @option options [::Boolean] :optional define this tag as optional. Default
-      #   is +false+
-      # @option options [Object] :default default value for DEFAULT tag
-      # @option options [Object] :bit_length default bit_length value. Should be
-      #   present if +:default+ is set
-      def initialize(name, options={})
+      # @overload initialize(options={})
+      #   @param [Hash] options
+      #   @option options [Object] :bit_length default bit_length value. Should be
+      #     present if +:default+ is set
+      # @overload initialize(value, options={})
+      #   @param [Object] value value to set for this ASN.1 object
+      #   @param [Hash] options
+      #   @option options [Object] :bit_length default bit_length value. Should be
+      #     present if +:default+ is set
+      # @see Base#initialize common options to all ASN.1 types
+      def initialize(value_or_options={}, options={})
         super
+        opts = value_or_options.is_a?(Hash) ? value_or_options : options
         if @default
-          if options[:bit_length].nil?
+          if opts[:bit_length].nil?
             raise ASN1Error, "TAG #@name: default bit length is not defined"
           end
-          @default_bit_length = options[:bit_length]
+          @default_bit_length = opts[:bit_length]
         end
       end
 
       def inspect(level=0)
         str = ''
         str << '  ' * level if level > 0
-        str << "#{name} #{type}: #{value.inspect} (bit length: #{bit_length})"
+        str << "#{name} " unless @name.nil?
+        str << "#{type}: #{value.inspect} (bit length: #{bit_length})"
       end
 
       private

data/lib/rasn1/types/constructed.rb

@@ -14,6 +14,7 @@ module RASN1
         when Array
           str = ''
           str << '  ' * level if level > 0
+          str << "#{@name} " unless @name.nil?
           level = level.abs
           str << "#{type}:\n"
           level += 1
@@ -21,7 +22,9 @@ module RASN1
             case item
             when Base, Model
               next if item.optional? and item.value.nil?
-              str << '  ' * level + "#{item.inspect(level)}\n"
+              str << '  ' * level
+              str << "#{item.name} " unless item.name.nil?
+              str << "#{item.inspect(level)}\n"
             else
               str << item.inspect
             end

data/lib/rasn1/types/enumerated.rb

@@ -21,20 +21,24 @@ module RASN1
       # @return [Hash]
       attr_reader :enum
 
-      # @param [Symbol, String] name name for this tag in grammar
-      # @param [Hash] options
-      # @option options [Symbol] :class ASN.1 tag class. Default value is +:universal+
-      # @option options [::Boolean] :optional define this tag as optional. Default
-      #   is +false+
-      # @option options [Object] :default default value for DEFAULT tag
-      # @option options [Hash] :enum enumeration hash. Keys are names, and values
-      #   are integers. This key is mandatory.
-      # @raise [EnumeratedError] +:enum+ key is not present
-      # @raise [EnumeratedError] +:default+ value is unknown
-      def initialize(name, options={})
+      # @overload initialize(options={})
+      #   @option options [Hash] :enum enumeration hash. Keys are names, and values
+      #     are integers. This key is mandatory.
+      #   @raise [EnumeratedError] +:enum+ key is not present
+      #   @raise [EnumeratedError] +:default+ value is unknown
+      # @overload initialize(value, options={})
+      #   @param [Object] value value to set for this ASN.1 object
+      #   @option options [Hash] :enum enumeration hash. Keys are names, and values
+      #     are integers. This key is mandatory.
+      #   @raise [EnumeratedError] +:enum+ key is not present
+      #   @raise [EnumeratedError] +:default+ value is unknown
+      # @see Base#initialize common options to all ASN.1 types
+      def initialize(value_or_options={}, options={})
         super
-        raise EnumeratedError, 'no enumeration given' unless options.has_key? :enum
-        @enum = options[:enum]
+        opts = value_or_options.is_a?(Hash) ? value_or_options : options
+
+        raise EnumeratedError, 'no enumeration given' unless opts.has_key? :enum
+        @enum = opts[:enum]
 
         case @default
         when String,Symbol

data/lib/rasn1/types/octet_string.rb

@@ -16,22 +16,8 @@ module RASN1
       def inspect(level=0)
         str = ''
         str << '  ' * level if level > 0
-        str << "#{name} #{type}: #{value.inspect}"
-      end
-
-      private
-
-      def value_to_der
-        case @value
-        when Base
-          @value.to_der
-        else
-          @value.to_s
-        end
-      end
-
-      def der_to_value(der, ber:false)
-        @value = der
+        str << "#{@name} " unless @name.nil?
+        str << "#{type}: #{value.inspect}"
       end
     end
   end

data/lib/rasn1/types/sequence.rb

@@ -14,9 +14,9 @@ module RASN1
     # do:
     #  seq = RASN1::Types::Sequence.new(:record)
     #  seq.value = [
-    #               RASN1::Types::Integer(:id),
-    #               RASN1::Types::Integer(:id, explicit: 0, optional: true),
-    #               RASN1::Types::Integer(:id, implicit: 1, default: 0)
+    #               RASN1::Types::Integer.new(:id),
+    #               RASN1::Types::Integer.new(:room, explicit: 0, optional: true),
+    #               RASN1::Types::Integer.new(:house, implicit: 1, default: 0)
     #              ]
     #
     # A sequence may also be used without value to not parse sequence content:
@@ -27,20 +27,10 @@ module RASN1
     class Sequence < Constructed
       TAG = 0x10
 
-      # @param [Symbol, String] name name for this tag in grammar
-      # @param [Hash] options
-      # @option options [Symbol] :class ASN.1 tag class. Default value is +:universal+.
-      #  If +:explicit+ or +:implicit:+ is defined, default value is +:context+.
-      # @option options [::Boolean] :optional define this tag as optional. Default
-      #   is +false+
-      # @option options [Object] :default default value for DEFAULT tag
-      # @option options [Object] :value value to set (default is +[]+)
-      # @option options [::Integer] :implicit define an IMPLICIT tagged type
-      # @option options [::Integer] :explicit define an EXPLICIT tagged type
-      # @option options [::Boolean] :constructed if +true+, set type as constructed.
-      #  May only be used when +:explicit+ is defined, else it is discarded.
-      def initialize(name, options={})
-        super(name, { value: [] }.merge(options))
+      # @see Base#initialize
+      def initialize(value_or_options={}, options={})
+        super
+        @value ||= []
       end
 
       def initialize_copy(other)

data/lib/rasn1/types/sequence_of.rb

@@ -53,8 +53,8 @@ module RASN1
       # @param [Symbol, String] name name for this tag in grammar
       # @param [Class, Base] of_type base type for sequence of
       # @see Base#initialize
-      def initialize(name, of_type, options={})
-        super(name, options)
+      def initialize(of_type, options={})
+        super(options)
         @of_type = of_type
         @value = []
       end
@@ -70,10 +70,10 @@ module RASN1
       def <<(obj)
         if of_type_class < Primitive
           raise ASN1Error, 'object to add should be an Array' unless obj.is_a?(Array)
-          @value += obj.map { |item| @of_type.new(nil, value: item) }
+          @value += obj.map { |item| @of_type.new(item) }
         elsif composed_of_type?
           raise ASN1Error, 'object to add should be an Array' unless obj.is_a?(Array)
-          new_value = of_type_class.new(@of_type.name, value: [])
+          new_value = of_type_class.new
           @of_type.value.each_with_index do |type, i|
             type2 = type.dup
             type2.value = obj[i]
@@ -161,7 +161,7 @@ module RASN1
       end
 
       def explicit_type
-        self.class.new(@name, self.of_type)
+        self.class.new(self.of_type)
       end
     end
   end

data/lib/rasn1/types/visible_string.rb

@@ -5,6 +5,6 @@ module RASN1
     # @author Sylvain Daubert
     class VisibleString < IA5String
       TAG = 26
-   end
+    end
   end
 end

data/lib/rasn1/version.rb

@@ -1,3 +1,3 @@
 module RASN1
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rasn1
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Sylvain Daubert
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-13 00:00:00.000000000 Z
+date: 2017-12-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yard