gobl 0.1.2

data/lib/gobl/currency/exchange_rate.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+##
+## DO NOT EDIT - This file was generated automatically.
+##
+## Generated with GOBL v0.30.4
+##
+
+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
+      # 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
+
+      # @!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
+    end
+  end
+end

data/lib/gobl/document.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+##
+## DO NOT EDIT - This file was generated automatically.
+##
+## Generated with GOBL v0.30.4
+##
+
+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
+  end
+end

data/lib/gobl/dsig/digest.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+##
+## DO NOT EDIT - This file was generated automatically.
+##
+## Generated with GOBL v0.30.4
+##
+
+module GOBL
+  module DSig
+    # Digest defines a structure to hold a digest value including the algorithm used to generate it.
+    class Digest < GOBL::Struct
+      # 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
+
+      # @!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
+    end
+  end
+end

data/lib/gobl/dsig/signature.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+##
+## DO NOT EDIT - This file was generated automatically.
+##
+## Generated with GOBL v0.30.4
+##
+
+module GOBL
+  module DSig
+    # JSON Web Signature in compact form.
+    class Signature < GOBL::Struct
+      # 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/envelope.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+##
+## DO NOT EDIT - This file was generated automatically.
+##
+## Generated with GOBL v0.30.4
+##
+
+module GOBL
+  # Envelope wraps around a gobl document and provides support for digest creation and digital signatures.
+  class Envelope < GOBL::Struct
+    # The Schema ID of the GOBL Envelope structure
+    SCHEMA_ID = 'https://gobl.org/draft-0/envelope'
+
+    # @!attribute [r] schema
+    # Schema identifies the schema that should be used to understand this document
+    # @return [String]
+    attribute :schema, GOBL::Types::String
+
+    # @!attribute [r] head
+    # Details on what the contents are
+    # @return [Header]
+    attribute :head, Header
+
+    # @!attribute [r] doc
+    # The data inside the envelope
+    # @return [Document]
+    attribute :doc, Document
+
+    # @!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
+  end
+end

data/lib/gobl/header.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+##
+## DO NOT EDIT - This file was generated automatically.
+##
+## Generated with GOBL v0.30.4
+##
+
+module GOBL
+  # Header defines the meta data of the body.
+  class Header < GOBL::Struct
+    # The Schema ID of the GOBL Header structure
+    SCHEMA_ID = 'https://gobl.org/draft-0/envelope#/$defs/Header'
+
+    # @!attribute [r] uuid
+    # Unique UUIDv1 identifier for the envelope.
+    # @return [GOBL::UUID::UUID]
+    attribute :uuid, GOBL::UUID::UUID
+
+    # @!attribute [r] dig
+    # Digest of the canonical JSON body.
+    # @return [GOBL::DSig::Digest]
+    attribute :dig, GOBL::DSig::Digest
+
+    # @!attribute [r] stamps
+    # Seals of approval from other organisations.
+    # @return [Array<Stamp>]
+    attribute? :stamps, GOBL::Types::Array.of(Stamp).optional
+
+    # @!attribute [r] tags
+    # Set of labels that describe but have no influence on the data.
+    # @return [Array<String>]
+    attribute? :tags, GOBL::Types::Array.of(GOBL::Types::String).optional
+
+    # @!attribute [r] meta
+    # Additional semi-structured information about this envelope.
+    # @return [GOBL::Org::Meta]
+    attribute? :meta, GOBL::Org::Meta.optional
+
+    # @!attribute [r] notes
+    # Any information that may be relevant to other humans about this envelope
+    # @return [String]
+    attribute? :notes, GOBL::Types::String.optional
+
+    # @!attribute [r] draft
+    # When true, implies that this document should not be considered final. Digital signatures are optional.
+    # @return [Boolean]
+    attribute? :draft, GOBL::Types::Bool.optional
+
+    # Creates a new object from a hash of GOBL data
+    #
+    # @param data [Hash] a hash of GOBL data
+    #
+    # @return [Header] the object created from the given data
+    def self.from_gobl!(data)
+      data = GOBL::Types::Hash[data]
+
+      new(
+        uuid: GOBL::UUID::UUID.from_gobl!(data['uuid']),
+        dig: GOBL::DSig::Digest.from_gobl!(data['dig']),
+        stamps: data['stamps']&.map { |item| Stamp.from_gobl!(item) },
+        tags: data['tags']&.map { |item| item },
+        meta: data['meta'] ? GOBL::Org::Meta.from_gobl!(data['meta']) : nil,
+        notes: data['notes'],
+        draft: data['draft']
+      )
+    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
+      {
+        'uuid' => attributes[:uuid]&.to_gobl,
+        'dig' => attributes[:dig]&.to_gobl,
+        'stamps' => attributes[:stamps]&.map { |item| item&.to_gobl },
+        'tags' => attributes[:tags]&.map { |item| item },
+        'meta' => attributes[:meta]&.to_gobl,
+        'notes' => attributes[:notes],
+        'draft' => attributes[:draft]
+      }.compact
+    end
+
+    # @!method self.new(attrs)
+    #
+    #   Returns a {Header} 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 [Header] the object corresponding to the given input
+  end
+end

data/lib/gobl/i18n/string.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+##
+## DO NOT EDIT - This file was generated automatically.
+##
+## Generated with GOBL v0.30.4
+##
+
+module GOBL
+  module I18n
+    # Map of 2-Letter language codes to their translations.
+    class String < GOBL::Struct
+      extend Forwardable
+      include Enumerable
+
+      # The Schema ID of the GOBL String structure
+      SCHEMA_ID = 'https://gobl.org/draft-0/i18n/string'
+
+      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 [String] 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
+    end
+  end
+end

data/lib/gobl/id.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module GOBL
+  # Provide a wrapper around Schema IDs (URLs) so that it's easy to extract the type of
+  # document we're dealing with
+  class ID
+    # Initializes a new {GOBL::ID} from a string URI
+    #
+    # @return [GOBL::ID]
+    def initialize(val)
+      @id = URI.parse(val)
+    end
+
+    # Returns whether the current schema ID represents a GOBL struct or not
+    #
+    # @return [Boolean] `true` if the current Schema ID represents a GOBL struct, `false`
+    #   otherwise
+    def gobl?
+      @id.host == 'gobl.org'
+    end
+
+    # Returns the fragment part of the URI, without the '#'. This is usually used with
+    # schema references
+    #
+    # @return [String] the fragment part of the schema URI
+    def fragment
+      @id.fragment
+    end
+
+    # Returns the GOBL schema version
+    #
+    # @return [String] the schema version
+    def version
+      @id.path.split('/')[1]
+    end
+
+    # Returns the name of the schema (by convention, the last element of a path)
+    #
+    # @return [String] the name of the schema
+    def name
+      @id.path.split('/').last
+    end
+
+    # Returns the module components of the path, which may be empty. The
+    # last element of the path is always considered the name of the current schema,
+    # and not the module
+    #
+    # @return [Array<String>] the module components of the schema
+    def modules
+      @id.path.split('/')[2..-2]
+    end
+
+    # Returns the module components of the path as a single string.
+    #
+    # @return [String] the module components string
+    def module
+      modules.join('/')
+    end
+
+    # Converts the schema into a `String`
+    #
+    # @return [String] the schema as a string
+    def to_s
+      @id.to_s
+    end
+
+    # Returns whether the current schema is equivalent to a given object. Any object that
+    # can be coerced into a string via `#to_s` can be provided.
+    #
+    # @param other [#to_s] another object to compare the current one with
+    #
+    # @return [Boolean] `true` if the given other can be considered equivalent to the
+    #   current schema, `false` otherwise
+    def ==(other)
+      to_s == other.to_s
+    end
+  end
+end