elastic-enterprise-search 7.10.0.beta.1 → 7.11.0

data/lib/generator/documentation_helper.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-# 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.
-
-module Elastic
-  module Generator
-    # Helper for setting up generated code documentation
-    module DocumentationHelper
-      def setup_documentation(endpoint)
-        description, url = url_and_description(endpoint)
-        docs = []
-        docs << "# #{@module_name} - #{endpoint['summary']}"
-        docs << "# #{description}" if description
-        docs << '#'
-        docs << parameters_documentation if @params && !@params.empty?
-        docs << "# @see #{url}" if url
-        docs << "#\n"
-        docs.join("\n")
-      end
-
-      private
-
-      # Description is markdown with [description](external_url)
-      # So we split the string with regexp:
-      def url_and_description(endpoint)
-        if endpoint['description'].nil?
-          description = nil
-          url = endpoint.dig('externalDocs', 'url')
-        else
-          matches = endpoint['description'].match(/\[(.+)\]\((.+)\)/)
-          description = matches[1]
-          url = matches[2]
-        end
-
-        [description, url]
-      end
-
-      def parameters_documentation
-        doc = ['# @param arguments [Hash] endpoint arguments']
-        # Show optional parameters for the `parameters` hash
-        doc = add_required(doc)
-        unless (optional = @params - required_params).empty?
-          optional.each { |param| doc << show_param(param) }
-        end
-        doc << "# @option body - The request body\n#" if body?
-        doc << '#'
-        doc.join("\n")
-      end
-
-      def add_required(doc)
-        # Show required parameters first
-        required_params.each do |param|
-          if in_signature?(param['name'])
-            doc.unshift(show_required_param(param))
-          else
-            doc << show_required_option(param)
-          end
-        end
-        doc
-      end
-
-      def show_param(param)
-        "# @option #{build_param_display(param)}"
-      end
-
-      def show_required_param(param)
-        "# @param #{build_param_display(param)} (*Required*)"
-      end
-
-      def show_required_option(param)
-        "# @option #{build_param_display(param)} (*Required*)"
-      end
-
-      def build_param_display(param)
-        "#{param['name']} [#{param['type']&.capitalize}] #{param['description']}"
-      end
-    end
-  end
-end

data/lib/generator/endpoint_generator.rb

@@ -1,119 +0,0 @@
-# frozen_string_literal: true
-
-# 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.
-
-require 'json'
-require 'erb'
-require_relative './utils'
-require_relative './documentation_helper'
-require_relative './parameters_helper'
-require_relative './parameters_exceptions'
-
-module Elastic
-  module Generator
-    # Generates code for REST API Endpoints
-    class EndpointGenerator
-      include DocumentationHelper
-      include ParametersHelper
-      include ParametersExceptions
-      CURRENT_PATH = File.dirname(__FILE__).freeze
-
-      def initialize(name)
-        @name = name
-        @spec = load_spec(name)
-        @target_dir = File.expand_path(__dir__ + "../../elastic/#{@name}-search/api").freeze
-      end
-
-      def generate
-        Dir.mkdir(@target_dir) unless File.directory?(@target_dir)
-        Utils.empty_directory(@target_dir)
-
-        # for each endpoint in the spec generate the code
-        @spec['paths'].each do |endpoint|
-          @path = generate_path(endpoint[0])
-          generate_classes(endpoint)
-        end
-        Utils.run_rubocop(@target_dir)
-      end
-
-      private
-
-      def namespace
-        return 'EnterpriseSearch' if @name == :enterprise
-
-        "#{@name.capitalize}Search"
-      end
-
-      def load_spec(name)
-        file_path = Pathname.new("./../json-specs/#{name}-search.json")
-        JSON.parse(File.read(file_path))
-      end
-
-      def generate_classes(endpoint)
-        # endpoint is an array with ['path', {'http_method(s)' => 'info'}
-        endpoint.last.each_key do |method|
-          @params = []
-          if method == 'parameters'
-            endpoint.last['parameters'].each { |param| add_parameter(param) }
-            next
-          end
-          @http_method = method
-          setup_values!(endpoint.last[method])
-          write_file(generate_code)
-        end
-      end
-
-      def write_file(code)
-        file_name = "#{@target_dir}/#{@method_name}.rb"
-        Utils.write_file(file_name, code)
-      end
-
-      def generate_path(path_string)
-        path = replace_path_variables(path_string).gsub(/^\//, '')
-
-        path.match?(/\/$/) ? path : "#{path}/"
-      end
-
-      def replace_path_variables(path)
-        # rubocop:disable Lint/InterpolationCheck
-        path.gsub(/{([a-z_]+)}/, '#{\1}')
-        # rubocop:enable Lint/InterpolationCheck
-      end
-
-      def setup_values!(endpoint)
-        @module_name = Utils.module_name(endpoint.fetch('tags'))
-        @method_name = Utils.to_ruby_name(endpoint['operationId'])
-        setup_parameters!(endpoint)
-        @doc = setup_documentation(endpoint)
-      end
-
-      def body?
-        # TODO: Define exactly when we need a body
-        return ['post', 'put', 'patch'].include? @http_method if @name != :app
-
-        true
-      end
-
-      def generate_code
-        template = "#{CURRENT_PATH}/templates/endpoint_template.erb"
-        code = ERB.new(File.read(template), nil, '-')
-        code.result(binding)
-      end
-    end
-  end
-end

data/lib/generator/parameters_exceptions.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Elastic
-  module Generator
-    # This module has the logic for parameter renaming like the friendlier
-    # :to_date to the api's filters[date][to] and any parameter serializing
-    # necessary such as date formatting.
-    module ParametersExceptions
-      PARAMETERS_MAPPING = {
-        name: 'engineName',
-        from_date: 'filters[date][from]',
-        to_date: 'filters[date][to]'
-      }.freeze
-
-      DATE_PARAMS = [:from_date, :to_date].freeze
-
-      EXCEPTIONAL_APIS = ['api_logs'].freeze
-
-      def rename_exceptional_parameters
-        return unless EXCEPTIONAL_APIS.include? @method_name
-
-        response = []
-        PARAMETERS_MAPPING.each do |param|
-          next unless @params.map { |p| p['name'] }.include? param[0].to_s
-
-          response << check_date_params(param[0])
-          response << "arguments['#{param[1]}'] = arguments.delete(:#{param[0]})"
-        end
-
-        response.join("\n")
-      end
-
-      def check_date_params(param_name)
-        return unless DATE_PARAMS.include?(param_name)
-
-        "arguments[:#{param_name}] = date_to_rfc3339(arguments[:#{param_name}])"
-      end
-    end
-  end
-end

data/lib/generator/parameters_helper.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-# 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.
-
-module Elastic
-  module Generator
-    # Generator Helper for working with parameters
-    module ParametersHelper
-      METHOD_SIGNATURE_PARAMS = [
-        'content_source_key',
-        'engine_name'
-      ].freeze
-
-      def setup_parameters!(endpoint)
-        endpoint['parameters']&.each { |param| add_parameter(param) }
-        extract_path_parameters.each do |param|
-          next unless @params.select { |p| p['name'] == param }.empty?
-
-          @params << {
-            'name' => param,
-            'required' => true,
-            'description' => '',
-            'type' => 'String'
-          }
-        end
-      end
-
-      def extract_path_parameters
-        @path.scan(/{(\w+)}/).flatten
-      end
-
-      def add_parameter(param)
-        @params << if param.keys.include?('$ref') && !param['$ref'].empty?
-                     parameter_name_and_description(Utils.dig_ref_from_spec(param['$ref'], @spec))
-                   else
-                     parameter_name_and_description(param)
-                   end
-      end
-
-      def parameter_name_and_description(param)
-        param['name'] = parameter_name(param)
-
-        # Check the spec for parameters with a given name and retrieve info
-        param_info = @spec.dig('components', 'parameters').select do |k, _|
-          k == param['name']
-        end.values.first
-        param_info = param if param_info.nil?
-
-        parameter_display(param['name'], param_info)
-      end
-
-      def parameter_display(name, param_info)
-        {
-          'name' => name,
-          'description' => param_info['description'],
-          'type' => param_info.dig('schema', 'type') || param_info['type'],
-          'required' => param_info['required']
-        }
-      end
-
-      def parameter_name(param)
-        if (name = param['x-codegen-param-name'])
-          if name == 'engineName'
-            'name'
-          else
-            Utils.to_ruby_name(name)
-          end
-        else
-          param['name']
-        end
-      end
-
-      def required_params
-        return [] unless @params
-
-        @params.select { |param| param['required'] }
-      end
-
-      def required_variables_from_parameters
-        response = []
-        required_params.map do |param|
-          name = param['name']
-          next if in_signature?(name) || !extract_path_parameters.include?(name)
-
-          response << "#{name} = arguments[:#{name}]"
-        end
-        response.join("\n")
-      end
-
-      def method_signature_params
-        return unless @params
-
-        parameters = required_params.select do |param|
-          in_signature?(param['name'])
-        end
-        parameters.map { |param| param['name'] }
-      end
-
-      def in_signature?(param_name)
-        METHOD_SIGNATURE_PARAMS.include?(param_name)
-      end
-
-      def raise_for_required_params
-        errors = []
-        required_params.map do |param|
-          name = param['name']
-          parameter = in_signature?(name) ? name : "arguments[:#{name}]"
-          errors << "raise ArgumentError, \"Required parameter '#{name}' missing\" unless #{parameter}"
-        end
-        errors.join("\n")
-      end
-
-      # Display the parameters that should be in the method signature
-      def display_signature_params
-        params = method_signature_params
-        params << 'arguments = {}'
-        "(#{params.join(', ')})"
-      end
-
-      def request_method_params
-        params = []
-        params += [":#{@http_method}", "\"#{@path}\""]
-        params << 'arguments'
-        params << (body? ? 'body' : {})
-        params.join(",\n")
-      end
-    end
-  end
-end

data/lib/generator/templates/endpoint_template.erb

@@ -1,29 +0,0 @@
-<%= ERB.new(File.read(CURRENT_PATH + "/templates/_license.erb"), trim_mode: '-').result(binding)%>
-
-module Elastic
-  module EnterpriseSearch
-    <% if @name != :enterprise -%>
-      module <%= namespace %>
-    <% end -%>
-      module Actions
-        <%= @doc -%>
-        def <%= @method_name %><%= display_signature_params %>
-          <%= raise_for_required_params %>
-
-          <%= required_variables_from_parameters %>
-          <% if body? %>
-            body = arguments.delete(:body) || {}
-          <% end %>
-
-          <%= rename_exceptional_parameters %>
-
-          request(
-            <%= request_method_params %>
-          )
-        end
-      end
-    end
-  end
-<% if @name != :enterprise -%>
-  end
-<% end -%>

data/lib/generator/templates/spec_template.erb

@@ -1 +0,0 @@
-<%= ERB.new(File.read(CURRENT_PATH + "/templates/_license.erb"), trim_mode: '-').result(binding)%>

data/lib/generator/utils.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-# 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.
-module Elastic
-  module Generator
-    # Utility functions for code generation
-    module Utils
-      def self.empty_directory(dir)
-        FileUtils.remove_dir(dir)
-        Dir.mkdir(dir)
-      end
-
-      def self.write_file(file_name, content)
-        File.open(file_name, 'w') { |f| f.puts content }
-        puts colorize(:green, "\nSuccessfully generated #{file_name}\n\n")
-      end
-
-      def self.run_rubocop(dir)
-        system("rubocop -c ./.rubocop.yml --format autogenconf -A #{dir}")
-      end
-
-      def self.module_name(tag)
-        tag.first.gsub(/\s{1}API/, '').gsub(/\s/, '')
-      end
-
-      def self.to_ruby_name(camel_case)
-        camel_case
-          .gsub(/([a-z])([A-Z])+/, '\1_\2') # to camel_case
-          .gsub(/get_/, '') # remove prepended 'get' in method names
-          .downcase
-      end
-
-      def self.colorize(color, message)
-        colors = { red: 31, green: 32 }
-        "\e[#{colors[color]}m#{message}\e[0m"
-      end
-
-      # TODO: Use this for modules
-      def self.setup_tags(tags)
-        tags.map do |tag|
-          {
-            name: tag['name'],
-            description: tag['description'],
-            url: tag['externalDocs']['url']
-          }
-        end
-      end
-
-      def self.dig_ref_from_spec(ref, spec)
-        path = ref.gsub('#', '').split('/').reject(&:empty?)
-        spec.dig(*path)
-      end
-    end
-  end
-end