Continued working on the Spect Insert feature for automatic conversion of API calls into Language SDK.

Signed-off-by: Daniel Jackson <[email protected]>

Author: Daniel Jackson

_api-reference/cat/cat-allocation.md

@@ -27,40 +27,6 @@ GET /_cat/allocation/{node_id}
 ```
 <!-- spec_insert_end -->
 
-<!-- spec_insert_start
-api: snapshot.restore
-component: example_code
-rest: GET _nodes/stats/indices
--->
-{% capture step1_rest %}
-POST _snapshot/<repository>/<snapshot>/_restore
-{% endcapture %}
-
-{% capture step1_python %}
-response = client.snapshot.restore(
-  repository = "<repository>",
-  snapshot = "<snapshot>",
-  body =   {
-    "indices": "opendistro-reports-definitions",
-    "ignore_unavailable": true,
-    "include_global_state": false,
-    "rename_pattern": "(.+)",
-    "rename_replacement": "$1_restored",
-    "include_aliases": false
-  }
-)
-
-{% endcapture %}
-
-{% capture step1_javascript %}
-JavaScript example code not yet implemented
-{% endcapture %}
-
-{% include code-block.html
-rest=step1_rest
-python=step1_python
-%}
-<!-- spec_insert_end -->
 
 <!-- spec_insert_start
 api: cat.allocation

spec-insert/lib/insert_arguments.rb

@@ -2,11 +2,13 @@
 
 require_relative 'utils'
 require_relative 'spec_insert_error'
-
+require 'json'
 # Doc Insert Arguments
 class InsertArguments
   attr_reader :raw
 
+  Rest = Struct.new(:verb, :path, :query, :body, :raw_lines, keyword_init:true)
+
   # @param [Hash] args raw arguments read from the doc insert marker
   def initialize(args)
     @raw = args.to_h.with_indifferent_access
@@ -61,6 +63,34 @@ def omit_header
     parse_boolean(@raw['omit_header'], default: false)
   end
 
+  # @return [Rest, nil]
+  def rest
+    lines = @raw['rest']&.split("\n")&.map(&:strip) || []
+    return nil if lines.empty?
+
+    verb, full_path = lines.first.to_s.split
+    path, query_string = full_path.to_s.split('?', 2)
+
+    query = (query_string || "").split('&').to_h do |pair|
+      k, v = pair.split('=', 2)
+      [k, v || "false"]
+    end
+
+    body = begin
+             JSON.parse(@raw['body']) if @raw['body']
+           rescue JSON::ParserError
+             @raw['body']
+           end
+
+    Rest.new(
+      verb: verb,
+      path: path,
+      query: query,
+      body: body,
+      raw_lines: lines
+    )
+  end
+
   private
 
   # @param [String] value comma-separated array

spec-insert/lib/renderers/example_code.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'json'
+require_relative 'example_code_python'
 
 class ExampleCode < BaseMustacheRenderer
   self.template_file = "#{__dir__}/templates/example_code.mustache"
@@ -9,217 +10,21 @@ def initialize(action, args)
     super(action, args)
   end
 
-  # Resolves the correct OpenSearch client method call
-  def client_method_call
-    segments = @action.full_name.to_s.split('.')
-    return "client" if segments.empty?
- 
-    if segments.size == 1
-      "client.#{segments.first}"
-    else
-      "client.#{se  gments.first}.#{segments[1]}"
-    end
-  end
-
   def rest_lines
-    @args.raw['rest']&.split("\n")&.map(&:strip) || []
+    @args.rest.raw_lines
   end
 
   def rest_code
-    rest_lines.join("\n")
-  end
-
-  # Uses the declared HTTP method in the OpenAPI spec
-  def http_method
-    @action.http_verbs.first&.upcase || "GET"
-  end
-
-  # Converts OpenAPI-style path (/index/{id}) into Ruby-style interpolation (/index/#{id})
-  def path_only
-    url = @action.urls.first
-    return '' unless url
-    url.gsub(/\{(\w+)\}/, '#{\1}')
-  end
-  def javascript_code
-    "JavaScript example code not yet implemented"
-  end
-  # Assembles a query string from the declared query parameters
-  def query_string
-    return '' if @action.query_parameters.empty?
-    @action.query_parameters.map { |param| "#{param.name}=example" }.join('&')
-  end
-
-  # Combines path and query string for display
-  def path_with_query
-    qs = query_string
-    qs.empty? ? path_only : "#{path_only}?#{qs}"
-  end
-
-  # Hash version of query params
-  def query_params
-    @action.query_parameters.to_h { |param| [param.name, "example"] }
-  end
-
-  # Parses the body from the REST example (only for preserving raw formatting)
-  def body
-    body_lines = rest_lines[1..]
-    return nil if body_lines.empty?
-    begin
-      JSON.parse(body_lines.join("\n"))
-    rescue
-      nil
-    end
-  end
-
-  def action_expects_body?(verb)
-    verb = verb.downcase
-    @action.operations.any? do |op|
-      op.http_verb.to_s.downcase == verb &&
-        op.spec&.requestBody &&
-        op.spec.requestBody.respond_to?(:content)
-    end
-  end
-
-  def matching_spec_path
-    return @matching_spec_path if defined?(@matching_spec_path)
-
-    # Extract raw request path from rest line
-    raw_line = rest_lines.first.to_s
-    _, request_path = raw_line.split
-    request_segments = request_path.split('?').first.split('/').reject(&:empty?)
-
-    # Choose the best matching spec URL
-    best = nil
-    best_score = -1
-
-    @action.urls.each do |spec_path|
-      spec_segments = spec_path.split('/').reject(&:empty?)
-      next unless spec_segments.size == request_segments.size
-
-      score = 0
-      spec_segments.each_with_index do |seg, i|
-        if seg.start_with?('{')
-          score += 1 # parameter match
-        elsif seg == request_segments[i]
-          score += 2 # exact match
-        else
-          score = -1
-          break
-        end
-      end
-
-      if score > best_score
-        best = spec_path
-        best_score = score
-      end
+    base = rest_lines.join("\n")
+    body = @args.rest.body
+    if body
+      body.is_a?(String) ? base + "\n" + body : base + "\n" + JSON.pretty_generate(body)
+    else
+      base
     end
-
-    @matching_spec_path = best
   end
 
-  # Final Python code using action metadata
   def python_code
-    return "# Invalid action" unless @action&.full_name
-
-    client_setup = <<~PYTHON
-    from opensearchpy import OpenSearch
-    
-    host = 'localhost'
-    port = 9200
-    auth = ('admin', 'admin') # For testing only. Don't store credentials in code.
-    ca_certs_path = '/full/path/to/root-ca.pem' # Provide a CA bundle if you use intermediate CAs with your root CA.
-    
-    # Create the client with SSL/TLS enabled, but hostname verification disabled.
-    client = OpenSearch(
-        hosts = [{'host': host, 'port': port}],
-        http_compress = True, # enables gzip compression for request bodies
-        http_auth = auth,
-        use_ssl = True,
-        verify_certs = True,
-        ssl_assert_hostname = False,
-        ssl_show_warn = False,
-        ca_certs = ca_certs_path
-    )
-
-    PYTHON
-
-    if @args.raw['body'] == '{"hello"}'
-      puts "# This is a debug example"
-    end
-
-    namespace, method = @action.full_name.split('.')
-    client_call = "client"
-    client_call += ".#{namespace}" if namespace
-    client_call += ".#{method}"
-
-    args = []
-
-    # Extract actual path and query from the first line of the REST input
-    raw_line = rest_lines.first.to_s
-    http_verb, full_path = raw_line.split
-    path_part, query_string = full_path.to_s.split('?', 2)
-
-    # Extract used path values from the path part
-    path_values = path_part.split('/').reject(&:empty?)
-
-    # Match spec path (e.g. /_cat/aliases/{name}) to determine which param this value belongs to
-    spec_path = matching_spec_path.to_s
-    spec_parts = spec_path.split('/').reject(&:empty?)
-
-    param_mapping = {}
-    spec_parts.each_with_index do |part, i|
-      if part =~ /\{(.+?)\}/ && path_values[i]
-        param_mapping[$1] = path_values[i]
-      end
-    end
-
-    # Add path parameters if they were present in the example
-    @action.path_parameters.each do |param|
-      if param_mapping.key?(param.name)
-        args << "#{param.name} = \"#{param_mapping[param.name]}\""
-      end
-    end
-
-    # Add query parameters from query string
-    if query_string
-      query_pairs = query_string.split('&').map { |s| s.split('=', 2) }
-      query_hash = query_pairs.map do |k, v|
-        "#{k}: #{v ? "\"#{v}\"" : "True"}"
-      end.join(', ')
-      args << "params = { #{query_hash} }" unless query_hash.empty?
-    end
-
-    # Add body if spec allows it AND it's present in REST
-    if action_expects_body?(http_verb)
-      if @args.raw['body']
-        begin
-          parsed = JSON.parse(@args.raw['body'])
-          pretty = JSON.pretty_generate(parsed).gsub(/^/, '  ')
-          args << "body = #{pretty}"
-        rescue JSON::ParserError
-          args << "body = #{JSON.dump(@args.raw['body'])}"
-        end
-      else
-        args << 'body = { "Insert body here" }'
-      end
-    end
-
-    # Final result
-    call_code = if args.empty?
-                  "response = #{client_call}()"
-                else
-                  final_args = args.map { |line| "  #{line}" }.join(",\n")
-                  <<~PYTHON
-                  response = #{client_call}(
-                  #{final_args}
-                  )
-                  PYTHON
-                end
-    # Prepend client if requested
-    if @args.raw['include_client_setup']
-      client_setup + call_code
-    else
-      call_code
-    end
+    ExampleCodePython.new(@action, @args).render
   end
-end
+end