sps_king 0.5.0 → 0.6.0

data/lib/sps_king/message.rb

@@ -1,10 +1,12 @@
 # encoding: utf-8
 
 module SPS
+
   PAIN_008_001_02_CH_03 = 'pain.008.001.02.ch.03'
   PAIN_001_001_03_CH_02 = 'pain.001.001.03.ch.02'
 
   class Message
+
     include ActiveModel::Validations
 
     attr_reader :account, :grouped_transactions
@@ -16,7 +18,7 @@ module SPS
 
     class_attribute :account_class, :transaction_class, :xml_main_tag, :known_schemas
 
-    def initialize(account_options={})
+    def initialize(account_options = {})
       @grouped_transactions = {}
       @account = account_class.new(account_options)
     end
@@ -24,6 +26,7 @@ module SPS
     def add_transaction(options)
       transaction = transaction_class.new(options)
       raise ArgumentError.new(transaction.errors.full_messages.join("\n")) unless transaction.valid?
+
       @grouped_transactions[transaction_group(transaction)] ||= []
       @grouped_transactions[transaction_group(transaction)] << transaction
     end
@@ -33,11 +36,11 @@ module SPS
     end
 
     # @return [String] xml
-    def to_xml(schema_name=self.known_schemas.first)
+    def to_xml(schema_name = self.known_schemas.first, encoding = 'UTF-8')
       raise SPS::Error.new(errors.full_messages.join("\n")) unless valid?
       raise SPS::Error.new("Incompatible with schema #{schema_name}!") unless schema_compatible?(schema_name)
 
-      builder = Nokogiri::XML::Builder.new do |builder|
+      builder = Nokogiri::XML::Builder.new(encoding: encoding) do |builder|
         builder.Document(xml_schema(schema_name)) do
           builder.__send__(xml_main_tag) do
             build_group_header(builder)
@@ -50,7 +53,7 @@ module SPS
       builder.to_xml
     end
 
-    def amount_total(selected_transactions=transactions)
+    def amount_total(selected_transactions = transactions)
       selected_transactions.inject(0) { |sum, t| sum + t.amount }
     end
 
@@ -58,10 +61,10 @@ module SPS
       raise ArgumentError.new("Schema #{schema_name} is unknown!") unless self.known_schemas.include?(schema_name)
 
       case schema_name
-        when PAIN_001_001_03_CH_02
-          transactions.all? { |t| t.schema_compatible?(schema_name) }
-        when PAIN_008_001_02_CH_03
-          transactions.all? { |t| t.schema_compatible?(schema_name) } &&
+      when PAIN_001_001_03_CH_02
+        transactions.all? { |t| t.schema_compatible?(schema_name) }
+      when PAIN_008_001_02_CH_03
+        transactions.all? { |t| t.schema_compatible?(schema_name) } &&
           !account.iban.to_s.match(/^(CH|LI)/).nil? # Only allowed for switzerland or liechtenstein
       end
     end
@@ -111,53 +114,56 @@ module SPS
       grouped_transactions.keys.collect { |group| payment_information_identification(group) }
     end
 
-  private
-    # @return {Hash<Symbol=>String>} xml schema information used in output xml
-    def xml_schema(schema_name)
-      {
-        :xmlns                => "http://www.six-interbank-clearing.com/de/#{schema_name}.xsd",
-        :'xmlns:xsi'          => 'http://www.w3.org/2001/XMLSchema-instance',
-        :'xsi:schemaLocation' => "http://www.six-interbank-clearing.com/de/#{schema_name}.xsd #{schema_name}.xsd"
-      }
-    end
+    private
 
-    def build_group_header(builder)
-      builder.GrpHdr do
-        builder.MsgId(message_identification)
-        builder.CreDtTm(creation_date_time)
-        builder.NbOfTxs(transactions.length)
-        builder.CtrlSum('%.2f' % amount_total)
-        builder.InitgPty do
-          builder.Nm(account.name)
-          builder.Id do
-            builder.OrgId do
-              builder.Othr do
-                builder.Id(account.creditor_identifier)
+      # @return {Hash<Symbol=>String>} xml schema information used in output xml
+      def xml_schema(schema_name)
+        {
+          :xmlns                => "http://www.six-interbank-clearing.com/de/#{schema_name}.xsd",
+          :'xmlns:xsi'          => 'http://www.w3.org/2001/XMLSchema-instance',
+          :'xsi:schemaLocation' => "http://www.six-interbank-clearing.com/de/#{schema_name}.xsd #{schema_name}.xsd"
+        }
+      end
+
+      def build_group_header(builder)
+        builder.GrpHdr do
+          builder.MsgId(message_identification)
+          builder.CreDtTm(creation_date_time)
+          builder.NbOfTxs(transactions.length)
+          builder.CtrlSum('%.2f' % amount_total)
+          builder.InitgPty do
+            builder.Nm(account.name)
+            builder.Id do
+              builder.OrgId do
+                builder.Othr do
+                  builder.Id(account.creditor_identifier)
+                end
               end
-            end
-          end if account.respond_to? :creditor_identifier
+            end if account.respond_to? :creditor_identifier
+          end
         end
       end
-    end
 
-    # Unique and consecutive identifier (used for the <PmntInf> blocks)
-    def payment_information_identification(group)
-      "#{message_identification}/#{grouped_transactions.keys.index(group)+1}"
-    end
+      # Unique and consecutive identifier (used for the <PmntInf> blocks)
+      def payment_information_identification(group)
+        "#{message_identification}/#{grouped_transactions.keys.index(group) + 1}"
+      end
 
-    # Returns a key to determine the group to which the transaction belongs
-    def transaction_group(transaction)
-      transaction
-    end
+      # Returns a key to determine the group to which the transaction belongs
+      def transaction_group(transaction)
+        transaction
+      end
 
-    def validate_final_document!(document, schema_name)
-      xsd = Nokogiri::XML::Schema(
-              File.read(
-                File.expand_path("../../../lib/schema/#{schema_name}.xsd", __FILE__)
+      def validate_final_document!(document, schema_name)
+        xsd = Nokogiri::XML::Schema(
+                File.read(
+                  File.expand_path("../../../lib/schema/#{schema_name}.xsd", __FILE__)
+                )
               )
-            )
-      errors = xsd.validate(document).map { |error| error.message }
-      raise SPS::Error.new("Incompatible with schema #{schema_name}: #{errors.join(', ')}") if errors.any?
-    end
+        errors = xsd.validate(document).map { |error| error.message }
+        raise SPS::Error.new("Incompatible with schema #{schema_name}: #{errors.join(', ')}") if errors.any?
+      end
+
   end
+
 end

data/lib/sps_king/structured_remittance_information.rb

@@ -1,5 +1,6 @@
 module SPS
   class StructuredRemittanceInformation
+
     include ActiveModel::Validations
     extend Converter
 
@@ -16,5 +17,6 @@ module SPS
         public_send("#{name}=", value)
       end
     end
+
   end
 end

data/lib/sps_king/transaction/credit_transfer_transaction.rb

@@ -1,6 +1,8 @@
 # encoding: utf-8
+
 module SPS
   class CreditTransferTransaction < Transaction
+
     attr_accessor :service_level,
                   :creditor_address,
                   :category_purpose,
@@ -20,5 +22,6 @@ module SPS
         !self.bic.nil?
       end
     end
+
   end
 end

data/lib/sps_king/transaction/direct_debit_transaction.rb

@@ -1,6 +1,13 @@
 # encoding: utf-8
+
 module SPS
   class DirectDebitTransaction < Transaction
+
+    attr_accessor :service_level,
+                  :local_instrument,
+                  :creditor_account,
+                  :debtor_address
+
     SERVICE_LEVELS = %w(CHDD CHTA)
 
     LOCAL_INSTRUMENTS_FOR_SERVICE_LEVELS = {
@@ -8,11 +15,6 @@ module SPS
       'CHTA' => %w(LSV+ BDD)
     }
 
-    attr_accessor :service_level,
-                  :local_instrument,
-                  :creditor_account,
-                  :debtor_address
-
     validates_format_of :iban, with: /\A(CH|LI)/
 
     validates_presence_of :instruction,
@@ -38,7 +40,7 @@ module SPS
       case schema_name
       when PAIN_008_001_02_CH_03
         self.structured_remittance_information.present? &&
-        self.structured_remittance_information.valid?
+          self.structured_remittance_information.valid?
       end
     end
 
@@ -54,5 +56,6 @@ module SPS
         end
       end
     end
+
   end
 end

data/lib/sps_king/transaction.rb

@@ -1,11 +1,11 @@
 # encoding: utf-8
+
 module SPS
   class Transaction
+
     include ActiveModel::Validations
     extend Converter
 
-    DEFAULT_REQUESTED_DATE = Date.new(1999, 1, 1).freeze
-
     attr_accessor :name,
                   :iban,
                   :bic,
@@ -20,6 +20,8 @@ module SPS
                   :debtor_address,
                   :creditor_address
 
+    DEFAULT_REQUESTED_DATE = Date.new(1999, 1, 1).freeze
+
     convert :name, :instruction, :reference, :remittance_information, to: :text
     convert :amount, to: :decimal
 
@@ -48,12 +50,13 @@ module SPS
 
     protected
 
-    def validate_requested_date_after(min_requested_date)
-      return unless requested_date.is_a?(Date)
+      def validate_requested_date_after(min_requested_date)
+        return unless requested_date.is_a?(Date)
 
-      if requested_date != DEFAULT_REQUESTED_DATE && requested_date < min_requested_date
-        errors.add(:requested_date, "must be greater or equal to #{min_requested_date}, or nil")
+        if requested_date != DEFAULT_REQUESTED_DATE && requested_date < min_requested_date
+          errors.add(:requested_date, "must be greater or equal to #{min_requested_date}, or nil")
+        end
       end
-    end
+
   end
 end

data/lib/sps_king/validator.rb

@@ -1,6 +1,9 @@
 # encoding: utf-8
+
 module SPS
+
   class IBANValidator < ActiveModel::Validator
+
     # IBAN2007Identifier (taken from schema)
     REGEX = /\A[A-Z]{2,2}[0-9]{2,2}[a-zA-Z0-9]{1,30}\z/
 
@@ -12,9 +15,11 @@ module SPS
         record.errors.add(field_name, :invalid, message: options[:message])
       end
     end
+
   end
 
   class BICValidator < ActiveModel::Validator
+
     # AnyBICIdentifier (taken from schema)
     REGEX = /\A[A-Z]{6,6}[A-Z2-9][A-NP-Z0-9]([A-Z0-9]{3,3}){0,1}\z/
 
@@ -28,9 +33,11 @@ module SPS
         end
       end
     end
+
   end
 
   class CreditorIdentifierValidator < ActiveModel::Validator
+
     REGEX = /\A[a-zA-Z]{2,2}[0-9]{2,2}([A-Za-z0-9]|[\+|\?|\/|\-|\:|\(|\)|\.|,|']){3,3}([A-Za-z0-9]|[\+|\?|\/|\-|:|\(|\)|\.|,|']){1,28}\z|\A[A-Z0-9]{5,5}\z/
 
     def validate(record)
@@ -51,5 +58,7 @@ module SPS
       end
       ok
     end
+
   end
+
 end

data/lib/sps_king/version.rb

@@ -1,3 +1,5 @@
 module SPS
-  VERSION = '0.5.0'
+
+  VERSION = '0.6.0'
+
 end

data/lib/sps_king.rb

@@ -9,6 +9,7 @@ require 'sps_king/converter'
 require 'sps_king/validator'
 require 'sps_king/version'
 require 'sps_king/account'
+require 'sps_king/account/address'
 require 'sps_king/account/debtor_account'
 require 'sps_king/account/debtor_address'
 require 'sps_king/account/creditor_account'

data/spec/lib/sps_king/account/address_spec.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe SPS::Address do
+  let(:country_code)    { 'CH' }
+  let(:street_name)     { 'Mustergasse' }
+  let(:building_number) { '123' }
+  let(:post_code)       { '12345' }
+  let(:town_name)       { 'Musterstadt' }
+  let(:address_line1)   { "#{street_name} #{building_number}" }
+  let(:address_line2)   { "#{post_code} #{town_name}" }
+  let(:subject_valid) do
+    described_class.new(
+      country_code:,
+      address_line2:
+    )
+  end
+  let(:subject_too_long) do
+    described_class.new(
+      country_code:,
+      address_line1: 'X' * 71,
+      address_line2: 'X' * 71,
+    )
+  end
+
+  it 'should validate country_code format' do
+    subject_valid.country_code = 'ch'
+    expect(subject_valid).not_to be_valid
+    expect(subject_valid.errors.details).to include(
+                                              country_code: [
+                                                {
+                                                  error: :invalid,
+                                                  value: "ch"
+                                                }
+                                              ]
+                                            )
+  end
+
+  context 'when using address_line1 and address_line2' do
+    it 'should initialize a new address in line mode' do
+      expect(subject_valid).to be_valid
+    end
+
+    it 'validates address_line1 and address_line2 length' do
+      expect(subject_too_long).not_to be_valid
+      expect(subject_too_long.errors.details).to include(
+                                                   address_line1: [{ error: :too_long, count: 70 }],
+                                                   address_line2: [{ error: :too_long, count: 70 }]
+                                                 )
+    end
+  end
+
+  context 'when using separate attributes' do
+    let(:subject_valid) do
+      described_class.new(
+        country_code:,
+        town_name:
+      )
+    end
+    let(:subject_too_long) do
+      described_class.new(
+        country_code:,
+        street_name:     'X' * 71,
+        building_number: 'X' * 17,
+        post_code:       'X' * 17,
+        town_name:       'X' * 36,
+      )
+    end
+
+    it 'should initialize a new address in separate mode' do
+      expect(subject_valid).to be_valid
+    end
+
+    it 'validates street_name, building_number, post_code, and town_name length' do
+      expect(subject_too_long).not_to be_valid
+      expect(subject_too_long.errors.details)
+        .to include(
+              street_name: [{ error: :too_long, count: 70 }],
+              post_code:   [{ error: :too_long, count: 16 }],
+              town_name:   [{ error: :too_long, count: 35 }]
+            )
+    end
+  end
+end

data/spec/lib/sps_king/account/creditor_account_spec.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+
 require 'spec_helper'
 
 describe SPS::CreditorAccount do
@@ -17,24 +18,24 @@ describe SPS::CreditorAccount do
     it 'should accept valid value' do
       expect(SPS::CreditorAccount)
         .to accept(
-          'DE98ZZZ09999999999',
-          'AT12ZZZ00000000001',
-          'IT97ZZZA1B2C3D4E5F6G7H8',
-          'NL97ZZZ123456780001',
-          'FR12ZZZ123456',
-          for: :creditor_identifier
-        )
+              'DE98ZZZ09999999999',
+              'AT12ZZZ00000000001',
+              'IT97ZZZA1B2C3D4E5F6G7H8',
+              'NL97ZZZ123456780001',
+              'FR12ZZZ123456',
+              for: :creditor_identifier
+            )
     end
 
     it 'should not accept invalid value' do
       expect(SPS::CreditorAccount)
         .not_to accept(
-          '',
-          'invalid',
-          'DE98ZZZ099999999990',
-          'DEAAAAAAAAAAAAAAAA',
-          for: :creditor_identifier
-        )
+                  '',
+                  'invalid',
+                  'DE98ZZZ099999999990',
+                  'DEAAAAAAAAAAAAAAAA',
+                  for: :creditor_identifier
+                )
     end
   end
 

data/spec/lib/sps_king/account/debtor_account_spec.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+
 require 'spec_helper'
 
 describe SPS::DebtorAccount do

data/spec/lib/sps_king/account_spec.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+
 require 'spec_helper'
 
 describe SPS::Account do
@@ -12,7 +13,12 @@ describe SPS::Account do
 
   describe :name do
     it 'should accept valid value' do
-      expect(SPS::Account).to accept('Gläubiger GmbH', 'Zahlemann & Söhne GbR', 'X' * 70, for: :name)
+      expect(SPS::Account).to accept(
+                                'Gläubiger GmbH',
+                                'Zahlemann & Söhne GbR',
+                                'X' * 70,
+                                for: :name
+                              )
     end
 
     it 'should not accept invalid value' do
@@ -22,7 +28,11 @@ describe SPS::Account do
 
   describe :iban do
     it 'should accept valid value' do
-      expect(SPS::Account).to accept('DE21500500009876543210', 'PL61109010140000071219812874', for: :iban)
+      expect(SPS::Account).to accept(
+                                'DE21500500009876543210',
+                                'PL61109010140000071219812874',
+                                for: :iban
+                              )
     end
 
     it 'should not accept invalid value' do

data/spec/lib/sps_king/converter_spec.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+
 require 'spec_helper'
 
 describe SPS::Converter do
@@ -8,7 +9,9 @@ describe SPS::Converter do
     context 'when the conversion method does not exist' do
       it 'raises an ArgumentError' do
         class DummyForConverter
+
           extend SPS::Converter
+
         end
 
         expect {
@@ -31,10 +34,10 @@ describe SPS::Converter do
     end
 
     it 'should convert line breaks' do
-      expect(convert_text("one\ntwo"))    .to eq('one two')
-      expect(convert_text("one\ntwo\n"))  .to eq('one two')
+      expect(convert_text("one\ntwo")).to eq('one two')
+      expect(convert_text("one\ntwo\n")).to eq('one two')
       expect(convert_text("\none\ntwo\n")).to eq('one two')
-      expect(convert_text("one\n\ntwo"))  .to eq('one two')
+      expect(convert_text("one\n\ntwo")).to eq('one two')
     end
 
     it 'should convert number' do
@@ -63,6 +66,14 @@ describe SPS::Converter do
       expect(convert_decimal(42.12)).to eq(BigDecimal('42.12'))
     end
 
+    it "should convert numeric string to BigDecimal" do
+      expect(convert_decimal('35.21')).to eq(BigDecimal('35.21'))
+    end
+
+    it "should keep BigDecimal" do
+      expect(convert_decimal(BigDecimal('55.01'))).to eq(BigDecimal('55.01'))
+    end
+
     it 'should round' do
       expect(convert_decimal(1.345)).to eq(BigDecimal('1.35'))
     end
@@ -81,8 +92,17 @@ describe SPS::Converter do
 
     it 'should not convert invalid value' do
       expect(convert_decimal('xyz')).to eq(nil)
-      expect(convert_decimal('NaN')).to eq(nil)
-      expect(convert_decimal('Infinity')).to eq(nil)
+      expect(convert_decimal([12.2])).to eq(nil)
+      expect(convert_decimal({ value: '1.1' })).to eq(nil)
+      expect(convert_decimal(Date.new(2025))).to eq(nil)
+      expect(convert_decimal(1..10)).to eq(nil)
+      expect(convert_decimal(Float::INFINITY)).to eq(nil)
+    end
+
+    it "should not convert NaN value" do
+      nan_value = 0.0 / 0
+      expect(nan_value).to be_nan
+      expect(convert_decimal(nan_value)).to eq(nil)
     end
   end
 end