keepr 0.3.0 → 0.6.0

data/lib/keepr/account_export.rb

@@ -1,35 +1,31 @@
+# frozen_string_literal: true
+
 class Keepr::AccountExport
-  def initialize(accounts, header_options={}, &block)
+  def initialize(accounts, header_options = {}, &block)
     @accounts = accounts
     @header_options = header_options
     @block = block
   end
 
-  def to_s
-    export.to_s
-  end
-
-  def to_file(filename)
-    export.to_file(filename)
-  end
+  delegate :to_s, :to_file,
+           to: :export
 
-private
+  private
 
   def export
     export = Datev::AccountExport.new(@header_options)
 
     @accounts.reorder(:number).each do |account|
-      unless account.debtor? || account.creditor?
-        export << to_datev(account)
-      end
+      export << to_datev(account) unless account.debtor? || account.creditor?
     end
 
     export
   end
 
   def to_datev(account)
-    { 'Konto'               => account.number,
-      'Kontenbeschriftung'  => account.name.slice(0,40)
+    {
+      'Konto'              => account.number,
+      'Kontenbeschriftung' => account.name.slice(0, 40)
     }.merge(@block ? @block.call(account) : {})
   end
 end

data/lib/keepr/active_record_extension.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Keepr::ActiveRecordExtension
   def self.included(base)
     base.extend ClassMethods
@@ -5,19 +7,19 @@ module Keepr::ActiveRecordExtension
 
   module ClassMethods
     def has_one_keepr_account
-      has_one :keepr_account, :class_name => 'Keepr::Account', :as => :accountable, :dependent => :restrict_with_error
-      has_many :keepr_postings, :class_name => 'Keepr::Posting', :through => :keepr_account, :dependent => :restrict_with_error
+      has_one :keepr_account, class_name: 'Keepr::Account', as: :accountable, dependent: :restrict_with_error
+      has_many :keepr_postings, class_name: 'Keepr::Posting', through: :keepr_account, dependent: :restrict_with_error
     end
 
     def has_many_keepr_accounts
-      has_many :keepr_accounts, :class_name => 'Keepr::Account', :as => :accountable, :dependent => :restrict_with_error
-      has_many :keepr_postings, :class_name => 'Keepr::Posting', :through => :keepr_accounts, :dependent => :restrict_with_error
+      has_many :keepr_accounts, class_name: 'Keepr::Account', as: :accountable, dependent: :restrict_with_error
+      has_many :keepr_postings, class_name: 'Keepr::Posting', through: :keepr_accounts, dependent: :restrict_with_error
     end
 
     def has_keepr_journals
-      has_many :keepr_journals, :class_name => 'Keepr::Journal', :as => :accountable, :dependent => :restrict_with_error
+      has_many :keepr_journals, class_name: 'Keepr::Journal', as: :accountable, dependent: :restrict_with_error
 
-      class_eval <<-EOT
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
         def keepr_booked?
           keepr_journals.exists?
         end
@@ -27,11 +29,11 @@ module Keepr::ActiveRecordExtension
                                     where('keepr_journals.id' => nil)
                                   }
         scope :keepr_booked,   -> { joins(:keepr_journals) }
-      EOT
+      CODE
     end
 
     def has_keepr_postings
-      has_many :keepr_postings, :class_name => 'Keepr::Posting', :as => :accountable, :dependent => :restrict_with_error
+      has_many :keepr_postings, class_name: 'Keepr::Posting', as: :accountable, dependent: :restrict_with_error
     end
   end
 end

data/lib/keepr/contact_export.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 class Keepr::ContactExport
-  def initialize(accounts, header_options={}, &block)
+  def initialize(accounts, header_options = {}, &block)
     raise ArgumentError unless block_given?
 
     @accounts = accounts
@@ -15,22 +17,19 @@ class Keepr::ContactExport
     export.to_file(filename)
   end
 
-private
+  private
 
   def export
     export = Datev::ContactExport.new(@header_options)
 
     @accounts.reorder(:number).each do |account|
-      if account.debtor? || account.creditor?
-        export << to_datev(account)
-      end
+      export << to_datev(account) if account.debtor? || account.creditor?
     end
 
     export
   end
 
   def to_datev(account)
-    { 'Konto' => account.number
-    }.merge(@block.call(account))
+    { 'Konto' => account.number }.merge(@block.call(account))
   end
 end

data/lib/keepr/cost_center.rb

@@ -1,8 +1,10 @@
+# frozen_string_literal: true
+
 class Keepr::CostCenter < ActiveRecord::Base
   self.table_name = 'keepr_cost_centers'
 
   validates_presence_of :number, :name
   validates_uniqueness_of :number
 
-  has_many :keepr_postings, :class_name => 'Keepr::Posting', :foreign_key => 'keepr_cost_center_id', :dependent => :restrict_with_error
+  has_many :keepr_postings, class_name: 'Keepr::Posting', foreign_key: 'keepr_cost_center_id', dependent: :restrict_with_error
 end

data/lib/keepr/group.rb

@@ -1,42 +1,51 @@
+# frozen_string_literal: true
+
 class Keepr::Group < ActiveRecord::Base
   self.table_name = 'keepr_groups'
 
-  has_ancestry :orphan_strategy => :restrict
+  has_ancestry orphan_strategy: :restrict
 
-  enum :target => [ :asset, :liability, :profit_and_loss ]
+  enum target: %i[asset liability profit_and_loss]
 
   validates_presence_of :name
 
-  has_many :keepr_accounts, :class_name => 'Keepr::Account', :foreign_key => 'keepr_group_id', :dependent => :restrict_with_error
+  has_many :keepr_accounts, class_name: 'Keepr::Account', foreign_key: 'keepr_group_id', dependent: :restrict_with_error
 
-  before_validation :get_from_parent
+  before_validation :set_target_from_parent
 
   validate :check_result_and_target
 
   def self.result
-    where(:is_result => true).first
+    where(is_result: true).first
   end
 
   def keepr_postings
     if is_result
-      Keepr::Posting.joins(:keepr_account).where(:keepr_accounts => { :kind => [ Keepr::Account.kinds[:revenue],
-                                                                                 Keepr::Account.kinds[:expense] ] })
+      Keepr::Posting
+        .joins(:keepr_account)
+        .where(keepr_accounts: { kind: [
+                 Keepr::Account.kinds[:revenue],
+                 Keepr::Account.kinds[:expense]
+               ] })
     else
-      Keepr::Posting.joins(:keepr_account => :keepr_group).merge(self.subtree)
+      Keepr::Posting
+        .joins(keepr_account: :keepr_group)
+        .merge(subtree)
     end
   end
 
-private
-  def get_from_parent
-    if self.parent
-      self.target = self.parent.target
+  private
+
+  def set_target_from_parent
+    self.class.unscoped do
+      self.target = parent.target if parent
     end
   end
 
   def check_result_and_target
-    if is_result
-      # Attribute `is_result` allowed for liability target only
-      errors.add :base, :liability_needed_for_result unless liability?
-    end
+    return unless is_result
+
+    # Attribute `is_result` allowed for liability target only
+    errors.add :base, :liability_needed_for_result unless liability?
   end
 end

data/lib/keepr/groups_creator.rb

@@ -1,7 +1,8 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 class Keepr::GroupsCreator
   def initialize(target)
-    raise ArgumentError unless [ :balance, :profit_and_loss ].include?(target)
+    raise ArgumentError unless %i[balance profit_and_loss].include?(target)
 
     @target = target
   end
@@ -9,14 +10,15 @@ class Keepr::GroupsCreator
   def run
     case @target
     when :balance then
-      load 'asset.txt', :target => :asset
-      load 'liability.txt', :target => :liability
+      load 'asset.txt', target: :asset
+      load 'liability.txt', target: :liability
     when :profit_and_loss
-      load 'profit_and_loss.txt', :target => :profit_and_loss
+      load 'profit_and_loss.txt', target: :profit_and_loss
     end
   end
 
-private
+  private
+
   def load(filename, options)
     full_filename = File.join(File.dirname(__FILE__), "groups_creator/#{filename}".downcase)
     lines = File.readlines(full_filename)
@@ -30,12 +32,10 @@ private
       # Remove leading spaces and separate number and name
       number, name = line.lstrip.match(/^(.*?)\s(.+)$/).to_a[1..-1]
 
-      attributes = options.merge(:name => name, :number => number)
-      if @target == :balance && name == 'Jahresüberschuss/Jahresfehlbetrag'
-        attributes[:is_result] = true
-      end
+      attributes = options.merge(name: name, number: number)
+      attributes[:is_result] = true if @target == :balance && name == 'Jahresüberschuss/Jahresfehlbetrag'
 
-      if depth == 0
+      if depth.zero?
         parents = []
         group = Keepr::Group.create!(attributes)
       else

data/lib/keepr/journal.rb

@@ -1,17 +1,19 @@
+# frozen_string_literal: true
+
 class Keepr::Journal < ActiveRecord::Base
   self.table_name = 'keepr_journals'
 
   validates_presence_of :date
-  validates_uniqueness_of :number, :allow_blank => true
+  validates_uniqueness_of :number, allow_blank: true
 
-  has_many :keepr_postings, -> { order(:amount => :desc) },
-           :class_name => 'Keepr::Posting', :foreign_key => 'keepr_journal_id', :dependent => :destroy
+  has_many :keepr_postings, -> { order(amount: :desc) },
+           class_name: 'Keepr::Posting', foreign_key: 'keepr_journal_id', dependent: :destroy
 
-  belongs_to :accountable, :polymorphic => true
+  belongs_to :accountable, polymorphic: true
 
-  accepts_nested_attributes_for :keepr_postings, :allow_destroy => true, :reject_if => :all_blank
+  accepts_nested_attributes_for :keepr_postings, allow_destroy: true, reject_if: :all_blank
 
-  default_scope { order({:date => :desc}, {:id => :desc}) }
+  default_scope { order({ date: :desc }, id: :desc) }
 
   validate :validate_postings
 
@@ -31,7 +33,8 @@ class Keepr::Journal < ActiveRecord::Base
   before_update :check_permanent
   before_destroy :check_permanent
 
-private
+  private
+
   def existing_postings
     keepr_postings.to_a.delete_if(&:marked_for_destruction?)
   end
@@ -51,15 +54,15 @@ private
   end
 
   def check_permanent
-    if self.permanent_was
-      # If marked as permanent, no changes are allowed
-      errors.add :base, :changes_not_allowed
-
-      if ActiveRecord::VERSION::MAJOR < 5
-        false
-      else
-        throw :abort
-      end
+    return unless permanent_was
+
+    # If marked as permanent, no changes are allowed
+    errors.add :base, :changes_not_allowed
+
+    if ActiveRecord::VERSION::MAJOR < 5
+      false
+    else
+      throw :abort
     end
   end
 end

data/lib/keepr/journal_export.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 class Keepr::JournalExport
-  def initialize(journals, header_options={}, &block)
+  def initialize(journals, header_options = {}, &block)
     @journals = journals
     @header_options = header_options
     @block = block
@@ -13,12 +15,12 @@ class Keepr::JournalExport
     export.to_file(filename)
   end
 
-private
+  private
 
   def export
     export = Datev::BookingExport.new(@header_options)
 
-    @journals.includes(:keepr_postings => :keepr_account).reorder(:date, :id).each do |journal|
+    @journals.includes(keepr_postings: :keepr_account).reorder(:date, :id).each do |journal|
       to_datev(journal).each do |hash|
         export << hash
       end
@@ -29,19 +31,20 @@ private
 
   def to_datev(journal)
     main_posting = journal.keepr_postings.find { |p| p.keepr_account.debtor? || p.keepr_account.creditor? }
-    main_posting ||= journal.keepr_postings.sort_by(&:amount).last
+    main_posting ||= journal.keepr_postings.max_by(&:amount)
 
-    journal.keepr_postings.sort_by { |p| [ p.side == main_posting.side ? 1 : 0, -p.amount ] }.map do |posting|
+    journal.keepr_postings.sort_by { |p| [p.side == main_posting.side ? 1 : 0, -p.amount] }.map do |posting|
       next if posting == main_posting
 
-      { 'Umsatz (ohne Soll/Haben-Kz)'    => posting.amount,
+      {
+        'Umsatz (ohne Soll/Haben-Kz)'    => posting.amount,
         'Soll/Haben-Kennzeichen'         => 'S',
         'Konto'                          => posting.debit?  ? posting.keepr_account.number : main_posting.keepr_account.number,
         'Gegenkonto (ohne BU-Schlüssel)' => posting.credit? ? posting.keepr_account.number : main_posting.keepr_account.number,
         'BU-Schlüssel'                   => '40', # Steuerautomatik deaktivieren
         'Belegdatum'                     => journal.date,
         'Belegfeld 1'                    => journal.number,
-        'Buchungstext'                   => journal.subject.slice(0,60),
+        'Buchungstext'                   => journal.subject.slice(0, 60),
         'Festschreibung'                 => journal.permanent
       }.merge(@block ? @block.call(posting) : {})
     end.compact

data/lib/keepr/posting.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 class Keepr::Posting < ActiveRecord::Base
   self.table_name = 'keepr_postings'
 
   validates_presence_of :keepr_account_id, :amount
   validate :cost_center_validation
 
-  belongs_to :keepr_account, :class_name => 'Keepr::Account'
-  belongs_to :keepr_journal, :class_name => 'Keepr::Journal'
-  belongs_to :keepr_cost_center, :class_name => 'Keepr::CostCenter'
-  belongs_to :accountable, :polymorphic => true
+  belongs_to :keepr_account, class_name: 'Keepr::Account'
+  belongs_to :keepr_journal, class_name: 'Keepr::Journal'
+  belongs_to :keepr_cost_center, class_name: 'Keepr::CostCenter'
+  belongs_to :accountable, polymorphic: true
 
   SIDE_DEBIT  = 'debit'
   SIDE_CREDIT = 'credit'
@@ -17,19 +19,20 @@ class Keepr::Posting < ActiveRecord::Base
 
   def side
     @side || begin
-      (raw_amount < 0 ? SIDE_CREDIT : SIDE_DEBIT) if raw_amount
+      (raw_amount.negative? ? SIDE_CREDIT : SIDE_DEBIT) if raw_amount
     end
   end
 
   def side=(value)
+    raise ArgumentError unless [SIDE_DEBIT, SIDE_CREDIT].include?(value)
+
     @side = value
+    return unless amount
 
     if credit?
-      self.raw_amount = -amount if amount
+      self.raw_amount = -amount.to_d
     elsif debit?
-      self.raw_amount =  amount if amount
-    else
-      raise ArgumentError
+      self.raw_amount =  amount.to_d
     end
   end
 
@@ -54,23 +57,25 @@ class Keepr::Posting < ActiveRecord::Base
   end
 
   def amount=(value)
-    raise ArgumentError.new('Negative amount not allowed!') if value.to_f < 0
     @side ||= SIDE_DEBIT
 
-    if credit?
-      self.raw_amount = -value
-    else
-      self.raw_amount = value
+    unless value
+      self.raw_amount = nil
+      return
     end
+
+    raise ArgumentError, 'Negative amount not allowed!' if value.to_d.negative?
+
+    self.raw_amount = credit? ? -value.to_d : value.to_d
   end
 
-private
+  private
+
   def cost_center_validation
-    if keepr_cost_center
-      unless keepr_account.profit_and_loss?
-        # allowed for expense or revenue accounts only
-        errors.add :keepr_cost_center_id, :allowed_for_expense_or_revenue_only
-      end
-    end
+    return unless keepr_cost_center
+    return if keepr_account.profit_and_loss?
+
+    # allowed for expense or revenue accounts only
+    errors.add :keepr_cost_center_id, :allowed_for_expense_or_revenue_only
   end
 end

data/lib/keepr/tax.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 class Keepr::Tax < ActiveRecord::Base
   self.table_name = 'keepr_taxes'
 
   validates_presence_of :name, :value, :keepr_account_id
   validates_numericality_of :value
 
-  belongs_to :keepr_account, :class_name => 'Keepr::Account'
-  has_many :keepr_accounts, :class_name => 'Keepr::Account', :foreign_key => 'keepr_tax_id', :dependent => :restrict_with_error
+  belongs_to :keepr_account, class_name: 'Keepr::Account'
+  has_many :keepr_accounts, class_name: 'Keepr::Account', foreign_key: 'keepr_tax_id', dependent: :restrict_with_error
 
   validate do |tax|
     tax.errors.add(:keepr_account_id, :circular_reference) if tax.keepr_account.try(:keepr_tax) == tax