ehbrs-tools 0.16.0 → 0.16.5

data/vendor/aranha-parsers/lib/aranha/parsers/html.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+
+module Aranha
+  module Parsers
+    module Html
+      ::EacRubyUtils.require_sub __FILE__
+    end
+  end
+end

data/vendor/aranha-parsers/lib/aranha/parsers/html/base.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'aranha/parsers/base'
+require 'aranha/parsers/html/node/default'
+
+module Aranha
+  module Parsers
+    module Html
+      class Base < ::Aranha::Parsers::Base
+        class << self
+          def fields
+            @fields ||= []
+            @fields.dup
+          end
+
+          def field(name, type, xpath)
+            @fields ||= []
+            @fields << Field.new(name, type, xpath)
+          end
+
+          Field = Struct.new(:name, :type, :xpath)
+        end
+
+        def nokogiri
+          @nokogiri ||= Nokogiri::HTML(content, &:noblanks)
+        end
+
+        protected
+
+        def node_parser_class
+          ::Aranha::Parsers::Html::Node::Default
+        end
+
+        private
+
+        def node_parser
+          @node_parser ||= node_parser_class.new(fields)
+        end
+
+        def fields
+          self.class.fields.map { |f| [f.name, f.type, f.xpath] }
+        end
+      end
+    end
+  end
+end

data/vendor/aranha-parsers/lib/aranha/parsers/html/item.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'aranha/parsers/html/base'
+
+module Aranha
+  module Parsers
+    module Html
+      class Item < Base
+        def data
+          @data ||= node_parser.parse(item_node)
+        end
+
+        def item_node
+          @item_node ||= begin
+            r = item_xpath ? nokogiri.at_xpath(item_xpath) : nokogiri
+            raise "Item node not found (Item xpath: #{item_xpath})" unless r
+
+            r
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/aranha-parsers/lib/aranha/parsers/html/item_list.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'aranha/parsers/html/base'
+
+module Aranha
+  module Parsers
+    module Html
+      class ItemList < Base
+        def data
+          items_data
+        end
+
+        def items_data
+          count = 0
+          @data ||= nokogiri.xpath(items_xpath).map do |m|
+            count += 1
+            node_parser.parse(m)
+          end
+        rescue StandardError => e
+          raise StandardError, "#{e.message} (Count: #{count})"
+        end
+
+        def items_xpath
+          raise "Class #{self.class} has no method \"#{__method__}\". Implement it"
+        end
+      end
+    end
+  end
+end

data/vendor/aranha-parsers/lib/aranha/parsers/html/node.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+
+module Aranha
+  module Parsers
+    module Html
+      module Node
+        ::EacRubyUtils.require_sub __FILE__
+      end
+    end
+  end
+end

data/vendor/aranha-parsers/lib/aranha/parsers/html/node/base.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Aranha
+  module Parsers
+    module Html
+      module Node
+        class Base
+          attr_reader :fields
+
+          def initialize(fields)
+            @fields = fields
+          end
+
+          def parse(node)
+            fields.map do |f|
+              begin
+                [f[0], parse_field(node, f[2], f[1])]
+              rescue StandardError => e
+                raise StandardError, "#{e.message}\nFields: #{f}"
+              end
+            end.to_h
+          end
+
+          private
+
+          def parse_field(node, xpath, parser_method)
+            value_method = "#{parser_method}_value"
+            return send(value_method, node, xpath) if respond_to?(value_method)
+
+            raise "Method \"#{value_method}\" not found in #{self.class}"
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/aranha-parsers/lib/aranha/parsers/html/node/default.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'aranha/parsers/html/node/base'
+
+module Aranha
+  module Parsers
+    module Html
+      module Node
+        class Default < ::Aranha::Parsers::Html::Node::Base
+          def string_value(node, xpath)
+            if node.at_xpath(xpath)
+              sanitize_string(node.at_xpath(xpath).text)
+            else
+              ''
+            end
+          end
+
+          def string_recursive_value(node, xpath, required = true)
+            root = node.at_xpath(xpath)
+            if root.blank?
+              return nil unless required
+
+              raise "No node found (Xpath: #{xpath})"
+            end
+            result = string_recursive(root)
+            return result if result.present?
+            return nil unless required
+
+            raise "String blank (Xpath: #{xpath})"
+          end
+
+          def string_recursive_optional_value(node, xpath)
+            string_recursive_value(node, xpath, false)
+          end
+
+          def quoted_value(node, xpath)
+            s = string_value(node, xpath)
+            return '' unless s
+
+            m = /\"([^\"]+)\"/.match(s)
+            return m[1] if m
+
+            ''
+          end
+
+          def integer_value(node, xpath)
+            r = string_value(node, xpath)
+            return nil if r.blank?
+
+            m = /\d+/.match(r)
+            raise "Integer not found in \"#{r}\"" unless m
+
+            m[0].to_i
+          end
+
+          def integer_optional_value(node, xpath)
+            r = string_value(node, xpath)
+            m = /\d+/.match(r)
+            m ? m[0].to_i : nil
+          end
+
+          def float_value(node, xpath)
+            parse_float(node, xpath, true)
+          end
+
+          def float_optional_value(node, xpath)
+            parse_float(node, xpath, false)
+          end
+
+          def array_value(node, xpath)
+            r = node.xpath(xpath).map { |n| n.text.strip }
+            r.join('|')
+          end
+
+          def join_value(node, xpath)
+            m = ''
+            node.xpath(xpath).each do |n|
+              m << n.text.strip
+            end
+            m
+          end
+
+          def duration_value(node, xpath)
+            m = /(\d+) m/.match(join_value(node, xpath))
+            m ? m[1].to_i : nil
+          end
+
+          def regxep(node, xpath, pattern)
+            s = string_value(node, xpath)
+            m = pattern.match(s)
+            return m if m
+
+            raise "Pattern \"#{pattern}\" not found in string \"#{s}\""
+          end
+
+          private
+
+          def parse_float(node, xpath, required)
+            s = string_value(node, xpath)
+            m = /\d+(?:[\.\,](\d+))?/.match(s)
+            if m
+              m[0].delete('.').tr(',', '.').to_f
+            elsif required
+              raise "Float value not found in \"#{s}\""
+            end
+          end
+
+          def sanitize_string(obj)
+            obj.to_s.tr("\u00A0", ' ').strip
+          end
+
+          def string_recursive(node)
+            return sanitize_string(node.text) if node.is_a?(::Nokogiri::XML::Text)
+
+            s = ''
+            node.children.each do |child|
+              child_s = string_recursive(child)
+              s += ' ' + child_s if child_s.present?
+            end
+            sanitize_string(s)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/aranha-parsers/lib/aranha/parsers/invalid_state_exception.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Aranha
+  module Parsers
+    class InvalidStateException < StandardError
+    end
+  end
+end

data/vendor/aranha-parsers/lib/aranha/parsers/patches.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+
+module Aranha
+  module Parsers
+    module Patches
+      ::EacRubyUtils.require_sub __FILE__
+    end
+  end
+end

data/vendor/aranha-parsers/lib/aranha/parsers/patches/ofx_parser.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'ofx-parser'
+
+module Aranha
+  module Parsers
+    module Patches
+      module OfxParser
+        module OfxParser
+          def self.included(base)
+            base.class_eval do
+              class << self
+                prepend ClassMethods
+              end
+            end
+          end
+
+          module ClassMethods
+            def build_transaction(transaction)
+              r = super
+              r.currate = (transaction / 'CURRENCY/CURRATE').inner_text
+              r
+            end
+          end
+        end
+
+        module Transaction
+          attr_accessor :currate, :cursym
+        end
+      end
+    end
+  end
+end
+
+require 'eac_ruby_utils/patch'
+
+::EacRubyUtils.patch(::OfxParser::OfxParser, ::Aranha::Parsers::Patches::OfxParser::OfxParser)
+::EacRubyUtils.patch(::OfxParser::Transaction, ::Aranha::Parsers::Patches::OfxParser::Transaction)

data/vendor/aranha-parsers/lib/aranha/parsers/source_address.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/delegation'
+require 'eac_ruby_utils/require_sub'
+require 'yaml'
+
+module Aranha
+  module Parsers
+    class SourceAddress
+      ::EacRubyUtils.require_sub __FILE__
+
+      class << self
+        SUBS = [
+          ::Aranha::Parsers::SourceAddress::HashHttpGet,
+          ::Aranha::Parsers::SourceAddress::HashHttpPost,
+          ::Aranha::Parsers::SourceAddress::HttpGet,
+          ::Aranha::Parsers::SourceAddress::File
+        ].freeze
+
+        def detect_sub(source)
+          return source.sub if source.is_a?(self)
+
+          SUBS.each do |sub|
+            return sub.new(source) if sub.valid_source?(source)
+          end
+          raise "No content fetcher found for source \"#{source}\""
+        end
+
+        def deserialize(string)
+          new(string =~ %r{\A[a-z]+://} ? string.strip : ::YAML.load(string)) # rubocop:disable Security/YAMLLoad
+        end
+
+        def from_file(path)
+          deserialize(::File.read(path))
+        end
+      end
+
+      attr_reader :sub
+
+      def initialize(source)
+        @sub = self.class.detect_sub(source)
+      end
+
+      delegate :content, :url, to: :sub
+
+      def to_s
+        sub.url
+      end
+
+      def serialize
+        sub.serialize.strip + "\n"
+      end
+    end
+  end
+end

data/vendor/aranha-parsers/lib/aranha/parsers/source_address/file.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'aranha/parsers/source_address/http_get'
+
+module Aranha
+  module Parsers
+    class SourceAddress
+      class File < ::Aranha::Parsers::SourceAddress::HttpGet
+        SCHEME = 'file://'
+
+        class << self
+          def valid_source?(source)
+            source.to_s.start_with?(SCHEME + '/', '/')
+          end
+        end
+
+        def initialize(source)
+          super source.to_s.gsub(/\A#{Regexp.quote(SCHEME)}/, '')
+        end
+
+        def url
+          "#{SCHEME}#{source}"
+        end
+
+        def content
+          ::File.open(source, &:read)
+        end
+      end
+    end
+  end
+end

data/vendor/aranha-parsers/lib/aranha/parsers/source_address/hash_http_get.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'aranha/parsers/source_address/hash_http_post'
+
+module Aranha
+  module Parsers
+    class SourceAddress
+      class HashHttpGet < ::Aranha::Parsers::SourceAddress::HashHttpPost
+        class << self
+          def valid_source?(source)
+            source.is_a?(::Hash) &&
+              source.with_indifferent_access[:method].to_s.downcase.strip == 'get'
+          end
+        end
+
+        def content
+          HTTPClient.new.get_content(
+            source[:url],
+            source[:params]
+          )
+        end
+      end
+    end
+  end
+end