gobl 0.1.2

data/lib/gobl/tax/rate_value.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 Tax
+    # RateValue contains a percentage rate or fixed amount for a given date range.
+    class RateValue < GOBL::Struct
+      # The Schema ID of the GOBL RateValue structure
+      SCHEMA_ID = 'https://gobl.org/draft-0/tax/region#/$defs/RateValue'
+
+      # @!attribute [r] since
+      # Date from which this value should be applied.
+      # @return [GOBL::Cal::Date]
+      attribute? :since, GOBL::Cal::Date.optional
+
+      # @!attribute [r] percent
+      # Percent rate that should be applied
+      # @return [GOBL::Num::Percentage]
+      attribute :percent, GOBL::Types.Constructor(GOBL::Num::Percentage)
+
+      # @!attribute [r] surcharge
+      # An additional surcharge to apply.
+      # @return [GOBL::Num::Percentage]
+      attribute? :surcharge, GOBL::Types.Constructor(GOBL::Num::Percentage).optional
+
+      # @!attribute [r] disabled
+      # When true, this value should no longer be used.
+      # @return [Boolean]
+      attribute? :disabled, GOBL::Types::Bool.optional
+
+      # Creates a new object from a hash of GOBL data
+      #
+      # @param data [Hash] a hash of GOBL data
+      #
+      # @return [RateValue] the object created from the given data
+      def self.from_gobl!(data)
+        data = GOBL::Types::Hash[data]
+
+        new(
+          since: data['since'] ? GOBL::Cal::Date.from_gobl!(data['since']) : nil,
+          percent: data['percent'],
+          surcharge: data['surcharge'] || nil,
+          disabled: data['disabled']
+        )
+      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
+        {
+          'since' => attributes[:since]&.to_gobl,
+          'percent' => attributes[:percent]&.to_gobl,
+          'surcharge' => attributes[:surcharge]&.to_gobl,
+          'disabled' => attributes[:disabled]
+        }.compact
+      end
+
+      # @!method self.new(attrs)
+      #
+      #   Returns a {RateValue} 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 [RateValue] the object corresponding to the given input
+    end
+  end
+end

data/lib/gobl/tax/region.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+##
+## DO NOT EDIT - This file was generated automatically.
+##
+## Generated with GOBL v0.30.4
+##
+
+module GOBL
+  module Tax
+    # Region defines the holding structure for a regions categories and subsequent Rates and Values.
+    class Region < GOBL::Struct
+      # The Schema ID of the GOBL Region structure
+      SCHEMA_ID = 'https://gobl.org/draft-0/tax/region'
+
+      # @!attribute [r] name
+      # Name of the region
+      # @return [GOBL::I18n::String]
+      attribute :name, GOBL::I18n::String
+
+      # @!attribute [r] country
+      # Country code for the region
+      # @return [GOBL::L10n::CountryCode]
+      attribute :country, GOBL::L10n::CountryCode
+
+      # @!attribute [r] locality
+      # Locality, city, province, county, or similar code inside the country, if needed.
+      # @return [GOBL::L10n::Code]
+      attribute? :locality, GOBL::L10n::Code.optional
+
+      # @!attribute [r] localities
+      # List of sub-localities inside a region.
+      # @return [Localities]
+      attribute? :localities, Localities.optional
+
+      # @!attribute [r] currency
+      # Currency used by the region for tax purposes.
+      # @return [GOBL::Currency::Code]
+      attribute :currency, GOBL::Currency::Code
+
+      # @!attribute [r] schemes
+      # Set of specific scheme definitions inside the region.
+      # @return [Schemes]
+      attribute? :schemes, Schemes.optional
+
+      # @!attribute [r] categories
+      # List of tax categories.
+      # @return [Array<Category>]
+      attribute :categories, GOBL::Types::Array.of(Category)
+
+      # Creates a new object from a hash of GOBL data
+      #
+      # @param data [Hash] a hash of GOBL data
+      #
+      # @return [Region] the object created from the given data
+      def self.from_gobl!(data)
+        data = GOBL::Types::Hash[data]
+
+        new(
+          name: GOBL::I18n::String.from_gobl!(data['name']),
+          country: GOBL::L10n::CountryCode.from_gobl!(data['country']),
+          locality: data['locality'] ? GOBL::L10n::Code.from_gobl!(data['locality']) : nil,
+          localities: data['localities'] ? Localities.from_gobl!(data['localities']) : nil,
+          currency: GOBL::Currency::Code.from_gobl!(data['currency']),
+          schemes: data['schemes'] ? Schemes.from_gobl!(data['schemes']) : nil,
+          categories: data['categories']&.map { |item| Category.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
+        {
+          'name' => attributes[:name]&.to_gobl,
+          'country' => attributes[:country]&.to_gobl,
+          'locality' => attributes[:locality]&.to_gobl,
+          'localities' => attributes[:localities]&.to_gobl,
+          'currency' => attributes[:currency]&.to_gobl,
+          'schemes' => attributes[:schemes]&.to_gobl,
+          'categories' => attributes[:categories]&.map { |item| item&.to_gobl }
+        }.compact
+      end
+
+      # @!method self.new(attrs)
+      #
+      #   Returns a {Region} 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 [Region] the object corresponding to the given input
+    end
+  end
+end

data/lib/gobl/tax/scheme.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+##
+## DO NOT EDIT - This file was generated automatically.
+##
+## Generated with GOBL v0.30.4
+##
+
+module GOBL
+  module Tax
+    # Scheme contains the definition of a scheme that belongs to a region and can be used to simplify validation processes for document contents.
+    class Scheme < GOBL::Struct
+      # The Schema ID of the GOBL Scheme structure
+      SCHEMA_ID = 'https://gobl.org/draft-0/tax/region#/$defs/Scheme'
+
+      # @!attribute [r] key
+      # Key used to identify this scheme
+      # @return [GOBL::Org::Key]
+      attribute :key, GOBL::Org::Key
+
+      # @!attribute [r] name
+      # Name of this scheme.
+      # @return [GOBL::I18n::String]
+      attribute :name, GOBL::I18n::String
+
+      # @!attribute [r] description
+      # Human details describing what this scheme is used for.
+      # @return [GOBL::I18n::String]
+      attribute? :description, GOBL::I18n::String.optional
+
+      # @!attribute [r] categories
+      # List of tax category codes that can be used when this scheme is applied.
+      # @return [Array<GOBL::Org::Code>]
+      attribute? :categories, GOBL::Types::Array.of(GOBL::Org::Code).optional
+
+      # @!attribute [r] note
+      # Note defines a message that should be added to a document when this scheme is used.
+      # @return [GOBL::Org::Note]
+      attribute? :note, GOBL::Org::Note.optional
+
+      # Creates a new object from a hash of GOBL data
+      #
+      # @param data [Hash] a hash of GOBL data
+      #
+      # @return [Scheme] the object created from the given data
+      def self.from_gobl!(data)
+        data = GOBL::Types::Hash[data]
+
+        new(
+          key: GOBL::Org::Key.from_gobl!(data['key']),
+          name: GOBL::I18n::String.from_gobl!(data['name']),
+          description: data['description'] ? GOBL::I18n::String.from_gobl!(data['description']) : nil,
+          categories: data['categories']&.map { |item| GOBL::Org::Code.from_gobl!(item) },
+          note: data['note'] ? GOBL::Org::Note.from_gobl!(data['note']) : 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,
+          'name' => attributes[:name]&.to_gobl,
+          'description' => attributes[:description]&.to_gobl,
+          'categories' => attributes[:categories]&.map { |item| item&.to_gobl },
+          'note' => attributes[:note]&.to_gobl
+        }.compact
+      end
+
+      # @!method self.new(attrs)
+      #
+      #   Returns a {Scheme} 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 [Scheme] the object corresponding to the given input
+    end
+  end
+end

data/lib/gobl/tax/schemes.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+##
+## DO NOT EDIT - This file was generated automatically.
+##
+## Generated with GOBL v0.30.4
+##
+
+module GOBL
+  module Tax
+    # Schemes defines an array of scheme objects with helper functions.
+    class Schemes < GOBL::Struct
+      extend Forwardable
+      include Enumerable
+
+      # The Schema ID of the GOBL Schemes structure
+      SCHEMA_ID = 'https://gobl.org/draft-0/tax/region#/$defs/Schemes'
+
+      attribute :_ary, GOBL::Types::Array.of(Scheme)
+
+      # @!method [](*args)
+      #   Returns elements from the array
+      #   @overload [](index)
+      #     Returns the element in a specific position
+      #     @param index [Integer] the position of the object
+      #     @return [Scheme] the element in the `index` position
+      #   @overload [](start, length)
+      #     Returns all the elements within a range of positions
+      #     @param start [Integer] start position of the range
+      #     @param length [Integer] length of the range
+      #     @return [Array<Scheme>] the elements in the range
+      #   @overload [](range)
+      #     Returns all the elements within a range
+      #     @param range [Range] start and end positions of the range
+      #     @return [Array<Scheme>] the elements in the range
+      #
+      # @!method each
+      #   Iterates over the array elements
+      #   @overload each(&block)
+      #     Calls the given block with each element in the array
+      #     @yield [element] element of the array
+      #     @return [self] the object itself
+      #   @overload each
+      #     Returns an Enumerator that iterates over the array elements
+      #     @return [Enumerator] the enumerator of the array elements
+      #
+      # @!method empty?
+      #   Returns `true` if the number of elements in the array is zero, `false` otherwise.
+      #   @return [Boolean] whether the array is empty or not
+      #
+      # @!method length
+      #   Returns the number of elements in the array
+      #   @return [Integer] the number of elements in the array
+      def_delegators :_ary, :[], :each, :empty?, :length
+
+      # Creates a new object from an array of GOBL data
+      #
+      # @param data [Array] an array of GOBL data
+      #
+      # @return [Schemes] the object created from the given data
+      def self.from_gobl!(data)
+        new(_ary: data&.map { |item| Scheme.from_gobl!(item) })
+      end
+
+      # Returns an array of GOBL data representing the current object
+      #
+      # @return [Array<Hash>] the array of GOBL data that represents the current object
+      def to_gobl
+        _ary.map(&:to_gobl)
+      end
+
+      # Returns a {Schemes} object from a given array of structs. The array may
+      # contain {Scheme} objects or hashes. If hashes are provided, the constructor
+      # will call `Scheme#new` to generate the objects that will be part of the
+      # returned {Schemes} object
+      #
+      # @param object [Array<Scheme, Hash>] the array containing the structs
+      #
+      # @return [Schemes] the object corresponding to the given input
+      def self.new(object)
+        case object
+        when Array
+          super _ary: object
+        else # internal use, not to be used in public calls
+          super
+        end
+      end
+    end
+  end
+end

data/lib/gobl/tax/set.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+##
+## DO NOT EDIT - This file was generated automatically.
+##
+## Generated with GOBL v0.30.4
+##
+
+module GOBL
+  module Tax
+    # Set defines a list of tax categories and their rates to be used alongside taxable items.
+    class Set < GOBL::Struct
+      extend Forwardable
+      include Enumerable
+
+      # The Schema ID of the GOBL Set structure
+      SCHEMA_ID = 'https://gobl.org/draft-0/tax/set'
+
+      attribute :_ary, GOBL::Types::Array.of(Combo)
+
+      # @!method [](*args)
+      #   Returns elements from the array
+      #   @overload [](index)
+      #     Returns the element in a specific position
+      #     @param index [Integer] the position of the object
+      #     @return [Combo] the element in the `index` position
+      #   @overload [](start, length)
+      #     Returns all the elements within a range of positions
+      #     @param start [Integer] start position of the range
+      #     @param length [Integer] length of the range
+      #     @return [Array<Combo>] the elements in the range
+      #   @overload [](range)
+      #     Returns all the elements within a range
+      #     @param range [Range] start and end positions of the range
+      #     @return [Array<Combo>] the elements in the range
+      #
+      # @!method each
+      #   Iterates over the array elements
+      #   @overload each(&block)
+      #     Calls the given block with each element in the array
+      #     @yield [element] element of the array
+      #     @return [self] the object itself
+      #   @overload each
+      #     Returns an Enumerator that iterates over the array elements
+      #     @return [Enumerator] the enumerator of the array elements
+      #
+      # @!method empty?
+      #   Returns `true` if the number of elements in the array is zero, `false` otherwise.
+      #   @return [Boolean] whether the array is empty or not
+      #
+      # @!method length
+      #   Returns the number of elements in the array
+      #   @return [Integer] the number of elements in the array
+      def_delegators :_ary, :[], :each, :empty?, :length
+
+      # Creates a new object from an array of GOBL data
+      #
+      # @param data [Array] an array of GOBL data
+      #
+      # @return [Set] the object created from the given data
+      def self.from_gobl!(data)
+        new(_ary: data&.map { |item| Combo.from_gobl!(item) })
+      end
+
+      # Returns an array of GOBL data representing the current object
+      #
+      # @return [Array<Hash>] the array of GOBL data that represents the current object
+      def to_gobl
+        _ary.map(&:to_gobl)
+      end
+
+      # Returns a {Set} object from a given array of structs. The array may
+      # contain {Combo} objects or hashes. If hashes are provided, the constructor
+      # will call `Combo#new` to generate the objects that will be part of the
+      # returned {Set} object
+      #
+      # @param object [Array<Combo, Hash>] the array containing the structs
+      #
+      # @return [Set] the object corresponding to the given input
+      def self.new(object)
+        case object
+        when Array
+          super _ary: object
+        else # internal use, not to be used in public calls
+          super
+        end
+      end
+    end
+  end
+end

data/lib/gobl/tax/total.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 Tax
+    # Total contains a set of Category Totals which in turn contain all the accumulated taxes contained in the document.
+    class Total < GOBL::Struct
+      # The Schema ID of the GOBL Total structure
+      SCHEMA_ID = 'https://gobl.org/draft-0/tax/total'
+
+      # @!attribute [r] categories
+      # Grouping of all the taxes by their category
+      # @return [Array<CategoryTotal>]
+      attribute? :categories, GOBL::Types::Array.of(CategoryTotal).optional
+
+      # @!attribute [r] sum
+      # Total value of all the taxes applied.
+      # @return [GOBL::Num::Amount]
+      attribute :sum, 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 [Total] the object created from the given data
+      def self.from_gobl!(data)
+        data = GOBL::Types::Hash[data]
+
+        new(
+          categories: data['categories']&.map { |item| CategoryTotal.from_gobl!(item) },
+          sum: data['sum']
+        )
+      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
+        {
+          'categories' => attributes[:categories]&.map { |item| item&.to_gobl },
+          'sum' => attributes[:sum]&.to_gobl
+        }.compact
+      end
+
+      # @!method self.new(attrs)
+      #
+      #   Returns a {Total} 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 [Total] the object corresponding to the given input
+    end
+  end
+end

data/lib/gobl/types.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module GOBL
+  # Types used by the generated GOBL code.
+  # @api private
+  module Types
+    include Dry.Types()
+
+    Nil     = Strict::Nil
+    Int     = Strict::Integer # deprecated, use Integer
+    Integer = Strict::Integer
+    Bool    = Strict::Bool
+    Hash    = Strict::Hash
+    String  = Strict::String
+    Double  = Strict::Float | Strict::Integer
+  end
+end

data/lib/gobl/uuid/uuid.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 UUID
+    # Universally Unique Identifier. We only recommend using versions 1 and 4 within GOBL.
+    class UUID < GOBL::Struct
+      # The Schema ID of the GOBL UUID structure
+      SCHEMA_ID = 'https://gobl.org/draft-0/uuid/uuid'
+
+      attribute :_value, GOBL::Types::String
+      private :_value
+
+      # Creates a new object from a GOBL value
+      #
+      # @param data [String] the GOBL value
+      #
+      # @return [UUID] 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 {UUID} 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 [UUID] the object corresponding to the given value.
+      #
+      # @example Instantiating from a symbol
+      #   uuid = GOBL::UUID::UUID.new(:value)
+      #
+      # @example Instantiating from a string
+      #   uuid = GOBL::UUID::UUID.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 {UUID} objects, the current object can be compared to a `Symbol`, a
+      # `String` or anything coercible into one (via `#to_s`)
+      #
+      # @param other [UUID, Symbol, String, #to_s] the other object to compare to
+      #
+      # @return [Boolean] `true` if the objects are equivalent, `false` otherwise
+      #
+      # @example Comparing to another {UUID} object
+      #   uuid = GOBL::UUID::UUID.new('value')
+      #   uuid == GOBL::UUID::UUID.new('value') #=> true
+      #   uuid == GOBL::UUID::UUID.new('other') #=> false
+      #
+      # @example Comparing to a string
+      #   uuid = GOBL::UUID::UUID.new('value')
+      #   uuid == 'value' #=> true
+      #   uuid == 'other' #=> false
+      #
+      # @example Comparing to a symbol
+      #   uuid = GOBL::UUID::UUID.new('value')
+      #   uuid == :value #=> true
+      #   uuid == :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/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module GOBL
+  VERSION = '0.1.2'
+end

data/lib/gobl.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'zeitwerk'
+require 'dry-struct'
+require 'active_support/core_ext/string/inflections'
+require 'forwardable'
+require 'net/http'
+require 'base64'
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect(
+  'gobl' => 'GOBL',
+  'gobl_extensions' => 'GOBLExtensions',
+  'uuid' => 'UUID',
+  'url' => 'URL',
+  'item_id' => 'ItemID',
+  'tax_id' => 'TaxID',
+  'dsig' => 'DSig',
+  'id' => 'ID'
+)
+loader.setup
+
+# Main GOBL namespace. It provides direct access to the library's configuration (see
+# {Config}) and to the available operations (see {Operations}).
+#
+# The library also provides Ruby classes for each structure defined in the GOBL JSON
+# Schema. They are available in namespaces defined under this one and named after the
+# schema ID of each structure.
+module GOBL
+  extend GOBL::Operations
+
+  # Returns the current configuration of the library
+  #
+  # @return [GOBL::Config]
+  def self.config
+    @config ||= Config.new
+  end
+end
+
+require_relative 'extensions'