hbci 0.2.0

data/lib/hbci/element_groups/segment_head.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Hbci
+  module ElementGroups
+    class SegmentHead < ElementGroup
+      element :type
+      element :position
+      element :version
+      element :reference
+    end
+  end
+end

data/lib/hbci/element_groups/unknown.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Hbci
+  module ElementGroups
+    class Unknown < ElementGroup
+      99.times do |i|
+        element :"entry_#{i}"
+      end
+    end
+  end
+end

data/lib/hbci/element_unparser.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Hbci
+  class ElementUnparser
+    attr_reader :element
+    attr_reader :type
+
+    def initialize(element, type)
+      @element = element
+      @type = type
+    end
+
+    def unparse
+      if type == :binary
+        "@#{element.size}@#{element}"
+      else
+        element.to_s.gsub('?', '??').gsub('+', '?+').gsub(':', '?:').gsub('\'', '?\'')
+      end
+    end
+  end
+end

data/lib/hbci/message.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Hbci
+  class Message
+    attr_reader :dialog, :segments, :sec_ref
+    attr_accessor :next_position
+
+    def initialize(dialog = nil)
+      @dialog = dialog
+      @sec_ref = generate_security_reference
+      @segments = []
+      @next_position = 1
+    end
+
+    def add_segment(segment)
+      segment.build(self)
+      @segments.push(segment)
+    end
+
+    def compile
+      @segments.each_with_index do |segment, index|
+        segment.compile
+        unless segment.head.position
+          segment.head.position = @next_position
+          @next_position += 1
+        end
+      end
+      @segments.each do |segment|
+        segment.after_compile if segment.respond_to?(:after_compile)
+      end
+    end
+
+    def to_s
+      segments.join('')
+    end
+
+    def to_base64
+      Base64.encode64(to_s)
+    end
+
+    private
+
+    def generate_security_reference
+      rand(1..23) * 999_999 + 1_000_000
+    end
+  end
+end

data/lib/hbci/message_factory.rb

@@ -0,0 +1,17 @@
+module Hbci
+  module MessageFactory
+    def self.build(dialog)
+      request_message = Message.new(dialog)
+      request_message.add_segment(Segments::HNHBKv3.new)
+      request_message.add_segment(Segments::HNVSKv3.new)
+      hnvsd = Segments::HNVSDv1.new do |s|
+        s.add_segment(Segments::HNSHKv4.new)
+        yield s
+        s.add_segment(Segments::HNSHAv2.new)
+      end
+      request_message.add_segment(hnvsd)
+      request_message.add_segment(Segments::HNHBSv1.new)
+      request_message
+    end
+  end
+end

data/lib/hbci/parser.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Hbci
+  class Parser
+    attr_reader :scanner
+    attr_accessor :segments
+
+    ELEMENT_DELIMITER       = ':'
+    ELEMENT_GROUP_DELIMITER = '+'
+    SEGMENT_DELIMITER       = '\''
+
+    # ELEMENT_REGEX matches everything until a a delimiter that is not escaped
+    #
+    # NODE                     EXPLANATION
+    # ------------------------------------------------------------------------
+    #   (                        group and capture to \1:
+    # ------------------------------------------------------------------------
+    #     .*?                      any character except \n (0 or more times
+    #                              (matching the least amount possible))
+    # ------------------------------------------------------------------------
+    #     (?=                      look ahead to see if there is:
+    # ------------------------------------------------------------------------
+    #       (?<!                     look behind to see if there is not:
+    # ------------------------------------------------------------------------
+    #         \?                       '?'
+    # ------------------------------------------------------------------------
+    #       )                        end of look-behind
+    # ------------------------------------------------------------------------
+    #       [:+']                    any character of: ':', '+', '''
+    # ------------------------------------------------------------------------
+    #     )                        end of look-ahead
+    # ------------------------------------------------------------------------
+    #   )                        end of \1
+    ELEMENT_REGEX           = /(.*?(?=(?<!\?)[:+']))/
+
+    # Binary Elements may contain unescaped delimiters. Thus they are not
+    # terminated by regular delimiters. But their content is preceeded with
+    # its length surrounded by '@'s. e.g.:
+    #
+    # '@6@mydata' or '@12@mydatamydata'
+    #
+    # The BINARY_ELEMENT_LENGTH_REGEx matches only the length.
+    BINARY_ELEMENT_LENGTH_REGEX = /@(\d+)@/
+
+    def self.parse(string)
+      new(string).parse
+    end
+
+    def initialize(string)
+      @scanner = StringScanner.new(string)
+      @segments = []
+      add_segment
+      add_element_group
+    end
+
+    def parse
+      parse_element
+      while scanner.rest_size > 1
+        parse_delimiter
+        parse_element
+      end
+      segments
+    end
+
+    private
+
+    def parse_regular_element
+      str = scanner.scan(ELEMENT_REGEX)
+      current_element_group << str.gsub('??', '?').gsub('?:', ':').gsub("?'", "'").gsub('?+', '+')
+    end
+
+    def parse_element
+      binary_element_ahead? ? parse_binary_element : parse_regular_element
+    end
+
+    def parse_delimiter
+      delimiter = scanner.getch
+      return if scanner.eos?
+      if delimiter == ELEMENT_GROUP_DELIMITER
+        add_element_group
+      elsif delimiter == SEGMENT_DELIMITER
+        add_segment
+        add_element_group
+      end
+    end
+
+    def parse_binary_element
+      scanner.scan(BINARY_ELEMENT_LENGTH_REGEX)
+      binary = scanner.rest.byteslice(0, scanner[1].to_i)
+      scanner.pos = scanner.pos + scanner[1].to_i
+      current_element_group << binary
+    end
+
+    def binary_element_ahead?
+      scanner.peek(1) == '@' && scanner.check(BINARY_ELEMENT_LENGTH_REGEX)
+    end
+
+    def add_segment
+      segments << []
+    end
+
+    def add_element_group
+      current_segment << []
+    end
+
+    def current_segment
+      segments.last
+    end
+
+    def current_element_group
+      current_segment.last
+    end
+  end
+end

data/lib/hbci/request.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Hbci
+  class Request < Message
+    attr_reader :dialog
+    attr_reader :sec_ref
+
+    def head
+      @head ||= Segments::HNHBKv3.build(dialog: dialog, message: self)
+    end
+
+    def enc_head
+      @enc_head ||= Segments::HNVSKv3.build(dialog: dialog)
+    end
+
+    def sig_head
+      @sig_head ||= Segments::HNSHKv4.build(dialog: dialog, message: self)
+    end
+
+    def encrypted_payload
+      @encrypted_payload ||= Segments::HNVSDv1.build(message: self)
+    end
+
+    def sig_tail
+      @sig_tail ||= Segments::HNSHAv2.build(dialog: dialog, message: self)
+    end
+
+    def tail
+      @tail ||= Segments::HNHBSv1.build(dialog: dialog, message: self)
+    end
+  end
+end

data/lib/hbci/response.rb

@@ -0,0 +1,25 @@
+
+# frozen_string_literal: true
+
+module Hbci
+  class Response
+    def initialize(raw_response)
+      @raw_response = raw_response
+      @raw_segments = Parser.parse(raw_response.force_encoding('iso-8859-1'))
+    end
+
+    def find(segment_type)
+      segments = find_all(segment_type)
+      warn "more then one #{segment_type} segment available" if segments.size > 1
+      segments.first
+    end
+
+    def find_all(segment_type)
+      @raw_segments.select { |sd| sd[0][0] == segment_type }.map{ |sd| Hbci::SegmentFactory.build(sd) }
+    end
+
+    def to_s
+      @raw_response
+    end
+  end
+end

data/lib/hbci/segment.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Hbci
+  class Segment
+    extend Forwardable
+
+    attr_reader :element_groups
+    attr_reader :defined_element_groups
+    attr_accessor :message
+    attr_accessor :dialog
+
+    attr_accessor :request_message
+
+    def self.element_groups_to_be_defined
+      @element_groups_to_be_defined ||= []
+    end
+
+    def self.element_group(name, definition = {}, &block)
+      element_groups_to_be_defined << definition.merge(name: name, block: block)
+    end
+
+    def self.element(name, definition = {})
+      element_groups_to_be_defined << definition.merge(name: name, block: nil, passthrough: true)
+    end
+
+    def build(message)
+      self.request_message = message
+
+      type, version = self.class.name.split('::').last.split('v')
+
+      head.type = type
+      head.version = version
+    end
+
+    def self.fill(segment_data)
+      segment_data.each_with_object(new).with_index do |(element_group_data, segment), element_group_index|
+        element_group_data.each_with_index do |element_data, element_index|
+          segment.element_groups[element_group_index][element_index] = element_data
+        end
+      end
+    end
+
+    def initialize
+      @element_groups = []
+      @defined_element_groups ||= []
+      define_element_groups
+    end
+
+    def compile
+    end
+
+    def to_s
+      element_groups.join('+').gsub(/\+*$/, '') << '\''
+    end
+
+    private
+
+    def define_element_groups
+      self.class.element_groups_to_be_defined.each { |element_group| define_element_group(element_group) }
+    end
+
+    def index_of_element_group(name)
+      defined_element_groups.index(name)
+    end
+
+    def define_element_group(definition)
+      defined_element_groups << definition[:name]
+
+      if definition[:passthrough]
+        initiate_passthrough_element_group(definition)
+        define_element_group_passthrough_reader(definition[:name])
+        define_element_group_passthrough_writer(definition[:name])
+      else
+        initiate_element_group(definition)
+        define_element_group_reader(definition[:name])
+        define_element_group_writer(definition[:name])
+      end
+    end
+
+    def initiate_passthrough_element_group(definition)
+      element_group = Hbci::ElementGroup.new
+      element_group.define_element(definition)
+      element_groups[index_of_element_group(definition[:name])] = element_group
+    end
+
+    def initiate_element_group(definition)
+      element_group = definition[:type] ? definition[:type].new : Hbci::ElementGroup.new
+      element_group.instance_eval(&definition[:block]) if definition[:block]
+      element_groups[index_of_element_group(definition[:name])] = element_group
+    end
+
+    def define_element_group_passthrough_reader(name)
+      define_singleton_method(name.to_s) do
+        element_groups[index_of_element_group(name)][0]
+      end
+    end
+
+    def define_element_group_reader(name)
+      define_singleton_method(name.to_s) do
+        element_groups[index_of_element_group(name)]
+      end
+    end
+
+    def define_element_group_writer(name)
+      define_singleton_method("#{name}=") do |value|
+        element_groups[index_of_element_group(name)] = value
+      end
+    end
+
+    def define_element_group_passthrough_writer(name)
+      define_singleton_method("#{name}=") do |value|
+        element_groups[index_of_element_group(name)][0] = value
+      end
+    end
+
+    def after_build; end
+  end
+end

data/lib/hbci/segment_factory.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Hbci
+  class SegmentFactory
+    def self.build(segment_data)
+      segment_class_name = "#{segment_data[0][0]}v#{segment_data[0][2]}"
+      segment_class = begin
+                        Object.const_get("Hbci::Segments::#{segment_class_name}")
+                      rescue StandardError
+                        Hbci::Segments::Unknown
+                      end
+      segment_class.fill(segment_data)
+    end
+  end
+end

data/lib/hbci/segments/hikaz.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Hbci
+  module Segments
+    class HIKAZv4 < Segment
+      element_group :head, type: ElementGroups::SegmentHead
+      element :booked
+      element :notbooked
+    end
+
+    class HIKAZv5 < Segment
+      element_group :head, type: ElementGroups::SegmentHead
+      element :booked
+      element :notbooked
+    end
+
+    class HIKAZv6 < Segment
+      element_group :head, type: ElementGroups::SegmentHead
+      element :booked
+      element :notbooked
+    end
+
+    class HIKAZv7 < Segment
+      element_group :head, type: ElementGroups::SegmentHead
+      element :booked
+      element :notbooked
+    end
+  end
+end