gobl 0.1.2

data/lib/gobl/pay/instructions.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+##
+## DO NOT EDIT - This file was generated automatically.
+##
+## Generated with GOBL v0.30.4
+##
+
+module GOBL
+  module Pay
+    # Instructions holds a set of instructions that determine how the payment has or should be made.
+    class Instructions < GOBL::Struct
+      # The Schema ID of the GOBL Instructions structure
+      SCHEMA_ID = 'https://gobl.org/draft-0/pay/instructions'
+
+      # @!attribute [r] key
+      # How payment is expected or has been arranged to be collected
+      # @return [MethodKey]
+      attribute :key, MethodKey
+
+      # @!attribute [r] detail
+      # Optional text description of the payment method
+      # @return [String]
+      attribute? :detail, GOBL::Types::String.optional
+
+      # @!attribute [r] ref
+      # Remittance information, a text value used to link the payment with the invoice.
+      # @return [String]
+      attribute? :ref, GOBL::Types::String.optional
+
+      # @!attribute [r] credit_transfer
+      # Instructions for sending payment via a bank transfer.
+      # @return [Array<CreditTransfer>]
+      attribute? :credit_transfer, GOBL::Types::Array.of(CreditTransfer).optional
+
+      # @!attribute [r] card
+      # Details of the payment that will be made via a credit or debit card.
+      # @return [Card]
+      attribute? :card, Card.optional
+
+      # @!attribute [r] direct_debit
+      # A group of terms that can be used by the customer or payer to consolidate direct debit payments.
+      # @return [DirectDebit]
+      attribute? :direct_debit, DirectDebit.optional
+
+      # @!attribute [r] online
+      # Array of online payment options
+      # @return [Array<Online>]
+      attribute? :online, GOBL::Types::Array.of(Online).optional
+
+      # @!attribute [r] notes
+      # Any additional instructions that may be required to make the payment.
+      # @return [String]
+      attribute? :notes, GOBL::Types::String.optional
+
+      # @!attribute [r] meta
+      # Non-structured additional data that may be useful.
+      # @return [GOBL::Org::Meta]
+      attribute? :meta, GOBL::Org::Meta.optional
+
+      # Creates a new object from a hash of GOBL data
+      #
+      # @param data [Hash] a hash of GOBL data
+      #
+      # @return [Instructions] the object created from the given data
+      def self.from_gobl!(data)
+        data = GOBL::Types::Hash[data]
+
+        new(
+          key: MethodKey.from_gobl!(data['key']),
+          detail: data['detail'],
+          ref: data['ref'],
+          credit_transfer: data['credit_transfer']&.map { |item| CreditTransfer.from_gobl!(item) },
+          card: data['card'] ? Card.from_gobl!(data['card']) : nil,
+          direct_debit: data['direct_debit'] ? DirectDebit.from_gobl!(data['direct_debit']) : nil,
+          online: data['online']&.map { |item| Online.from_gobl!(item) },
+          notes: data['notes'],
+          meta: data['meta'] ? GOBL::Org::Meta.from_gobl!(data['meta']) : nil
+        )
+      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
+        {
+          'key' => attributes[:key]&.to_gobl,
+          'detail' => attributes[:detail],
+          'ref' => attributes[:ref],
+          'credit_transfer' => attributes[:credit_transfer]&.map { |item| item&.to_gobl },
+          'card' => attributes[:card]&.to_gobl,
+          'direct_debit' => attributes[:direct_debit]&.to_gobl,
+          'online' => attributes[:online]&.map { |item| item&.to_gobl },
+          'notes' => attributes[:notes],
+          'meta' => attributes[:meta]&.to_gobl
+        }.compact
+      end
+
+      # @!method self.new(attrs)
+      #
+      #   Returns a {Instructions} 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 [Instructions] the object corresponding to the given input
+    end
+  end
+end

data/lib/gobl/pay/method_key.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+##
+## DO NOT EDIT - This file was generated automatically.
+##
+## Generated with GOBL v0.30.4
+##
+
+module GOBL
+  module Pay
+    # Method Key describes how a payment should be made
+    class MethodKey < GOBL::Struct
+      # The Schema ID of the GOBL MethodKey structure
+      SCHEMA_ID = 'https://gobl.org/draft-0/pay/instructions#/$defs/MethodKey'
+
+      # The enumeration of values of the object and their descriptions (Values different to these are not allowed)
+      ENUM = {
+        'any' => 'Any method available, no preference',
+        'card' => 'Credit or debit card',
+        'credit-transfer' => 'Send initiated bank or wire transfer',
+        'debit-transfer' => 'Receive initiated bank or wire transfer',
+        'cash' => 'Cash',
+        'direct-debit' => 'Direct debit',
+        'online' => 'Online or web payment'
+      }.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 [MethodKey] 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 {MethodKey} 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 [MethodKey] the object corresponding to the given value.
+      #
+      # @example Instantiating from a symbol
+      #   method_key = GOBL::Pay::MethodKey.new(:any)
+      #
+      # @example Instantiating from a string
+      #   method_key = GOBL::Pay::MethodKey.new('any')
+      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 {MethodKey} objects, the current object can be compared to a `Symbol`, a
+      # `String` or anything coercible into one (via `#to_s`)
+      #
+      # @param other [MethodKey, Symbol, String, #to_s] the other object to compare to
+      #
+      # @return [Boolean] `true` if the objects are equivalent, `false` otherwise
+      #
+      # @example Comparing to another {MethodKey} object
+      #   method_key = GOBL::Pay::MethodKey.new('any')
+      #   method_key == GOBL::Pay::MethodKey.new('any') #=> true
+      #   method_key == GOBL::Pay::MethodKey.new('card') #=> false
+      #
+      # @example Comparing to a string
+      #   method_key = GOBL::Pay::MethodKey.new('any')
+      #   method_key == 'any' #=> true
+      #   method_key == 'card' #=> false
+      #
+      # @example Comparing to a symbol
+      #   method_key = GOBL::Pay::MethodKey.new('any')
+      #   method_key == :any #=> true
+      #   method_key == :card #=> 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<MethodKey>] 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 `MethodKey#any?` 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
+      #   method_key = GOBL::Pay::MethodKey.new('any')
+      #   method_key.any? # => true
+      #   method_key.card? # => false
+      def method_missing(method_name, *args, &block)
+        if value = self.class.find_by_inquirer(method_name)
+          self == value
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/gobl/pay/online.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 Pay
+    # Online provides the details required to make a payment online using a website
+    class Online < GOBL::Struct
+      # The Schema ID of the GOBL Online structure
+      SCHEMA_ID = 'https://gobl.org/draft-0/pay/instructions#/$defs/Online'
+
+      # @!attribute [r] name
+      # Descriptive name given to the online provider.
+      # @return [String]
+      attribute? :name, GOBL::Types::String.optional
+
+      # @!attribute [r] addr
+      # Full URL to be used for payment.
+      # @return [String]
+      attribute :addr, GOBL::Types::String
+
+      # Creates a new object from a hash of GOBL data
+      #
+      # @param data [Hash] a hash of GOBL data
+      #
+      # @return [Online] the object created from the given data
+      def self.from_gobl!(data)
+        data = GOBL::Types::Hash[data]
+
+        new(
+          name: data['name'],
+          addr: data['addr']
+        )
+      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
+        {
+          'name' => attributes[:name],
+          'addr' => attributes[:addr]
+        }.compact
+      end
+
+      # @!method self.new(attrs)
+      #
+      #   Returns a {Online} 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 [Online] the object corresponding to the given input
+    end
+  end
+end

data/lib/gobl/pay/term_key.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+##
+## DO NOT EDIT - This file was generated automatically.
+##
+## Generated with GOBL v0.30.4
+##
+
+module GOBL
+  module Pay
+    # Payment terms key
+    class TermKey < GOBL::Struct
+      # The Schema ID of the GOBL TermKey structure
+      SCHEMA_ID = 'https://gobl.org/draft-0/pay/terms#/$defs/TermKey'
+
+      # The enumeration of values of the object and their descriptions (Values different to these are not allowed)
+      ENUM = {
+        '' => 'Not yet defined',
+        'end-of-month' => 'End of month',
+        'due-date' => 'Due on a specific date',
+        'deferred' => 'Deferred until after the due date',
+        'proximo' => 'Month after the present',
+        'instant' => 'On receipt of invoice',
+        'elective' => 'Chosen by the buyer',
+        'pending' => 'Seller to advise buyer in separate transaction',
+        'advance' => 'Payment made in advance',
+        'delivery' => 'Payment on Delivery'
+      }.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 [TermKey] 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 {TermKey} 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 [TermKey] the object corresponding to the given value.
+      #
+      # @example Instantiating from a symbol
+      #   term_key = GOBL::Pay::TermKey.new(:)
+      #
+      # @example Instantiating from a string
+      #   term_key = GOBL::Pay::TermKey.new('')
+      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 {TermKey} objects, the current object can be compared to a `Symbol`, a
+      # `String` or anything coercible into one (via `#to_s`)
+      #
+      # @param other [TermKey, Symbol, String, #to_s] the other object to compare to
+      #
+      # @return [Boolean] `true` if the objects are equivalent, `false` otherwise
+      #
+      # @example Comparing to another {TermKey} object
+      #   term_key = GOBL::Pay::TermKey.new('')
+      #   term_key == GOBL::Pay::TermKey.new('') #=> true
+      #   term_key == GOBL::Pay::TermKey.new('end-of-month') #=> false
+      #
+      # @example Comparing to a string
+      #   term_key = GOBL::Pay::TermKey.new('')
+      #   term_key == '' #=> true
+      #   term_key == 'end-of-month' #=> false
+      #
+      # @example Comparing to a symbol
+      #   term_key = GOBL::Pay::TermKey.new('')
+      #   term_key == : #=> true
+      #   term_key == :end_of_month #=> 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<TermKey>] 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 `TermKey#?` 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
+      #   term_key = GOBL::Pay::TermKey.new('')
+      #   term_key.? # => true
+      #   term_key.end_of_month? # => false
+      def method_missing(method_name, *args, &block)
+        if value = self.class.find_by_inquirer(method_name)
+          self == value
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/gobl/pay/terms.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+##
+## DO NOT EDIT - This file was generated automatically.
+##
+## Generated with GOBL v0.30.4
+##
+
+module GOBL
+  module Pay
+    # Terms defines when we expect the customer to pay, or have paid, for the contents of the document.
+    class Terms < GOBL::Struct
+      # The Schema ID of the GOBL Terms structure
+      SCHEMA_ID = 'https://gobl.org/draft-0/pay/terms'
+
+      # @!attribute [r] key
+      # Type of terms to be applied.
+      # @return [TermKey]
+      attribute :key, TermKey
+
+      # @!attribute [r] detail
+      # Text detail of the chosen payment terms.
+      # @return [String]
+      attribute? :detail, GOBL::Types::String.optional
+
+      # @!attribute [r] due_dates
+      # Set of dates for agreed payments.
+      # @return [Array<DueDate>]
+      attribute? :due_dates, GOBL::Types::Array.of(DueDate).optional
+
+      # @!attribute [r] notes
+      # Description of the conditions for payment.
+      # @return [String]
+      attribute? :notes, GOBL::Types::String.optional
+
+      # Creates a new object from a hash of GOBL data
+      #
+      # @param data [Hash] a hash of GOBL data
+      #
+      # @return [Terms] the object created from the given data
+      def self.from_gobl!(data)
+        data = GOBL::Types::Hash[data]
+
+        new(
+          key: TermKey.from_gobl!(data['key']),
+          detail: data['detail'],
+          due_dates: data['due_dates']&.map { |item| DueDate.from_gobl!(item) },
+          notes: data['notes']
+        )
+      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
+        {
+          'key' => attributes[:key]&.to_gobl,
+          'detail' => attributes[:detail],
+          'due_dates' => attributes[:due_dates]&.map { |item| item&.to_gobl },
+          'notes' => attributes[:notes]
+        }.compact
+      end
+
+      # @!method self.new(attrs)
+      #
+      #   Returns a {Terms} 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 [Terms] the object corresponding to the given input
+    end
+  end
+end

data/lib/gobl/stamp.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+##
+## DO NOT EDIT - This file was generated automatically.
+##
+## Generated with GOBL v0.30.4
+##
+
+module GOBL
+  # Stamp defines an official seal of approval from a third party like a governmental agency or intermediary and should thus be included in any official envelopes.
+  class Stamp < GOBL::Struct
+    # The Schema ID of the GOBL Stamp structure
+    SCHEMA_ID = 'https://gobl.org/draft-0/envelope#/$defs/Stamp'
+
+    # @!attribute [r] prv
+    # Identity of the agency used to create the stamp usually defined by each region.
+    # @return [GOBL::Org::Key]
+    attribute :prv, GOBL::Org::Key
+
+    # @!attribute [r] val
+    # The serialized stamp value generated for or by the external agency
+    # @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 [Stamp] the object created from the given data
+    def self.from_gobl!(data)
+      data = GOBL::Types::Hash[data]
+
+      new(
+        prv: GOBL::Org::Key.from_gobl!(data['prv']),
+        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
+      {
+        'prv' => attributes[:prv]&.to_gobl,
+        'val' => attributes[:val]
+      }.compact
+    end
+
+    # @!method self.new(attrs)
+    #
+    #   Returns a {Stamp} 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 [Stamp] the object corresponding to the given input
+  end
+end

data/lib/gobl/struct.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module GOBL
+  # Base class for any GOBL structure
+  class Struct < Dry::Struct
+    # Returns a new GOBL struct from a hash of GOBL data. The type of the returned struct
+    # is determined from the `$schema` attribute.
+    #
+    # This method is usually overwritten at sub-class level, where the `$schema` attribute
+    # isn't necessary since the type is determined by the sub-class itself.
+    #
+    # @param data [Hash] the hash of GOBL data
+    #
+    # @return [GOBL::Struct] the created GOBL struct
+    def self.from_gobl!(data)
+      raise ArgumentError, 'Schema not present in the given data' unless data&.key?('$schema')
+
+      schema = GOBL::ID.new(data['$schema'])
+
+      # This could become more sophisticated in the future. For the moment, any schema not
+      # being an envelope is considered to be a document as these are the only two structures
+      # that are required to specify its schema.
+      if schema.name == 'envelope'
+        GOBL::Envelope.from_gobl! data
+      else
+        GOBL::Document.from_gobl! data
+      end
+    end
+
+    # Deserializes a GOBL struct from a JSON string
+    #
+    # @param json [String] the JSON string representing the GOBL struct
+    #
+    # @return [GOBL::Struct] the deserialized GOBL struct
+    def self.from_json!(json)
+      from_gobl!(JSON.parse(json))
+    end
+
+    # Serializes a GOBL struct into a JSON string
+    #
+    # @param options [#to_h] a Hash-like object to pass to `JSON.generate`
+    #
+    # @return [GOBL::Struct] the JSON string representing the GOBL struct
+    def to_json(options = nil)
+      JSON.generate(to_gobl, options)
+    end
+  end
+end