taimour_openapi_sdk_generator 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: edb42df3a6a1c4802d39ed957bbb54daa2d3d2352524a06486412477336db50d
+  data.tar.gz: d98bce34a6c069bd33bc0d1e1e127122df935077e8c278bf3fefa783bb6c921f
+SHA512:
+  metadata.gz: 4f49be3da129f05378d4946a921b0fa7e164473c225b2418b3dfb04e696bdf9288f50c1534b71dd4c172b2ea650e963edebfa9c98c1a8136c4c7a167162e0634
+  data.tar.gz: 488c788f5e003b49247311b16a809f828ea7da34b261ea9cc0b0932b839fd55680d6a7cccbe5bf819c963761e72afa065c0e738ac5ed49cbac98f3db15983a42

data/bin/openapi-sdk-generator

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require_relative '../lib/openapi_sdk_generator'
+
+options = {}
+
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: openapi-sdk-generator [options]"
+  opts.separator ""
+  opts.separator "Generate SDK from OpenAPI specification"
+  opts.separator ""
+  
+  opts.on("-i", "--input FILE", "OpenAPI specification file (JSON or YAML)") do |v|
+    options[:input] = v
+  end
+  
+  opts.on("-o", "--output DIR", "Output directory for generated SDK") do |v|
+    options[:output] = v
+  end
+  
+  opts.on("-l", "--language LANG", "Target language (ruby, javascript)") do |v|
+    options[:language] = v
+  end
+  
+  opts.on("-h", "--help", "Show this help message") do
+    puts opts
+    exit
+  end
+  
+  opts.on("-v", "--version", "Show version") do
+    puts "OpenAPI SDK Generator v0.1.0"
+    exit
+  end
+end
+
+begin
+  parser.parse!
+  
+  if options.empty?
+    puts parser
+    exit
+  end
+  
+  OpenapiSdkGenerator::CLI.new(options).run
+rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
+  puts "Error: #{e.message}"
+  puts parser
+  exit 1
+rescue OpenapiSdkGenerator::Error => e
+  puts "Error: #{e.message}"
+  exit 1
+rescue => e
+  puts "Unexpected error: #{e.message}"
+  puts e.backtrace.first(5)
+  exit 1
+end

data/lib/openapi_sdk_generator/generator.rb

@@ -0,0 +1,36 @@
+module OpenapiSdkGenerator
+  class Generator
+    attr_reader :parser
+    
+    def initialize(parser)
+      @parser = parser
+    end
+    
+    def generate
+      raise NotImplementedError, "Subclasses must implement #generate"
+    end
+    
+    def write_to_directory(output_dir)
+      raise NotImplementedError, "Subclasses must implement #write_to_directory"
+    end
+    
+    protected
+    
+    def render_template(template_name, binding_context)
+      template_path = File.join(__dir__, 'templates', template_name)
+      template = File.read(template_path)
+      ERB.new(template, trim_mode: '-').result(binding_context)
+    end
+    
+    def sanitize_name(name)
+      puts "DEBUG param: #{p.inspect} (#{p.class})"
+
+      # Convert to snake_case and remove special characters
+      name.gsub(/[^a-zA-Z0-9_]/, '_').gsub(/_{2,}/, '_').downcase
+    end
+    
+    def camelize(string)
+      string.split('_').map(&:capitalize).join
+    end
+  end
+end

data/lib/openapi_sdk_generator/generators/javascript_generator.rb

@@ -0,0 +1,107 @@
+module OpenapiSdkGenerator
+  module Generators
+    class JavascriptGenerator < Generator
+      def generate
+        {
+          client: generate_client
+        }
+      end
+      
+      def write_to_directory(output_dir)
+        FileUtils.mkdir_p(output_dir)
+        
+        # Write client file
+        client_content = generate_client
+        File.write(File.join(output_dir, 'client.js'), client_content)
+        
+        # Write package.json
+        package_json = generate_package_json
+        File.write(File.join(output_dir, 'package.json'), package_json)
+        
+        # Write README
+        readme_content = generate_readme
+        File.write(File.join(output_dir, 'README.md'), readme_content)
+      end
+      
+      private
+
+
+        def generate_client
+        render_template('javascript_client.erb', binding)
+        end
+
+        def format_js_params(endpoint)
+        return "" unless endpoint[:parameters]
+
+        endpoint[:parameters].map { |p| sanitize_name(p[:name]) }.join(", ")
+        end      
+
+      def generate_client
+        render_template('javascript_client.erb', binding)
+      end
+      
+      def generate_package_json
+        {
+          name: sanitize_name(parser.api_title).tr('_', '-'),
+          version: parser.api_version,
+          description: parser.api_description,
+          main: "client.js",
+          scripts: {
+            test: "echo \"Error: no test specified\" && exit 1"
+          },
+          keywords: ["api", "client", "sdk"],
+          author: "",
+          license: "MIT"
+        }.to_json
+      end
+      
+      def generate_readme
+        <<~README
+        # #{parser.api_title}
+        
+        #{parser.api_description}
+        
+        Version: #{parser.api_version}
+        
+        ## Installation
+```bash
+
+npm install
+
+## Usage
+```javascript
+
+const APIClient = require('./client');
+
+
+// Example usage
+    #{parser.endpoints.first ? "// #{parser.endpoints.first[:summary]}" : '// Make API calls'}
+    #{parser.endpoints.first ? "// const response = await client.#{js_method_name(parser.endpoints.first)}(...);" : ''}
+
+
+## Available Methods
+        
+        #{parser.endpoints.map { |e| "- `#{js_method_name(e)}()` - #{e[:summary]}" }.join("\n")}
+        README
+      end
+            
+      def js_method_name(endpoint)
+      op = endpoint[:operation_id] || "#{endpoint[:method]}_#{endpoint[:path]}"
+      parts = sanitize_name(op).split('_')
+      parts.first + parts[1..].map(&:capitalize).join
+      end
+      
+      
+      def js_type(openapi_type)
+        case openapi_type
+        when 'integer', 'number' then 'number'
+        when 'string' then 'string'
+        when 'boolean' then 'boolean'
+        when 'array' then 'array'
+        when 'object' then 'object'
+        else 'any'
+        end
+      end
+    end
+  end
+end    

data/lib/openapi_sdk_generator/generators/ruby_generator.rb

@@ -0,0 +1,148 @@
+module OpenapiSdkGenerator
+  module Generators
+    class RubyGenerator < Generator
+      def generate
+        {
+          client: generate_client,
+          models: generate_models
+        }
+      end
+      
+      def write_to_directory(output_dir)
+        FileUtils.mkdir_p(output_dir)
+        FileUtils.mkdir_p(File.join(output_dir, 'models'))
+        
+        # Write client file
+        client_content = generate_client
+        File.write(File.join(output_dir, 'client.rb'), client_content)
+        
+        # Write model files
+        parser.models.each do |name, model|
+          model_content = generate_model(model)
+          filename = "#{sanitize_name(name)}.rb"
+          File.write(File.join(output_dir, 'models', filename), model_content)
+        end
+        
+        # Write README
+        readme_content = generate_readme
+        File.write(File.join(output_dir, 'README.md'), readme_content)
+      end
+      
+      private
+      
+      def generate_client
+        render_template('ruby_client.erb', binding)
+      end
+      
+      def generate_models
+        parser.models.map do |name, model|
+          generate_model(model)
+        end
+      end
+      
+      def generate_model(model)
+        @current_model = model
+        render_template('ruby_model.erb', binding)
+      end
+      
+      def generate_readme
+        <<~README
+        # #{parser.api_title}
+        
+        #{parser.api_description}
+        
+        Version: #{parser.api_version}
+        
+        ## Installation
+        
+        Add this to your application's Gemfile:
+        ```ruby
+        gem 'your_gem_name'
+        ```
+        
+        ## Usage
+        ```ruby
+        require_relative 'client'
+        
+        client = APIClient.new('#{parser.base_url}')
+        
+        # Example usage
+        #{parser.endpoints.first ? "# #{parser.endpoints.first[:summary]}" : '# Make API calls'}
+        #{parser.endpoints.first ? "# response = client.#{method_name(parser.endpoints.first)}(...)" : ''}
+        ```
+        
+        ## Available Methods
+        
+        #{parser.endpoints.map { |e| "- `#{method_name(e)}` - #{e[:summary]}" }.join("\n")}
+        README
+      end
+      
+      def method_name(endpoint)
+        sanitize_name(endpoint[:operation_id])
+      end
+      
+      def ruby_type(openapi_type)
+        case openapi_type
+        when 'integer' then 'Integer'
+        when 'number' then 'Float'
+        when 'string' then 'String'
+        when 'boolean' then 'Boolean'
+        when 'array' then 'Array'
+        when 'object' then 'Hash'
+        else 'Object'
+        end
+      end
+
+
+
+
+        # Converts parameters into Ruby method signature
+        def format_method_params(params)
+        return "" unless params.is_a?(Array) && !params.empty?
+
+        params.map do |p|
+            next unless p.is_a?(Hash)
+
+            name = sanitize_name(p[:name].to_s)
+            required = p[:required] ? "" : " = nil"
+            "#{name}#{required}"
+        end.compact.join(", ")
+        end
+
+        # Converts "/pets/{petId}" → "/pets/#{pet_id}"
+        def format_url_path(path, params = [])
+        return path unless params.is_a?(Array) && !params.empty?
+
+        params
+            .select { |p| p[:location] == "path" } # FIXED HERE
+            .reduce(path) do |memo, p|
+            ruby_name = sanitize_name(p[:name].to_s)
+            memo.gsub("{#{p[:name]}}", "\#{#{ruby_name}}")
+            end
+        end
+
+        # Converts OpenAPI type to Ruby class (used by templates)
+        def format_ruby_type(schema)
+        return "Object" if schema.nil?
+
+        case schema[:type]
+        when "integer" then "Integer"
+        when "number"  then "Float"
+        when "string"  then "String"
+        when "boolean" then "Boolean"
+        when "array"   then "Array"
+        when "object"  then "Hash"
+        else
+            if schema.is_a?(Hash) && schema["$ref"]
+            sanitize_name(schema["$ref"].split('/').last)
+            else
+            "Object"
+            end
+        end
+        end
+
+
+
+    end
+  end
+end

data/lib/openapi_sdk_generator/parser.rb

@@ -0,0 +1,158 @@
+module OpenapiSdkGenerator
+  class Parser
+    attr_reader :spec, :api_info, :base_url, :endpoints, :models
+    
+    def initialize(file_path)
+      @file_path = file_path
+      @spec = load_spec
+      @endpoints = []
+      @models = {}
+      @api_info = {}
+      parse_spec
+    end
+    
+    def api_title
+      @api_info[:title] || 'Generated API Client'
+    end
+    
+    def api_version
+      @api_info[:version] || '1.0.0'
+    end
+    
+    def api_description
+      @api_info[:description] || 'API client generated from OpenAPI specification'
+    end
+    
+    private
+    
+    def load_spec
+      content = File.read(@file_path)
+      if @file_path.end_with?('.json')
+        JSON.parse(content)
+      elsif @file_path.end_with?('.yaml', '.yml')
+        YAML.load(content)
+      else
+        raise Error, "Unsupported file format. Use .json, .yaml, or .yml"
+      end
+    rescue => e
+      raise Error, "Failed to parse OpenAPI spec: #{e.message}"
+    end
+    
+    def parse_spec
+      parse_info
+      parse_servers
+      parse_paths
+      parse_schemas
+    end
+    
+    def parse_info
+      info = @spec['info'] || {}
+      @api_info = {
+        title: info['title'],
+        version: info['version'],
+        description: info['description']
+      }
+    end
+    
+    def parse_servers
+      servers = @spec['servers'] || []
+      @base_url = servers.first&.dig('url') || 'https://api.example.com'
+    end
+    
+    def parse_paths
+      paths = @spec['paths'] || {}
+      
+      paths.each do |path, methods|
+        methods.each do |method, details|
+          next if method.start_with?('$') # Skip special keys like $ref
+          
+          @endpoints << {
+            path: path,
+            method: method.upcase,
+            operation_id: details['operationId'] || generate_operation_id(method, path),
+            summary: details['summary'],
+            description: details['description'],
+            parameters: parse_parameters(details['parameters']),
+            request_body: parse_request_body(details['requestBody']),
+            responses: parse_responses(details['responses'])
+          }
+        end
+      end
+    end
+    
+    def parse_parameters(parameters)
+      return [] unless parameters
+      
+      parameters.map do |param|
+        {
+          name: param['name'],
+          location: param['in'],
+          required: param['required'] || false,
+          type: param['schema']&.dig('type') || 'string',
+          description: param['description']
+        }
+      end
+    end
+    
+    def parse_request_body(request_body)
+      return nil unless request_body
+      
+      content = request_body['content'] || {}
+      json_content = content['application/json'] || {}
+      
+      {
+        required: request_body['required'] || false,
+        schema: json_content['schema']
+      }
+    end
+    
+    def parse_responses(responses)
+      return {} unless responses
+      
+      responses.transform_values do |response|
+        {
+          description: response['description'],
+          content: response['content']
+        }
+      end
+    end
+    
+    def parse_schemas
+      components = @spec['components'] || {}
+      schemas = components['schemas'] || {}
+      
+      schemas.each do |name, schema|
+        @models[name] = {
+          name: name,
+          type: schema['type'],
+          properties: parse_properties(schema['properties']),
+          required: schema['required'] || []
+        }
+      end
+    end
+    
+    def parse_properties(properties)
+      return {} unless properties
+      
+      properties.transform_values do |prop|
+        {
+          type: prop['type'],
+          format: prop['format'],
+          description: prop['description'],
+          items: prop['items']
+        }
+      end
+    end
+    
+    def generate_operation_id(method, path)
+      # Generate operation ID from method and path
+      # e.g., GET /users/{id} -> getUserById
+      path_parts = path.split('/').reject(&:empty?)
+      path_name = path_parts.map do |part|
+        part.start_with?('{') ? "by_#{part.tr('{}', '')}" : part
+      end.join('_')
+      
+      "#{method}_#{path_name}".downcase
+    end
+  end
+end

data/lib/openapi_sdk_generator/templates/javascript_client.erb

@@ -0,0 +1,102 @@
+/**
+ * <%= parser.api_title %>
+ * <%= parser.api_description %>
+ * Version: <%= parser.api_version %>
+ */
+
+class APIClient {
+  constructor(baseUrl = '<%= parser.base_url %>', apiKey = null) {
+    this.baseUrl = baseUrl;
+    this.headers = {
+      'Content-Type': 'application/json',
+      'Accept': 'application/json'
+    };
+    
+    if (apiKey) {
+      this.headers['Authorization'] = `Bearer ${apiKey}`;
+    }
+  }
+  
+  <% parser.endpoints.each do |endpoint| %>
+  /**
+   * <%= endpoint[:summary] %>
+   * <%= endpoint[:description] %>
+   <%- params = endpoint[:parameters] || [] -%>
+   <%- params.each do |param| -%>
+   * @param {<%= js_type(param[:type]) %>} <%= sanitize_name(param[:name]) %> - <%= param[:description] %>
+   <%- end -%>
+   <%- if endpoint[:request_body] -%>
+   * @param {object} body - Request body
+   <%- end -%>
+   * @returns {Promise<object>}
+   */
+  async <%= js_method_name(endpoint) %>(<%= format_js_params(endpoint) %>) {
+    <%- path_params = params.select { |p| p[:location] == 'path' } -%>
+    <%- query_params = params.select { |p| p[:location] == 'query' } -%>
+    <%- if path_params.any? -%>
+    let path = '<%= endpoint[:path] %>';
+    <%- path_params.each do |param| -%>
+    path = path.replace('{<%= param[:name] %>}', <%= sanitize_name(param[:name]) %>);
+    <%- end -%>
+    <%- else -%>
+    let path = '<%= endpoint[:path] %>';
+    <%- end -%>
+    
+    <%- if query_params.any? -%>
+    const queryParams = new URLSearchParams();
+    <%- query_params.each do |param| -%>
+    if (<%= sanitize_name(param[:name]) %> !== undefined && <%= sanitize_name(param[:name]) %> !== null) {
+      queryParams.append('<%= param[:name] %>', <%= sanitize_name(param[:name]) %>);
+    }
+    <%- end -%>
+    
+    const queryString = queryParams.toString();
+    if (queryString) {
+      path += `?${queryString}`;
+    }
+    <%- end -%>
+    
+    return this.makeRequest('<%= endpoint[:method].upcase %>', path<%= endpoint[:request_body] ? ', body' : '' %>);
+  }
+  <% end %>
+  
+  async makeRequest(method, path, body = null) {
+    const url = `${this.baseUrl}${path}`;
+    
+    const options = {
+      method: method,
+      headers: this.headers
+    };
+    
+    if (body) {
+      options.body = JSON.stringify(body);
+    }
+    
+    try {
+      const response = await fetch(url, options);
+      
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`HTTP Error ${response.status}: ${errorText}`);
+      }
+      
+      const contentType = response.headers.get('content-type');
+      if (contentType && contentType.includes('application/json')) {
+        return await response.json();
+      }
+      
+      return await response.text();
+    } catch (error) {
+      throw new Error(`Request failed: ${error.message}`);
+    }
+  }
+}
+
+module.exports = APIClient;
+
+<%- def format_js_params(endpoint)
+  params = endpoint[:parameters] || []
+  param_list = params.map { |p| sanitize_name(p[:name]) }
+  param_list << 'body = null' if endpoint[:request_body]
+  param_list.join(', ')
+end -%>

data/lib/openapi_sdk_generator/templates/ruby_client.erb

@@ -0,0 +1,87 @@
+require 'net/http'
+require 'json'
+require 'uri'
+
+class APIClient
+  attr_reader :base_url, :headers
+  
+  def initialize(base_url = '<%= parser.base_url %>', api_key: nil)
+    @base_url = base_url
+    @headers = {
+      'Content-Type' => 'application/json',
+      'Accept' => 'application/json'
+    }
+    @headers['Authorization'] = "Bearer #{api_key}" if api_key
+  end
+  
+  <% parser.endpoints.each do |endpoint| %>
+  # <%= endpoint[:summary] %>
+  # <%= endpoint[:description] %>
+  <%- params = endpoint[:parameters] || [] -%>
+  <%- query_params = params.select { |p| p[:location] == 'query' } -%>
+  <%- path_params = params.select { |p| p[:location] == 'path' } -%>
+  def <%= method_name(endpoint) %>(<%= format_method_params(endpoint) %>)
+    <%- if path_params.any? -%>
+    path = "<%= endpoint[:path] %>"
+    <%- path_params.each do |param| -%>
+    path = path.gsub('{<%= param[:name] %>}', <%= sanitize_name(param[:name]) %>.to_s)
+    <%- end -%>
+    <%- else -%>
+    path = "<%= endpoint[:path] %>"
+    <%- end -%>
+    
+    <%- if query_params.any? -%>
+    query_params = {}
+    <%- query_params.each do |param| -%>
+    query_params['<%= param[:name] %>'] = <%= sanitize_name(param[:name]) %> if <%= sanitize_name(param[:name]) %>
+    <%- end -%>
+    path += "?#{URI.encode_www_form(query_params)}" unless query_params.empty?
+    <%- end -%>
+    
+    make_request('<%= endpoint[:method] %>', path<%= endpoint[:request_body] ? ', body: body' : '' %>)
+  end
+  <% end %>
+  
+  private
+  
+  def make_request(method, path, body: nil)
+    uri = URI.join(@base_url, path)
+    
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = uri.scheme == 'https'
+    
+    request = case method.upcase
+    when 'GET'
+      Net::HTTP::Get.new(uri)
+    when 'POST'
+      Net::HTTP::Post.new(uri)
+    when 'PUT'
+      Net::HTTP::Put.new(uri)
+    when 'DELETE'
+      Net::HTTP::Delete.new(uri)
+    when 'PATCH'
+      Net::HTTP::Patch.new(uri)
+    else
+      raise "Unsupported HTTP method: #{method}"
+    end
+    
+    @headers.each { |key, value| request[key] = value }
+    request.body = body.to_json if body
+    
+    response = http.request(request)
+    
+    case response
+    when Net::HTTPSuccess
+      response.body.empty? ? {} : JSON.parse(response.body)
+    else
+      raise "HTTP Error #{response.code}: #{response.body}"
+    end
+  end
+end
+
+<%- def format_method_params(endpoint)
+  params = endpoint[:parameters] || []
+  param_list = params.map { |p| sanitize_name(p[:name]) }
+  param_list << 'body: nil' if endpoint[:request_body]
+  param_list.join(', ')
+end -%>

data/lib/openapi_sdk_generator/templates/ruby_model.erb

@@ -0,0 +1,29 @@
+# <%= @current_model[:name] %>
+class <%= camelize(@current_model[:name]) %>
+  <%- @current_model[:properties].each do |name, prop| -%>
+  attr_accessor :<%= sanitize_name(name) %>
+  <%- end -%>
+  
+  def initialize(attributes = {})
+    <%- @current_model[:properties].each do |name, prop| -%>
+    @<%= sanitize_name(name) %> = attributes['<%= name %>'] || attributes[:<%= sanitize_name(name) %>]
+    <%- end -%>
+  end
+  
+  def to_h
+    {
+      <%- @current_model[:properties].keys.each_with_index do |name, index| -%>
+      '<%= name %>' => @<%= sanitize_name(name) %><%= index < @current_model[:properties].keys.length - 1 ? ',' : '' %>
+      <%- end -%>
+    }
+  end
+  
+  def to_json(*args)
+    to_h.to_json(*args)
+  end
+  
+  def self.from_json(json)
+    data = JSON.parse(json)
+    new(data)
+  end
+end

data/lib/openapi_sdk_generator.rb

@@ -0,0 +1,58 @@
+require 'json'
+require 'yaml'
+require 'erb'
+require 'fileutils'
+
+require_relative 'openapi_sdk_generator/parser'
+require_relative 'openapi_sdk_generator/generator'
+require_relative 'openapi_sdk_generator/generators/ruby_generator'
+require_relative 'openapi_sdk_generator/generators/javascript_generator'
+
+module OpenapiSdkGenerator
+  class Error < StandardError; end
+  
+  class CLI
+    def initialize(options)
+      @options = options
+    end
+    
+    def run
+      validate_options!
+      
+      puts " Parsing OpenAPI specification..."
+      parser = Parser.new(@options[:input])
+      
+      puts "🔨 Generating #{@options[:language]} SDK..."
+      generator = create_generator(@options[:language], parser)
+      
+      puts " Writing files to #{@options[:output]}..."
+      generator.write_to_directory(@options[:output])
+      
+      puts " SDK generated successfully!"
+      puts "📁 Output directory: #{@options[:output]}"
+    rescue => e
+      puts " Error: #{e.message}"
+      exit 1
+    end
+    
+    private
+    
+    def validate_options!
+      raise Error, "Input file is required" unless @options[:input]
+      raise Error, "Output directory is required" unless @options[:output]
+      raise Error, "Language is required (ruby or javascript)" unless @options[:language]
+      raise Error, "Input file not found" unless File.exist?(@options[:input])
+    end
+    
+    def create_generator(language, parser)
+      case language.downcase
+      when 'ruby'
+        Generators::RubyGenerator.new(parser)
+      when 'javascript', 'js'
+        Generators::JavascriptGenerator.new(parser)
+      else
+        raise Error, "Unsupported language: #{language}"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: taimour_openapi_sdk_generator
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Taimour
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: A lightweight tool to generate client SDKs in multiple languages from
+  OpenAPI/Swagger specs
+email: taimour.ffcb@gmail.com
+executables:
+- openapi-sdk-generator
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/openapi-sdk-generator
+- lib/openapi_sdk_generator.rb
+- lib/openapi_sdk_generator/generator.rb
+- lib/openapi_sdk_generator/generators/javascript_generator.rb
+- lib/openapi_sdk_generator/generators/ruby_generator.rb
+- lib/openapi_sdk_generator/parser.rb
+- lib/openapi_sdk_generator/templates/javascript_client.erb
+- lib/openapi_sdk_generator/templates/ruby_client.erb
+- lib/openapi_sdk_generator/templates/ruby_model.erb
+homepage: https://github.com/yourusername/openapi_sdk_generator
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Generate SDKs from OpenAPI specifications
+test_files: []