eac_tools 0.69.0 → 0.70.0

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

@@ -1,61 +0,0 @@
-# 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
-
-          # @param node [Nokogiri::XML::Node]
-          # @return [Aranha::Parsers::Html::Base]
-          def from_node(node)
-            from_string(node.to_html)
-          end
-
-          # @param haystack [String]
-          # @param needle [String]
-          # @return [String]
-          def xpath_ends_with(haystack, needle)
-            "substring(#{haystack}, string-length(#{haystack}) - string-length(#{needle}) + 1) " \
-              "= #{needle}"
-          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/sub/aranha-parsers/lib/aranha/parsers/html/item.rb

@@ -1,24 +0,0 @@
-# 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/sub/aranha-parsers/lib/aranha/parsers/html/item_list.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'aranha/parsers/html/base'
-
-module Aranha
-  module Parsers
-    module Html
-      class ItemList < Base
-        def data
-          items_data
-        end
-
-        def item_data(item)
-          item
-        end
-
-        def items_data
-          count = 0
-          @data ||= nokogiri.xpath(items_xpath).map do |m|
-            count += 1
-            item_data(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/sub/aranha-parsers/lib/aranha/parsers/html/node/base.rb

@@ -1,34 +0,0 @@
-# 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|
-              [f[0], parse_field(node, f[2], f[1])]
-            rescue StandardError => e
-              raise StandardError, "#{e.message}\nFields: #{f}"
-            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/sub/aranha-parsers/lib/aranha/parsers/html/node/default/numeric_support.rb

@@ -1,129 +0,0 @@
-# frozen_string_literal: true
-
-require 'aranha/parsers/html/node/base'
-require 'eac_ruby_utils/core_ext'
-
-module Aranha
-  module Parsers
-    module Html
-      module Node
-        class Default < ::Aranha::Parsers::Html::Node::Base
-          module NumericSupport
-            # @param node [Nokogiri::XML::Element]
-            # @param xpath [String]
-            # @return [Float]
-            def decimal_comma_value(node, xpath)
-              parse_decimal_comma(node, xpath, true)
-            end
-
-            # @param node [Nokogiri::XML::Element]
-            # @param xpath [String]
-            # @return [Float, nil]
-            def decimal_comma_optional_value(node, xpath)
-              parse_decimal_comma(node, xpath, false)
-            end
-
-            # @param node [Nokogiri::XML::Element]
-            # @param xpath [String]
-            # @return [Float]
-            def decimal_dot_value(node, xpath)
-              parse_decimal_dot(node, xpath, true)
-            end
-
-            # @param node [Nokogiri::XML::Element]
-            # @param xpath [String]
-            # @return [Float, nil]
-            def decimal_dot_optional_value(node, xpath)
-              parse_decimal_dot(node, xpath, false)
-            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
-
-            # @deprecated Use {#decimal_dot_value} instead.
-            # @param node [Nokogiri::XML::Element]
-            # @param xpath [String]
-            # @return [Float]
-            def us_decimal_value(node, xpath)
-              decimal_dot_value(node, xpath)
-            end
-
-            # @deprecated Use {#decimal_dot_optional_value} instead.
-            # @param node [Nokogiri::XML::Element]
-            # @param xpath [String]
-            # @return [Float, nil]
-            def us_decimal_optional_value(node, xpath)
-              decimal_dot_optional_value(node, xpath)
-            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
-
-            # @param node [Nokogiri::XML::Element]
-            # @param xpath [String]
-            # @param required [Boolean]
-            # @param separator [String]
-            # @param delimiter [String]
-            # @return [Float, nil]
-            def parse_decimal(node, xpath, required, separator, delimiter)
-              s = string_value(node, xpath)
-              m = /\d+(?:[#{::Regexp.quote(separator + delimiter)}](\d+))?/.match(s)
-              if m
-                m[0].delete(delimiter).to_f
-              elsif required
-                raise "decimal [Separator=\"#{separator}, Delimiter=\"#{delimiter}\"] value not " \
-                  "found in \"#{s}\""
-              end
-            end
-
-            # @param node [Nokogiri::XML::Element]
-            # @param xpath [String]
-            # @param required [Boolean]
-            # @return [Float, nil]
-            def parse_decimal_dot(node, xpath, required)
-              parse_decimal(node, xpath, required, '.', ',')
-            end
-
-            # @param node [Nokogiri::XML::Element]
-            # @param xpath [String]
-            # @param required [Boolean]
-            # @return [Float, nil]
-            def parse_decimal_comma(node, xpath, required)
-              parse_decimal(node, xpath, required, ',', '.')
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/sub/aranha-parsers/lib/aranha/parsers/html/node/default/string_support.rb

@@ -1,77 +0,0 @@
-# frozen_string_literal: true
-
-require 'aranha/parsers/html/node/base'
-require 'eac_ruby_utils/core_ext'
-
-module Aranha
-  module Parsers
-    module Html
-      module Node
-        class Default < ::Aranha::Parsers::Html::Node::Base
-          module StringSupport
-            def quoted_value(node, xpath)
-              s = string_value(node, xpath)
-              return '' unless s
-
-              m = /\"([^\"]+)\"/.match(s)
-              return m[1] if m
-
-              ''
-            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
-
-            # @param node [Nokogiri::XML::Node]
-            # @param xpath [String]
-            # @return [String]
-            def string_value(node, xpath)
-              found = node_value(node, xpath)
-              found ? sanitize_string(found.text) : ''
-            end
-
-            def string_recursive_value(node, xpath, required = true)
-              root = node_value(node, 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
-
-            private
-
-            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
-end

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

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'aranha/parsers/html/node/base'
-require 'eac_ruby_utils/core_ext'
-
-module Aranha
-  module Parsers
-    module Html
-      module Node
-        class Default < ::Aranha::Parsers::Html::Node::Base
-          require_sub __FILE__, include_modules: true
-
-          def join_value(node, xpath)
-            m = ''
-            node_set_value(node, 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
-
-          # @param node [Nokogiri::XML::Node]
-          # @param xpath [String]
-          # @return [Nokogiri::XML::NodeSet]
-          def node_set_value(node, xpath)
-            node.xpath(xpath)
-          end
-
-          # @param node [Nokogiri::XML::Node]
-          # @param xpath [String]
-          # @return [Nokogiri::XML::Node]
-          def node_value(node, xpath)
-            node.at_xpath(xpath)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-# 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/sub/aranha-parsers/lib/aranha/parsers/html.rb

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

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

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

data/sub/aranha-parsers/lib/aranha/parsers/json/base.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'aranha/parsers/base'
-require 'json'
-
-module Aranha
-  module Parsers
-    module Json
-      class Base < ::Aranha::Parsers::Base
-        def data
-          default_data
-        end
-
-        def default_data
-          ::JSON.parse(content)
-        end
-      end
-    end
-  end
-end

data/sub/aranha-parsers/lib/aranha/parsers/json.rb

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

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

@@ -1,38 +0,0 @@
-# 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/sub/aranha-parsers/lib/aranha/parsers/patches.rb

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

data/sub/aranha-parsers/lib/aranha/parsers/rspec/setup.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module Aranha
-  module Parsers
-    module Rspec
-      module Setup
-        def self.extended(_setup_obj)
-          require 'aranha/parsers/rspec/shared_examples/source_target_fixtures'
-        end
-      end
-    end
-  end
-end

data/sub/aranha-parsers/lib/aranha/parsers/rspec/shared_examples/source_target_fixtures.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require 'aranha/parsers/rspec/source_target_fixtures_controller'
-require 'aranha/parsers/source_target_fixtures'
-require 'yaml'
-
-RSpec.shared_examples 'source_target_fixtures' do |spec_file| # rubocop:disable Metrics/BlockLength
-  fixtures_controller = ::Aranha::Parsers::Rspec::SourceTargetFixturesController
-                          .new(self, spec_file)
-
-  let(:fixtures_controller) { fixtures_controller }
-  let(:spec_file) { spec_file }
-
-  it 'fixtures directory should exist' do
-    expect(::File.directory?(fixtures_controller.fixtures_dir)).to be true
-  end
-
-  context 'with fixtures directory' do
-    it 'has at least one file' do
-      expect(source_target_fixtures.source_target_files.count).to be > 0 # rubocop:disable Style/NumericPredicate
-    end
-
-    fixtures_controller.source_target_fixtures.source_target_files.each do |st|
-      context "when source file is \"#{::File.basename(st.source)}\"" do
-        if fixtures_controller.write_target_fixtures?
-          it 'writes target data' do
-            sd = sort_results(source_data(st.source))
-            basename = ::Aranha::Parsers::SourceTargetFixtures.source_target_basename(st.source)
-            target_file = File.expand_path("../#{basename}.target#{target_file_extname}", st.source)
-            File.write(target_file, target_content(sd))
-          end
-        else
-          it 'parses data' do
-            assert_source_target_complete(st)
-            sd = source_data(st.source)
-            td = target_data(st.target)
-            expect(sort_results(sd)).to eq(sort_results(td))
-          end
-        end
-      end
-    end
-  end
-
-  delegate :source_target_fixtures, to: :fixtures_controller
-
-  def assert_source_target_complete(source_target)
-    expect(source_target.source).to(be_truthy, "Source not found (Target: #{source_target.target})")
-    expect(source_target.target).to(be_truthy, "Target not found (Source: #{source_target.source})")
-  end
-
-  def source_data(source_file)
-    instance = described_class.new(source_file)
-    return instance.data if instance.respond_to?(:data)
-
-    raise "#{instance} has no \"data\" method. You need to implement \"#{instance}.data\" or " \
-      "\"#{self}.source_data(source_file)\""
-  end
-
-  def sort_results(results)
-    results
-  end
-
-  def target_data(target_file)
-    ::YAML.load_file(target_file)
-  end
-
-  def target_content(data)
-    data.to_yaml
-  end
-
-  def target_file_extname
-    '.yaml'
-  end
-end

data/sub/aranha-parsers/lib/aranha/parsers/rspec/source_target_fixtures_controller.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'eac_ruby_utils/core_ext'
-
-module Aranha
-  module Parsers
-    module Rspec
-      class SourceTargetFixturesController
-        enable_simple_cache
-        common_constructor :example, :spec_file
-
-        def default_fixtures_dir
-          ::File.join(
-            ::File.dirname(spec_file),
-            ::File.basename(spec_file, '.*') + '_files'
-          )
-        end
-
-        def fixtures_dir
-          if example.respond_to?(:fixtures_dir)
-            example.fixtures_dir
-          else
-            default_fixtures_dir
-          end
-        end
-
-        def write_target_fixtures?
-          ENV['WRITE_TARGET_FIXTURES'].to_bool
-        end
-
-        private
-
-        def source_target_fixtures_uncached
-          ::Aranha::Parsers::SourceTargetFixtures.new(fixtures_dir)
-        end
-      end
-    end
-  end
-end

data/sub/aranha-parsers/lib/aranha/parsers/rspec.rb

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

data/sub/aranha-parsers/lib/aranha/parsers/source_address/fetch_content_error.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module Aranha
-  module Parsers
-    class SourceAddress
-      class FetchContentError < ::RuntimeError
-        attr_reader :request
-
-        def initialize(msg, request)
-          super(msg)
-          @request = request
-        end
-      end
-    end
-  end
-end