eac_tools 0.108.0 → 0.110.0

data/sub/aranha-parsers/aranha-parsers.gemspec

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-$LOAD_PATH.push File.expand_path('lib', __dir__)
-
-require 'aranha/parsers/version'
-
-Gem::Specification.new do |s|
-  s.name        = 'aranha-parsers'
-  s.version     = Aranha::Parsers::VERSION
-  s.authors     = ['Esquilo Azul Company']
-  s.summary     = 'Parsers\' utilities for Ruby.'
-
-  s.files = Dir['{lib}/**/*']
-  s.required_ruby_version = '>= 2.7'
-
-  s.add_dependency 'activesupport', '>= 4.0.0'
-  s.add_dependency 'addressable', '~> 2.8', '>= 2.8.8'
-  s.add_dependency 'aranha', '~> 0.20'
-  s.add_dependency 'eac_envs-http', '~> 0.7', '>= 0.7.1'
-  s.add_dependency 'eac_ruby_utils', '~> 0.129'
-  s.add_dependency 'nokogiri', '~> 1.19'
-  s.add_dependency 'ofx-parser', '~> 1.1'
-
-  s.add_development_dependency 'eac_ruby_gem_support', '~> 0.12', '>= 0.12.1'
-end

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

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require 'open-uri'
-require 'fileutils'
-
-module Aranha
-  module Parsers
-    class Base
-      class << self
-        # @deprecated Use {#from_string} instead.
-        # @param content [String]
-        # @return [Aranha::Parsers::Base]
-        def from_content(content)
-          from_string(content)
-        end
-
-        # @param string [String]
-        # @return [Aranha::Parsers::Base]
-        def from_string(string)
-          ::EacRubyUtils::Fs::Temp.on_file do |path|
-            ::File.open(path.to_s, 'w:UTF-8') do |f|
-              f.write string.dup.force_encoding('UTF-8')
-            end
-            r = new(path.to_path)
-            r.content
-            r
-          end
-        end
-      end
-
-      LOG_DIR_ENVVAR = 'ARANHA_PARSERS_LOG_DIR'
-
-      attr_reader :source_address
-
-      def initialize(url)
-        @source_address = ::Aranha::Parsers::SourceAddress.new(url)
-        log_content(source_address.serialize, '-source-address')
-      end
-
-      delegate :url, to: :source_address
-
-      def content
-        @content ||= log_content(source_address_content)
-      end
-
-      # @return [String, nil]
-      def content_encoding
-        nil
-      end
-
-      # @return [String]
-      def source_address_content
-        source_address.content.then do |r|
-          content_encoding.if_present(r) { |v| r.force_encoding(v) }
-        end
-      end
-
-      private
-
-      # @return [String]
-      def log_content(content, suffix = '')
-        path = log_file(suffix)
-
-        File.binwrite(path, content) if path
-
-        content
-      end
-
-      def log_file(suffix)
-        dir = log_parsers_dir
-        return nil unless dir
-
-        f = ::File.join(dir, "#{self.class.name.parameterize}#{suffix}.log")
-        FileUtils.mkdir_p(File.dirname(f))
-        f
-      end
-
-      def log_parsers_dir
-        return ENV[LOG_DIR_ENVVAR] if ENV[LOG_DIR_ENVVAR]
-        return ::Rails.root.join('log/parsers') if rails_root_exist?
-
-        nil
-      end
-
-      def rails_root_exist?
-        ::Rails.root
-        true
-      rescue NameError
-        false
-      end
-    end
-  end
-end

data/sub/aranha-parsers/lib/aranha/parsers/firefox/request_from_firefox.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Aranha
-  module Parsers
-    module Firefox
-      class RequestFromFirefox
-        BASE_URL_SUBPATH = 'base_url'
-        BODY_SUBPATH = 'body'
-        REQUEST_SUBPATH = 'request'
-
-        class << self
-          def from_directory(path)
-            path = path.to_pathname
-            body_path = path.join(BODY_SUBPATH)
-            new(
-              path.join(BASE_URL_SUBPATH).read.strip,
-              ::Aranha::Parsers::Firefox::RequestHeaderFromFirefox
-              .from_file(path.join(REQUEST_SUBPATH)),
-              body_path.file? ? body_path.read : nil
-            )
-          end
-        end
-
-        enable_simple_cache
-        common_constructor :the_base_uri, :header, :body, default: [nil] do
-          self.the_base_uri = the_base_uri.to_uri
-        end
-
-        def to_uri_source
-          {
-            method: header.verb,
-            url: url,
-            headers: header.headers,
-            body: body
-          }
-        end
-
-        def url
-          (the_base_uri + header.uri).to_s
-        end
-      end
-    end
-  end
-end

data/sub/aranha-parsers/lib/aranha/parsers/firefox/request_header_from_firefox.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module Aranha
-  module Parsers
-    module Firefox
-      class RequestHeaderFromFirefox
-        class << self
-          def from_file(path)
-            new(path.to_pathname.read)
-          end
-        end
-
-        FIRST_LINE_PARSER = /\A(\S+)\s(\S+)\s(\S+)\z/.to_parser do |m|
-          { verb: m[1], uri: m[2], version: m[3] }
-        end
-
-        HEADER_LINE_PARSER = /\A([^:]+):\s+(.+)\z/.to_parser do |m|
-          m[1..2]
-        end
-
-        enable_simple_cache
-
-        common_constructor :string
-
-        def to_h
-          %w[verb uri headers].index_with { |m| send(m) }
-        end
-
-        def headers
-          all_except_first_line.map { |line| HEADER_LINE_PARSER.parse!(line) }.to_h # rubocop:disable Style/MapToHash
-        end
-
-        def verb
-          parsed_first_line.fetch(:verb)
-        end
-
-        def uri
-          parsed_first_line.fetch(:uri)
-        end
-
-        private
-
-        def all_lines_uncached
-          string.each_line.map(&:strip)
-        end
-
-        def parsed_first_line_uncached
-          FIRST_LINE_PARSER.parse!(all_lines.first)
-        end
-
-        def all_except_first_line
-          all_lines[1..-1] # rubocop:disable Style/SlicingWithRange
-        end
-      end
-    end
-  end
-end

data/sub/aranha-parsers/lib/aranha/parsers/firefox/uri_from_har.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-
-module Aranha
-  module Parsers
-    module Firefox
-      class UriFromHar
-        class << self
-          def from_file(path)
-            new(::JSON.parse(path.to_pathname.read))
-          end
-        end
-
-        common_constructor :data
-
-        def result
-          data.fetch('log').fetch('entries').map { |e| e.fetch('request').fetch('url') }
-        end
-
-        def request_data; end
-      end
-    end
-  end
-end

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

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require 'nokogiri'
-
-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 node [String]
-          # @param klass [String]
-          # @return [String]
-          def xpath_contains_class(klass, node = '@class')
-            "contains(concat(' ', normalize-space(#{node}), ' '), ' #{klass} ')"
-          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,22 +0,0 @@
-# frozen_string_literal: true
-
-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,31 +0,0 @@
-# frozen_string_literal: true
-
-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.to_h do |f|
-              [f[0], parse_field(node, f[2], f[1])]
-            rescue StandardError => e
-              raise StandardError, "#{e.message}\nFields: #{f}"
-            end
-          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/miscellaneous_support.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Aranha
-  module Parsers
-    module Html
-      module Node
-        class Default < ::Aranha::Parsers::Html::Node::Base
-          module MiscellaneousSupport
-            # @param node [Nokogiri::XML::Node]
-            # @param xpath [String]
-            # @return [Boolean]
-            def boolean_value(node, xpath)
-              node_value(node, xpath).to_bool
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Aranha
-  module Parsers
-    module Html
-      module Node
-        class Default < ::Aranha::Parsers::Html::Node::Base
-          module NodesSupport
-            # @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
-end

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

@@ -1,154 +0,0 @@
-# frozen_string_literal: true
-
-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
-
-            # @param node [Nokogiri::XML::Element]
-            # @param xpath [String]
-            # @return [Integer]
-            def integer_comma_value(node, xpath)
-              decimal_comma_value(node, xpath).to_i
-            end
-
-            # @param node [Nokogiri::XML::Element]
-            # @param xpath [String]
-            # @return [Integer]
-            def integer_comma_optional_value(node, xpath)
-              decimal_comma_optional_value(node, xpath).to_i
-            end
-
-            # @param node [Nokogiri::XML::Element]
-            # @param xpath [String]
-            # @return [Integer]
-            def integer_dot_value(node, xpath)
-              decimal_dot_value(node, xpath).to_i
-            end
-
-            # @param node [Nokogiri::XML::Element]
-            # @param xpath [String]
-            # @return [Integer]
-            def integer_dot_optional_value(node, xpath)
-              decimal_dot_optional_value(node, xpath).to_i
-            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,74 +0,0 @@
-# frozen_string_literal: true
-
-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) # rubocop:disable Style/OptionalBooleanParameter
-              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,20 +0,0 @@
-# frozen_string_literal: true
-
-module Aranha
-  module Parsers
-    module Html
-      module Node
-        class Default < ::Aranha::Parsers::Html::Node::Base
-          require_sub __FILE__, include_modules: true
-
-          # @param node [Nokogiri::XML::Node]
-          # @param xpath [String]
-          # @return [Boolean]
-          def boolean_value(node, xpath)
-            node_value(node, xpath).to_bool
-          end
-        end
-      end
-    end
-  end
-end