opensearch-ruby 3.4.0 → 4.0.0.pre.beta.1

data/lib/opensearch/api/actions/update_by_query_rethrottle.rb

@@ -3,60 +3,39 @@
 # The OpenSearch Contributors require contributions made to
 # this file be licensed under the Apache-2.0 license or a
 # compatible open source license.
-#
-# Modifications Copyright OpenSearch Contributors. See
-# GitHub history for details.
-#
-# Licensed to Elasticsearch B.V. under one or more contributor
-# license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright
-# ownership. Elasticsearch B.V. licenses this file to you under
-# the Apache License, Version 2.0 (the "License"); you may
-# not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
+
+# This file is generated from the OpenSearch REST API spec.
+# Do not modify it by hand. Instead, modify the generator or the spec.
+
+# frozen_string_literal: true
 
 module OpenSearch
   module API
-    module Actions
-      # Changes the number of requests per second for a particular Update By Query operation.
-      #
-      # @option arguments [String] :task_id The task id to rethrottle
-      # @option arguments [Number] :requests_per_second The throttle to set on this request in floating sub-requests per second. -1 means set no throttle. (*Required*)
-      # @option arguments [Hash] :headers Custom HTTP headers
-      #
-      #
-      def update_by_query_rethrottle(arguments = {})
-        raise ArgumentError, "Required argument 'task_id' missing" unless arguments[:task_id]
+    module Root
+      module Actions
+        # Changes the number of requests per second for a particular Update By Query operation.
+        #
+        # @option args [String] :task_id *Required* The ID for the task.
+        # @option args [Float] :requests_per_second The throttle for this request in sub-requests per second.
+        def update_by_query_rethrottle(args = {})
+          args = Utils.clone_and_normalize_arguments(args)
+          raise ArgumentError, "Required argument 'task_id' missing" if args['task_id'].nil?
 
-        headers = arguments.delete(:headers) || {}
+          _task_id = args.delete('task_id')
 
-        arguments = arguments.clone
+          headers = args.delete('headers') || {}
+          body    = args.delete('body')
+          method  = 'POST'
+          url     = Utils.build_url('_update_by_query', _task_id, '_rethrottle')
 
-        _task_id = arguments.delete(:task_id)
+          Utils.validate_query_params! args, UPDATE_BY_QUERY_RETHROTTLE_QUERY_PARAMS
+          transport.perform_request(method, url, args, body, headers).body
+        end
 
-        method = OpenSearch::API::HTTP_POST
-        path   = "_update_by_query/#{Utils.__listify(_task_id)}/_rethrottle"
-        params = Utils.__validate_and_extract_params arguments, ParamsRegistry.get(__method__)
-
-        body = nil
-        perform_request(method, path, params, body, headers).body
+        UPDATE_BY_QUERY_RETHROTTLE_QUERY_PARAMS = Set.new(%w[
+          requests_per_second
+        ]).freeze
       end
-
-      # Register this action with its valid params when the module is loaded.
-      #
-      # @since 6.2.0
-      ParamsRegistry.register(:update_by_query_rethrottle, [
-        :requests_per_second
-      ].freeze)
     end
   end
 end

data/lib/opensearch/api/actions/wlm/create_query_group.rb

@@ -0,0 +1,34 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# The OpenSearch Contributors require contributions made to
+# this file be licensed under the Apache-2.0 license or a
+# compatible open source license.
+
+# This file is generated from the OpenSearch REST API spec.
+# Do not modify it by hand. Instead, modify the generator or the spec.
+
+# frozen_string_literal: true
+
+module OpenSearch
+  module API
+    module Wlm
+      module Actions
+        # Creates a new query group and sets the resource limits for the new query group.
+        #
+        # @option args [Hash] :body *Required*
+        def create_query_group(args = {})
+          args = Utils.clone_and_normalize_arguments(args)
+          raise ArgumentError, "Required argument 'body' missing" if args['body'].nil?
+
+          headers = args.delete('headers') || {}
+          body    = args.delete('body')
+          method  = 'PUT'
+          url     = '_wlm/query_group'
+
+          Utils.validate_query_params! args
+          transport.perform_request(method, url, args, body, headers).body
+        end
+      end
+    end
+  end
+end

data/lib/opensearch/api/actions/wlm/delete_query_group.rb

@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# The OpenSearch Contributors require contributions made to
+# this file be licensed under the Apache-2.0 license or a
+# compatible open source license.
+
+# This file is generated from the OpenSearch REST API spec.
+# Do not modify it by hand. Instead, modify the generator or the spec.
+
+# frozen_string_literal: true
+
+module OpenSearch
+  module API
+    module Wlm
+      module Actions
+        # Deletes the specified query group.
+        #
+        # @option args [String] :name *Required* The name of the query group.
+        # @option args [List] :ignore set to [404] to ignore server's NOT FOUND error for this request
+        def delete_query_group(args = {})
+          args = Utils.clone_and_normalize_arguments(args)
+          raise ArgumentError, "Required argument 'name' missing" if args['name'].nil?
+
+          _name = args.delete('name')
+
+          ignore  = args.delete('ignore') || []
+          headers = args.delete('headers') || {}
+          body    = args.delete('body')
+          method  = 'DELETE'
+          url     = Utils.build_url('_wlm/query_group', _name)
+
+          Utils.validate_query_params! args
+          transport.perform_delete_request method, url, args, body, headers, ignore.include?(404)
+        end
+      end
+    end
+  end
+end

data/lib/opensearch/api/actions/wlm/get_query_group.rb

@@ -0,0 +1,34 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# The OpenSearch Contributors require contributions made to
+# this file be licensed under the Apache-2.0 license or a
+# compatible open source license.
+
+# This file is generated from the OpenSearch REST API spec.
+# Do not modify it by hand. Instead, modify the generator or the spec.
+
+# frozen_string_literal: true
+
+module OpenSearch
+  module API
+    module Wlm
+      module Actions
+        # Retrieves the specified query group. If no query group is specified, all query groups in the cluster are retrieved.
+        #
+        # @option args [String] :name The name of the query group.
+        def get_query_group(args = {})
+          args = Utils.clone_and_normalize_arguments(args)
+          _name = args.delete('name')
+
+          headers = args.delete('headers') || {}
+          body    = args.delete('body')
+          method  = 'GET'
+          url     = Utils.build_url('_wlm/query_group', _name)
+
+          Utils.validate_query_params! args
+          transport.perform_request(method, url, args, body, headers).body
+        end
+      end
+    end
+  end
+end

data/lib/opensearch/api/actions/wlm/update_query_group.rb

@@ -0,0 +1,38 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# The OpenSearch Contributors require contributions made to
+# this file be licensed under the Apache-2.0 license or a
+# compatible open source license.
+
+# This file is generated from the OpenSearch REST API spec.
+# Do not modify it by hand. Instead, modify the generator or the spec.
+
+# frozen_string_literal: true
+
+module OpenSearch
+  module API
+    module Wlm
+      module Actions
+        # Updates the specified query group.
+        #
+        # @option args [String] :name *Required* The name of the query group.
+        # @option args [Hash] :body *Required*
+        def update_query_group(args = {})
+          args = Utils.clone_and_normalize_arguments(args)
+          raise ArgumentError, "Required argument 'name' missing" if args['name'].nil?
+          raise ArgumentError, "Required argument 'body' missing" if args['body'].nil?
+
+          _name = args.delete('name')
+
+          headers = args.delete('headers') || {}
+          body    = args.delete('body')
+          method  = 'PUT'
+          url     = Utils.build_url('_wlm/query_group', _name)
+
+          Utils.validate_query_params! args
+          transport.perform_request(method, url, args, body, headers).body
+        end
+      end
+    end
+  end
+end

data/lib/opensearch/api/http.rb

@@ -0,0 +1,94 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# The OpenSearch Contributors require contributions made to
+# this file be licensed under the Apache-2.0 license or a
+# compatible open source license.
+
+# frozen_string_literal: true
+
+module OpenSearch
+  module API
+    module Http
+      module Actions
+        # Make a customized CONNECT request.
+        #
+        # @option arguments [String] :url Relative path to the endpoint (e.g. 'cat/indices/books,movies') (*Required*)
+        # @option arguments [Hash] :params Querystring parameters to be appended to the path
+        # @option arguments [Hash] :headers Custom HTTP headers
+        # @option arguments [String | Hash | Array<Hash>] :body The body of the request
+        def connect(url, headers: {}, body: nil, params: {})
+          request('CONNECT', url, headers: headers, body: body, params: params)
+        end
+
+        # Make a customized DELETE request.
+        #
+        # @option arguments [String] :url Relative path to the endpoint (e.g. 'cat/indices/books,movies') (*Required*)
+        # @option arguments [Hash] :params Querystring parameters to be appended to the path
+        # @option arguments [Hash] :headers Custom HTTP headers
+        # @option arguments [String | Hash | Array<Hash>] :body The body of the request
+        def delete(url, headers: {}, body: nil, params: {})
+          request('DELETE', url, headers: headers, body: body, params: params)
+        end
+
+        # Make a customized GET request.
+        #
+        # @option arguments [String] :url Relative path to the endpoint (e.g. 'cat/indices/books,movies') (*Required*)
+        # @option arguments [Hash] :params Querystring parameters to be appended to the path
+        # @option arguments [Hash] :headers Custom HTTP headers
+        # @option arguments [String | Hash | Array<Hash>] :body The body of the request
+        def get(url, headers: {}, body: nil, params: {})
+          request('GET', url, headers: headers, body: body, params: params)
+        end
+
+        # Make a customized HEAD request.
+        #
+        # @option arguments [String] :url Relative path to the endpoint (e.g. 'cat/indices/books,movies') (*Required*)
+        # @option arguments [Hash] :params Querystring parameters to be appended to the path
+        # @option arguments [Hash] :headers Custom HTTP headers
+        # @option arguments [String | Hash | Array<Hash>] :body The body of the request
+        def head(url, headers: {}, body: nil, params: {})
+          request('HEAD', url, headers: headers, body: body, params: params)
+        end
+
+        # Make a customized OPTIONS request.
+        #
+        # @option arguments [String] :url Relative path to the endpoint (e.g. 'cat/indices/books,movies') (*Required*)
+        # @option arguments [Hash] :params Querystring parameters to be appended to the path
+        # @option arguments [Hash] :headers Custom HTTP headers
+        # @option arguments [String | Hash | Array<Hash>] :body The body of the request
+        def options(url, headers: {}, body: nil, params: {})
+          request('OPTIONS', url, headers: headers, body: body, params: params)
+        end
+
+        # Make a customized POST request.
+        #
+        # @option arguments [String] :url Relative path to the endpoint (e.g. 'cat/indices/books,movies') (*Required*)
+        # @option arguments [Hash] :params Querystring parameters to be appended to the path
+        # @option arguments [Hash] :headers Custom HTTP headers
+        # @option arguments [String | Hash | Array<Hash>] :body The body of the request
+        def post(url, headers: {}, body: nil, params: {})
+          request('POST', url, headers: headers, body: body, params: params)
+        end
+
+        # Make a customized PUT request.
+        #
+        # @option arguments [String] :url Relative path to the endpoint (e.g. 'cat/indices/books,movies') (*Required*)
+        # @option arguments [Hash] :params Querystring parameters to be appended to the path
+        # @option arguments [Hash] :headers Custom HTTP headers
+        # @option arguments [String | Hash | Array<Hash>] :body The body of the request
+        def put(url, headers: {}, body: nil, params: {})
+          request('PUT', url, headers: headers, body: body, params: params)
+        end
+
+        private
+
+        def request(method, url, headers: {}, body: nil, params: {})
+          body = OpenSearch::API::Utils.bulkify(body) if body.is_a?(Array)
+          headers.merge!('Content-Type' => 'application/x-ndjson') if body.is_a?(Array)
+
+          transport.perform_request(method, url, params, body, headers).body
+        end
+      end
+    end
+  end
+end

data/lib/opensearch/api/namespace.rb

@@ -0,0 +1,23 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# The OpenSearch Contributors require contributions made to
+# this file be licensed under the Apache-2.0 license or a
+# compatible open source license.
+
+# frozen_string_literal: true
+
+module OpenSearch
+  module API
+    # A child-client housing all the actions for a specific namespace
+    class Namespace
+      attr_reader :transport
+
+      # @param [OpenSearch::Transport::Client] transport
+      # @param [Module] ns_actions the module containing the API actions for this namespace
+      def initialize(transport, ns_actions)
+        @transport = transport
+        send :extend, ns_actions
+      end
+    end
+  end
+end

data/lib/opensearch/api/utils.rb

@@ -3,96 +3,56 @@
 # The OpenSearch Contributors require contributions made to
 # this file be licensed under the Apache-2.0 license or a
 # compatible open source license.
-#
-# Modifications Copyright OpenSearch Contributors. See
-# GitHub history for details.
-#
-# Licensed to Elasticsearch B.V. under one or more contributor
-# license agreements. See the NOTICE file distributed with
-# this work for additional information regarding copyright
-# ownership. Elasticsearch B.V. licenses this file to you under
-# the Apache License, Version 2.0 (the "License"); you may
-# not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
+
+# This file is generated from the OpenSearch REST API spec.
+# Do not modify it by hand. Instead, modify the generator or the spec
+
+# frozen_string_literal: true
+
+require 'cgi'
 
 module OpenSearch
   module API
-    # Generic utility methods
-    #
     module Utils
-      # URL-escape a string
-      #
-      # @example
-      #     __escape('foo/bar') # => 'foo%2Fbar'
-      #     __escape('bar^bam') # => 'bar%5Ebam'
-      #
-      # @api private
-      def __escape(string)
-        return string if string == '*'
-
-        CGI.escape(string.to_s)
+      NON_URL_ARGS = Set.new(%w[body headers ignore]).freeze
+      BULK_OPERATIONS = Set.new(%w[index create delete update]).freeze
+
+      # @return a new hash with all keys converted to strings and url param values escaped
+      # @param [Hash] args
+      def self.clone_and_normalize_arguments(args)
+        args.each_with_object({}) do |(k, v), acc|
+          k = k.to_s
+          acc[k] = NON_URL_ARGS.include?(k) ? v : normalize_value(v)
+        end
       end
 
-      # Create a "list" of values from arguments, ignoring nil values and encoding special characters.
-      #
-      # @example Create a list from array
-      #     __listify(['A','B']) # => 'A,B'
-      #
-      # @example Create a list from arguments
-      #     __listify('A','B') # => 'A,B'
-      #
-      # @example Escape values
-      #     __listify('foo','bar^bam') # => 'foo,bar%5Ebam'
-      #
-      # @example Do not escape the values
-      #     __listify('foo','bar^bam', escape: false) # => 'foo,bar^bam'
-      #
-      # @api private
-      def __listify(*list)
-        options = list.last.is_a?(Hash) ? list.pop : {}
+      # @param [Hash] params the query params to validate
+      # @param [Set<String>] valid_param_names the list of valid params names for the api method
+      def self.validate_query_params!(params, valid_param_names = nil)
+        return if OpenSearch::API.settings[:skip_parameter_validation]
+        params.each_key do |k|
+          next if valid_param_names&.include?(k)
+          next if GLOBAL_QUERY_PARAMS.include?(k)
+          raise ArgumentError, "URL parameter '#{k}' is not supported"
+        end
+      end
 
-        escape = options[:escape]
-        Array(list)
-          .flat_map { |e| e.respond_to?(:split) ? e.split(',') : e }
-          .flatten
-          .compact
-          .map { |e| escape == false ? e : __escape(e) }
-          .join(',')
+      # @return the value escaped for URL unless it is a Hash
+      def self.normalize_value(value)
+        return value.clone if value.is_a? Hash
+        value = value.to_s.strip unless value.is_a? Enumerable
+        value = value.split(',') if value.is_a? String
+        value.map { |v| CGI.escape(v.to_s) }.join(',')
       end
 
-      # Create a path (URL part) from arguments, ignoring nil values and empty strings.
-      #
-      # @example Create a path from array
-      #     __pathify(['foo', '', nil, 'bar']) # => 'foo/bar'
-      #
-      # @example Create a path from arguments
-      #     __pathify('foo', '', nil, 'bar') # => 'foo/bar'
-      #
-      # # @example Encode special characters
-      #     __pathify(['foo', 'bar^bam']) # => 'foo/bar%5Ebam'
-      #
-      # @api private
-      def __pathify(*segments)
-        Array(segments).flatten
-                       .compact
-                       .reject { |s| s.to_s.strip.empty? }
-                       .join('/')
-                       .squeeze('/')
+      def self.build_url(*parts)
+        parts.compact.join('/').squeeze('/')
       end
 
       # Convert an array of payloads into OpenSearch `header\ndata` format
       #
       # Supports various different formats of the payload: Array of Strings, Header/Data pairs,
-      # or the conveniency "combined" format where data is passed along with the header
+      # or the convenient "combined" format where data is passed along with the header
       # in a single item.
       #
       #     OpenSearch::API::Utils.__bulkify [
@@ -104,13 +64,13 @@ module OpenSearch
       #     # => {"title":"Test"}
       #     # => {"update":{"_index":"myindexB","_id":"2"}}
       #     # => {"doc":{"title":"Update"}}
-      #
-      def __bulkify(payload)
-        operations = %w[index create delete update]
+      # TODO: refactor this method to be more readable
+      def self.bulkify(payload)
+        return payload unless payload.is_a?(Array)
 
         # Hashes with `:data`
         if payload.any? do |d|
-             d.is_a?(Hash) && d.values.first.is_a?(Hash) && operations.include?(d.keys.first.to_s) && (d.values.first[:data] || d.values.first['data'])
+             d.is_a?(Hash) && d.values.first.is_a?(Hash) && BULK_OPERATIONS.include?(d.keys.first.to_s) && (d.values.first[:data] || d.values.first['data'])
            end
           payload = payload
                     .each_with_object([]) do |item, sum|
@@ -134,163 +94,8 @@ module OpenSearch
           payload << ''
         end
 
-        payload = payload.join("\n")
-      end
-
-      # Validates the argument Hash against common and valid API parameters
-      #
-      # @param arguments    [Hash]          Hash of arguments to verify and extract, **with symbolized keys**
-      # @param valid_params [Array<Symbol>] An array of symbols with valid keys
-      #
-      # @return [Hash]         Return whitelisted Hash
-      # @raise [ArgumentError] If the arguments Hash contains invalid keys
-      #
-      # @example Extract parameters
-      #   __validate_and_extract_params( { :foo => 'qux' }, [:foo, :bar] )
-      #   # => { :foo => 'qux' }
-      #
-      # @example Raise an exception for invalid parameters
-      #   __validate_and_extract_params( { :foo => 'qux', :bam => 'mux' }, [:foo, :bar] )
-      #   # ArgumentError: "URL parameter 'bam' is not supported"
-      #
-      # @example Skip validating parameters
-      #   __validate_and_extract_params( { :foo => 'q', :bam => 'm' }, [:foo, :bar], { skip_parameter_validation: true } )
-      #   # => { :foo => "q", :bam => "m" }
-      #
-      # @example Skip validating parameters when the module setting is set
-      #   OpenSearch::API.settings[:skip_parameter_validation] = true
-      #   __validate_and_extract_params( { :foo => 'q', :bam => 'm' }, [:foo, :bar] )
-      #   # => { :foo => "q", :bam => "m" }
-      #
-      # @api private
-      #
-      def __validate_and_extract_params(arguments, params = [], options = {})
-        if options[:skip_parameter_validation] || OpenSearch::API.settings[:skip_parameter_validation]
-          arguments
-        else
-          __validate_params(arguments, params)
-          __extract_params(arguments, params, options.merge(escape: false))
-        end
-      end
-
-      def __validate_params(arguments, valid_params = [])
-        arguments.each do |k, _v|
-          raise ArgumentError, "URL parameter '#{k}' is not supported" \
-            unless COMMON_PARAMS.include?(k) || COMMON_QUERY_PARAMS.include?(k) || valid_params.include?(k)
-        end
+        payload.join("\n")
       end
-
-      def __extract_params(arguments, params = [], options = {})
-        result = arguments.select { |k, _v| COMMON_QUERY_PARAMS.include?(k) || params.include?(k) }
-        result = result.to_h unless result.is_a?(Hash) # Normalize Ruby 1.8 and Ruby 1.9 Hash#select behaviour
-        result.map { |k, v| v.is_a?(Array) ? [k, __listify(v, options)] : [k, v] }.to_h # Listify Arrays
-      end
-
-      # Extracts the valid parts of the URL from the arguments
-      #
-      # @note Mutates the `arguments` argument, to prevent failures in `__validate_and_extract_params`.
-      #
-      # @param arguments   [Hash]          Hash of arguments to verify and extract, **with symbolized keys**
-      # @param valid_parts [Array<Symbol>] An array of symbol with valid keys
-      #
-      # @return [Array<String>]            Valid parts of the URL as an array of strings
-      #
-      # @example Extract parts
-      #   __extract_parts { :foo => true }, [:foo, :bar]
-      #   # => [:foo]
-      #
-      #
-      # @api private
-      #
-      def __extract_parts(arguments, valid_parts = [])
-        parts = arguments.select { |k, _v| valid_parts.include?(k) }.to_h
-        parts = parts.reduce([]) do |sum, item|
-          k, v = item
-          sum << (v.is_a?(TrueClass) ? k.to_s : v)
-        end
-
-        arguments.delete_if { |k, _v| valid_parts.include? k }
-        parts
-      end
-
-      # Calls the given block, rescuing from `StandardError`.
-      #
-      # Primary use case is the `:ignore` parameter for API calls.
-      #
-      # Returns `false` if exception contains NotFound in its class name or message,
-      # else re-raises the exception.
-      #
-      # @yield [block] A block of code to be executed with exception handling.
-      #
-      # @api private
-      #
-      def __rescue_from_not_found
-        yield
-      rescue StandardError => e
-        raise e unless e.class.to_s =~ /NotFound/ || e.message =~ /Not\s*Found/i
-        false
-      end
-
-      def __report_unsupported_parameters(arguments, params = [])
-        messages = []
-        unsupported_params = params.select do |d|
-          d.is_a?(Hash) ? arguments.include?(d.keys.first) : arguments.include?(d)
-        end
-
-        unsupported_params.each do |param|
-          name = case param
-                 when Symbol
-                   param
-                 when Hash
-                   param.keys.first
-                 else
-                   raise ArgumentError, 'The param must be a Symbol or a Hash'
-                 end
-
-          explanation = if param.is_a?(Hash)
-                          ". #{param.values.first[:explanation]}."
-                        else
-                          ". This parameter is not supported in the version you're using: #{OpenSearch::VERSION}, and will be removed in the next release."
-                        end
-
-          message = "[!] You are using unsupported parameter [:#{name}]"
-
-          if (source = caller&.last)
-            message += " in `#{source}`"
-          end
-
-          message += explanation
-
-          messages << message
-        end
-
-        return if messages.empty?
-
-        messages << 'Suppress this warning by the `-WO` command line flag.'
-
-        if $stderr.tty?
-          Kernel.warn messages.map { |m| "\e[31;1m#{m}\e[0m" }.join("\n")
-        else
-          Kernel.warn messages.join("\n")
-        end
-      end
-
-      def __report_unsupported_method(name)
-        message = "[!] You are using unsupported method [#{name}]"
-        if (source = caller&.last)
-          message += " in `#{source}`"
-        end
-
-        message += ". This method is not supported in the version you're using: #{OpenSearch::VERSION}, and will be removed in the next release. Suppress this warning by the `-WO` command line flag."
-
-        if $stderr.tty?
-          Kernel.warn "\e[31;1m#{message}\e[0m"
-        else
-          Kernel.warn message
-        end
-      end
-
-      extend self
     end
   end
 end