ledger_sync 1.0.10 → 1.1.1

data/lib/ledger_sync/resource_attribute.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'ledger_sync/type/value'
+
+Gem.find_files('ledger_sync/type/**/*.rb').each do |path|
+  require path
+end
+
+Gem.find_files('ledger_sync/resource_attribute/**/*.rb').each do |path|
+  require path
+end
+
+module LedgerSync
+  class ResourceAttribute
+    include Fingerprintable::Mixin
+    include SimplySerializable::Mixin
+
+    attr_accessor :value
+    attr_reader :name,
+                :reference,
+                :type
+
+    def initialize(name:, type:, value: nil)
+      @name = name.to_sym
+
+      type = type.new if type.respond_to?(:new) && !type.is_a?(Type::Value)
+
+      raise "Invalid Type: #{type}" unless type.is_a?(ActiveModel::Type::Value)
+
+      @type = type
+
+      @value = value
+    end
+
+    def cast(value)
+      type.cast(value)
+    end
+
+    # This is for ActiveModel::Dirty, since we define @attributes
+    # def forgetting_assignment; end
+
+    def reference?
+      is_a?(Reference)
+    end
+
+    def valid_with?(value:)
+      type.valid_without_casting?(value: value)
+    end
+  end
+end

data/lib/ledger_sync/resource_attribute/dirty_mixin.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Helper methods for adding dirty tracked attributes
+module LedgerSync
+  class ResourceAttribute
+    module DirtyMixin
+      def self.included(base)
+        base.include(ActiveModel::Dirty)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def dirty_attribute(*names)
+          names.each do |name|
+            class_eval do
+              attr_reader name
+              define_attribute_methods name # From ActiveModel
+              dirty_attributes[name] = {
+                name: name
+              }
+
+              define_method("#{name}=") do |val|
+                send("#{name}_will_change!") unless val == instance_variable_get("@#{name}")
+                instance_variable_set("@#{name}", val)
+              end
+            end
+          end
+        end
+
+        def dirty_attributes
+          @dirty_attributes ||= {}
+        end
+      end
+
+      # Normally you would just call `changes_applied`, but because we
+      # define an `@attributes` instance variable, the `ActiveModel::Dirty`
+      # mixin assumes it is a list of attributes in their format (spoiler: it
+      # isn't).  So this is copying the code from `changes_applied` and setting
+      # `@mutations_from_database` to the value it would receive if
+      # `@attributes` did not exist.
+      def save
+        # changes_applied # Code reproduced below.
+        @mutations_before_last_save = mutations_from_database
+        # forget_attribute_assignments # skipped as our attributes do not implement this method
+        @mutations_from_database = ActiveModel::ForcedMutationTracker.new(self) # Manually set to expected value
+      end
+    end
+  end
+end

data/lib/ledger_sync/resource_attribute/mixin.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative '../resource_attribute_set'
+require_relative 'dirty_mixin'
+
+# Mixin for attribute functionality
+module LedgerSync
+  class ResourceAttribute
+    module Mixin
+      def self.included(base)
+        base.include(DirtyMixin)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def _define_attribute_methods(name)
+          class_eval do
+            define_attribute_methods name
+
+            define_method name do
+              resource_attributes[name].value
+            end
+
+            define_method "#{name}=" do |val|
+              public_send("#{name}_will_change!") unless val == resource_attributes[name] # For Dirty
+
+              attribute = resource_attributes[name]
+
+              unless attribute.valid_with?(value: val)
+                raise ResourceError::AttributeTypeError.new(
+                  attribute: attribute,
+                  resource: self,
+                  value: val
+                )
+              end
+
+              attribute.value = val
+            end
+
+            serialize attributes: [name]
+          end
+        end
+
+        def attribute(name, type:)
+          resource_attribute = ResourceAttribute.new(name: name, type: type)
+
+          _define_attribute_methods(name)
+
+          resource_attributes.add(resource_attribute)
+
+          resource_attribute
+        end
+
+        def resource_attributes
+          @resource_attributes ||= ResourceAttributeSet.new(resource: self)
+        end
+      end
+
+      def initialize(**data)
+        # Initialize empty values
+        resource_attributes.keys.each { |e| instance_variable_set("@#{e}", nil) }
+
+        assign_attributes(data)
+
+        super()
+      end
+
+      def assign_attribute(name, value)
+        raise "#{name} is not an attribute of #{self.class.name}" unless resource_attributes.key?(name)
+
+        public_send("#{name}=", value)
+      end
+
+      def assign_attributes(attribute_hash)
+        attribute_hash.each do |name, value|
+          assign_attribute(name, value)
+        end
+      end
+
+      # Store attribute instance values separately
+      def resource_attributes
+        @resource_attributes ||= Marshal.load(Marshal.dump(self.class.resource_attributes))
+      end
+
+      def serialize_attributes
+        Hash[resource_attributes.map { |k, v| [k, v.value] }]
+      end
+    end
+  end
+end

data/lib/ledger_sync/resource_attribute/reference.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Reference attribute type that enforces values are a resource
+module LedgerSync
+  class ResourceAttribute
+    class Reference < ResourceAttribute
+    end
+  end
+end

data/lib/ledger_sync/resource_attribute/reference/many.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../reference'
+
+# Reference attribute type for has_one
+module LedgerSync
+  class ResourceAttribute
+    class Reference
+      class Many < Reference
+        module Mixin
+          def self.included(base)
+            base.extend(ClassMethods)
+          end
+
+          module ClassMethods
+            def references_many(name, to:)
+              resource_attribute = ResourceAttribute::Reference::Many.new(name: name, to: to)
+              resource_attributes.add resource_attribute
+              _define_attribute_methods(name)
+            end
+          end
+        end
+
+        def initialize(name:, to:)
+          super(
+            name: name,
+            type: Type::ReferenceMany.new(resource_class: to),
+            value: []
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/resource_attribute/reference/one.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../reference'
+
+# Reference attribute type for has_one
+module LedgerSync
+  class ResourceAttribute
+    class Reference
+      class One < Reference
+        module Mixin
+          def self.included(base)
+            base.extend(ClassMethods)
+          end
+
+          module ClassMethods
+            def references_one(name, to:)
+              resource_attribute = ResourceAttribute::Reference::One.new(name: name, to: to)
+              resource_attributes.add resource_attribute
+              _define_attribute_methods(name)
+            end
+          end
+        end
+
+        def initialize(name:, to:)
+          super(
+            name: name,
+            type: Type::ReferenceOne.new(resource_class: to)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ledger_sync/resource_attribute_set.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  class ResourceAttributeSet
+    attr_reader :attributes,
+                :references,
+                :references_one,
+                :references_many,
+                :resource
+
+    delegate  :[],
+              :each,
+              :include?,
+              :key?,
+              :keys,
+              :map,
+              to: :attributes
+
+    alias names keys
+
+    def initialize(resource:)
+      @attributes = {}
+      @references = []
+      @references_one = []
+      @references_many = []
+
+      @resource = resource
+    end
+
+    def add(attribute)
+      name = attribute.name
+      raise "Attribute #{name} already exists on #{resource.name}." if attributes.key?(name)
+
+      case attribute
+      when ResourceAttribute
+        nil
+      when ResourceAttribute::Reference::One
+        @references << attribute
+        @references_one << attribute
+      when ResourceAttribute::Reference::Many
+        @references << attribute
+        @references_many << attribute
+      else
+        raise 'Unknown attribute class'
+      end
+
+      @attributes[attribute.name] = attribute
+    end
+
+    def to_a
+      attributes.values
+    end
+
+    def to_h
+      Hash[attributes.map { |k, v| [k, v.value] }]
+    end
+  end
+end

data/lib/ledger_sync/resources/account.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module LedgerSync
+  class Account < LedgerSync::Resource
+    attribute :name, type: Type::String
+    attribute :classification, type: Type::String
+    attribute :account_type, type: Type::String
+    attribute :account_sub_type, type: Type::String
+    attribute :number, type: Type::Integer
+    attribute :currency, type: Type::String
+    attribute :description, type: Type::String
+    attribute :active, type: Type::Boolean
+  end
+end

data/lib/ledger_sync/resources/bill.rb

@@ -0,0 +1,17 @@
+module LedgerSync
+  class Bill < LedgerSync::Resource
+    attribute :currency, type: Type::String
+    attribute :memo, type: Type::String
+    attribute :transaction_date, type: Type::Date
+    attribute :due_date, type: Type::Date
+
+    references_one :vendor, to: Vendor
+    references_one :account, to: Account
+
+    references_many :line_items, to: BillLineItem
+
+    def name
+      "Bill: #{transaction_date.to_s}"
+    end
+  end
+end

data/lib/ledger_sync/resources/bill_line_item.rb

@@ -0,0 +1,11 @@
+module LedgerSync
+  class BillLineItem < LedgerSync::Resource
+    references_one :account, to: Account
+    attribute :amount, type: Type::Integer
+    attribute :description, type: Type::String
+
+    def name
+      description
+    end
+  end
+end

data/lib/ledger_sync/resources/customer.rb

@@ -1,8 +1,9 @@
+# frozen_string_literal: true
+
 module LedgerSync
   class Customer < LedgerSync::Resource
-    attribute :email
-    attribute :name
-    attribute :phone_number
-    # attribute :active
+    attribute :email, type: Type::String
+    attribute :name, type: Type::String
+    attribute :phone_number, type: Type::String
   end
 end

data/lib/ledger_sync/resources/deposit.rb

@@ -0,0 +1,16 @@
+module LedgerSync
+  class Deposit < LedgerSync::Resource
+    attribute :currency, type: Type::String
+    attribute :memo, type: Type::String
+    attribute :transaction_date, type: Type::Date
+    attribute :exchange_rate, type: Type::Float
+
+    references_one :account, to: Account
+
+    references_many :line_items, to: DepositLineItem
+
+    def name
+      "Deposit: #{currency}"
+    end
+  end
+end

data/lib/ledger_sync/resources/deposit_line_item.rb

@@ -0,0 +1,11 @@
+module LedgerSync
+  class DepositLineItem < LedgerSync::Resource
+    references_one :account, to: Account
+    attribute :amount, type: Type::Integer
+    attribute :description, type: Type::String
+
+    def name
+      description
+    end
+  end
+end

data/lib/ledger_sync/resources/expense.rb

@@ -0,0 +1,19 @@
+module LedgerSync
+  class Expense < LedgerSync::Resource
+    attribute :currency, type: Type::String
+    attribute :amount, type: Type::Integer
+    attribute :memo, type: Type::String
+    attribute :payment_type, type: Type::String
+    attribute :transaction_date, type: Type::Date
+    attribute :exchange_rate, type: Type::Float
+
+    references_one :vendor, to: Vendor
+    references_one :account, to: Account
+
+    references_many :line_items, to: ExpenseLineItem
+
+    def name
+      "Purchase: #{amount} #{currency}"
+    end
+  end
+end

data/lib/ledger_sync/resources/expense_line_item.rb

@@ -0,0 +1,11 @@
+module LedgerSync
+  class ExpenseLineItem < LedgerSync::Resource
+    references_one :account, to: Account
+    attribute :amount, type: Type::Integer
+    attribute :description, type: Type::String
+
+    def name
+      description
+    end
+  end
+end