gobl 0.1.3 → 0.3.0

data/lib/gobl/currency/code.rb

@@ -9,7 +9,7 @@
 module GOBL
   module Currency
     # ISO Currency Code
-    class Code < GOBL::Struct
+    class Code < GOBL::Enum
       # The Schema ID of the GOBL Code structure
       SCHEMA_ID = 'https://gobl.org/draft-0/currency/code'
 
@@ -183,139 +183,8 @@ module GOBL
         'ZWL' => 'Zimbabwe Dollar'
       }.freeze
 
-      attribute :_value, GOBL::Types::String.enum(*ENUM.keys)
-      private :_value
-
-      # Creates a new object from a GOBL value
-      #
-      # @param data [String] the GOBL value
-      #
-      # @return [Code] the object created from the given data
-      def self.from_gobl!(data)
-        new(_value: data)
-      end
-
-      # Returns a GOBL value representing the current object
-      #
-      # @return [String] the GOBL value that represents the current object
-      def to_gobl
-        _value
-      end
-
-      # Returns a {Code} that corresponds to a given object. The object can be a
-      # `Symbol`, a `String` or anything coercible into one (via `#to_s`).
-      #
-      # @param object [Symbol, String, #to_s] the value of the object.
-      #
-      # @return [Code] the object corresponding to the given value.
-      #
-      # @example Instantiating from a symbol
-      #   code = GOBL::Currency::Code.new(:aed)
-      #
-      # @example Instantiating from a string
-      #   code = GOBL::Currency::Code.new('AED')
-      def self.new(object)
-        case object
-        when Hash, self # internal use, not to be used in public calls
-          super
-        when Symbol
-          new find_by_sym(object)
-        else
-          super _value: object.to_s
-        end
-      end
-
-      # Returns the string representation of the current object
-      #
-      # @return [String] the string representation of the current object
-      def to_s
-        _value.to_s
-      end
-
-      # Returns the symbol representation of the current object
-      #
-      # @return [Symbol] the symbol representation of the current object
-      def to_sym
-        to_s.parameterize.underscore.to_sym
-      end
-
-      # Returns whether the current object is equivalent to a given one. In addition
-      # to {Code} objects, the current object can be compared to a `Symbol`, a
-      # `String` or anything coercible into one (via `#to_s`)
-      #
-      # @param other [Code, Symbol, String, #to_s] the other object to compare to
-      #
-      # @return [Boolean] `true` if the objects are equivalent, `false` otherwise
-      #
-      # @example Comparing to another {Code} object
-      #   code = GOBL::Currency::Code.new('AED')
-      #   code == GOBL::Currency::Code.new('AED') #=> true
-      #   code == GOBL::Currency::Code.new('AFN') #=> false
-      #
-      # @example Comparing to a string
-      #   code = GOBL::Currency::Code.new('AED')
-      #   code == 'AED' #=> true
-      #   code == 'AFN' #=> false
-      #
-      # @example Comparing to a symbol
-      #   code = GOBL::Currency::Code.new('AED')
-      #   code == :aed #=> true
-      #   code == :afn #=> false
-      def ==(other)
-        case other
-        when self.class
-          super
-        when Symbol
-          to_sym == other
-        else
-          to_s == other.to_s
-        end
-      end
-
-      # Returns an array with all the enumerated objects of this type
-      #
-      # @return [Array<Code>] the array of enumerated objects
-      def self.all
-        ENUM.keys.map { |key| new(key) }
-      end
-
-      # @api private
-      def self.find_by_sym(sym)
-        all.find { |object| object.to_sym == sym }
-      end
-
-      # @api private
-      def self.find_by_inquirer(method_name)
-        method_name =~ /(.+)\?$/ && find_by_sym(Regexp.last_match(1).to_sym)
-      end
-
-      # Returns the description of the current object
-      #
-      # @return [String] the description of the current object
-      def description
-        ENUM.fetch(_value, _value)
-      end
-
-      # @api private
-      def respond_to_missing?(method_name, include_private = false)
-        self.class.find_by_inquirer(method_name) || super
-      end
-
-      # Enables dynamic value inquirers like `Code#aed?` for
-      # each of the declared enum values (see {ENUM}). Each inquirer returns a
-      # `Boolean` denoting whether the value equals the enquired value (`true`) or
-      # not (`false`)
-      #
-      # @example
-      #   code = GOBL::Currency::Code.new('AED')
-      #   code.aed? # => true
-      #   code.afn? # => false
-      def method_missing(method_name, *args, &block)
-        if value = self.class.find_by_inquirer(method_name)
-          self == value
-        else
-          super
-        end
+      def strict_enum?
+        true
       end
     end
   end

data/lib/gobl/currency/exchange_rate.rb

@@ -9,57 +9,21 @@
 module GOBL
   module Currency
     # ExchangeRate contains data on the rate to be used when converting amounts from the document's base currency to whatever is defined.
-    class ExchangeRate < GOBL::Struct
+    class ExchangeRate < GOBL::Object
       # The Schema ID of the GOBL ExchangeRate structure
       SCHEMA_ID = 'https://gobl.org/draft-0/currency/exchange-rate'
 
       # @!attribute [r] currency
       # ISO currency code this rate represents.
       # @return [GOBL::Currency::Code]
-      attribute :currency, GOBL::Currency::Code
+      property :currency, GOBL::Currency::Code
+      validates :currency, presence: true
 
       # @!attribute [r] amount
       # How much is 1.00 of this currency worth in the documents currency.
       # @return [GOBL::Num::Amount]
-      attribute :amount, GOBL::Types.Constructor(GOBL::Num::Amount)
-
-      # Creates a new object from a hash of GOBL data
-      #
-      # @param data [Hash] a hash of GOBL data
-      #
-      # @return [ExchangeRate] the object created from the given data
-      def self.from_gobl!(data)
-        data = GOBL::Types::Hash[data]
-
-        new(
-          currency: GOBL::Currency::Code.from_gobl!(data['currency']),
-          amount: data['amount']
-        )
-      end
-
-      # Returns a hash of GOBL data representing the current object
-      #
-      # @return [Hash] the array of GOBL data that represents the current object
-      def to_gobl
-        {
-          'currency' => attributes[:currency]&.to_gobl,
-          'amount' => attributes[:amount]&.to_gobl
-        }.compact
-      end
-
-      # @!method self.new(attrs)
-      #
-      #   Returns a {ExchangeRate} object from a given hash of attributes. Nested
-      #   attributes are supported: the constructor will instantiate the proper GOBL
-      #   objects when nested hashes or arrays are given as part of the `attrs`
-      #   parameter.
-      #
-      #   The `new` method will only allow to create a new object if all attributes
-      #   marked as mandatory and not calculated in the JSON schema are provided.
-      #
-      #   @param attrs [Hash] the hash of attributes
-      #
-      #   @return [ExchangeRate] the object corresponding to the given input
+      property :amount, GOBL::Num::Amount
+      validates :amount, presence: true
     end
   end
 end

data/lib/gobl/document.rb

@@ -8,63 +8,6 @@
 
 module GOBL
   # Contents of the envelope that must contain a $schema.
-  class Document < GOBL::Struct
-    extend Forwardable
-    include Enumerable
-
-    # The Schema ID of the GOBL Document structure
-    SCHEMA_ID = 'https://gobl.org/draft-0/envelope#/$defs/Document'
-
-    attribute :_value, GOBL::Types::Hash
-
-    # @!method [](key)
-    #   Returns the value associated with the given key
-    #   @param key [Object] the key
-    #   @return [Object] the value associated with the given key
-    #
-    # @!method each
-    #   Iterates over each key-value pair in the map
-    #   @overload each(&block)
-    #     Calls the given block with each key-value pair in the map
-    #     @yield [key, value] a key-value pair of the map
-    #     @return [self] the object itself
-    #   @overload each
-    #     Returns an Enumerator that iterates over the key-value pairs in the map
-    #     @return [Enumerator] the enumerator of the key-value pairs
-    #
-    # @!method empty?
-    #   Returns `true` if the number of entires in the map is zero, `false` otherwise.
-    #   @return [Boolean] whether the map is empty or not
-    #
-    # @!method length
-    #   Returns the number of entries in the map
-    #   @return [Integer] the number of entries in the map
-    #
-    # @!method each_key
-    #   Iterates over each key in the map
-    #   @overload each(&block)
-    #     Calls the given block with each key in the map
-    #     @yield [key] a key of the map
-    #     @return [self] the object itself
-    #   @overload each
-    #     Returns an Enumerator that iterates over the keys in the map
-    #     @return [Enumerator] the enumerator of the keys
-    def_delegators :_value, :[], :each, :empty?, :length, :each_key
-
-    # Creates a new object from a hash of GOBL data
-    #
-    # @param data [Hash] a hash of GOBL data
-    #
-    # @return [Document] the object created from the given data
-    def self.from_gobl!(data)
-      new(_value: data)
-    end
-
-    # Returns a hash of GOBL data representing the current object
-    #
-    # @return [Hash] the hash of GOBL data that represents the current object
-    def to_gobl
-      _value
-    end
+  class Document < GOBL::Map
   end
 end

data/lib/gobl/dsig/digest.rb

@@ -9,57 +9,21 @@
 module GOBL
   module DSig
     # Digest defines a structure to hold a digest value including the algorithm used to generate it.
-    class Digest < GOBL::Struct
+    class Digest < GOBL::Object
       # The Schema ID of the GOBL Digest structure
       SCHEMA_ID = 'https://gobl.org/draft-0/dsig/digest'
 
       # @!attribute [r] alg
       # Algorithm stores the algorithm key that was used to generate the value.
       # @return [String]
-      attribute :alg, GOBL::Types::String
+      property :alg, String
+      validates :alg, presence: true
 
       # @!attribute [r] val
       # Value contains the Hexadecimal representation of the resulting hash generated by the algorithm.
       # @return [String]
-      attribute :val, GOBL::Types::String
-
-      # Creates a new object from a hash of GOBL data
-      #
-      # @param data [Hash] a hash of GOBL data
-      #
-      # @return [Digest] the object created from the given data
-      def self.from_gobl!(data)
-        data = GOBL::Types::Hash[data]
-
-        new(
-          alg: data['alg'],
-          val: data['val']
-        )
-      end
-
-      # Returns a hash of GOBL data representing the current object
-      #
-      # @return [Hash] the array of GOBL data that represents the current object
-      def to_gobl
-        {
-          'alg' => attributes[:alg],
-          'val' => attributes[:val]
-        }.compact
-      end
-
-      # @!method self.new(attrs)
-      #
-      #   Returns a {Digest} object from a given hash of attributes. Nested
-      #   attributes are supported: the constructor will instantiate the proper GOBL
-      #   objects when nested hashes or arrays are given as part of the `attrs`
-      #   parameter.
-      #
-      #   The `new` method will only allow to create a new object if all attributes
-      #   marked as mandatory and not calculated in the JSON schema are provided.
-      #
-      #   @param attrs [Hash] the hash of attributes
-      #
-      #   @return [Digest] the object corresponding to the given input
+      property :val, String
+      validates :val, presence: true
     end
   end
 end

data/lib/gobl/dsig/signature.rb

@@ -9,98 +9,9 @@
 module GOBL
   module DSig
     # JSON Web Signature in compact form.
-    class Signature < GOBL::Struct
+    class Signature < GOBL::Value
       # The Schema ID of the GOBL Signature structure
       SCHEMA_ID = 'https://gobl.org/draft-0/dsig/signature'
-
-      attribute :_value, GOBL::Types::String
-      private :_value
-
-      # Creates a new object from a GOBL value
-      #
-      # @param data [String] the GOBL value
-      #
-      # @return [Signature] the object created from the given data
-      def self.from_gobl!(data)
-        new(_value: data)
-      end
-
-      # Returns a GOBL value representing the current object
-      #
-      # @return [String] the GOBL value that represents the current object
-      def to_gobl
-        _value
-      end
-
-      # Returns a {Signature} that corresponds to a given object. The object can be a
-      # `Symbol`, a `String` or anything coercible into one (via `#to_s`).
-      #
-      # @param object [Symbol, String, #to_s] the value of the object.
-      #
-      # @return [Signature] the object corresponding to the given value.
-      #
-      # @example Instantiating from a symbol
-      #   signature = GOBL::DSig::Signature.new(:value)
-      #
-      # @example Instantiating from a string
-      #   signature = GOBL::DSig::Signature.new('value')
-      def self.new(object)
-        case object
-        when Hash, self # internal use, not to be used in public calls
-          super
-        when Symbol
-          new object.to_s
-        else
-          super _value: object.to_s
-        end
-      end
-
-      # Returns the string representation of the current object
-      #
-      # @return [String] the string representation of the current object
-      def to_s
-        _value.to_s
-      end
-
-      # Returns the symbol representation of the current object
-      #
-      # @return [Symbol] the symbol representation of the current object
-      def to_sym
-        to_s.parameterize.underscore.to_sym
-      end
-
-      # Returns whether the current object is equivalent to a given one. In addition
-      # to {Signature} objects, the current object can be compared to a `Symbol`, a
-      # `String` or anything coercible into one (via `#to_s`)
-      #
-      # @param other [Signature, Symbol, String, #to_s] the other object to compare to
-      #
-      # @return [Boolean] `true` if the objects are equivalent, `false` otherwise
-      #
-      # @example Comparing to another {Signature} object
-      #   signature = GOBL::DSig::Signature.new('value')
-      #   signature == GOBL::DSig::Signature.new('value') #=> true
-      #   signature == GOBL::DSig::Signature.new('other') #=> false
-      #
-      # @example Comparing to a string
-      #   signature = GOBL::DSig::Signature.new('value')
-      #   signature == 'value' #=> true
-      #   signature == 'other' #=> false
-      #
-      # @example Comparing to a symbol
-      #   signature = GOBL::DSig::Signature.new('value')
-      #   signature == :value #=> true
-      #   signature == :other #=> false
-      def ==(other)
-        case other
-        when self.class
-          super
-        when Symbol
-          to_sym == other
-        else
-          to_s == other.to_s
-        end
-      end
     end
   end
 end

data/lib/gobl/enum.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module GOBL
+  # Base class for single value structures in the GOBL schema that have a controlled set
+  # of values associated to them (i.e., an enumeration) that may constrain them
+  class Enum < Value
+    # Returns an enum value object that corresponds to a given value. The value can be a
+    # `Symbol`, a `String` or anything coercible into one (via `#to_s`)
+    #
+    # @param value [Symbol, String, #to_s] the value of the object
+    #
+    # @return [Enum] the enum value instance corresponding to the given value
+    def initialize(value)
+      if value.is_a? Symbol
+        self._value = value_from_sym(value) || value.to_s
+      else
+        super
+      end
+    end
+
+    # Returns the description of the current enum value
+    #
+    # @return [String] the description of the current enum value
+    def description
+      self.class::ENUM.fetch(_value, _value)
+    end
+
+    # Enables dynamic value inquirers for each of the declared enum values. Each inquirer
+    # returns a `Boolean` denoting whether the value equals the enquired value (`true`) or
+    # not (`false`)
+    def method_missing(method_name, *args, &block)
+      if (value = self.class.find_by_inquirer(method_name))
+        self == value
+      else
+        super
+      end
+    end
+
+    # @api private
+    def respond_to_missing?(method_name, include_private = false)
+      self.class.find_by_inquirer(method_name) || super
+    end
+
+    class << self
+      # Returns an array with all the enumerated objects of this type
+      #
+      # @return [Array<#{name}>] the array of enumerated objects
+      def all
+        self::ENUM.keys.map { |key| new(key) }
+      end
+
+      # @api private
+      def find_by_sym(sym)
+        all.find { |object| object.to_sym == sym }
+      end
+
+      # @api private
+      def find_by_inquirer(method_name)
+        method_name =~ /(.+)\?$/ && find_by_sym(Regexp.last_match(1).to_sym)
+      end
+    end
+
+    private
+
+    def _value=(value)
+      if strict_enum? && !self.class::ENUM.key?(value)
+        raise TypeError, "\"#{value}\" is not within the valid values of the enumeration"
+      end
+
+      super
+    end
+
+    def strict_enum?
+      false
+    end
+
+    def value_from_sym(sym)
+      self.class.find_by_sym(sym)&.to_s
+    end
+  end
+end

data/lib/gobl/envelope.rb

@@ -8,70 +8,31 @@
 
 module GOBL
   # Envelope wraps around a gobl document and provides support for digest creation and digital signatures.
-  class Envelope < GOBL::Struct
+  class Envelope < GOBL::Object
     # The Schema ID of the GOBL Envelope structure
     SCHEMA_ID = 'https://gobl.org/draft-0/envelope'
 
-    # @!attribute [r] schema
+    # @!attribute [r] $schema
     # Schema identifies the schema that should be used to understand this document
     # @return [String]
-    attribute :schema, GOBL::Types::String
+    property :$schema, String
+    validates :$schema, presence: true
 
     # @!attribute [r] head
     # Details on what the contents are
     # @return [Header]
-    attribute :head, Header
+    property :head, Header
+    validates :head, presence: true
 
     # @!attribute [r] doc
     # The data inside the envelope
     # @return [Document]
-    attribute :doc, Document
+    property :doc, Document
+    validates :doc, presence: true
 
     # @!attribute [r] sigs
     # JSON Web Signatures of the header
     # @return [Array<GOBL::DSig::Signature>]
-    attribute? :sigs, GOBL::Types::Array.of(GOBL::DSig::Signature).optional
-
-    # Creates a new object from a hash of GOBL data
-    #
-    # @param data [Hash] a hash of GOBL data
-    #
-    # @return [Envelope] the object created from the given data
-    def self.from_gobl!(data)
-      data = GOBL::Types::Hash[data]
-
-      new(
-        schema: data['$schema'],
-        head: Header.from_gobl!(data['head']),
-        doc: Document.from_gobl!(data['doc']),
-        sigs: data['sigs']&.map { |item| GOBL::DSig::Signature.from_gobl!(item) }
-      )
-    end
-
-    # Returns a hash of GOBL data representing the current object
-    #
-    # @return [Hash] the array of GOBL data that represents the current object
-    def to_gobl
-      {
-        '$schema' => attributes[:schema],
-        'head' => attributes[:head]&.to_gobl,
-        'doc' => attributes[:doc]&.to_gobl,
-        'sigs' => attributes[:sigs]&.map { |item| item&.to_gobl }
-      }.compact
-    end
-
-    # @!method self.new(attrs)
-    #
-    #   Returns a {Envelope} object from a given hash of attributes. Nested
-    #   attributes are supported: the constructor will instantiate the proper GOBL
-    #   objects when nested hashes or arrays are given as part of the `attrs`
-    #   parameter.
-    #
-    #   The `new` method will only allow to create a new object if all attributes
-    #   marked as mandatory and not calculated in the JSON schema are provided.
-    #
-    #   @param attrs [Hash] the hash of attributes
-    #
-    #   @return [Envelope] the object corresponding to the given input
+    property :sigs, [GOBL::DSig::Signature]
   end
 end