wvanbergen-clieop 0.1.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Willem van Bergen
+ 
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+ 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,22 @@
+= CLIEOP
+
+This library is a pure Ruby implementation of the CLIEOP03 format. Currently, it only supports writing
+CLIEOP files with accounts receivable transactions. Accounts payable transactions, and reading existing
+CLIEOP files is planned to be supported
+
+This library is licensed under the MIT license.
+
+== CLIEOP format
+
+CLIEOP03 is a file format that is used for communication about cash transaction between bank accounts. 
+It is mainly used in the Netherlands and is supported by the banking software package of the main
+banks. CLIEOP supports transactions in both directions: accounts payable and accounts receivable. 
+For accounts receivable, you need proper authorization from your bank.
+
+For more information about the CLIEOP file format, see:
+http://www.ingbank.nl/ing/downloadables/eclieop1.pdf
+
+== Usage
+
+You can create a file (<tt>Clieop::File</tt>), which can contain one or more batches (<tt>Clieop::Batch</tt>) 
+consisting of one or more records (<tt>Clieop::Record</tt>). There are different rcord types.

data/Rakefile

@@ -0,0 +1,73 @@
+require 'rubygems'
+
+load 'test/tasks.rake'
+ 
+desc 'Default: run unit tests.'
+task :default => :test
+
+namespace :gem do
+
+  desc "Sets the version and date of the clieop gem. Requires the VERSION environment variable."
+  task :version => [:manifest] do
+    
+    require 'date'
+    
+    new_version = ENV['VERSION']
+    raise "VERSION is required" unless /\d+(\.\d+)*/ =~ new_version
+    
+    spec_file = Dir['*.gemspec'].first
+    
+    spec = File.read(spec_file)
+    spec.gsub!(/^(\s*s\.version\s*=\s*)('|")(.+)('|")(\s*)$/) { "#{$1}'#{new_version}'#{$5}" }
+    spec.gsub!(/^(\s*s\.date\s*=\s*)('|")(.+)('|")(\s*)$/) { "#{$1}'#{Date.today.strftime('%Y-%m-%d')}'#{$5}" }    
+    File.open(spec_file, 'w') { |f| f << spec }
+  end
+  
+  task :tag => [:version] do
+    
+    new_version = ENV['VERSION']
+    raise "VERSION is required" unless /\d+(\.\d+)*/ =~ new_version
+    
+    spec_file = Dir['*.gemspec'].first
+        
+    sh "git add #{spec_file} .manifest"
+    sh "git commit -m \"Set gem version to #{new_version}\""
+    sh "git push origin"    
+    sh "git tag -a \"clieop-#{new_version}\" -m \"Tagged version #{new_version}\""
+    sh "git push --tags"
+  end
+
+  desc "Builds a ruby gem for the CLIEOP library"
+  task :build => [:manifest] do
+    spec_file = Dir['*.gemspec'].first
+    system "gem build #{spec_file}"
+  end
+
+  desc %{Update ".manifest" with the latest list of project filenames. Respect\
+  .gitignore by excluding everything that git ignores. Update `files` and\
+  `test_files` arrays in "*.gemspec" file if it's present.}
+  task :manifest do
+    list = Dir['**/*'].sort
+    spec_file = Dir['*.gemspec'].first
+    list -= [spec_file] if spec_file
+  
+    File.read('.gitignore').each_line do |glob|
+      glob = glob.chomp.sub(/^\//, '')
+      list -= Dir[glob]
+      list -= Dir["#{glob}/**/*"] if File.directory?(glob) and !File.symlink?(glob)
+      puts "excluding #{glob}"
+    end
+ 
+    if spec_file
+      spec = File.read spec_file
+      spec.gsub! /^(\s* s.(test_)?files \s* = \s* )( \[ [^\]]* \] | %w\( [^)]* \) )/mx do
+        assignment = $1
+        bunch = $2 ? list.grep(/^test.*_test\.rb$/) : list
+        '%s%%w(%s)' % [assignment, bunch.join(' ')]
+      end
+      
+      File.open(spec_file,   'w') {|f| f << spec }
+    end
+    File.open('.manifest', 'w') {|f| f << list.join("\n") }
+  end
+end

data/TODO

@@ -0,0 +1,6 @@
+- Add a Clieop::Transaction class
+- Implement CLIEOP03 reader
+- Add unit tests
+- Test with additional banking software, both invoice and payment batches
+
+Contact willem AT vanbergen DOT org if you want to hack on the CLIEOP library.

data/lib/clieop.rb

@@ -0,0 +1,4 @@
+require 'date'
+require File.dirname(__FILE__) + '/clieop/record.rb'
+require File.dirname(__FILE__) + '/clieop/file.rb'
+require File.dirname(__FILE__) + '/clieop/batch.rb'

data/lib/clieop/batch.rb

@@ -0,0 +1,102 @@
+module Clieop
+  
+  class Batch
+    
+    attr_accessor :transactions, :batch_info
+    
+    def initialize(batch_info)
+      raise "Required: :description, :account_nr, :account_owner" unless ([:description, :account_nr, :account_owner] - batch_info.keys).empty?        
+      @transactions = []
+      @batch_info = batch_info
+    end
+    
+    # Adds a transaction to the batch
+    #
+    # :amount The amount involved with this transaction
+    # :account_nr The bank account from the other party
+    # :account_owner The name of the owner of the bank account
+    # :reference_number A reference number to identify this transaction
+    # :description A description for this transaction (4 lines max)
+    def add_transaction (transaction)
+      raise "No :account_nr given"    if transaction[:account_nr].nil?
+      raise "No :amount given"        if transaction[:amount].nil?
+      raise "No :account_owner given" if transaction[:account_owner].nil?
+      @transactions << transaction      
+    end
+    
+    alias_method :<<, :add_transaction
+    
+    def to_clieop
+      
+      # generate batch header records
+      batch_data = ""
+      batch_data << Clieop::Record.new(:batch_header,
+                        :transaction_group => @batch_info[:transaction_group] || 0,
+                        :acount_nr         => @batch_info[:account_nr] || 0,
+                        :serial_nr         => @batch_info[:serial_nr] || 1,
+                        :currency          => @batch_info[:currency] || "EUR").to_clieop
+      
+      batch_data << Clieop::Record.new(:batch_description, :description => @batch_info[:description]).to_clieop
+      batch_data << Clieop::Record.new(:batch_owner, 
+                        :process_date => @batch_info[:process_date] || 0,
+                        :owner        => @batch_info[:account_owner]).to_clieop
+      
+      # initialize checksums
+      total_account = @batch_info[:account_nr].to_i * @transactions.length
+      total_amount  = 0
+      
+      # add transactions to batch
+      @transactions.each do |tr|
+        
+        # update checksums
+        total_account += tr[:account_nr].to_i
+        total_amount  += (tr[:amount].to_f * 100).truncate
+        
+        # prepare data for this transaction's records
+        transaction_type = @batch_info[:transaction_group] == 10 ? 1002 : 0
+        to_account       = @batch_info[:transaction_group] == 10 ? @batch_info[:account_nr] : tr[:account_nr]
+        from_account     = @batch_info[:transaction_group] == 10 ? tr[:account_nr] : @batch_info[:account_nr]
+        amount_in_cents  = (tr[:amount].to_f * 100).truncate
+        name_record      = @batch_info[:transaction_group] == 10 ? :invoice_name : :payment_name
+        
+        # generate transaction record
+        batch_data << Clieop::Record.new(:transaction_info, 
+                          :transaction_type => transaction_type, :amount       => amount_in_cents,
+                          :to_account       => to_account,       :from_account => from_account).to_clieop
+        
+        # generate record with transaction information         
+        batch_data << Clieop::Record.new(name_record, :name => tr[:account_owner]).to_clieop
+        batch_data << Clieop::Record.new(:transaction_reference, :reference_number => tr[:reference_number]).to_clieop unless tr[:reference_number].nil?
+        
+        # split discription into lines and make a record for the first 4 lines
+        unless tr[:description].nil? || tr[:description] == ''
+          tr[:description].split(/\r?\n/)[0, 4].each do |line|
+            batch_data << Clieop::Record.new(:transaction_description, :description => line.strip).to_s unless line == ''
+          end
+        end
+      end
+      
+      # generate batch footer record including some checks
+      batch_data << Clieop::Record.new(:batch_footer, :tranasction_count => @transactions.length, 
+                        :total_amount => total_amount, :account_checksum => total_account.to_s[0..10]).to_clieop
+      
+    end
+    
+    def to_s
+      self.to_clieop
+    end
+    
+    # creates a batch for payments from a given account
+    def self.payment_batch(batch_info = {})
+      batch_info[:transaction_group] ||= 0
+      Clieop::Batch.new(batch_info)
+    end
+    
+    # creates a batch for invoices to a given account
+    def self.invoice_batch(batch_info = {})
+      batch_info[:transaction_group] ||= 10
+      Clieop::Batch.new(batch_info)
+    end    
+    
+  end
+end

data/lib/clieop/file.rb

@@ -0,0 +1,39 @@
+module Clieop
+  
+  class File
+    
+    attr_accessor :batches
+    attr_reader   :file_info
+    
+    def initialize(file_info = {})
+      file_info[:date] = Date.today unless file_info[:date]
+      file_info[:date] = file_info[:date].strftime('%d%m%y') if file_info[:date].respond_to?(:strftime)
+      @file_info = file_info
+      @batches = []
+    end
+
+    # renders this file as a CLIEOP03 formatted string
+    def to_clieop
+      clieop_data = Clieop::Record.new(:file_header, @file_info).to_clieop
+      @batches.each { |batch| clieop_data << batch.to_clieop }
+      clieop_data << Clieop::Record.new(:file_footer).to_clieop
+    end
+      
+    def payment_batch(options)
+      @payment << Clieop::Batch.payment_batch(options, block)
+      yield(@batches.last) if block_given?      
+      return @batches.last
+    end      
+
+    def invoice_batch(options)
+      @batches << Clieop::Batch.invoice_batch(options)
+      yield(@batches.last) if block_given?
+      return @batches.last
+    end
+
+    # Alias for to_clieop
+    def to_s
+      self.to_clieop
+    end
+  end 
+end

data/lib/clieop/record.rb

@@ -0,0 +1,115 @@
+module Clieop
+  
+  class Record
+
+    TYPE_DEFINITIONS = {
+        :file_header => [
+            [:record_code, :numeric, 4, 1],
+            [:record_variant, :alpha, 1, 'A'],
+            [:date, :numeric, 6],
+            [:filename, :alpha, 8, 'CLIEOP03'],
+      			[:sender_identification, :alpha, 5],
+      			[:file_identification, :alpha, 4],
+      			[:duplicate_code, :numeric, 1, 1]      
+          ],
+        :file_footer => [
+            [:record_code, :numeric, 4, 9999],
+            [:record_variant, :alpha, 1, 'A'],     
+          ],
+        :batch_header => [
+            [:record_code, :numeric, 4, 10],
+            [:record_variant, :alpha, 1, 'B'],   
+            [:transaction_group, :alpha, 2],
+            [:acount_nr, :numeric, 10],
+            [:serial_nr, :numeric, 4],
+            [:currency, :alpha, 3, 'EUR']     
+          ],
+        :batch_footer => [
+            [:record_code, :numeric, 4, 9990],
+            [:record_variant, :alpha, 1, 'A'],  
+            [:total_amount, :numeric, 18],   
+            [:account_checksum, :numeric, 10],
+            [:tranasction_count, :numeric, 7],    
+          ],
+        :batch_description => [
+            [:record_code, :numeric, 4, 20],
+            [:record_variant, :alpha, 1, 'A'],
+            [:description, :alpha, 32]
+          ],
+        :batch_owner => [
+            [:record_code, :numeric, 4, 30],
+            [:record_variant, :alpha, 1, 'B'],
+            [:naw_code, :numeric, 1, 1],
+            [:process_date, :numeric, 6, 0],
+            [:owner, :alpha, 35],
+            [:test, :alpha, 1, 'P']
+          ],
+        :transaction_info => [
+            [:record_code, :numeric, 4, 100],
+            [:record_variant, :alpha, 1, 'A'],
+            [:transaction_type, :numeric, 4, 1002],
+            [:amount, :numeric, 12],
+            [:from_account, :numeric, 10],
+            [:to_account, :numeric, 10],
+          ],
+        :invoice_name => [
+            [:record_code, :numeric, 4, 110],
+            [:record_variant, :alpha, 1, 'B'],
+            [:name, :alpha, 35],
+          ],
+        :payment_name =>[
+            [:record_code, :numeric, 4, 170],
+            [:record_variant, :alpha, 1, 'B'],
+            [:name, :alpha, 35],
+          ],
+        :transaction_reference => [
+            [:record_code, :numeric, 4, 150],
+            [:record_variant, :alpha, 1, 'A'],
+            [:reference_number, :numeric, 16],
+          ],
+        :transaction_description => [
+            [:record_code, :numeric, 4, 160],
+            [:record_variant, :alpha, 1, 'A'],
+            [:description, :alpha, 32],
+          ],    
+      }
+
+    attr_accessor :definition, :data
+    
+    def initialize record_type, record_data = {}
+      
+      # load record definition
+      raise "Unknown record type" unless Clieop::Record::TYPE_DEFINITIONS[record_type.to_sym]
+      @definition = Clieop::Record::TYPE_DEFINITIONS[record_type.to_sym]
+      
+      # set default values according to definition
+      @data = {}
+      @definition.each { |field| @data[field[0]] = field[3] if field[3] }
+  
+      # set values for all the provided data
+      record_data.each { |field, value| @data[field] = value }
+    end
+    
+    def to_clieop
+      line = ""
+      #format each field
+      @definition.each do |field|
+        fmt = '%'
+  			fmt << (field[1] == :numeric ? '0' : '-')
+  			fmt << (field[2].to_s)
+  			fmt << (field[1] == :numeric ? 'd' : 's')
+  			raw_data = (field[1] == :numeric) ? @data[field[0]].to_i : @data[field[0]]
+        value = sprintf(fmt, raw_data)
+        line << (field[1] == :numeric ? value[0 - field[2], field[2]] : value[0, field[2]])
+      end
+      # fill each line with spaces up to 50 characters and close with a CR/LF
+      line.ljust(50) + "\r\n"
+    end
+    
+    def to_s
+      self.to_clieop
+    end
+    
+  end
+  
+end

data/test/clieop_writer_test.rb

@@ -0,0 +1,32 @@
+require 'test/unit'
+require "#{File.dirname(__FILE__)}/../lib/clieop.rb"
+
+class ClieopWriterTest < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def teardown
+  end
+  
+  
+  def test_basic_invoice_usage
+    file = Clieop::File.new
+    file.invoice_batch({:description => 'some description', :account_nr => 123, :account_owner => 'me'}) do |batch|
+      
+      batch << { :account_nr => 123456, :account_owner => 'you', :amount => 133.0, 
+                 :description => "Testing a CLIEOP direct debt transaction\nCharging your bank account" }
+                 
+      batch << { :account_nr => 654321, :account_owner => 'somebody else', :amount => 233.0,
+                 :description => 'Some description for the other guy' }
+                 
+    end
+    
+    clieop_data = file.to_clieop
+    
+    #TODO: more tests
+    assert_kind_of String, clieop_data
+    
+  end
+  
+end

data/test/tasks.rake

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+ 
+desc 'Test the clieop library.'
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+  t.libs << 'test'
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: wvanbergen-clieop
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Willem van Bergen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-09-17 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: This library is a pure Ruby, MIT licensed implementation of the CLIEOP03 transaction format. CLIEOP03 can be used to communicate direct debt transactions with your (Dutch) bank.
+email: 
+- willem@vanbergen.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- TODO
+- lib
+- lib/clieop
+- lib/clieop.rb
+- lib/clieop/batch.rb
+- lib/clieop/file.rb
+- lib/clieop/record.rb
+- test
+- test/clieop_writer_test.rb
+- test/tasks.rake
+has_rdoc: false
+homepage: http://github.com/wvanbergen/clieop/wikis
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A pure Ruby implementation to write CLIEOP files
+test_files: 
+- test/clieop_writer_test.rb