dear_inventory 0.2.0

data/lib/dear_inventory/config.rb

@@ -0,0 +1,55 @@
+# typed: ignore
+# frozen_string_literal: true
+
+module DearInventory
+  class Config
+    extend T::Sig
+
+    sig { returns(DearInventory::Environment.class) }
+    def environment
+      DearInventory::Environment
+    end
+
+    sig { params(value: Symbol).void }
+    def environment=(value)
+      DearInventory::Environment.set(value)
+    end
+
+    sig { returns(T.nilable(String)) }
+    attr_accessor :account_id
+
+    sig { returns(T.nilable(String)) }
+    attr_accessor :key
+
+    sig { params(param: Symbol).returns(String) }
+    def require(param)
+      value = public_send(param)
+      return value unless value.nil? || value.empty?
+
+      require_error(param)
+    end
+
+    sig { params(param: Symbol).returns(String) }
+    def require_parameter(param)
+      require(param)
+    rescue ArgumentError => e
+      message = e.message + "\n" \
+        "Alternatively, you can pass dynamic values with your request " \
+        "parameters"
+      raise ArgumentError, message
+    end
+
+    private
+
+    sig { params(param: Symbol).void }
+    def require_error(param)
+      raise(
+        ArgumentError,
+        "#{param} is required but hasn't been set.\n" \
+          "DearInventory.configure do |config|\n" +
+          %(  config.#{param} = "value") + "\n" \
+          "end"
+      )
+    end
+  end
+end

data/lib/dear_inventory/environment.rb

@@ -0,0 +1,54 @@
+# typed: ignore
+# frozen_string_literal: true
+
+# Usually this class wouldn't be called directly, the environment can be managed
+# via the DearInventory::Config class or one of it's sub-classes
+module DearInventory
+  class Environment
+    class << self
+      def production?
+        to_sym == :production
+      end
+
+      def test?
+        to_sym == :test
+      end
+
+      def to_sym
+        @to_sym ||= set(default)
+      end
+
+      ENVIRONMENTS = %i[production test].freeze
+
+      def set(value)
+        return @to_sym = value if ENVIRONMENTS.include?(value)
+
+        error_value = value.is_a?(Symbol) ? ":#{value}" : value.to_s
+        raise(
+          ArgumentError,
+          "#{error_value} is not an acceptable environment; " \
+            "please use either :production or :test"
+        )
+      end
+
+      private
+
+      def default
+        return :test if ENV["ENV"] == "test"
+        return rails if rails?
+
+        :production
+      end
+
+      def rails?
+        defined?(Rails)
+      end
+
+      def rails
+        return :production if Rails.env.production?
+
+        :test
+      end
+    end
+  end
+end

data/lib/dear_inventory/error.rb

@@ -0,0 +1,16 @@
+# typed: strong
+# frozen_string_literal: true
+
+module DearInventory
+  class Error < StandardError
+    extend T::Sig
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :message
+
+    sig { params(message: T.nilable(String)).void }
+    def initialize(message = nil)
+      @message = T.let(message, T.nilable(String))
+    end
+  end
+end

data/lib/dear_inventory/errors/request.rb

@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+module DearInventory
+  class RequestError < Error
+    extend T::Sig
+
+    sig do
+      params(
+        message: T.nilable(String),
+        response: T.nilable(DearInventory::Response)
+      ).void
+    end
+    def initialize(message = nil, response = nil)
+      super(message)
+
+      @response = T.let(response, T.nilable(DearInventory::Response))
+    end
+
+    sig { returns(T.nilable(String)) }
+    def http_body
+      @response&.error || @response&.body&.to_s
+    end
+
+    sig { returns(T.nilable(T::Hash[Symbol, String])) }
+    def http_headers
+      @response&.headers
+    end
+
+    sig { returns(T.nilable(Integer)) }
+    def http_status
+      @response&.http_status
+    end
+
+    sig { returns(T.nilable(String)) }
+    def url
+      @response&.url&.to_s
+    end
+  end
+end

data/lib/dear_inventory/errors/validation.rb

@@ -0,0 +1,6 @@
+# typed: strong
+# frozen_string_literal: true
+
+module DearInventory
+  class ValidationError < DearInventory::Error; end
+end

data/lib/dear_inventory/lib/date_time.rb

@@ -0,0 +1,18 @@
+# typed: strict
+# frozen_string_literal: true
+
+module DearInventory
+  class DateTime
+    extend T::Sig
+
+    sig { params(date: T.any(Date, Time)).void }
+    def initialize(date)
+      @date = T.let(date, T.any(Date, Time))
+    end
+
+    sig { returns(String) }
+    def to_s
+      @date.strftime("%FT%T%:z")
+    end
+  end
+end

data/lib/dear_inventory/lib/endpoint_class.rb

@@ -0,0 +1,57 @@
+# typed: strict
+# frozen_string_literal: true
+
+module DearInventory
+  class EndpointClass
+    extend T::Sig
+
+    sig do
+      params(
+        class_type: String,
+        resource_class: T.class_of(DearInventory::Resource),
+        endpoint: T.nilable(String)
+      ).returns(
+        T.nilable(T.class_of(DearInventory::Parameters))
+      )
+    end
+    def self.call(class_type:, resource_class:, endpoint:)
+      new(
+        class_type: class_type,
+        resource_class: resource_class,
+        endpoint: endpoint
+      ).call
+    end
+
+    sig do
+      params(
+        class_type: String,
+        resource_class: T.class_of(DearInventory::Resource),
+        endpoint: T.nilable(String)
+      ).void
+    end
+    def initialize(class_type:, resource_class:, endpoint:)
+      @class_type = T.let(class_type, String)
+      @resource_class = T.let(resource_class, T.untyped)
+      @endpoint = T.let(endpoint || "Index", String)
+      @class_name = T.let(nil, T.nilable(String))
+    end
+
+    sig { returns(T.nilable(T.class_of(DearInventory::Parameters))) }
+    def call
+      Object.const_get(class_name) if Object.const_defined?(class_name)
+    end
+
+    private
+
+    sig { returns(String) }
+    def class_name
+      @class_name ||= begin
+        name = ["DearInventory"]
+        name << @class_type
+        name << @resource_class.name.split("::").last
+        name << @endpoint
+        name.join("::")
+      end
+    end
+  end
+end

data/lib/dear_inventory/lib/is_a_subclass.rb

@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+module DearInventory
+  module IsASubclass
+    extend T::Sig
+
+    sig { params(comparison_class: T.untyped).returns(T::Boolean) }
+    def is_a?(comparison_class)
+      return true if super
+
+      if T.unsafe(self).class == Class
+        return T.unsafe(self).ancestors.include?(comparison_class)
+      end
+
+      false
+    end
+  end
+end

data/lib/dear_inventory/model.rb

@@ -0,0 +1,98 @@
+# typed: true
+# frozen_string_literal: true
+
+require "json"
+
+module DearInventory
+  class Model
+    extend T::Sig
+    extend T::Helpers
+    abstract!
+
+    extend DearInventory::IsASubclass
+
+    sig do
+      params(
+        fields: T::Hash[
+          Symbol,
+          T::Hash[Symbol, T.any(Symbol, T.class_of(DearInventory::Model))]
+        ]
+      ).void
+    end
+    def self.fields(fields)
+      if const_defined?(:FIELDS, false)
+        fields = remove_const(:FIELDS).merge(fields)
+      end
+      const_set(:FIELDS, fields.freeze)
+
+      enumerate_fields do |_, specifications|
+        __send__(:attr_reader, specifications[:name])
+      end
+    end
+
+    sig { void }
+    def self.enumerate_fields
+      const_get(:FIELDS).each do |response_name, specifications|
+        yield(response_name, specifications)
+      end
+    end
+
+    sig do
+      params(values: T.nilable(T::Hash[String, T.untyped])).void
+    end
+    def initialize(values)
+      return if values.nil?
+
+      self.class.enumerate_fields do |response_name, specifications|
+        value = field_value(response_name, T.must(values), specifications)
+        instance_variable_set(:"@#{specifications[:name]}", value)
+      end
+    end
+
+    private
+
+    sig do
+      params(
+        response_name: Symbol,
+        values:
+          T::Hash[String, T.untyped],
+        specifications:
+          T::Hash[Symbol, T.any(Symbol, T.class_of(DearInventory::Model))]
+      ).returns(
+        T.nilable(
+          T.any(
+            String, Numeric, T::Boolean,
+            DearInventory::Model, T::Array[DearInventory::Model]
+          )
+        )
+      )
+    end
+    def field_value(response_name, values, specifications)
+      model = specifications[:model]
+      value = values[response_name.to_s]
+
+      case specifications[:type]
+      when :Array
+        initialize_array_values_in_models(value, model)
+      when :Hash
+        model.new(value)
+      else
+        value
+      end
+    end
+
+    sig do
+      params(
+        array: T.nilable(T::Array[T::Hash[String, T.untyped]]),
+        model: T.class_of(DearInventory::Model)
+      ).returns(T.nilable(T::Array[DearInventory::Model]))
+    end
+    def initialize_array_values_in_models(array, model)
+      return if array.nil?
+
+      array.each_with_object([]) do |values, records|
+        records << model.new(values)
+      end
+    end
+  end
+end

data/lib/dear_inventory/models/additional_attributes.rb

@@ -0,0 +1,53 @@
+# typed: strong
+# frozen_string_literal: true
+
+module DearInventory
+  module Models
+    class AdditionalAttributes < DearInventory::Model
+      extend T::Sig
+
+      fields({
+        AdditionalAttribute1: {
+          name: :additional_attribute_1,
+          type: :String,
+        },
+        AdditionalAttribute2: {
+          name: :additional_attribute_2,
+          type: :String,
+        },
+        AdditionalAttribute3: {
+          name: :additional_attribute_3,
+          type: :String,
+        },
+        AdditionalAttribute4: {
+          name: :additional_attribute_4,
+          type: :String,
+        },
+        AdditionalAttribute5: {
+          name: :additional_attribute_5,
+          type: :String,
+        },
+        AdditionalAttribute6: {
+          name: :additional_attribute_6,
+          type: :String,
+        },
+        AdditionalAttribute7: {
+          name: :additional_attribute_7,
+          type: :String,
+        },
+        AdditionalAttribute8: {
+          name: :additional_attribute_8,
+          type: :String,
+        },
+        AdditionalAttribute9: {
+          name: :additional_attribute_9,
+          type: :String,
+        },
+        AdditionalAttribute10: {
+          name: :additional_attribute_10,
+          type: :String,
+        },
+      })
+    end
+  end
+end

data/lib/dear_inventory/models/additional_charge.rb

@@ -0,0 +1,45 @@
+# typed: strong
+# frozen_string_literal: true
+
+module DearInventory
+  module Models
+    class AdditionalCharge < DearInventory::Model
+      extend T::Sig
+
+      fields({
+        Description: {
+          name: :description,
+          type: :String,
+        },
+        Price: {
+          name: :price,
+          type: :Numeric,
+        },
+        Quantity: {
+          name: :quantity,
+          type: :Numeric,
+        },
+        Discount: {
+          name: :discount,
+          type: :Numeric,
+        },
+        Tax: {
+          name: :tax,
+          type: :Numeric,
+        },
+        Total: {
+          name: :total,
+          type: :Numeric,
+        },
+        TaxRule: {
+          name: :tax_rule,
+          type: :String,
+        },
+        Comment: {
+          name: :comment,
+          type: :String,
+        },
+      })
+    end
+  end
+end