sie-analysis 0.1.1

data/lib/sie_analysis/parser.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require "date"
+
+module SieAnalysis
+  # Parses financial export types 2–4 into balances and (for type 4) voucher lines.
+  class Parser
+    Record = Data.define(:tag, :fields)
+    Voucher = Data.define(:series, :number, :date, :description, :lines)
+    Line = Data.define(:account, :amount)
+
+    # Parsed ledger: monetary values are BigDecimal; voucher dates are Date.
+    # Period keys are YYYYMM strings; object keys are [dimension number, code].
+    Parsed = Data.define(
+      :accounts, :objects, :opening_balances, :closing_balances, :results, :period_changes,
+      :financial_years, :vouchers, :budgets, :sie_type
+    )
+
+    # @param text [String] export text already decoded to UTF-8
+    # @return [Parsed] recognized balances, objects, budgets and vouchers
+    # @raise [ParseError] invalid export type, financial year or recognized record
+    def self.parse(text)
+      new(text).parse
+    end
+
+    # @param text [String] decoded SIE 2, 3 or 4 text
+    def initialize(text)
+      @text = text.to_s
+      @accounts = {}
+      @objects = {}
+      @opening = Hash.new(BigDecimal("0"))
+      @closing = Hash.new(BigDecimal("0"))
+      @results = Hash.new(BigDecimal("0"))
+      @periods = Hash.new { |hash, key| hash[key] = Hash.new(BigDecimal("0")) }
+      @budgets = Hash.new { |hash, key| hash[key] = Hash.new(BigDecimal("0")) }
+      @years = {}
+      @vouchers = []
+      @current_voucher = nil
+    end
+
+    # Consumes this parser once. Use .parse for each separate export.
+    # @return [Parsed] parsed ledger
+    # @raise [ParseError] unreadable or invalid recognized records
+    def parse
+      each_record { |record| apply_record(record) }
+      finish_voucher!
+      raise ArgumentError unless [2, 3, 4].include?(@sie_type) && @years.key?(0)
+      @periods.default_proc = nil
+      @budgets.default_proc = nil
+      Parsed.new(
+        accounts: @accounts, objects: @objects, opening_balances: @opening, closing_balances: @closing,
+        results: @results, period_changes: @periods, financial_years: @years, vouchers: @vouchers,
+        budgets: @budgets, sie_type: @sie_type
+      )
+    rescue ParseError
+      raise
+    rescue StandardError
+      raise ParseError, "Unreadable financial export"
+    end
+
+    private
+
+    def each_record
+      @text.each_line do |line|
+        stripped = line.strip
+        next if stripped.empty? || !stripped.start_with?("#")
+
+        tokens = SieTokenizer.tokenize(stripped[1..])
+        next if tokens.empty?
+
+        yield Record.new(tag: tokens[0], fields: tokens[1..])
+      end
+    end
+
+    def apply_record(record)
+      case record.tag
+      when "SIETYP"
+        raise ArgumentError if @sie_type
+        @sie_type = Integer(record.fields.fetch(0))
+      when "KONTO" then apply_account(record.fields)
+      when "OBJEKT" then apply_object(record.fields)
+      when "RAR" then apply_year(record.fields)
+      when "IB" then apply_balance!(@opening, record.fields)
+      when "UB" then apply_balance!(@closing, record.fields)
+      when "RES" then apply_balance!(@results, record.fields)
+      when "PSALDO" then apply_period!(record.fields)
+      when "PBUDGET" then apply_budget!(record.fields)
+      when "VER" then start_voucher!(record.fields)
+      when "TRANS" then apply_trans!(record.fields)
+      end
+    end
+
+    def apply_account(fields)
+      number = integer_field(fields[0])
+      @accounts[number] = unquote(fields[1]).to_s if number
+    end
+
+    def apply_object(fields)
+      dim = integer_field(fields[0])
+      code = unquote(fields[1]).to_s
+      name = unquote(fields[2]).to_s
+      @objects[[dim, code]] = name if dim && !code.empty?
+    end
+
+    def apply_year(fields)
+      year_no = integer_field(fields[0])
+      first, last = sie_date(fields[1]), sie_date(fields[2])
+      raise ArgumentError unless year_no && first && last && first <= last
+      raise ArgumentError if @years.key?(year_no)
+      @years[year_no] = { from: unquote(fields[1]), to: unquote(fields[2]) }
+    end
+
+    def apply_balance!(target, fields)
+      year = integer_field(fields[0])
+      raise ArgumentError unless year
+      return unless year.zero?
+
+      account = integer_field(fields[1])
+      amount = decimal_field(fields[2])
+      raise ArgumentError unless account&.positive? && amount&.finite?
+
+      target[account] += amount
+    end
+
+    def apply_period!(fields, target = @periods)
+      year = integer_field(fields[0])
+      raise ArgumentError unless year
+      return unless year.zero?
+
+      period = fields[1].to_s
+      account = integer_field(fields[2])
+      object_field = fields[3].to_s
+      amount = object_field.start_with?("{") ? decimal_field(fields[4]) : decimal_field(fields[3])
+      raise ArgumentError unless period.match?(/\A\d{4}(0[1-9]|1[0-2])\z/) && account&.positive? && amount&.finite?
+      raise ArgumentError if object_field.start_with?("{") && !valid_budget_objects?(object_field)
+
+      refs = object_refs_from(object_field)
+      if refs.empty?
+        target[period][account] += amount
+      else
+        refs.each { |dim, code| target[period][[account, dim, code]] += amount }
+      end
+    end
+
+    def apply_budget!(fields)
+      year = integer_field(fields[0])
+      raise ArgumentError unless year
+      return unless year.zero?
+
+      period, account, objects, amount = fields.values_at(1, 2, 3, 4)
+      raise ArgumentError unless period.to_s.match?(/\A\d{4}(0[1-9]|1[0-2])\z/)
+      raise ArgumentError unless integer_field(account)&.positive? && decimal_field(amount)&.finite?
+      raise ArgumentError unless valid_budget_objects?(objects)
+
+      apply_period!(fields, @budgets)
+    end
+
+    def valid_budget_objects?(objects)
+      return false unless objects.to_s.start_with?("{") && objects.end_with?("}")
+
+      parts = SieTokenizer.tokenize(objects[1...-1])
+      parts.length.even? && parts.each_slice(2).all? do |dim, code|
+        integer_field(dim)&.positive? && !unquote(code).empty?
+      end
+    end
+
+    def start_voucher!(fields)
+      finish_voucher!
+      date = sie_date(fields[2])
+      number = integer_field(fields[1])
+      raise ArgumentError unless date && number
+
+      @current_voucher = {
+        series: unquote(fields[0]).to_s,
+        number:,
+        date:,
+        description: unquote(fields[3]).to_s,
+        lines: []
+      }
+    end
+
+    def apply_trans!(fields)
+      raise ArgumentError unless @current_voucher
+
+      account = integer_field(fields[0])
+      object_field = fields[1].to_s
+      amount = object_field.start_with?("{") ? decimal_field(fields[2]) : decimal_field(fields[1])
+      raise ArgumentError unless account&.positive? && amount&.finite?
+
+      raise ArgumentError if object_field.start_with?("{") && !valid_budget_objects?(object_field)
+
+      @current_voucher[:lines] << Line.new(account:, amount:)
+    end
+
+    def finish_voucher!
+      voucher = @current_voucher
+      @current_voucher = nil
+      return unless voucher && voucher[:lines].any?
+
+      @vouchers << Voucher.new(
+        series: voucher[:series], number: voucher[:number], date: voucher[:date],
+        description: voucher[:description], lines: voucher[:lines]
+      )
+    end
+
+    def object_refs_from(field)
+      text = field.to_s
+      return [] unless text.start_with?("{") && text.end_with?("}")
+
+      inner = text[1...-1].strip
+      return [] if inner.empty?
+
+      parts = SieTokenizer.tokenize(inner)
+      parts.each_slice(2).filter_map do |dim_token, code_token|
+        dim = integer_field(dim_token)
+        code = unquote(code_token).to_s
+        [dim, code] if dim && !code.empty?
+      end
+    end
+
+    def sie_date(value)
+      text = unquote(value).to_s
+      return unless text.match?(/\A\d{8}\z/)
+
+      Date.strptime(text, "%Y%m%d")
+    rescue Date::Error
+      nil
+    end
+
+    def integer_field(value)
+      Integer(unquote(value))
+    rescue TypeError, ArgumentError
+      nil
+    end
+
+    def decimal_field(value)
+      text = unquote(value).tr(",", ".")
+      return unless text.match?(/\A[+-]?\d+(?:\.\d+)?\z/)
+      BigDecimal(text)
+    rescue TypeError, ArgumentError
+      nil
+    end
+
+    def unquote(value)
+      text = value.to_s
+      return text[1...-1] if text.start_with?('"') && text.end_with?('"') && text.length >= 2
+
+      text
+    end
+  end
+end

data/lib/sie_analysis/sie_tokenizer.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module SieAnalysis
+  # Tokenizes one SIE record line, keeping quoted strings and {object lists} intact.
+  class SieTokenizer
+    def self.tokenize(line)
+      new(line).tokens
+    end
+
+    def initialize(line)
+      @line = line
+      @tokens = []
+      @buffer = +""
+      @in_quotes = false
+      @brace_depth = 0
+      @index = 0
+    end
+
+    def tokens
+      consume while @index < @line.length
+      flush_buffer
+      @tokens
+    end
+
+    private
+
+    def consume
+      return append_escaped if escaped?
+      return toggle_quote if current == '"'
+      return handle_structure if !@in_quotes && structural?
+
+      @buffer << current
+      @index += 1
+    end
+
+    def current
+      @line[@index]
+    end
+
+    def escaped?
+      @in_quotes && current == "\\" && @index + 1 < @line.length
+    end
+
+    def structural?
+      current == "{" || (current == "}" && @brace_depth.positive?) ||
+        (@brace_depth.zero? && current.match?(/\s/))
+    end
+
+    def handle_structure
+      return open_brace if current == "{"
+      return close_brace if current == "}"
+
+      split_token
+    end
+
+    def append_escaped
+      @buffer << @line[@index + 1]
+      @index += 2
+    end
+
+    def toggle_quote
+      if @in_quotes
+        close_quote
+      else
+        @in_quotes = true
+        @buffer << '"' if @brace_depth.positive?
+      end
+      @index += 1
+    end
+
+    def close_quote
+      @in_quotes = false
+      if @brace_depth.positive?
+        @buffer << '"'
+      elsif @buffer.empty?
+        @tokens << ""
+      end
+    end
+
+    def open_brace
+      @brace_depth += 1
+      @buffer << "{"
+      @index += 1
+    end
+
+    def close_brace
+      @brace_depth -= 1
+      @buffer << "}"
+      flush_buffer if @brace_depth.zero?
+      @index += 1
+    end
+
+    def split_token
+      flush_buffer
+      @index += 1
+    end
+
+    def flush_buffer
+      return if @buffer.empty?
+
+      @tokens << @buffer
+      @buffer = +""
+    end
+  end
+end

data/lib/sie_analysis/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SieAnalysis
+  VERSION = "0.1.1"
+end

data/lib/sie_analysis.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require_relative "sie_analysis/version"
+
+# Analysis of Swedish SIE financial exports.
+module SieAnalysis
+  # A malformed or unsupported SIE export.
+  class ParseError < StandardError; end
+end
+
+require_relative "sie_analysis/groups"
+require_relative "sie_analysis/sie_tokenizer"
+require_relative "sie_analysis/parser"
+require_relative "sie_analysis/amounts"
+require_relative "sie_analysis/budgets"
+require_relative "sie_analysis/income_statements"
+require_relative "sie_analysis/dimension_statements"
+require_relative "sie_analysis/balance_sheets"
+require_relative "sie_analysis/analysis"

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: sie-analysis
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Standout AB
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- assets/header-vector.svg
+- lib/sie_analysis.rb
+- lib/sie_analysis/amounts.rb
+- lib/sie_analysis/analysis.rb
+- lib/sie_analysis/balance_sheets.rb
+- lib/sie_analysis/budgets.rb
+- lib/sie_analysis/dimension_statements.rb
+- lib/sie_analysis/groups.rb
+- lib/sie_analysis/income_statements.rb
+- lib/sie_analysis/parser.rb
+- lib/sie_analysis/sie_tokenizer.rb
+- lib/sie_analysis/version.rb
+homepage: https://github.com/standout/sie-analysis
+licenses: []
+metadata:
+  source_code_uri: https://github.com/standout/sie-analysis
+  allowed_push_host: https://rubygems.org
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: Income statements, account movements and budget analysis for SIE exports
+test_files: []