subledger 0.7.7

data/lib/subledger/domain/roles/collectable.rb

@@ -0,0 +1,175 @@
+module Subledger
+  module Domain
+    module Roles
+      module Collectable
+        def self.included base
+          base.extend CollectableClass
+        end
+
+        module CollectableClass
+
+          def collect args, &block
+            limit = args[:limit] ||= 25 unless block_given?
+
+            validate args
+
+            store           = args[:store]
+            client          = args[:client]
+            anchor          = args[:anchor]
+            action          = args[:action]
+            collection_name =  CollectionName.with_state( args.
+                                                            merge :klass => self )
+
+            args[:collection_name] = collection_name
+
+            unless anchor
+              anchor = args[:anchor] = client.send collection_name, args
+
+              anchor.read if [:preceding, :following].include? action
+            end
+
+            validate_criterion args
+
+            if block_given?
+              collect_with_block args, &block
+            else
+              store.collect args
+            end
+          end
+
+          private
+
+          ACTION_MAP = { :before    => :preceding,
+                         :ending    => :preceding,
+                         :starting  => :following,
+                         :after     => :following,
+                         :preceding => :preceding,
+                         :following => :following }
+
+          MAX_LIMIT = 100
+
+          def collect_with_block args
+            store  = args[:store]
+            anchor = args[:anchor]
+            action = args[:action]
+            limit  = args[:limit]
+
+            next_action = ACTION_MAP[ action ]
+
+            total = 0
+
+            store_limit = first_limit limit
+
+            while not ( finished_collecting? limit, total ) and
+                  not ( collected = store.collect(
+                                      args.merge!(
+                                        :anchor => anchor,
+                                        :action => action,
+                                        :limit  => store_limit ) ) ).empty?
+
+              collected.each do |item|
+                yield item
+
+                total += 1
+              end
+
+              action      = next_action
+              anchor      = collected.last
+              store_limit = next_limit limit, total
+            end
+          end
+
+          def finished_collecting? limit, total
+            not limit.nil? and total >= limit
+          end
+
+          def first_limit limit
+            ( limit.nil? or limit > MAX_LIMIT ) ? MAX_LIMIT : limit
+          end
+
+          def next_limit limit, total
+            limit.nil? ? MAX_LIMIT : calculated_limit( limit, total )
+          end
+
+          def calculated_limit limit,total
+            new_limit = limit - total
+
+            new_limit < MAX_LIMIT ? new_limit : MAX_LIMIT
+          end
+
+          def validate args
+            validate_action    args
+            validate_limit     args
+            validate_state     args
+          end
+
+          ACTIONS = [ :before,
+                      :ending,
+                      :starting,
+                      :after,
+                      :preceding,
+                      :following ]
+
+          def validate_action args
+            unless ACTIONS.include? args[:action]
+              raise CollectableError, ':action must be :before, :ending, :starting, :after, :preceding, or :following'
+            end
+          end
+
+          def validate_limit args
+            limit = args[:limit]
+
+            if not limit.nil? and limit < 1
+              raise CollectableError, ':limit must be greater than zero or nil'
+            end
+          end
+
+          def validate_state args
+            state = args[:state]
+
+            if state.nil?
+              raise CollectableError, ':state is required'
+            end
+          end
+
+          COLLECTABLE_BY  = { :building_report_renderings  => :rendered_at,
+                              :completed_report_renderings => :rendered_at,
+
+                              :archived_accounts           => :description,
+                              :active_accounts             => :description,
+                              :archived_books              => :description,
+                              :active_books                => :description,
+                              :archived_categories         => :description,
+                              :active_categories           => :description,
+                              :archived_reports            => :description,
+                              :active_reports              => :description,
+
+                              :account_lines               => :effective_at,
+                              :active_journal_entries      => :effective_at,
+                              :archived_journal_entries    => :effective_at,
+                              :posting_journal_entries     => :effective_at,
+                              :posted_journal_entries      => :effective_at,
+
+                              :archived_lines              => :order,
+                              :active_lines                => :order,
+                              :posted_lines                => :order,
+
+                              :archived_controls           => :id,
+                              :active_controls             => :id,
+                              :archived_keys               => :id,
+                              :active_keys                 => :id }
+
+          def validate_criterion args
+            anchor          = args[ :anchor ]
+            collection_name = args[ :collection_name ]
+            required_field  = COLLECTABLE_BY[ collection_name ]
+
+            if anchor.send( required_field ).nil?
+              raise CollectableError, "#{required_field.inspect} is required"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/subledger/domain/roles/creatable.rb

@@ -0,0 +1,58 @@
+module Subledger
+  module Domain
+    module Roles
+      module Creatable
+        def self.included base
+          base.extend CreatableClass
+        end
+
+        module CreatableClass
+          def create args
+            validate_creatability args
+
+            creatable = args[:client].send active_klass.collection_name, args
+
+            args[:store].create creatable
+          end
+
+          def new_or_create args
+            id = args[:id]
+
+            if id.nil?
+              item = active_klass.create args
+
+              yield item
+
+              item
+            else
+              active_klass.new args
+            end
+          end
+
+          private
+
+          def validate_creatability args
+            raise_unless_creatable args
+            validate_creatability_modules args
+          end
+
+          def validate_creatability_modules args
+            self.included_modules.each do |mod|
+              if mod.respond_to? :raise_unless_creatable
+                mod.raise_unless_creatable args
+              end
+            end
+          end
+        end
+
+        def create
+          created = self.class.create self.attributes
+
+          initialize created.attributes
+
+          self
+        end
+      end
+    end
+  end
+end

data/lib/subledger/domain/roles/describable.rb

@@ -0,0 +1,33 @@
+module Subledger
+  module Domain
+    module Roles
+      module Describable
+        attr_accessor :description, :reference
+
+        def self.raise_unless_creatable args
+          description = args[:description]
+
+          if description.nil? or not description.kind_of? String
+            raise DescribableError, ':description is required and must be a String'
+          end
+
+          reference = args[:reference]
+
+          if not reference.nil? and reference !~ URI.regexp
+            raise DescribableError, ':reference must be a URL'
+          end
+        end
+
+        private
+
+        def describable args
+          description  = args[:description]
+          @description = description.nil? ? nil : description.encode('UTF-8')
+
+          reference  = args[:reference]
+          @reference = reference.nil? ? nil : reference.encode('UTF-8')
+        end
+      end
+    end
+  end
+end

data/lib/subledger/domain/roles/describable_report_rendering.rb

@@ -0,0 +1,50 @@
+module Subledger
+  module Domain
+    module Roles
+      module DescribableReportRendering
+        attr_accessor :description, :reference
+
+        def self.raise_unless_creatable args
+          report = args[:report]
+
+          if report.nil? or not report.kind_of? Report
+            raise DescribableReportRenderingError, ':report is required and must be a Report'
+          end
+
+          description = report.description
+
+          if description.nil? or not description.kind_of? String
+            raise DescribableReportRenderingError, ':report :description is required and must be a String'
+          end
+
+          reference = report.reference
+
+          if not reference.nil? and reference !~ URI.regexp
+            raise DescribableReportRenderingError, ':report :reference must be a URL'
+          end
+
+        end
+
+        private
+
+        def describable_report_rendering args
+          description = args[:description]
+          reference   = args[:reference]
+          report      = args[:report]
+
+          if description.nil?
+            @description = report.nil? ? nil : report.description
+          else
+            @description = description.encode('UTF-8')
+          end
+
+          if reference.nil?
+            @reference = report.nil? ? nil : report.reference
+          else
+            @reference = reference.encode('UTF-8')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/subledger/domain/roles/identifiable.rb

@@ -0,0 +1,15 @@
+module Subledger
+  module Domain
+    module Roles
+      module Identifiable
+        attr_reader :id
+
+        private
+
+        def identifiable args
+          @id = args[:id]
+        end
+      end
+    end
+  end
+end

data/lib/subledger/domain/roles/postable.rb

@@ -0,0 +1,54 @@
+module Subledger
+  module Domain
+    module Roles
+      module Postable
+        def post
+          validate_postability
+
+          from_db = read
+
+          from_store = store.post self
+
+          if from_db.kind_of? posted_klass
+            from_db
+          else
+            from_store
+          end
+        end
+
+        def posting_klass
+          PostingJournalEntry
+        end
+
+        def posted_klass
+          PostedJournalEntry
+        end
+
+        private
+
+        def validate_postability
+          case self
+            when ArchivedJournalEntry
+              raise PostableError, 'Cannot post an archived journal entry'
+            when ActiveJournalEntry
+
+              reason = if lines.length.zero?
+                         'Cannot post a journal entry with no lines'
+                       elsif not balanced?
+                         'Cannot post an unbalanced journal entry'
+                       end
+
+              unless reason.nil?
+                set_reason reason
+                raise PostableError, reason
+              end
+            when PostingJournalEntry
+              # All is fine
+            when PostedJournalEntry
+              # All is fine
+          end
+        end
+      end
+    end
+  end
+end

data/lib/subledger/domain/roles/progressable.rb

@@ -0,0 +1,11 @@
+module Subledger
+  module Domain
+    module Roles
+      module Progressable
+        def progress
+          store.progress self
+        end
+      end
+    end
+  end
+end

data/lib/subledger/domain/roles/readable.rb

@@ -0,0 +1,34 @@
+module Subledger
+  module Domain
+    module Roles
+      module Readable
+        def self.included base
+          base.extend ReadableClass
+        end
+
+        module ReadableClass
+          def read args
+            unless args[:id]
+              raise ReadableError, 'Cannot read without :id'
+            end
+
+            readable = args[:client].send collection_name, args
+
+            args[:store].read readable
+          end
+        end
+
+        def read
+          readable = self.class.read attributes
+
+          if self.class == readable.class
+            initialize readable.attributes
+            self
+          else
+            readable
+          end
+        end
+      end
+    end
+  end
+end

data/lib/subledger/domain/roles/restable.rb

@@ -0,0 +1,69 @@
+module Subledger
+  module Domain
+    module Roles
+      module Restable
+        def post_hash
+          hash = { }
+
+          self.class.post_keys.each do |key|
+            value = self.send key
+
+            hash[key] = translate( key, value ) unless exclude? value
+          end
+
+          hash
+        end
+
+        def patch_hash
+          hash = { }
+
+          self.class.patch_keys.each do |key|
+            value = self.send key
+
+            hash[key] = translate( key, value ) unless exclude? value
+          end
+
+          hash
+        end
+
+        def serializable_hash
+          entity = self.class::Entity.new self
+
+          hash = entity.serializable_hash
+
+          hash.each do |key, value|
+            hash.delete( key ) if exclude? value
+          end
+
+          hash
+        end
+
+        def to_json
+          MultiJson.dump serializable_hash
+        end
+
+        private
+
+        # TODO elimate this using serializable hash
+        def translate key, value
+          case key.to_s
+            when /at$/
+              value.iso8601(3)
+            when 'org', 'book', 'account', 'journal_entry', 'identity', 'report'
+              value.id
+            when 'value'
+              value.rest_hash
+            when 'normal_balance'
+              value.type
+            else
+              value
+          end
+        end
+
+        def exclude? value
+          value.nil? or ( value.kind_of?( String ) and value.length.zero? )
+        end
+      end
+    end
+  end
+end

data/lib/subledger/domain/roles/storable.rb

@@ -0,0 +1,30 @@
+module Subledger
+  module Domain
+    module Roles
+      module Storable
+        attr_reader :store, :client
+
+        def self.raise_unless_creatable args
+          store = args[:store]
+
+          if store.nil? or not store.kind_of? Store
+            raise StorableError, ':store is required and must be a Store'
+          end
+
+          client = args[:client]
+
+          if client.nil? or not client.kind_of? Interface::Client
+            raise StorableError, ':client is required and must be a Client'
+          end
+        end
+
+        private
+
+        def storable args
+          @store  = args[:store]
+          @client = args[:client]
+        end
+      end
+    end
+  end
+end

data/lib/subledger/domain/roles/timeable.rb

@@ -0,0 +1,18 @@
+module Subledger
+  module Domain
+    module Roles
+      module Timeable
+
+        private
+
+        def utc_or_nil time
+          time.nil? ? nil : time.utc
+        end
+
+        def utc_or_now time
+          time.nil? ? Time.now.utc : time.utc
+        end
+      end
+    end
+  end
+end

data/lib/subledger/domain/roles/updatable.rb

@@ -0,0 +1,35 @@
+module Subledger
+  module Domain
+    module Roles
+      module Updatable
+        def self.included base
+          base.extend UpdatableClass
+        end
+
+        module UpdatableClass
+          def update args
+            client = args[:client]
+
+            updatable = client.send collection_name, args
+
+            args[:store].update updatable
+          end
+        end
+
+        def update
+          updatable = dup
+
+          updatable.send :increment_version
+
+          args = updatable.attributes
+
+          updated = self.class.update args
+
+          initialize updated.attributes
+
+          self
+        end
+      end
+    end
+  end
+end

data/lib/subledger/domain/roles/versionable.rb

@@ -0,0 +1,35 @@
+module Subledger
+  module Domain
+    module Roles
+      module Versionable
+        def self.included base
+          base.extend VersionableClass
+        end
+
+        module VersionableClass
+          def self.raise_unless_creatable args
+            version = args[:version]
+
+            if version.nil? or not version.kind_of? Fixnum
+              raise VersionableError, ':version is required and must be a Fixnum'
+            end
+          end
+        end
+
+        attr_reader :version
+
+        protected
+
+        private
+
+        def versionable args
+          @version = args[:version] || 1
+        end
+
+        def increment_version
+          @version += 1
+        end
+      end
+    end
+  end
+end

data/lib/subledger/domain/roles.rb

@@ -0,0 +1,16 @@
+require 'subledger/domain/roles/activatable'
+require 'subledger/domain/roles/archivable'
+require 'subledger/domain/roles/attributable'
+require 'subledger/domain/roles/collectable'
+require 'subledger/domain/roles/creatable'
+require 'subledger/domain/roles/describable'
+require 'subledger/domain/roles/describable_report_rendering'
+require 'subledger/domain/roles/identifiable'
+require 'subledger/domain/roles/postable'
+require 'subledger/domain/roles/progressable'
+require 'subledger/domain/roles/readable'
+require 'subledger/domain/roles/restable'
+require 'subledger/domain/roles/storable'
+require 'subledger/domain/roles/timeable'
+require 'subledger/domain/roles/updatable'
+require 'subledger/domain/roles/versionable'

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

@@ -0,0 +1,16 @@
+module Subledger
+  module Domain
+    class Credit
+
+      include Value
+
+      def self.type
+        'credit'
+      end
+
+      def rest_hash
+        { 'type' => 'credit', 'amount' => amount_to_s(@amount) }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Subledger
+  module Domain
+    class Debit
+
+      include Value
+
+      def self.type
+        'debit'
+      end
+
+      def rest_hash
+        { 'type' => 'debit', 'amount' => amount_to_s(@amount) }
+      end
+    end
+  end
+end