subledger 0.7.7

data/lib/subledger/domain/value/zero.rb

@@ -0,0 +1,24 @@
+module Subledger
+  module Domain
+    class Zero
+
+      include Value
+
+      def self.type
+        'zero'
+      end
+
+      def rest_hash
+        { 'type' => 'zero', 'amount' => amount_to_s(@amount) }
+      end
+
+      private
+
+      def validate_sign arg_amount
+        unless arg_amount.zero?
+          raise ValueError, 'Amount must be zero'
+        end
+      end
+    end
+  end
+end

data/lib/subledger/domain/value.rb

@@ -0,0 +1,111 @@
+# additional requires at bottom
+
+module Subledger
+  module Domain
+    class ValueError < Error; end
+
+    module Value
+
+      def self.included base
+        base.extend ValueClass
+      end
+
+      module ValueClass
+        def raise_unless_creatable args
+          value = args[:value]
+
+          if value.nil? or not value.kind_of? Value
+            raise ValueError, ':value is required and must be a Value'
+          end
+        end
+      end
+
+      attr_reader :amount
+
+      def initialize arg_amount=0
+        if arg_amount.nil?
+          raise ValueError, 'amount may not be nil'
+        end
+
+        validate_amount(arg_amount) if arg_amount.respond_to?(:match)
+
+        big_amount = BigDecimal arg_amount
+
+        validate_sign big_amount
+
+        validate_amount( amount_to_s big_amount )
+
+        @amount = big_amount
+      end
+
+      def + other
+        (Balance.new + value + other.value).value
+      end
+
+      def == other
+        self.value.class == other.value.class and amount == other.amount
+      end
+
+      def value
+        self
+      end
+
+      def to_s
+        "#{self.class.type}: #{amount_to_s @amount}"
+      end
+
+      alias :inspect :to_s
+
+      private
+
+      def amount_to_s arg_amount
+        if arg_amount.zero?
+          '0'
+        else
+          arg_amount.to_s( 'F' ).chomp( '.0' ).sub( /^0+/, '' )
+        end
+      end
+
+      def validate_sign arg_amount
+        unless arg_amount > 0
+          raise ValueError, 'amount must be positive'
+        end
+      end
+
+      ERROR_TEXT = 'amount is limited to 15 whole digits and 12 fractional digits'
+
+      def validate_amount arg_amount
+
+        unless arg_amount.match /^\d*[.]?\d*$/
+          raise ValueError, "amount (#{arg_amount}) must be numeric"
+        end
+
+        return if BigDecimal(arg_amount).zero?
+
+        arg_amount.sub! /^0+/, ''
+        arg_amount.sub! /[.](\d)*0+$/, '.\\1'
+
+        if arg_amount.include? '.'
+          whole, fraction = arg_amount.split '.'
+
+          whole    ||= ''
+          fraction ||= ''
+
+          if whole.length > 15 or fraction.length > 12
+            raise ValueError, ERROR_TEXT
+          end
+        else
+          if arg_amount.length > 15
+            raise ValueError, ERROR_TEXT
+          end
+        end
+
+      end
+
+    end
+  end
+end
+
+require 'subledger/domain/value/credit'
+require 'subledger/domain/value/debit'
+require 'subledger/domain/value/zero'

data/lib/subledger/domain.rb

@@ -0,0 +1,95 @@
+require 'bcrypt'
+require 'grape-entity'
+
+# additional requires at bottom
+
+module Subledger
+  module Domain
+    class ActivatableError                < Error; end
+    class ArchivableError                 < Error; end
+    class AttributableError               < Error; end
+    class CollectableError                < Error; end
+    class CreatableError                  < Error; end
+    class DescribableError                < Error; end
+    class DescribableReportRenderingError < Error; end
+    class IdentifiableError               < Error; end
+    class PostableError                   < Error; end
+    class ProgressableError               < Error; end
+    class ReadableError                   < Error; end
+    class RestableError                   < Error; end
+    class StorableError                   < Error; end
+    class TimeableError                   < Error; end
+    class UpdatableError                  < Error; end
+    class VersionableError                < Error; end
+
+    def self.included base
+      base.extend DomainClass
+    end
+
+    module DomainClass
+      def keys
+        self::Entity.exposures.keys
+      end
+
+      def entity_name
+        self::Entity.instance_variable_get( :@root ).to_sym
+      end
+
+      def collection_name
+        self::Entity.instance_variable_get( :@collection_root ).to_sym
+      end
+
+      def raise_unless_creatable args
+        raise NoMethodError, 'subclasses must provide self.raise_unless_creatable'
+      end
+    end
+
+    def == other
+      if respond_to?( :id )       and
+         other.respond_to?( :id ) and
+         ( ( not id.nil? ) and ( not other.id.nil? ) )
+        id == other.id
+      else
+        super
+      end
+    end
+
+    def collection_name
+      self.class.collection_name
+    end
+
+    def entity_name
+      self.class.entity_name
+    end
+
+    def to_s
+      "#{entity_name}: #{ MultiJson.dump serializable_hash }"
+    end
+
+    alias :inspect :to_s
+
+    private
+
+    def short_klass_name
+      self.class.name.match( /[^:]+$/ )[0] + ': '
+    end
+  end
+end
+
+require 'subledger/domain/formatters'
+require 'subledger/domain/roles'
+
+require 'subledger/domain/value'
+
+require 'subledger/domain/account'
+require 'subledger/domain/balance'
+require 'subledger/domain/book'
+require 'subledger/domain/category'
+require 'subledger/domain/control'
+require 'subledger/domain/identity'
+require 'subledger/domain/journal_entry'
+require 'subledger/domain/key'
+require 'subledger/domain/line'
+require 'subledger/domain/org'
+require 'subledger/domain/report'
+require 'subledger/domain/report_rendering'

data/lib/subledger/exception_handler.rb

@@ -0,0 +1,65 @@
+module Subledger
+  class ExceptionHandler
+
+    # attempts   seconds
+    #        1      no point!
+    #        2      0.15+
+    #        3      0.35+
+    #        4      0.75+
+    #        5      1.55+
+    #        6      3.15+
+    #        7      6.35+
+    #        8     12.75+
+    #        9     25.55+ default max_attempts
+    #       10     51.15
+    #
+    # attempts 11 and up are 2 seconds apart
+
+    def initialize args
+      @name          = args[:name]
+      @exception     = args[:exception]     || Exception
+      @max_attempts  = args[:max_attempts]  || 10
+      @initial_delay = args[:initial_delay] || 0
+    end
+
+    def with_retry
+
+      attempts = 1
+      total    = 0
+
+      sleep @initial_delay
+
+      begin
+        yield
+      rescue @exception => e
+        if is_internal?( e ) or ( attempts >= @max_attempts )
+          raise e, "FAILURE: #{@name}, attempts: #{attempts}, total: #{total}, #{e}"
+        elsif attempts < @max_attempts
+
+          if attempts < 11
+            delay = 2 ** attempts * 0.05
+          else
+            delay += 2
+          end
+
+          if attempts > 8
+            LOG.warn "RETRY: #{@name}, attempts: #{attempts}, delay: #{delay}, #{e}"
+          end
+
+          sleep delay
+
+          total    += delay
+          attempts += 1
+
+          retry
+        end
+      end
+    end
+
+    private
+
+    def is_internal? e
+      e.class.name.to_s =~ /^Subledger::/
+    end
+  end
+end

data/lib/subledger/interface/client.rb

@@ -0,0 +1,295 @@
+module Subledger
+  module Interface
+    class ClientError < Error; end
+
+    class Client
+
+      private
+
+      attr_reader :client_args
+
+      COLLECTIONS = { :identity                    => { :klass           => Domain::Identity,
+                                                        :root_collection => :identities,
+                                                        :state           => :active },
+                      :identities                  => { :klass           => Domain::Identity,
+                                                        :root_collection => :identities,
+                                                        :state           => :active },
+                      :archived_identity           => { :klass           => Domain::ArchivedIdentity,
+                                                        :root_collection => :identities,
+                                                        :state           => :archived },
+                      :archived_identities         => { :klass           => Domain::ArchivedIdentity,
+                                                        :root_collection => :identities,
+                                                        :state           => :archived },
+                      :active_identity             => { :klass           => Domain::ActiveIdentity,
+                                                        :root_collection => :identities,
+                                                        :state           => :active },
+                      :active_identities           => { :klass           => Domain::ActiveIdentity,
+                                                        :root_collection => :identities,
+                                                        :state           => :active },
+                      :key                         => { :klass           => Domain::Key,
+                                                        :root_collection => :keys,
+                                                        :state           => :active },
+                      :keys                        => { :klass           => Domain::Key,
+                                                        :root_collection => :keys,
+                                                        :state           => :active },
+                      :archived_key                => { :klass           => Domain::ArchivedKey,
+                                                        :root_collection => :keys,
+                                                        :state           => :archived },
+                      :archived_keys               => { :klass           => Domain::ArchivedKey,
+                                                        :root_collection => :keys,
+                                                        :state           => :archived },
+                      :active_key                  => { :klass           => Domain::ActiveKey,
+                                                        :root_collection => :keys,
+                                                        :state           => :active },
+                      :active_keys                 => { :klass           => Domain::ActiveKey,
+                                                        :root_collection => :keys,
+                                                        :state           => :active },
+                      :control                     => { :klass           => Domain::Control,
+                                                        :root_collection => :controls,
+                                                        :state           => :active },
+                      :controls                    => { :klass           => Domain::Control,
+                                                        :root_collection => :controls,
+                                                        :state           => :active },
+                      :archived_control            => { :klass           => Domain::ArchivedControl,
+                                                        :root_collection => :controls,
+                                                        :state           => :archived },
+                      :archived_controls           => { :klass           => Domain::ArchivedControl,
+                                                        :root_collection => :controls,
+                                                        :state           => :archived },
+                      :active_control              => { :klass           => Domain::ActiveControl,
+                                                        :root_collection => :controls,
+                                                        :state           => :active },
+                      :active_controls             => { :klass           => Domain::ActiveControl,
+                                                        :root_collection => :controls,
+                                                        :state           => :active },
+                      :org                         => { :klass           => Domain::Org,
+                                                        :root_collection => :orgs,
+                                                        :state           => :active },
+                      :orgs                        => { :klass           => Domain::Org,
+                                                        :root_collection => :orgs,
+                                                        :state           => :active },
+                      :archived_org                => { :klass           => Domain::ArchivedOrg,
+                                                        :root_collection => :orgs,
+                                                        :state           => :archived },
+                      :archived_orgs               => { :klass           => Domain::ArchivedOrg,
+                                                        :root_collection => :orgs,
+                                                        :state           => :archived },
+                      :active_org                  => { :klass           => Domain::ActiveOrg,
+                                                        :root_collection => :orgs,
+                                                        :state           => :active },
+                      :active_orgs                 => { :klass           => Domain::ActiveOrg,
+                                                        :root_collection => :orgs,
+                                                        :state           => :active },
+                      :book                        => { :klass           => Domain::Book,
+                                                        :root_collection => :books,
+                                                        :state           => :active },
+                      :books                       => { :klass           => Domain::Book,
+                                                        :root_collection => :books,
+                                                        :state           => :active },
+                      :archived_book               => { :klass           => Domain::ArchivedBook,
+                                                        :root_collection => :books,
+                                                        :state           => :archived },
+                      :archived_books              => { :klass           => Domain::ArchivedBook,
+                                                        :root_collection => :books,
+                                                        :state           => :archived },
+                      :active_book                 => { :klass           => Domain::ActiveBook,
+                                                        :root_collection => :books,
+                                                        :state           => :active },
+                      :active_books                => { :klass           => Domain::ActiveBook,
+                                                        :root_collection => :books,
+                                                        :state           => :active },
+                      :account                     => { :klass           => Domain::Account,
+                                                        :root_collection => :accounts,
+                                                        :state           => :active },
+                      :accounts                    => { :klass           => Domain::Account,
+                                                        :root_collection => :accounts,
+                                                        :state           => :active },
+                      :archived_account            => { :klass           => Domain::ArchivedAccount,
+                                                        :root_collection => :accounts,
+                                                        :state           => :archived },
+                      :archived_accounts           => { :klass           => Domain::ArchivedAccount,
+                                                        :root_collection => :accounts,
+                                                        :state           => :archived },
+                      :active_account              => { :klass           => Domain::ActiveAccount,
+                                                        :root_collection => :accounts,
+                                                        :state           => :active },
+                      :active_accounts             => { :klass           => Domain::ActiveAccount,
+                                                        :root_collection => :accounts,
+                                                        :state           => :active },
+                      :category_accounts           => { :klass           => Domain::Account,
+                                                        :root_collection => :category_accounts,
+                                                        :state           => :nil },
+                      :journal_entry               => { :klass           => Domain::JournalEntry,
+                                                        :root_collection => :journal_entries,
+                                                        :state           => :active },
+                      :journal_entries             => { :klass           => Domain::JournalEntry,
+                                                        :root_collection => :journal_entries,
+                                                        :state           => :active },
+                      :archived_journal_entry      => { :klass           => Domain::ArchivedJournalEntry,
+                                                        :root_collection => :journal_entries,
+                                                        :state           => :archived },
+                      :archived_journal_entries    => { :klass           => Domain::ArchivedJournalEntry,
+                                                        :root_collection => :journal_entries,
+                                                        :state           => :archived },
+                      :active_journal_entry        => { :klass           => Domain::ActiveJournalEntry,
+                                                        :root_collection => :journal_entries,
+                                                        :state           => :active },
+                      :active_journal_entries      => { :klass           => Domain::ActiveJournalEntry,
+                                                        :root_collection => :journal_entries,
+                                                        :state           => :active },
+                      :posting_journal_entry       => { :klass           => Domain::PostingJournalEntry,
+                                                        :root_collection => :journal_entries,
+                                                        :state           => :posting },
+                      :posting_journal_entries     => { :klass           => Domain::PostingJournalEntry,
+                                                        :root_collection => :journal_entries,
+                                                        :state           => :posting },
+                      :posted_journal_entry        => { :klass           => Domain::PostedJournalEntry,
+                                                        :root_collection => :journal_entries,
+                                                        :state           => :posted },
+                      :posted_journal_entries      => { :klass           => Domain::PostedJournalEntry,
+                                                        :root_collection => :journal_entries,
+                                                        :state           => :posted },
+                      :line                        => { :klass           => Domain::Line,
+                                                        :root_collection => :lines,
+                                                        :state           => :active },
+                      :lines                       => { :klass           => Domain::Line,
+                                                        :root_collection => :lines,
+                                                        :state           => :active },
+                      :archived_line               => { :klass           => Domain::ArchivedLine,
+                                                        :root_collection => :lines,
+                                                        :state           => :archived },
+                      :archived_lines              => { :klass           => Domain::ArchivedLine,
+                                                        :root_collection => :lines,
+                                                        :state           => :archived },
+                      :active_line                 => { :klass           => Domain::ActiveLine,
+                                                        :root_collection => :lines,
+                                                        :state           => :active },
+                      :active_lines                => { :klass           => Domain::ActiveLine,
+                                                        :root_collection => :lines,
+                                                        :state           => :active },
+                      :posted_line                 => { :klass           => Domain::PostedLine,
+                                                        :root_collection => :lines,
+                                                        :state           => :posted },
+                      :posted_lines                => { :klass           => Domain::PostedLine,
+                                                        :root_collection => :lines,
+                                                        :state           => :posted },
+                      :account_line                => { :klass           => Domain::PostedLine,
+                                                        :root_collection => :account_lines,
+                                                        :state           => :nil },
+                      :account_lines               => { :klass           => Domain::PostedLine,
+                                                        :root_collection => :account_lines,
+                                                        :state           => :nil },
+                      :category                    => { :klass           => Domain::Category,
+                                                        :root_collection => :categories,
+                                                        :state           => :active },
+                      :categories                  => { :klass           => Domain::Category,
+                                                        :root_collection => :categories,
+                                                        :state           => :active },
+                      :archived_category           => { :klass           => Domain::ArchivedCategory,
+                                                        :root_collection => :categories,
+                                                        :state           => :archived },
+                      :archived_categories         => { :klass           => Domain::ArchivedCategory,
+                                                        :root_collection => :categories,
+                                                        :state           => :archived },
+                      :active_category             => { :klass           => Domain::ActiveCategory,
+                                                        :root_collection => :categories,
+                                                        :state           => :active },
+                      :active_categories           => { :klass           => Domain::ActiveCategory,
+                                                        :root_collection => :categories,
+                                                        :state           => :active },
+                      :report_categories           => { :klass           => Domain::Category,
+                                                        :root_collection => :report_categories,
+                                                        :state           => :nil },
+                      :report                      => { :klass           => Domain::Report,
+                                                        :root_collection => :reports,
+                                                        :state           => :active },
+                      :reports                     => { :klass           => Domain::Report,
+                                                        :root_collection => :reports,
+                                                        :state           => :active },
+                      :archived_report             => { :klass           => Domain::ArchivedReport,
+                                                        :root_collection => :reports,
+                                                        :state           => :archived },
+                      :archived_reports            => { :klass           => Domain::ArchivedReport,
+                                                        :root_collection => :reports,
+                                                        :state           => :archived },
+                      :active_report               => { :klass           => Domain::ActiveReport,
+                                                        :root_collection => :reports,
+                                                        :state           => :active },
+                      :active_reports              => { :klass           => Domain::ActiveReport,
+                                                        :root_collection => :reports,
+                                                        :state           => :active },
+                      :report_rendering            => { :klass           => Domain::ReportRendering,
+                                                        :root_collection => :report_renderings,
+                                                        :state           => :building },
+                      :report_renderings           => { :klass           => Domain::ReportRendering,
+                                                        :root_collection => :report_renderings,
+                                                        :state           => :building },
+                      :building_report_rendering   => { :klass           => Domain::BuildingReportRendering,
+                                                        :root_collection => :report_renderings,
+                                                        :state           => :building },
+                      :building_report_renderings  => { :klass           => Domain::BuildingReportRendering,
+                                                        :root_collection => :report_renderings,
+                                                        :state           => :building },
+                      :completed_report_rendering  => { :klass           => Domain::CompletedReportRendering,
+                                                        :root_collection => :report_renderings,
+                                                        :state           => :completed },
+                      :completed_report_renderings => { :klass           => Domain::CompletedReportRendering,
+                                                        :root_collection => :report_renderings,
+                                                        :state           => :completed }
+      }
+
+      public
+
+      attr_reader :store
+
+      def initialize args
+        @client_args = args
+
+        # TODO client should not have @store and #store
+
+        @store = args[:store]
+      end
+
+      COLLECTIONS.each do |name, attributes|
+        klass           = attributes[:klass]
+        state           = attributes[:state] == :nil ? 'nil' : attributes[:state].inspect
+        root_collection = attributes[:root_collection]
+
+        method_text = <<-"EOM"
+          def #{name} *args
+            @#{name}_dispatcher ||= Dispatcher.new @client_args.
+                                                     merge(
+                                                       { :klass           => #{klass},
+                                                         :client          => self,
+                                                         :state           => #{state},
+                                                         :root_collection => :#{root_collection} } )
+
+            if args.empty?
+              @#{name}_dispatcher
+            else
+              @#{name}_dispatcher.new args.first.dup
+            end
+          end
+        EOM
+
+        class_eval method_text
+      end
+
+      def debit *args
+        args.empty? ? Domain::Debit  : Domain::Debit.new( *args )
+      end
+
+      def credit *args
+        args.empty? ? Domain::Credit : Domain::Credit.new( *args )
+      end
+
+      def zero *args
+        Domain::Zero.new
+      end
+
+      def balance *args
+        Domain::Balance.new *args
+      end
+    end
+  end
+end

data/lib/subledger/interface/dispatcher.rb

@@ -0,0 +1,20 @@
+module Subledger
+  module Interface
+    class Dispatcher
+      def initialize args
+        @klass  = args[:klass]
+
+        @dispatch_args = args
+      end
+
+      def method_missing method, args, &block
+        args.delete :store
+        args.delete :client
+
+        merged_args = @dispatch_args.merge args
+
+        @klass.send method, merged_args, &block
+      end
+    end
+  end
+end

data/lib/subledger/interface.rb

@@ -0,0 +1,2 @@
+require 'subledger/interface/client'
+require 'subledger/interface/dispatcher'