aspera-cli 4.26.2 → 4.27.1

data/lib/aspera/schema/documentation.rb

@@ -7,6 +7,15 @@ module Aspera
   module Schema
     # Generate documentation from Schema, for Transfer Spec, or async Conf spec
     class Documentation
+      # Map JSON Schema type names to user-friendly display names
+      JSON_TYPE_TO_DOC = {
+        'string'  => 'String',
+        'integer' => 'Integer',
+        'number'  => 'Number',
+        'boolean' => 'Bool',
+        'array'   => 'Array',
+        'object'  => 'Hash'
+      }.freeze
       # @param formatter [Cli::Formatter] Formatter instance with methods: markdown_text, tick, check_row
       # @param schema [Reader]
       # @param include_option [Boolean] `true`: include CLI options (switches, env vars) in descriptions
@@ -18,25 +27,27 @@ module Aspera
         @include_option = include_option
         @agent_columns = agent_columns
         @code_highlight = code_highlight
-        @columns = %i[name type description]
-        @columns.insert(-2, *Agent::Factory::ALL.values.map{ |i| i[:short]}.sort) if @agent_columns
-        # @type [Array<Hash<Symbol,String>>]
-        @rows = []
+        @columns = %w[name type description]
+        @columns.insert(-2, *Agent::Factory::ALL.values.map { |i| i[:short].to_s }.sort) if @agent_columns
+        # Sections: each entry is {header: row_or_nil, rows: []}
+        # A flat schema produces a single section with no header.
+        @sections = [{header: nil, rows: []}]
       end
 
       def rows
-        @rows.sort_by{ |i| i[:name]}
+        @sections.flat_map do |section|
+          sorted = section[:rows].sort_by { |i| i['name'] }
+          section[:header] ? [section[:header]] + sorted : sorted
+        end
       end
 
       # @return [Array<String>]
-      def columns
-        @columns.map(&:to_s)
-      end
+      attr_reader :columns
 
-      # First row is the titles
+      # First row is the titles (for Markdown table generation)
       # @return [Array<Array<String>>]
       def table
-        [@columns.map(&:to_s)] + @rows.sort_by{ |i| i[:name]}.map{ |row| @columns.map{ |field| row[field]}}
+        [@columns] + rows.map { |row| @columns.map { |field| row[field] } }
       end
 
       # Generate a documentation table from a JSON schema for transfer specifications
@@ -47,39 +58,65 @@ module Aspera
       # @param schema [Reader] The JSON schema to process
       # @return [Documentation]
       def build(schema = nil)
-        code = @code_highlight ? ->(c){"`#{c}`"} : ->(c){c}
+        code = @code_highlight ? ->(c) { "`#{c}`" } : ->(c) { c }
         schema ||= @schema
-        schema.each_property do |property_schema, _name, property_full_name|
+        render_title = ->(title) { title.gsub(Markdown::FORMATS) { @formatter.markdown_text(Regexp.last_match) } }
+        on_variant = ->(variant_reader, discriminant_property, discriminant_value) do
+          title = variant_reader.current['title'] || variant_reader.current['description']
+          header =
+            if discriminant_property && discriminant_value
+              desc = render_title.call("`#{discriminant_value}`")
+              desc += ": #{render_title.call(title)}" if title
+              @formatter.check_row({
+                'name'        => render_title.call("**#{discriminant_property}**"),
+                'type'        => code.call(JSON_TYPE_TO_DOC['string']),
+                'description' => desc
+              })
+            elsif title
+              @formatter.check_row({'name' => "**#{render_title.call(title)}**", 'type' => '&nbsp;', 'description' => '&nbsp;'})
+            end
+          @sections.push({header: header, rows: []})
+        end
+        schema.each_property(on_variant: on_variant) do |property_schema, _name, property_full_name|
           node = property_schema.current
           # Manual table
+          item_type =
+            if node['type'].is_a?(Array)
+              node['type'].map { |t| JSON_TYPE_TO_DOC.fetch(t, t) }.join(', ')
+            elsif node['type'].eql?('array') && node.dig('items', 'type').is_a?(String)
+              "#{JSON_TYPE_TO_DOC.fetch(node['type'], node['type'])}[#{JSON_TYPE_TO_DOC.fetch(node.dig('items', 'type'), node.dig('items', 'type'))}]"
+            else
+              JSON_TYPE_TO_DOC.fetch(node['type'], node['type'])
+            end
           item = {
-            name:        code.call(property_full_name),
-            type:        code.call(node['type']),
-            description: []
+            'name'        => code.call(property_full_name),
+            'type'        => code.call(item_type),
+            'description' => []
           }
           # Render Markdown formatting and split lines
-          item[:description] =
+          item['description'] =
             node['description']
-              .gsub(Markdown::FORMATS){@formatter.markdown_text(Regexp.last_match)}
+              .gsub(Markdown::FORMATS) { @formatter.markdown_text(Regexp.last_match) }
               .split("\n") if node.key?('description')
-          item[:description].unshift("DEPRECATED: #{node['x-deprecation']}") if node.key?('x-deprecation')
+          item['description'].unshift("DEPRECATED: #{node['x-deprecation']}") if node.key?('x-deprecation')
           # Add flags for supported agents in doc
           agents = []
           Agent::Factory::ALL.each_key do |sym|
             agents.push(sym) if node['x-agents'].nil? || node['x-agents'].include?(sym.to_s)
           end
-          Aspera.assert(agents.include?(:direct)){"#{name}: x-cli-option requires agent direct (or nil)"} if node['x-cli-option']
+          Aspera.assert(agents.include?(:direct)) { "#{property_full_name}: x-cli-option requires agent direct (or nil)" } if node['x-cli-option']
           if @agent_columns
             Agent::Factory::ALL.each do |sym, names|
-              item[names[:short]] = @formatter.tick(agents.include?(sym))
+              item[names[:short].to_s] = @formatter.tick(agents.include?(sym))
             end
           else
-            item[:description].push("(#{agents.map{ |i| Agent::Factory::ALL[i][:short].to_s.upcase}.sort.join(', ')})") unless agents.length.eql?(Agent::Factory::ALL.length)
+            item['description'].push("(#{agents.map { |i| Agent::Factory::ALL[i][:short].to_s.upcase }.sort.join(', ')})") unless agents.length.eql?(Agent::Factory::ALL.length)
           end
           # Only keep lines that are usable in supported agents
-          next false if agents.empty?
-          item[:description].push("Allowed values: #{node['enum'].map{ |v| @formatter.markdown_text("`#{v}`")}.join(', ')}.") if node.key?('enum')
-          item[:description].push("Default: #{code.call(node['default'])}.") if node.key?('default')
+          next if agents.empty?
+          item['description'].push("Allowed values: #{node['enum'].map { |v| @formatter.markdown_text("`#{v}`") }.join(', ')}.") if node.key?('enum')
+          item['description'].push("Default: #{@formatter.markdown_text("`#{node['default']}`")}.") if node.key?('default')
+          item['description'].push("Example: #{@formatter.markdown_text("`#{node['example']}`")}.") if node.key?('example')
           if @include_option
             envvar_prefix = ''
             cli_option =
@@ -87,18 +124,18 @@ module Aspera
                 envvar_prefix = 'env:'
                 node['x-cli-envvar']
               elsif node['x-cli-switch']
-                node['x-cli-option']
+                false_part = node.key?('x-cli-false') ? " / #{node['x-cli-false']}" : ''
+                "#{node['x-cli-option']}#{false_part}"
               elsif node['x-cli-option']
                 arg_type = node.key?('enum') ? '{enum}' : "{#{[node['type']].flatten.join('|')}}"
-                # conversion_tag = node['x-cli-convert']
                 conversion_tag = node.key?('x-cli-convert') ? 'conversion' : nil
                 sep = node['x-cli-option'].start_with?('--') ? '=' : ' '
                 "#{node['x-cli-option']}#{sep}#{"(#{conversion_tag})" if conversion_tag}#{arg_type}"
               end
             short = node.key?('x-cli-short') ? "(#{node['x-cli-short']})" : nil
-            item[:description].push("(#{'special:' if node['x-cli-special']}#{envvar_prefix}#{@formatter.markdown_text("`#{cli_option}`")})#{short}") if cli_option
+            item['description'].push("(#{'special:' if node['x-cli-special']}#{envvar_prefix}#{@formatter.markdown_text("`#{cli_option}`")})#{short}") if cli_option
           end
-          @rows.push(@formatter.check_row(item))
+          @sections.last[:rows].push(@formatter.check_row(item))
         end
         self
       end

data/lib/aspera/schema/reader.rb

@@ -7,11 +7,34 @@ module Aspera
     class Reader
       attr_reader :current
 
+      class << self
+        # Build a synthetic Reader from an OAS `parameters` array (entries with `in: query`).
+        # Produces a JSON Schema object whose `properties` map each query param name to its schema,
+        # with the OAS-level `description` and `required` merged in.
+        # @param params [Array<Hash>] raw OAS parameter objects (may contain path/header params too)
+        # @return [Reader]
+        def from_query_params(params)
+          properties = {}
+          required_names = []
+          params.each do |param|
+            next unless param['in'] == 'query'
+            name = param['name']
+            prop = (param['schema'] || {}).dup
+            prop['description'] = param['description'] if param['description'] && !prop.key?('description')
+            properties[name] = prop
+            required_names << name if param['required']
+          end
+          synthetic = {'type' => 'object', 'properties' => properties}
+          synthetic['required'] = required_names unless required_names.empty?
+          new(synthetic)
+        end
+      end
+
       # Shortcut to access current value at path
-      # @param x [String] path element
+      # @param key [String] path element
       # @return [Hash, Array, String, Integer] current value at path
-      def [](x)
-        @current[x]
+      def [](key)
+        @current[key]
       end
 
       # Find sub path relative to current
@@ -19,18 +42,24 @@ module Aspera
       def dig(*path)
         current = @current
         path.each do |p|
-          Aspera.assert(current.key?(p)){"schema: #{p} in #{path}"}
+          Aspera.assert(current.key?(p)) { "schema: #{p} in #{path}" }
           current = current[p]
-          Aspera.assert_type(current, Hash){'schema'}
+          Aspera.assert_type(current, Hash) { 'schema' }
           if current.key?('$ref')
             ref = current['$ref']
-            Aspera.assert(ref.start_with?('#/')){"schema $ref must start with '#/': #{ref}"}
+            Aspera.assert(ref.start_with?('#/')) { "schema $ref must start with '#/': #{ref}" }
             current = @root.dig(*ref[2..].split('/'))
           end
         end
         Reader.new(@root, current)
       end
 
+      # Resolve a $ref string to a Reader
+      def resolve_ref(ref)
+        Aspera.assert(ref.start_with?('#/')) { "schema $ref must start with '#/': #{ref}" }
+        Reader.new(@root, @root.dig(*ref[2..].split('/')))
+      end
+
       # Read schema from file or from cache
       # @param root [Hash] root schema
       # @param current [Hash, nil] current position in
@@ -40,15 +69,44 @@ module Aspera
         @current = current || root
       end
 
-      # Recursively traverse schema properties with a block
-      # Handles nested objects and arrays automatically
-      # @param prefix [String] Prefix for property names (e.g., 'parent.child.')
+      # Recursively traverse schema properties with a block.
+      # If the current node has `oneOf`, each variant is traversed in turn and
+      # `on_variant` is called (if given) before each variant's properties.
+      # @param prefix     [String] Prefix for property names (e.g., 'parent.child.')
+      # @param on_variant [Proc, nil] Called with the variant Reader before its properties
       # @yield [property_schema, name, full_name] Yields property info to block
-      # @yieldparam property_schema [Reader] Schema reader for this property (use .current to get node hash)
+      # @yieldparam property_schema [Reader] Schema reader for this property
       # @yieldparam name [String] Property name
       # @yieldparam full_name [String] Full property name with prefix
       # @return [nil]
-      def each_property(prefix = '', &block)
+      def each_property(prefix = '', on_variant: nil, &block)
+        if @current.key?('oneOf')
+          # Build reverse map: $ref -> discriminant value, from discriminator.mapping if present
+          discriminant_by_ref = {}
+          if @current.dig('discriminator', 'mapping').is_a?(Hash)
+            @current['discriminator']['mapping'].each do |value, ref|
+              discriminant_by_ref[ref] = value
+            end
+          end
+          discriminant_property = @current.dig('discriminator', 'propertyName')
+          @current['oneOf'].each do |variant_node|
+            ref = variant_node['$ref']
+            variant_reader = ref ? resolve_ref(ref) : Reader.new(@root, variant_node)
+            discriminant_value = ref ? discriminant_by_ref[ref] : nil
+            on_variant&.call(variant_reader, discriminant_property, discriminant_value)
+            variant_reader.each_property(prefix, on_variant: on_variant, &block)
+          end
+          return
+        end
+        if @current.key?('allOf')
+          # Merge all branches: each branch contributes its properties (no variants)
+          @current['allOf'].each do |branch_node|
+            ref = branch_node['$ref']
+            branch_reader = ref ? resolve_ref(ref) : Reader.new(@root, branch_node)
+            branch_reader.each_property(prefix, on_variant: on_variant, &block)
+          end
+          return
+        end
         properties = dig('properties')
         properties.current.each_key do |name|
           property_full_name = "#{prefix}#{name}"
@@ -61,13 +119,78 @@ module Aspera
           # Recursively process nested structures
           case node['type']
           when 'object'
-            property_schema.each_property("#{property_full_name}.", &block) if node['properties']
+            property_schema.each_property("#{property_full_name}.", on_variant: on_variant, &block) if node['properties']
           when 'array'
             if node['items']
               array_item_schema = property_schema.dig('items')
-              array_item_schema.each_property("#{property_full_name}[].", &block) if array_item_schema.current['properties']
+              array_item_schema.each_property("#{property_full_name}[].", on_variant: on_variant, &block) if array_item_schema.current['properties']
+            end
+          end
+          # allOf without explicit type: object — recurse to merge all branches
+          property_schema.each_property("#{property_full_name}.", on_variant: on_variant, &block) if node['allOf']
+        end
+      end
+
+      # Convert this schema to a flat array of field descriptors.
+      # Returns raw semantic fields with no ANSI or formatting, suitable for
+      # JSON/YAML output or MCP consumption. An AI or script can use the result
+      # directly to build a valid payload.
+      #
+      # Each Hash entry contains:
+      #   name        [String]  dot/bracket-path of the field (e.g. "recipients[].name")
+      #   type        [String]  JSON type string (e.g. "string", "boolean", "Array[object]")
+      #   required    [Boolean] true when the field is in its immediate parent's required list
+      #   description [String]  human description (may contain Markdown **bold** / `code`)
+      #   default     [Object]  (optional) default value as native Ruby type
+      #   enum        [Array]   (optional) list of allowed string values
+      #
+      # @return [Array<Hash>]
+      def to_rows
+        rows = []
+        collect_rows(rows, self, '')
+        rows
+      end
+
+      private
+
+      # Recursively collect rows from a schema node, passing each property's own
+      # parent `required` array so that only direct-parent membership is checked.
+      def collect_rows(rows, reader, prefix)
+        return unless reader.current.key?('properties')
+        parent_required = Set.new(Array(reader.current['required']))
+        props_reader = reader.dig('properties')
+        props_reader.current.each_key do |name|
+          prop_reader  = props_reader.dig(name)
+          node         = prop_reader.current
+          full_name    = "#{prefix}#{name}"
+          type_val =
+            if node['type'].is_a?(Array)
+              node['type'].join(', ')
+            elsif node['type'].eql?('array') && node.dig('items', 'type').is_a?(String)
+              "Array[#{node.dig('items', 'type')}]"
+            else
+              node['type'].to_s
+            end
+          row = {
+            'name'        => full_name,
+            'type'        => type_val,
+            'required'    => parent_required.include?(name),
+            'description' => node['description'].to_s
+          }
+          row['default'] = node['default'] if node.key?('default')
+          row['enum']    = node['enum']    if node.key?('enum')
+          rows << row
+          # Recurse into nested object or array-of-objects
+          case node['type']
+          when 'object'
+            collect_rows(rows, prop_reader, "#{full_name}.") if node['properties']
+          when 'array'
+            if node['items']
+              item_reader = prop_reader.dig('items')
+              collect_rows(rows, item_reader, "#{full_name}[].") if item_reader.current['properties']
             end
           end
+          collect_rows(rows, prop_reader, "#{full_name}.") if node['allOf']
         end
       end
     end

data/lib/aspera/schema/registry.rb

@@ -18,10 +18,32 @@ module Aspera
           LOCATIONS.key?(sym)
         end
 
-        # Get path to request body, no check if it exists
-        # @return [String] path to request body
+        # Split a component string into registry key and optional path prefix.
+        # Syntax: 'key' or 'key+/prefix' (e.g. 'shares+/api/v1')
+        # @param component [String] registry key with optional '+/prefix'
+        # @return [Array(String, String)] [key, prefix] where prefix may be ''
+        def split_component(component)
+          key, prefix = component.split('+', 2)
+          [key, prefix || '']
+        end
+
+        # Get path to request body schema, no check if it exists
+        # @param component [String] registry key, optionally with path prefix (e.g. 'shares+/api/v1')
+        # @param endpoint  [String] endpoint path without leading slash (e.g. 'data/shares.post')
+        # @return [String] schema path usable in schema: keyword
         def req_body(component, endpoint)
-          "#{component}:paths./#{endpoint}.requestBody.content.application/json.schema"
+          key, prefix = split_component(component)
+          "#{key}:paths.#{prefix}/#{endpoint}.requestBody.content.application/json.schema"
+        end
+
+        # Get path to query parameters for a GET endpoint
+        # @param component [String] registry key, optionally with path prefix (e.g. 'shares+/api/v1')
+        # @param endpoint  [String] resource path without leading slash (e.g. 'data/shares')
+        # @param method    [String] HTTP method (default: 'get')
+        # @return [String] schema path usable in query_schema: keyword
+        def query_params(component, endpoint, method: 'get')
+          key, prefix = split_component(component)
+          "#{key}:paths.#{prefix}/#{endpoint}.#{method}#{QUERY_PARAMS_SUFFIX}"
         end
       end
 
@@ -32,6 +54,9 @@ module Aspera
         opts:         'aspera/cli/options.schema.yaml',
         aoc:          'aspera/schema/IBM Aspera on Cloud API-0.2.6-enhanced.yaml',
         faspex:       'aspera/schema/IBM Aspera Faspex API-5.0-enhanced.yaml',
+        faspio:       'aspera/schema/IBM Aspera faspio Gateway API-1.0.0.yaml',
+        node:         'aspera/schema/IBM Aspera Node API-4.4.6.yaml',
+        shares:       'aspera/schema/IBM_Aspera_Shares.yaml',
         async_tables: 'aspera/schema/async_tables.yaml'
       }
 
@@ -41,26 +66,53 @@ module Aspera
       SYNC_ARGS = 'args'
       AOC = 'aoc'
       FASPEX = 'faspex'
+      FASPIO = 'faspio'
+      NODE = 'node'
+      SHARES = 'shares+/api/v1'
       ASYNC_TABLES = 'async_tables'
-      TRANSFER_INFO = "#{OPTIONS}:components.schemas.TransferInfo"
+      LOG_OPTIONS             = "#{OPTIONS}:components.schemas.LogOptions"
+      DIRECT_AGENT_OPTIONS    = "#{OPTIONS}:components.schemas.DirectAgentOptions"
+      NODE_AGENT_OPTIONS      = "#{OPTIONS}:components.schemas.NodeAgentOptions"
+      HTTPGW_AGENT_OPTIONS    = "#{OPTIONS}:components.schemas.HttpgwAgentOptions"
+      TRANSFERD_AGENT_OPTIONS = "#{OPTIONS}:components.schemas.TransferdAgentOptions"
+      TRANSFER_AGENT_OPTIONS  = "#{OPTIONS}:components.schemas.TransferAgentOptions"
+      SMTP_OPTIONS            = "#{OPTIONS}:components.schemas.SmtpOptions"
+      HTTP_OPTIONS            = "#{OPTIONS}:components.schemas.HttpOptions"
+      VAULT_OPTIONS           = "#{OPTIONS}:components.schemas.VaultOptions"
+      VAULT_SECRET            = "#{OPTIONS}:components.schemas.VaultSecret"
+      IMAGE_OPTIONS           = "#{OPTIONS}:components.schemas.ImageOptions"
+      OUT_OPTIONS             = "#{OPTIONS}:components.schemas.OutOptions"
+      PACKAGE_FOLDER_OPTIONS  = "#{OPTIONS}:components.schemas.PackageFolderOptions"
 
       REQ_BODY = '.requestBody.content.application/json.schema'
+      # Suffix appended to a dotted path to signal query-param extraction in reader()
+      QUERY_PARAMS_SUFFIX = '.parameters'
 
       def initialize
         @cache = {}
         @main_folder = File.expand_path('../..', __dir__)
       end
 
-      # Read schema from file or from cache
-      # @param name_path [String] one of the keys in LOCATIONS, with optional :<path> suffix
-      # @return [Reader] schema
+      # Read schema from file or from cache.
+      # When name_path ends with QUERY_PARAMS_SUFFIX, the OAS `parameters` array at that path
+      # is synthesised into an object schema via Reader.from_query_params instead of navigating
+      # into the tree.
+      # @param name_path [String] registry key with optional colon-separated dotted path suffix,
+      #   e.g. "faspex:paths./packages.get.parameters" or "faspex:paths./packages.post.requestBody..."
+      # @return [Reader] schema reader
       def reader(name_path)
         name, path = name_path.split(':', 2)
         sym = name.to_sym
-        Aspera.assert(Registry.known?(sym)){"schema: #{sym}"}
+        Aspera.assert(Registry.known?(sym)) { "schema: #{sym}" }
         spec_file = File.join(@main_folder, LOCATIONS[sym])
         @cache[sym] = Yaml.safe_load(File.read(spec_file)) if spec_file.end_with?('.yaml') && !@cache.key?(sym)
         @cache[sym] = JSON.parse(File.read(spec_file)) if spec_file.end_with?('.json') && !@cache.key?(sym)
+        # Query-params path: strip the suffix, navigate to the operation node, extract parameters
+        if path&.end_with?(QUERY_PARAMS_SUFFIX)
+          parent_path = path.delete_suffix(QUERY_PARAMS_SUFFIX)
+          node = @cache[sym].dig(*parent_path.split('.'))
+          return Reader.from_query_params(node&.fetch('parameters', []) || [])
+        end
         reader = Reader.new(@cache[sym])
         return reader unless path
         reader.dig(*path.split('.'))

data/lib/aspera/secret_hider.rb

@@ -45,41 +45,46 @@ module Aspera
     private_constant :HIDDEN_PASSWORD, :ASCP_ENV_SECRETS, :KEY_SECRETS, :HTTP_SECRETS, :ALL_SECRETS, :KEY_FALSE_POSITIVES, :REGEX_LOG_REPLACES
     attr_accessor :log_secrets
 
-    # @return new log formatter that hides secrets
+    # @return [Proc] new log formatter that hides secrets
     def log_formatter(original_formatter)
       original_formatter ||= Logger::Formatter.new
       # NOTE: that @log_secrets may be set AFTER this init is done, so it's done at runtime
       return lambda do |severity, date_time, program_name, msg|
         if msg.is_a?(String) && !@log_secrets
           REGEX_LOG_REPLACES.each do |reg_ex|
-            msg = msg.gsub(reg_ex){"#{Regexp.last_match(:begin)}#{HIDDEN_PASSWORD}#{Regexp.last_match(:end)}"}
+            msg = msg.gsub(reg_ex) { "#{Regexp.last_match(:begin)}#{HIDDEN_PASSWORD}#{Regexp.last_match(:end)}" }
           end
         end
         original_formatter.call(severity, date_time, program_name, msg)
       end
     end
 
+    # Replace private key content in a string with the hidden password placeholder
+    # @param value [String] Input string possibly containing a private key
+    # @return [String] String with private key replaced by placeholder
     def hide_secrets_in_string(value)
-      return value.gsub(REGEX_LOG_REPLACES.first){"#{Regexp.last_match(:begin)}#{HIDDEN_PASSWORD}#{Regexp.last_match(:end)}"}
+      return value.gsub(REGEX_LOG_REPLACES.first) { "#{Regexp.last_match(:begin)}#{HIDDEN_PASSWORD}#{Regexp.last_match(:end)}" }
     end
 
-    # @return true if the key denotes a secret
+    # @param keyword [String, Symbol] Key name to check
+    # @param value   [String]         Associated value (must be a String to be a secret)
+    # @return [Boolean] true if the key denotes a secret
     def secret?(keyword, value)
       keyword = keyword.to_s if keyword.is_a?(Symbol)
       # only Strings can be secrets, not booleans, or hash, arrays
       return false unless keyword.is_a?(String) && value.is_a?(String)
       # those are not secrets
-      return false if KEY_FALSE_POSITIVES.any?{ |f| f.match?(keyword)}
+      return false if KEY_FALSE_POSITIVES.any? { |f| f.match?(keyword) }
       return true if ADDITIONAL_KEYS_TO_HIDE.include?(keyword)
       # check if keyword (name) contains an element that designate it as a secret
-      ALL_SECRETS.any?{ |kw| keyword.include?(kw)}
+      ALL_SECRETS.any? { |kw| keyword.include?(kw) }
     end
 
     # Hides recursively secrets in Hash or Array of Hash
     def deep_remove_secret(obj)
       case obj
       when Array
-        obj.each{ |i| deep_remove_secret(i)}
+        obj.each { |i| deep_remove_secret(i) }
       when Hash
         obj.each do |k, v|
           if secret?(k, v)