rasn1 0.16.2 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: da1e2001517b21898280f0c865be1f0ca74c350d536d2cf80253291819e4536b
-  data.tar.gz: 2becfcf1810e777d9a4dc2f497f1a6fdd67e2dae319f3d15100d66a4566ce410
+  metadata.gz: 67e24db40c3ec0a8e7d7ad23211549c1aadda9511ea73f632034a4cdefa97ae0
+  data.tar.gz: d8847b0b52cce0014f02772077da519df146c14a1f65ffebc72cc206e888b0cd
 SHA512:
-  metadata.gz: 2671492ba54d676699a6238ecfd95703b8f2ebbe5cf40adea249f3ef394b1476d4a03bb6da419349753b5ffe05d25c93bdc25aa6614ec5676f2de9b8147dea78
-  data.tar.gz: 3524a58800943b251980b78e5935f1af88a3e5d84ee209bfd910447c00142661f07d4067ffd48892dd767409a92b0dcaca5598e0078520e6b8996d7ab466e909
+  metadata.gz: 12da7b29112a40073dd64e3eb949412cd941932d63fb87e2cf36cf020c1df784cdd85e6e2cd04113f8bf74e7b16c630fad2346b885933874f86dcd329f42511b
+  data.tar.gz: a5294cfc1a3ebc0430c1be31558ed1e33ac97e5d87ad8ff3c14d6c8633b251d53b33e7818762f46bb6272c4f71da439a42aa86f79413c3af405b5b3d076777a3

data/README.md

@@ -52,7 +52,9 @@ ComplexRecord ::= SEQUENCE {
 }
 ```
 
-### Create a ASN.1 model
+### Create an ASN.1 model
+
+A model is created this way:
 
 ```ruby
 class Record < RASN1::Model
@@ -63,14 +65,31 @@ class Record < RASN1::Model
 end
 ```
 
+or, this ways in a more rubyish style:
+
+```ruby
+# This Record class is defined as a sequence conaining:
+# * an ID (integer)
+# * a room number (integer, with explicit tag, optional)
+# * a house if (integer, with explicit tag and a default value)
+class Record < RASN1::Model
+  sequence :record do
+    integer(:id)
+    integer(:room, implicit: 0, optional: true)
+    integer(:house, implicit: 1, default: 0)
+  end
+end
+```
+
 More comple classes may be designed by nesting simple classes. For example:
 
 ```ruby
 class ComplexRecord < RASN1::Model
-  sequence :cplx_record,
-           content: [boolean(:bool),
-                     octet_string(:data, explicit: 0),
-                     model(:a_record, Record)]
+  sequence :cplx_record do
+    boolean(:bool)
+    octet_string(:data, explicit: 0)
+    model(:a_record, Record)          # Use another model in model
+  end
 end
 ```
 
@@ -115,10 +134,6 @@ record.set id: 124, house: 155
 record.to_der         # => String
 ```
 
-### More information
-
-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://codeberg.org/lemontree55/rasn1>.

data/lib/rasn1/errors.rb

@@ -26,7 +26,7 @@ module RASN1
 
   # CHOICE error: {Types::Choice#chosen} not set
   class ChoiceError < RASN1::Error
-    # @param [Types::Base] object
+    # @param object [Types::Base]
     def initialize(object)
       @object = object
       super()
@@ -42,7 +42,7 @@ module RASN1
   # @version 0.11.0
   # @author Sylvain Daubert
   class ConstraintError < Error
-    # @param [Types::Base] object
+    # @param object [Types::Base]
     def initialize(object)
       @object = object
       super()

data/lib/rasn1/model/accel.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+# This file is part of RASN1
+# See https://codeberg.org/lemontree55/rasn1 for more informations
+# Copyright (C) 2016-2024 Sylvain Daubert <sylvain.daubert@laposte.net>
+# Copyright (C) 2024 LemonTree55 <lenontree@proton.me>
+# This program is published under MIT license.
+
+module RASN1
+  class Model
+    # Define helper methods to define models
+    # @author Sylvain Daubert
+    module Accel
+      # @return [Hash]
+      attr_reader :options
+
+      # On inheritance, create +@elements+ class variable
+      # @param klass [Class]
+      # @return [void]
+      def inherited(klass)
+        super
+        current_elements = @elements
+        klass.class_eval { @elements = current_elements.dup }
+      end
+
+      # @since 0.17.0
+      def elements
+        return @elements unless @elements.nil?
+
+        @elements = []
+      end
+
+      # Use another model in this model
+      # @param name [String,Symbol]
+      # @param model_klass [Class]
+      # @return [Elem]
+      def model(name, model_klass)
+        push_element(ModelElem.new(name, model_klass))
+      end
+
+      # @since 0.17.0
+      # @param [BaseElem, WrapElem, ModelElem] elem
+      # @return [BaseElem, WrapElem, ModelElem] elem
+      def push_element(elem)
+        elements << elem
+        elem
+      end
+
+      # @since 0.17.0
+      def root
+        elements.last
+      end
+
+      # @since 0.17.0
+      def root=(elem)
+        if elements.empty?
+          elements << elem
+        else
+          elements[-1] = elem
+        end
+      end
+
+      # @overload wrapper(element, options={})
+      #   Use a {Wrapper} around a {Types::Base} or a {Model} object
+      #   @param element [Types::Base,Model]
+      #   @param options [Hash]
+      #   @return [WrapElem]
+      #   @since 0.12
+      # @overload(options={})
+      #   @param options [Hash]
+      #   @return [WrapElem]
+      #   @yieldreturn [BaseElem, ModelElem] element to wrapp
+      #   @since 0.17.0
+      def wrapper(element_or_options={}, options={}, &)
+        case element_or_options
+        when Hash
+          element = generate_content(&).last
+          options = element_or_options
+        else
+          element = element_or_options
+        end
+        push_element(WrapElem.new(element, options))
+      end
+
+      # Update options of root element.
+      # May be used when subclassing.
+      #  class Model1 < RASN1::Model
+      #    sequence :seq, implicit: 0,
+      #             content: [bool(:bool), integer(:int)]
+      #  end
+      #
+      #  # same as Model1 but with implicit tag set to 1
+      #  class Model2 < Model1
+      #    root_options implicit: 1
+      #  end
+      # @param options [Hash]
+      # @return [void]
+      # @since 0.12.0 may change name through +:name+
+      def root_options(options)
+        @options = options
+        return unless options.key?(:name)
+
+        self.root = root.dup
+        root.name = options[:name]
+      end
+
+      # @private
+      # @param accel_name [String,Symbol]
+      # @param klass [Class]
+      # @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
+            push_element(BaseElem.new(name, proc, nil))
+          end
+        EVAL
+      end
+
+      # @private
+      # @param accel_name [String,Symbol]
+      # @param klass [Class]
+      # @since 0.17.0
+      def define_type_accel_container(accel_name, klass)
+        singleton_class.class_eval <<-EVAL, __FILE__, __LINE__ + 1
+          def #{accel_name}(name, options={}, &block) # def sequence(name, type, options, &block)
+            options[:name] = name
+            proc = proc do |opts|
+              #{klass}.new(options.merge(opts)) # Sequence.new(options.merge(opts))
+            end
+            options[:content] ||= []
+            options[:content] += generate_content(&block)
+            push_element(BaseElem.new(name, proc, options[:content]))
+          end
+        EVAL
+      end
+
+      # @private
+      # @since 0.17.0
+      def generate_content
+        return [] unless block_given?
+
+        previous_elements = @elements
+        @elements = []
+        yield
+        content = @elements
+        @elements = previous_elements
+        content
+      end
+
+      # @private
+      # @param accel_name [String,Symbol]
+      # @param klass [Class]
+      # @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
+            push_element(BaseElem.new(name, proc, nil))
+          end
+        EVAL
+      end
+
+      # Define an accelarator to access a type in a model definition
+      # @param accel_name [String]
+      # @param klass [Class] class to instanciate
+      # @since 0.11.0
+      # @since 0.12.0 track source location on error (adfoster-r7)
+      def define_type_accel(accel_name, klass)
+        if klass <= Types::SequenceOf
+          define_type_accel_of(accel_name, klass)
+        elsif (klass <= Types::Sequence) || (klass <= Types::Choice)
+          define_type_accel_container(accel_name, klass)
+        else
+          define_type_accel_base(accel_name, klass)
+        end
+      end
+
+      # @param name [Symbol,String] name of object in model
+      # @param options [Hash]
+      # @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)) }
+        push_element(BaseElem.new(name, proc, nil))
+      end
+
+      # @param name [Symbol,String] name of object in model
+      # @param options [Hash]
+      # @return [Elem]
+      # @see Types::Any#initialize
+      def any(name, options={})
+        options[:name] = name
+        proc = proc { |opts| Types::Any.new(options.merge(opts)) }
+        push_element(BaseElem.new(name, proc, nil))
+      end
+
+      # Give type name (aka class name)
+      # @return [String]
+      def type
+        return @type if defined? @type
+
+        @type = self.to_s.gsub(/.*::/, '')
+      end
+
+      # Parse a DER/BER encoded string
+      # @param str [String]
+      # @param ber [Boolean] accept BER encoding or not
+      # @return [Model]
+      # @raise [ASN1Error] error on parsing
+      def parse(str, ber: false)
+        model = new
+        model.parse!(str, ber: ber)
+        model
+      end
+    end
+  end
+end