taxger 0.2.0

data/lib/taxger/lohnsteuer.rb

@@ -0,0 +1,28 @@
+require 'taxger/lohnsteuer/bigdecimal'
+require 'taxger/lohnsteuer/lohnsteuer2006'
+require 'taxger/lohnsteuer/lohnsteuer2007'
+require 'taxger/lohnsteuer/lohnsteuer2008'
+require 'taxger/lohnsteuer/lohnsteuer2009'
+require 'taxger/lohnsteuer/lohnsteuer2010'
+require 'taxger/lohnsteuer/lohnsteuer2011'
+require 'taxger/lohnsteuer/lohnsteuer2011dezember'
+require 'taxger/lohnsteuer/lohnsteuer2012'
+require 'taxger/lohnsteuer/lohnsteuer2013'
+require 'taxger/lohnsteuer/lohnsteuer2014'
+require 'taxger/lohnsteuer/lohnsteuer2015'
+require 'taxger/lohnsteuer/lohnsteuer2015dezember'
+require 'taxger/lohnsteuer/lohnsteuer2016'
+
+module Taxger
+  module Lohnsteuer
+    extend self
+
+    def calculate(year, input)
+      input = Hash[input.map do |key, value|
+        [key, Taxger::Lohnsteuer::BigDecimal.new(value)]
+      end]
+      lst = Object.const_get("Taxger::Lohnsteuer::Lohnsteuer#{year}")
+      lst.new(input)
+    end
+  end
+end

data/lib/taxger/version.rb

@@ -0,0 +1,3 @@
+module Taxger
+  VERSION = "0.2.0"
+end

data/lib/taxger.rb

@@ -0,0 +1,9 @@
+require 'bigdecimal'
+require 'taxger/version'
+require 'taxger/lohnsteuer'
+require 'taxger/einkommensteuer'
+
+module Taxger
+  # Your code goes here...
+end
+

data/src/README.md

@@ -0,0 +1,141 @@
+# Taxger Source Generation
+
+The Lohnsteuer calculator is created from [https://www.bmf-steuerrechner.de/interface/pseudocode.jsp](pseudo code) offered by the
+Ministery of Finance.
+
+To rebuild these files (or create files for years not yet included in
+this gem), execute the following steps:
+
+### Download the pseudo code
+
+Download the files by running
+
+```
+$ rake taxger:source:download
+```
+
+The files will be stored in `src/xml/`. The rake task assumes you have
+`curl` installed. If not, check `src/converter.rb` to see where to
+download the files manually.
+
+### Parse and generate Ruby code
+
+To create Ruby code from the pseudo code, run:
+
+```
+$ rake taxger:source:generate
+```
+
+For every year, a Ruby class will be generated in `src/generated/`.
+
+### Copy generated sources to gem sources
+
+Inspect the automatically generated files in `src/generated/` and apply
+changes if necessary.
+
+To make them usable for the actual gem, copy them to `lib/lohnsteuer/`
+and adjust `lib/taxger.rb` to make sure these files are loaded.
+
+## About the parser
+
+The pseudo code consists of two different structural layers. Declaration
+of variables, method bodies and control flow (IF/THEN/ELSE) is specified
+in XML.
+
+### Parsing XML
+
+The XML tags contain Java-like pseudo code (for example to specify a
+boolean expression for a conditional statement or an assignment).
+
+The parser uses Nokogiri to parse the XML and generates its own nodes
+(classes in `src/node` to translate the structure).
+
+These nodes build up a tree structure (for example a `MethodNode`
+containing a `ConditionalNode` which in turn contains a `MethodCallNode`
+etc.).
+
+### Parsing Java-like pseudo code
+
+Every `Node` exposes a `render` method that returns the actual Ruby code
+(and is mostly fed by content of attributes of the underlying XML tag).
+
+This pseudo code has a Java like syntax. `PseudoCodeParser` uses Ruby's
+internal `StringScanner` class to tokenize the input.
+
+The parser is nowhere near complete but enough to parse the existing
+pseudo code XML files from the last 10 years.
+
+It distinguishes between instance variables and constants. While in
+pseudo code, all these are uppercase, the parser translates instance
+variables to proper lowercase names prefixed with `@`.
+
+Constants are left in uppercase.
+
+Instantiations of `BigDecimal` are translated into a Ruby syntax (`new
+BigDecimal(0)` becomes `BigDecimal.new(0)`.
+
+*Please note that BigDecimal has been monkey-patched to make it
+compatible with the Java-like syntax of doing calculations with
+designated methods (i.e. `a.substract(b)` instead of `a - b`!)*
+
+The parser accepts an optional `;` at EOL, but other unknown symbols
+will trigger an error (to make sure it roughly understands whats going
+on).
+
+### Parser warnings
+
+You will encounter the following messages for older files:
+
+```
+WARNING: Orphaned ELSE block found, but assigning it to previous IF statement` in some older files.
+```
+
+These can be safely ignored. The reason is that older files use an
+ambigous XML nesting like this:
+
+```xml
+<IF>
+  <THEN> ... </THEN>
+</IF>
+<ELSE> ... </ELSE>
+```
+
+The parser checks if the `ELSE` tag is follwing an `IF` tag immediatly.
+If so, it is attached there and the warning is shown.
+
+Newer files from the Ministery of Finance use the following syntax:
+
+```xml
+<IF>
+  <THEN> ... </THEN>
+  <ELSE> ... </ELSE>
+</IF>
+```
+
+### TODO
+
+`Lohnsteuer2012.xml` contains namespace references to *some* variables.
+The parser doesn't deal with it, so they must be removed manually from
+the Ruby source.
+
+`lib/taxger/lohnsteuer/lohnsteuer2012.rb` Line 818:
+
+```ruby
+if @zre4vp.compare_to(Lohnsteuer2012Big.RENTBEMESSUNGSGR_WEST) == 1
+```
+should be changed to
+```ruby
+if @zre4vp.compare_to(RENTBEMESSUNGSGR_WEST) == 1
+```
+etc.
+
+This should be handled automatically in the future.
+
+### Final words
+
+I would not consider this code to be a text book example on how to do
+something like this (the whole thing could use some refactoring). It is
+more of a quick hack, but this does not affect the quality of the
+resulting Ruby files.
+
+They are 100% compatible with the pseudo code provided.

data/src/code_tree.rb

@@ -0,0 +1,122 @@
+class CodeTree
+  attr_accessor :nodes
+
+  def initialize(xml, class_name = nil)
+    @class_name = class_name
+    @xml = xml
+    @nodes = []
+    @internals = []
+    @var = {}
+    @var[:outputs] = @xml.css('OUTPUT').map { |e| e.attr('name') }
+    @var[:inputs] = @xml.css('INPUT').map { |e| e.attr('name') }
+    @var[:internals] = @xml.css('INTERNAL').map { |e| e.attr('name') }
+    @var[:constants] = @xml.css('CONSTANT').map { |e| e.attr('name') }
+    @instance_vars = []
+    PseudoCode.set_vars(@var)
+    parse_vars
+    parse_methods
+  end
+
+  def render
+    ClassNode.new(@class_name || @xml.css('PAP').attr('name'), @nodes, ['Taxger', 'Lohnsteuer']).render
+  end
+
+  private
+
+  def parse_vars
+    @instance_vars << VarBlockNode.new(@xml.css('INPUTS').first, tag: :input, show_type: true)
+    @instance_vars << VarBlockNode.new(@xml.css('OUTPUTS').first, tag: :output, show_type: true)
+    @instance_vars << VarBlockNode.new(@xml.css('INTERNALS').first, tag: :internal)
+    @nodes << VarBlockNode.new(@xml.css('CONSTANTS').first, tag: :constant)
+  end
+
+  def parse_methods
+    comments = []
+    @nodes << InitializerNode.new(@xml.xpath('/PAP/METHODS/MAIN').first, @instance_vars, @var)
+    @xml.xpath('/PAP/METHODS/METHOD').each do |line|
+      if Node.is_comment?(line)
+        comments << CommentNode.new(line)
+      elsif Node.is_text?(line)
+        if line.inner_text.strip != ''
+          raise UnknownTextError.new(line)
+        end
+      elsif line.name == 'METHOD'
+        @nodes << MethodNode.new(line, description: comments)
+        comments = []
+      else
+        raise UnknownTagError.new(line)
+      end
+    end
+  end
+end
+
+class ParserError < StandardError
+end
+
+class UnknownTextError < ParserError
+end
+
+class UnknownTagError < ParserError
+end
+
+class PseudoCode
+  def self.set_vars(var)
+    @outputs = var[:outputs].sort { |b, a| a.length <=> b.length }
+    @inputs = var[:inputs].sort { |b, a| a.length <=> b.length }
+    @internals = var[:internals].sort { |b, a| a.length <=> b.length }
+    @instance_vars = (@outputs + @inputs + @internals).sort { |b, a| a.length <=> b.length }
+  end
+
+  def self.parse_expr(pseudo_code)
+    parser = PseudoCodeParser.new(pseudo_code.strip, @instance_vars)
+    parser.tokens.join
+  end
+
+  def self.parse_method_name(name)
+    "#{name.downcase}"
+  end
+
+  def self.parse_var(name)
+    if @instance_vars.include?(name)
+      "@#{name.downcase}"
+    else
+      name
+    end
+  end
+
+  def self.parse_default(default, type)
+    if default
+      parser = PseudoCodeParser.new(default.strip, @instance_vars)
+      parser.tokens.join
+    else
+      case type
+      when 'int'
+        '0'
+      when 'double'
+        '0.0'
+      when 'float'
+        '0.0'
+      when 'BigDecimal'
+        'BigDecimal.new(0)'
+      end
+    end
+  end
+
+  def self.parse_constant_value(value)
+    if value[0] == '{'
+      list = value[1..-2].split(',').map do |field|
+        PseudoCodeParser.new(field.strip, @instance_vars).tokens.join
+      end
+      lines = []
+      while (list != [])
+        lines << list.shift(4)
+      end
+      '[' + lines.map { |items| items.join(', ') }.join(",\n#{' ' * 20}") + ']'
+    else
+      PseudoCodeParser.new(value.strip, @instance_vars).tokens.join
+    end
+  end
+end
+
+
+

data/src/converter.rb

@@ -0,0 +1,61 @@
+require 'nokogiri'
+require 'strscan'
+require 'bigdecimal'
+
+require 'node/node'
+require 'node/comment_node.rb'
+require 'node/expr_node.rb'
+require 'node/method_node.rb'
+require 'node/initializer_node.rb'
+require 'node/method_call_node.rb'
+require 'node/conditional_node.rb'
+require 'node/source_node.rb'
+require 'node/class_node.rb'
+require 'node/var_block_node.rb'
+require 'node/pseudo_code_parser.rb'
+
+require 'code_tree.rb'
+
+module Taxger
+  class Converter
+    XML_PATH = File.expand_path('../xml/', __FILE__)
+    GENERATED_PATH = File.expand_path('../generated/', __FILE__)
+    URI = 'https://www.bmf-steuerrechner.de/pruefdaten/'
+    FILES = {
+    'Lohnsteuer2016.xml'            => 'Lohnsteuer2016',
+    'Lohnsteuer2015Dezember.xml'    => 'Lohnsteuer2015Dezember',
+    'Lohnsteuer2015BisNovember.xml' => 'Lohnsteuer2015',
+    'Lohnsteuer2014.xml'            => 'Lohnsteuer2014',
+    'Lohnsteuer2013_2.xml'          => 'Lohnsteuer2013',
+    'Lohnsteuer2012.xml'            => 'Lohnsteuer2012',
+    'Lohnsteuer2011Dezember.xml'    => 'Lohnsteuer2011Dezember',
+    'Lohnsteuer2011BisNovember.xml' => 'Lohnsteuer2011',
+    'Lohnsteuer2010Big.xml'         => 'Lohnsteuer2010',
+    'Lohnsteuer2009Big.xml'         => 'Lohnsteuer2009',
+    'Lohnsteuer2008Big.xml'         => 'Lohnsteuer2008',
+    'Lohnsteuer2007Big.xml'         => 'Lohnsteuer2007',
+    'Lohnsteuer2006Big.xml'         => 'Lohnsteuer2006'}
+
+    def self.download_all!
+      FILES.keys.each do |file|
+        puts "Downloading #{file}"
+        `curl #{URI}#{file} -s -o #{File.join(XML_PATH, file)}`
+      end
+    end
+
+    def self.generate_all!
+      FILES.each do |file, class_name|
+        generate_file(file, class_name)
+      end
+    end
+
+    def self.generate_file(file, class_name)
+      code = CodeTree.new(Nokogiri::XML(File.read(File.join(XML_PATH, file))), class_name)
+      name = file.split('.').first.downcase
+      puts "Generating #{name}.rb"
+      File.open(File.join(GENERATED_PATH, "#{class_name.downcase}.rb"), 'w+') do |f|
+        f.puts code.render
+      end
+    end
+  end
+end

data/src/node/class_node.rb

@@ -0,0 +1,30 @@
+class ClassNode < Node
+  def initialize(name, content, namespaces)
+    @namespaces = namespaces.reverse
+    @name = name
+    @content = content
+    super()
+  end
+
+  def render
+    render_with_namespace(@namespaces)
+    output_buffer
+  end
+
+  private
+
+  def render_with_namespace(namespaces)
+    if namespaces.size > 0
+      output "module #{namespaces.pop}"
+      ident { render_with_namespace(namespaces) }
+      output "end"
+    else
+      output "class #{@name}"
+      ident do
+        output(@content)
+      end
+      output 'end'
+    end
+  end
+end
+

data/src/node/comment_node.rb

@@ -0,0 +1,19 @@
+class CommentNode < Node
+  def initialize(element)
+    if element.is_a?(String)
+      @comments = [element]
+    else
+      @comments = element.inner_text.split("\n").map(&:strip)
+    end
+    super()
+  end
+
+  def render
+    @comments.each do |line|
+      comment(line)
+    end
+    #linefeed if @comments.size > 0
+    output_buffer
+  end
+end
+

data/src/node/conditional_node.rb

@@ -0,0 +1,32 @@
+class ConditionalNode < Node
+  def initialize(element)
+    @cond_expr = element.attr('expr')
+    @then = SourceNode.new(element.xpath('./THEN/*'))
+    @else = SourceNode.new(element.xpath('./ELSE/*'))
+    super()
+  end
+
+  def attach_else(elements)
+    if @else.lines.count > 0
+      raise "Cannot attach another ELSE block to this conditional statement: #{elements}"
+    else
+      @else = SourceNode.new(elements)
+    end
+  end
+
+  def render
+    output("if #{PseudoCode.parse_expr(@cond_expr)}")
+    ident do
+      output @then
+    end
+    if @else.lines.count > 0
+      output('else')
+      ident do
+        output @else
+      end
+    end
+    output('end')
+    output_buffer
+  end
+end
+

data/src/node/expr_node.rb

@@ -0,0 +1,13 @@
+class ExprNode < Node
+  def initialize(element)
+    @expression = element.attr('exec')
+    # TODO: parse expression hard core
+    super()
+  end
+
+  def render
+    output(PseudoCode.parse_expr(@expression))
+    #linefeed
+    output_buffer
+  end
+end

data/src/node/initializer_node.rb

@@ -0,0 +1,37 @@
+class InitializerNode < Node
+  def initialize(element, instance_vars, var, options = {})
+    @options = options
+    @name = element.attr('name')
+    @instance_vars = instance_vars
+    @var = var
+    @body = SourceNode.new(element.xpath('./*'))
+    super()
+  end
+
+  def render
+    @var[:outputs].map(&:downcase).each do |field|
+      output "attr_accessor :#{field}"
+    end
+    linefeed
+    output('INPUT_VARS = ' + @var[:inputs].map(&:downcase).map(&:to_sym).inspect)
+    output('OUTPUT_VARS = ' + @var[:outputs].map(&:downcase).map(&:to_sym).inspect)
+    if @options[:description] && @options[:description].length > 0
+      output(@options[:description])
+    end
+    output('def initialize(params)')
+    ident do
+      output 'raise "Unknown parameters: #{params.keys - INPUT_VARS}" if params.keys - INPUT_VARS != []'
+      output @instance_vars
+      output 'params.each do |key, value|'
+      output '  instance_variable_set("@#{key}", value)'
+      output 'end'
+      linefeed
+      output @body
+    end
+    output('end')
+    linefeed
+    output('private')
+    linefeed
+    output_buffer
+  end
+end

data/src/node/method_call_node.rb

@@ -0,0 +1,12 @@
+class MethodCallNode < Node
+  def initialize(element)
+    @method = element.attr('method')
+    super()
+  end
+
+  def render
+    output("#{PseudoCode.parse_method_name(@method)}")
+    output_buffer
+  end
+end
+

data/src/node/method_node.rb

@@ -0,0 +1,21 @@
+class MethodNode < Node
+  def initialize(element, options = {})
+    @options = options
+    @name = element.attr('name')
+    @body = SourceNode.new(element.xpath('./*'))
+    super()
+  end
+
+  def render
+    if @options[:description] && @options[:description].length > 0
+      output(@options[:description])
+    end
+    output("def #{PseudoCode.parse_method_name(@name)}")
+    ident do
+      output(@body)
+    end
+    output('end')
+    linefeed
+    output_buffer
+  end
+end

data/src/node/node.rb

@@ -0,0 +1,47 @@
+class Node
+  @@ident = 0
+  def initialize
+    @output = []
+  end
+
+  def output_buffer
+    @output
+  end
+
+  def self.is_comment?(element)
+    element.is_a?(Nokogiri::XML::Comment)
+  end
+
+  def self.is_text?(element)
+    element.is_a?(Nokogiri::XML::Text)
+  end
+
+  protected
+
+  def ident(&block)
+    @@ident += 1
+    yield
+    @@ident -= 1
+  end
+
+  def output(node)
+    if node.is_a?(String)
+      @output << "#{'  ' * @@ident}#{node}".rstrip
+    elsif node.is_a?(Node)
+      @output += node.render
+    elsif node.is_a?(Array)
+      node.each { |n| output(n) }
+    end
+  end
+
+  def comment(str)
+    (str.is_a?(Array) ? str : [str]).map(&:strip).compact.each do |line|
+      output("# #{str}")
+    end
+  end
+
+  def linefeed
+    output('')
+  end
+end
+

data/src/node/pseudo_code_parser.rb

@@ -0,0 +1,88 @@
+class PseudoCodeParser
+  attr_reader :tokens
+
+  NUMBER = /^-?\d+/
+  IDENTIFIER = /\w+/
+  RESERVED = {
+    multiply:  'multiply',
+    divide:    'divide',
+    substract: 'substract',
+    add:       'add',
+    valueOf:   'value_of',
+    compareTo: 'compare_to',
+    setScale:  'set_scale'
+  }
+
+  class ParserError < StandardError
+  end
+
+  def initialize(source, instance_vars)
+    @buffer = StringScanner.new(source)
+    @instance_vars = instance_vars
+    @tokens = []
+    parse
+  end
+
+  private
+
+  def parse
+    until @buffer.eos?
+      parse_next
+    end
+  end
+
+  def parse_next
+    skip_spaces
+    if @buffer.scan(/new BigDecimal/)
+      @tokens << 'BigDecimal.new'
+    elsif parse_number_or_identifier
+      # ...
+    elsif @buffer.scan(/,/)
+      @tokens << ', '
+    elsif ['&&', '>=', '<=', '==', '!='].include?(@buffer.peek(2))
+      @tokens << " #{@buffer.getch + @buffer.getch} "
+    elsif ['+', '-', '/', '*', '<' ,'>', '='].include?(@buffer.peek(1))
+      @tokens << " #{@buffer.getch} "
+    elsif ['.', '(', ')', '[', ']'].include?(@buffer.peek(1))
+      @tokens << @buffer.getch
+    elsif @buffer.rest == ';'
+      # some older files (< 2012) have semicolons at the end of some lines.
+      # we ignore this if it is the last character.
+      @buffer.getch
+    else
+      error('Unexpected token')
+    end
+  end
+
+  def parse_number_or_identifier
+    skip_spaces
+    if @buffer.check(NUMBER)
+      result = @tokens.push(@buffer.scan(NUMBER))
+
+      # remove numeric literal data types (like '0.01D'). these occur in the 2011 XML file
+      if %w(D L).include?(@buffer.peek(1))
+        @buffer.getch
+      end
+
+      result
+    elsif @buffer.check(IDENTIFIER)
+      token = @buffer.scan(IDENTIFIER)
+      if RESERVED[token.to_sym]
+        token = RESERVED[token.to_sym]
+      else
+        token = "@#{token.downcase}" if @instance_vars.include?(token)
+      end
+      @tokens.push(token)
+    else
+      nil
+    end
+  end
+
+  def skip_spaces
+    @buffer.skip(/\s+/)
+  end
+
+  def error(description)
+    raise ParserError.new("#{description} at position #{@buffer.pos+1}: \"#{@buffer.string}\"")
+  end
+end