salt-parser 0.0.1

data/lib/ofx/parser/ofx102.rb

@@ -0,0 +1,28 @@
+module SaltParser
+  module Ofx
+    module Parser
+      class OFX102 < SaltParser::Ofx::Parser::Base
+        VERSION = "1.0.2"
+
+        def self.parse_headers(header_text)
+          # TODO: refactor
+          # Change single CR's to LF's to avoid issues with some banks
+          header_text.gsub!(/\r(?!\n)/, "\n")
+
+          # Parse headers. When value is NONE, convert it to nil.
+          headers = header_text.to_enum(:each_line).inject({}) do |memo, line|
+            _, key, value = *line.match(/^(.*?):(.*?)\s*(\r?\n)*$/)
+
+            unless key.nil?
+              memo[key] = value == "NONE" ? nil : value
+            end
+
+            memo
+          end
+
+          return headers unless headers.empty?
+        end
+      end
+    end
+  end
+end

data/lib/ofx/parser/ofx211.rb

@@ -0,0 +1,21 @@
+module SaltParser
+  module Ofx
+    module Parser
+      class OFX211 < SaltParser::Ofx::Parser::Base
+        VERSION = "2.1.1"
+
+        def self.parse_headers(header_text)
+          Nokogiri::XML(header_text).children.each do |element|
+            if element.name == "OFX"
+              headers = element.text.gsub("\"",'')
+                               .split(/\s+/)
+                               .map { |el| el.split("=") }
+                               .flatten
+              return Hash[*headers]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ofx/sign_on.rb

@@ -0,0 +1,18 @@
+module SaltParser
+  module Ofx
+    class SignOn < SaltParser::Base
+      attr_accessor :language, :fi_id, :fi_name, :code, :severity, :message
+
+      def to_hash
+        {
+          :language => language,
+          :fi_id    => fi_id,
+          :fi_name  => fi_name,
+          :code     => code,
+          :severity => severity,
+          :message  => message
+        }
+      end
+    end
+  end
+end

data/lib/ofx/transaction.rb

@@ -0,0 +1,28 @@
+module SaltParser
+  module Ofx
+    class Transaction < SaltParser::Base
+      attr_accessor :amount, :amount_in_pennies, :check_number, :fit_id,
+                    :memo, :name, :payee, :posted_at, :ref_number, :type,
+                    :sic, :units, :unit_price, :account_id
+
+      def to_hash
+        {
+          :amount             => amount,
+          :amount_in_pennies  => amount_in_pennies,
+          :check_number       => check_number,
+          :fit_id             => fit_id,
+          :memo               => memo,
+          :name               => name,
+          :payee              => payee,
+          :posted_at          => posted_at,
+          :ref_number         => ref_number,
+          :type               => type,
+          :sic                => sic,
+          :units              => units,
+          :unit_price         => unit_price,
+          :account_id         => account_id
+        }
+      end
+    end
+  end
+end

data/lib/qif/account.rb

@@ -0,0 +1,19 @@
+module SaltParser
+  module Qif
+    class Account < SaltParser::Base
+      attr_accessor :name, :type, :transactions
+
+      def identifier
+        name
+      end
+
+      def to_hash
+        {
+          :name         => name,
+          :type         => type,
+          :transactions => transactions.map(&:to_hash)
+        }
+      end
+    end
+  end
+end

data/lib/qif/accounts.rb

@@ -0,0 +1,54 @@
+module SaltParser
+  module Qif
+    class Accounts < SaltParser::Accounts
+      SUPPORTED_ACCOUNTS = {
+        "!Type:Bank"  => {
+          "type"        => "bank_account",
+          "name"        => "Bank account"
+        },
+        "!Type:Cash"  => {
+          "type"        => "cash",
+          "name"        => "Cash account"
+        },
+        "!Type:CCard" => {
+          "type"        => "credit_card",
+          "name"        => "Credit card account"
+        },
+        "!Type:Oth A" => {
+          "type"        => "asset",
+          "name"        => "Asset account"
+        },
+        "!Type:Oth L" => {
+          "type"        => "liability_account",
+          "name"        => "Liability account"
+        }
+      }
+      SUPPORTED_ACCOUNTS.default = {
+        "type"        => "account",
+        "name"        => "account"
+      }
+      NOT_SUPPORTED_ACCOUNTS = {
+        "!Account"   => {
+          "type"        => "account_list",
+          "name"        => "Account list or which account follows"
+        },
+        "!Type:Cat"  => {
+          "type"        => "category_list",
+          "name"        => "Category list"
+        },
+        "!Type:Class"  => {
+          "type"        => "class_list",
+          "name"        => "Class list"
+        },
+        "!Type:Memorized" => {
+          "type"        => "memorized_transaction_list",
+          "name"        => "Memorized transaction list"
+        },
+        "!Type:Invoice" => {
+          "type"        => "invoice",
+          "name"        => "Invoice (Quicken for Business only)"
+        }
+      }
+    end
+  end
+end

data/lib/qif/builder.rb

@@ -0,0 +1,37 @@
+module SaltParser
+  module Qif
+    class Builder < SaltParser::Builder
+
+      def initialize(resource, date_format="%m/%d/%Y")
+        resource = open_resource(resource)
+        resource.rewind
+
+        @content = convert_to_utf8(resource.read)
+        prepare(content)
+
+        @parser = Parser.new(:headers => headers, :body => body, :date_format => date_format)
+      end
+
+      private
+
+      def prepare(content)
+        # ignore internal Quicken information
+        # http://en.wikipedia.org/wiki/Quicken_Interchange_Format#Header_line
+        split_content = content.split(/(^!.+)/).reject(&:blank?).map(&:strip)
+        split_content.each_slice(2) do |slice|
+          if slice.length == 1
+            @body   = slice.first
+          else
+            next if Qif::Accounts::NOT_SUPPORTED_ACCOUNTS.keys.include?(slice.first)
+            @headers = slice.first
+            @body    = slice.last
+          end
+        end
+
+        if body.nil? or body.match(/(^!.+)/)
+          raise SaltParser::Error::EmptyFileBody
+        end
+      end
+    end
+  end
+end

data/lib/qif/dependencies.rb

@@ -0,0 +1,8 @@
+require "date"
+require "chronic"
+
+require_relative "builder"
+require_relative "account"
+require_relative "accounts"
+require_relative "transaction"
+require_relative "parser"

data/lib/qif/parser.rb

@@ -0,0 +1,68 @@
+module SaltParser
+  module Qif
+    class Parser
+      attr_reader :headers, :body, :accounts, :date_format
+
+      def initialize(options = {})
+        @headers     = options[:headers].try(:chomp)
+        @body        = options[:body]
+        @date_format = options[:date_format]
+        @accounts    = Qif::Accounts.new
+        parse_account
+      end
+
+      def to_hash
+        { :accounts => accounts.to_hash }
+      end
+
+      def parse_account
+        @accounts << Qif::Account.new({
+          :name         => Qif::Accounts::SUPPORTED_ACCOUNTS[headers]["name"],
+          :type         => Qif::Accounts::SUPPORTED_ACCOUNTS[headers]["type"],
+          :transactions => build_transactions
+        })
+      end
+
+      def build_transactions
+        transactions_array = body.split("^").reject(&:blank?)
+        check_dates(transactions_array)
+
+        transactions_array.each_with_object([]) do |transaction, transactions|
+          transaction_hash = build_transaction_hash(transaction.split("\n"))
+          transactions << Qif::Transaction.new(transaction_hash) unless transaction_hash.empty?
+        end
+      end
+
+      def build_transaction_hash(rows)
+        hash = {}
+        rows.map do |row|
+          type = Qif::Transaction::SUPPORTED_FIELDS[row[0].try(:upcase)]
+          next unless type
+          hash[type] = type == :date ? parse_date(row[1..-1]) : row[1..-1].strip
+        end
+        hash[:date].nil? ? {} : hash
+      end
+
+      def parse_date(row)
+        date = Date.strptime(row, date_format)
+        raise ArgumentError if date.year < 1900
+        date.as_json
+      rescue ArgumentError => error
+        Chronic.parse(row, :endian_precedence => [:middle, :little]).to_date.as_json
+      end
+
+      def check_dates(transactions_array)
+        dates = transactions_array.map{ |transaction| transaction.split("\n") }
+                                  .flatten
+                                  .select{ |line| line.match(/^D/) }
+                                  .map{ |line| line[1..-1] }
+
+        dates.each do |row|
+          unless Chronic.parse(row)
+            raise SaltParser::Error::UnsupportedDateFormat.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/qif/transaction.rb

@@ -0,0 +1,28 @@
+module SaltParser
+  module Qif
+    class Transaction < SaltParser::Base
+      SUPPORTED_FIELDS = {
+        "D" => :date     , # Date
+        "T" => :amount   , # Amount
+        "C" => :status   , # Cleared status
+        "N" => :number   , # Num (check or reference number)
+        "P" => :payee    , # Payee
+        "M" => :memo     , # Memo
+        "L" => :category   # Category (Category/Subcategory/Transfer/Class)
+      }
+      SUPPORTED_FIELDS.values.each{ |field| attr_accessor field }
+
+      def to_hash
+        {
+          :date     => date,
+          :amount   => amount,
+          :status   => status,
+          :number   => number,
+          :payee    => payee,
+          :memo     => memo,
+          :category => category
+        }
+      end
+    end
+  end
+end

data/lib/salt-parser/accounts.rb

@@ -0,0 +1,11 @@
+module SaltParser
+  class Accounts < Array
+    def find(identifier)
+      detect { |account| account.identifier == identifier }
+    end
+
+    def to_hash
+      map { |account| account.to_hash }
+    end
+  end
+end

data/lib/salt-parser/base.rb

@@ -0,0 +1,19 @@
+require "active_support"
+require "active_support/core_ext"
+
+module SaltParser
+  class Base
+    def initialize(attrs)
+      attrs.each do |key, value|
+        send("#{key}=", value)
+      end
+    end
+  end
+end
+
+require_relative "accounts"
+require_relative "errors"
+require_relative "builder"
+
+require "ofx/dependencies"
+require "qif/dependencies"

data/lib/salt-parser/builder.rb

@@ -0,0 +1,24 @@
+module SaltParser
+  class Builder
+    attr_reader :headers, :body, :content, :parser
+
+    private
+
+    def open_resource(resource)
+      if resource.respond_to?(:read)
+        resource
+      else
+        open(resource)
+      end
+    rescue Exception
+      StringIO.new(resource)
+    end
+
+    def convert_to_utf8(string)
+      return string if Kconv.isutf8(string)
+      string.encode(Encoding::UTF_8.to_s, Encoding::ISO_8859_1.to_s)
+    rescue Exception
+      raise SaltParser::Error::InvalidEncoding
+    end
+  end
+end

data/lib/salt-parser/errors.rb

@@ -0,0 +1,14 @@
+module SaltParser
+  module Error
+    class EmptyFileBody         < StandardError; end
+    class InvalidEncoding       < StandardError; end
+    class ParseError            < StandardError
+      AMOUNT = "Error while parsing numeric field."
+      TIME   = "Error while parsing time field."
+      FLOAT  = "Error while parsing float field."
+    end
+    class RequestError          < StandardError; end
+    class UnsupportedDateFormat < StandardError; end
+    class UnsupportedFileError  < StandardError; end
+  end
+end

data/lib/salt-parser/version.rb

@@ -0,0 +1,8 @@
+module SaltParser
+  module Version
+    MAJOR = 0
+    MINOR = 0
+    PATCH = 1
+    STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"
+  end
+end

data/salt-parser.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "salt-parser/version"
+
+Gem::Specification.new do |s|
+  s.name        = "salt-parser"
+  s.version     = SaltParser::Version::STRING
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["saltedge team"]
+  s.email       = ["support@saltedge.com"]
+  s.homepage    = "http://example.com"
+  s.summary     = "Gem for parsing OFX, HBCI, QIF and SWIFT formats."
+  s.description = "Gem for parsing OFX, HBCI, QIF and SWIFT formats."
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |file| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "nokogiri"
+  s.add_development_dependency "rspec", "~> 3.0"
+  s.add_development_dependency 'bundler', '~> 1.3'
+  s.add_development_dependency "rake"
+  s.add_development_dependency "pry-byebug"
+end

data/spec/ofx/account_spec.rb

@@ -0,0 +1,97 @@
+require "spec_helper"
+
+describe SaltParser::Ofx::Account do
+  let(:ofx)     { SaltParser::Ofx::Builder.new("spec/ofx/fixtures/v102.ofx") }
+  let(:parser)  { ofx.parser }
+  let(:account) { parser.accounts.first }
+  let(:hash)    { account.to_hash }
+
+  describe "account" do
+    context "Bank account" do
+      it "should return currency" do
+        account.currency.should == "BRL"
+        hash[:currency].should == account.currency
+      end
+
+      it "should return bank id" do
+        account.bank_id.should == "0356"
+        hash[:bank_id].should == account.bank_id
+      end
+
+      it "should return id" do
+        account.id.should == "03227113109"
+        hash[:id].should == account.id
+      end
+
+      it "should return type" do
+        account.type.should == :checking
+        hash[:type].should == account.type
+      end
+
+      it "should return transactions" do
+        account.transactions.should be_a_kind_of(Array)
+        account.transactions.size.should == 36
+        hash[:transactions].should be_a_kind_of(Array)
+        hash[:transactions].size.should == account.transactions.size
+        hash[:transactions].first.should == account.transactions.first.to_hash
+      end
+
+      it "should return balance" do
+        account.balance.amount.should == 598.44
+        hash[:balance][:amount].should == account.balance.amount
+      end
+
+      it "should return balance in pennies" do
+        account.balance.amount_in_pennies.should == 59844
+        hash[:balance][:amount_in_pennies].should == account.balance.amount_in_pennies
+      end
+
+      it "should return balance date" do
+        account.balance.posted_at.should == Time.parse("2009-11-01")
+        hash[:balance][:posted_at].should == Time.parse("2009-11-01")
+      end
+
+      context "available_balance" do
+        it "should return available balance" do
+          account.available_balance.amount.should == 1555.99
+          hash[:available_balance][:amount].should == account.available_balance.amount
+        end
+
+        it "should return available balance in pennies" do
+          account.available_balance.amount_in_pennies.should == 155599
+          hash[:available_balance][:amount_in_pennies].should == account.available_balance.amount_in_pennies
+        end
+
+        it "should return available balance date" do
+          account.available_balance.posted_at.should == Time.parse("2009-11-01")
+          hash[:available_balance][:posted_at].should == account.available_balance.posted_at
+        end
+
+        it "should return nil if AVAILBAL not found" do
+          ofx     = SaltParser::Ofx::Builder.new("spec/ofx/fixtures/utf8.ofx")
+          account = ofx.parser.accounts.first
+          account.available_balance.should be_nil
+        end
+      end
+    end
+
+    context "Credit Card" do
+      let(:ofx)     { SaltParser::Ofx::Builder.new("spec/ofx/fixtures/v211.ofx") }
+      let(:account) { parser.accounts.last }
+
+      it "should return id" do
+        account.id.should == "123412341234"
+      end
+
+      it "should return currency" do
+        account.currency.should == "USD"
+      end
+    end
+
+    context "#to_hash" do
+      it "should return Hash" do
+        hash.should be_a_kind_of(Hash)
+      end
+    end
+  end
+end

data/spec/ofx/accounts_response_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe "Bank accounts response" do
+  let(:ofx)      { SaltParser::Ofx::Builder.new("spec/ofx/fixtures/accounts_response.ofx") }
+  let(:parser)   { ofx.parser }
+  let(:accounts) { parser.accounts }
+
+  describe "accounts" do
+    it "should parse bank account from bank response" do
+      accounts.size.should          == 5
+      accounts.first.to_hash.should == {
+        :bank_id           => "123456789",
+        :id                => "1234567890",
+        :name              => "SILVERWIZ SAVINGS",
+        :broker_id         => nil,
+        :type              => :savings,
+        :units             => nil,
+        :unit_price        => nil,
+        :currency          => "",
+        :balance           => nil,
+        :transactions      => [],
+        :available_balance => nil
+      }
+    end
+  end
+
+  describe "sign_on" do
+    it "should parse sign_on data from bank response" do
+      parser.sign_on.to_hash.should == {
+        :language => "ENG",
+        :fi_id    => "10898",
+        :fi_name  => "B1",
+        :code     => "0",
+        :severity => "INFO",
+        :message  => "SUCCESS"
+      }
+    end
+  end
+
+  describe "errors" do
+    it "should not have any errors" do
+      parser.errors.size.should be_zero
+    end
+  end
+end

data/spec/ofx/accounts_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe SaltParser::Ofx::Accounts do
+  let(:ofx)      { SaltParser::Ofx::Builder.new("spec/ofx/fixtures/v211.ofx") }
+  let(:accounts) { ofx.parser.accounts }
+  let(:hash)     { accounts.to_hash }
+
+  describe "accounts" do
+    it "should return multiple accounts" do
+      accounts.size.should == 2
+    end
+
+    describe "#find" do
+      it "returns first by id" do
+        accounts.find("123456").class.should == SaltParser::Ofx::Account
+      end
+    end
+
+    describe "#find_by_transaction" do
+      it "returns first by transaction's account_id and it's currency code" do
+        account = accounts.first
+        transaction = account.transactions.first
+        accounts.find_by_transaction(transaction).should == account
+      end
+    end
+
+    context "#to_hash" do
+      it "should return array of Hashes" do
+        hash.should be_a_kind_of(Array)
+        hash.first.should be_a_kind_of(Hash)
+      end
+    end
+  end
+end

data/spec/ofx/balance_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe SaltParser::Ofx::Balance do
+  let(:ofx)     { SaltParser::Ofx::Builder.new("spec/ofx/fixtures/v102.ofx") }
+  let(:parser)  { ofx.parser }
+  let(:account) { parser.accounts.first }
+  let(:balance) { account.balance }
+  let(:hash)    { balance.to_hash }
+
+  describe "balance" do
+    it "should return amount" do
+      balance.amount.should == 598.44
+      hash[:amount].should == balance.amount
+    end
+
+    it "should return amount_in_pennies" do
+      balance.amount_in_pennies.should == 59844
+      hash[:amount_in_pennies].should == balance.amount_in_pennies
+    end
+
+    it "should return posted_at" do
+      balance.posted_at.should == Time.parse("2009-11-01")
+      hash[:posted_at].should == balance.posted_at
+    end
+
+    context "#to_hash" do
+      it "should return Hash" do
+        hash.should be_a_kind_of(Hash)
+      end
+    end
+  end
+end