swagger-to-rbs 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 651f699800da6263854e5f030b5b2e9084570686b17b92b164319c8c18dbe28f
-  data.tar.gz: 23e3253fd8e999fa5042045c9548227e5addd97ed26fe230c0303850665a6d85
+  metadata.gz: 4009216d856b770d4226cdc662c17250a113cf2a06366f7a5731d39a72d417ed
+  data.tar.gz: 456756e34e5ce92d602ac0c23aa0d6e243a78b95e4f20a39210976a477a41ad7
 SHA512:
-  metadata.gz: 6ceb2196aaf7cb48385a7c3d200f45a1c28880385ce00da876a6dcb9d19c08ca1a991fbc461e5d026e4276f78266e8f5d3ccc444f26d6fb61c309b9e5edae73b
-  data.tar.gz: 27fc3959ff9f6a56846322e03b14e83fd60a96659e006abfe23c6ccb069bd404e4a4a89b0472edc92c4b87415bedf6b1bbad47ef96721a47473adfc1fd3b59c9
+  metadata.gz: ba0e9c1101cfa113600e891feef046f2aff46b4dfa56d8c9f16dc38f08327ecd5bc16f49633bbb5420a7835401ceb0c3cd036137eccd7e7636da3537fb9fd866
+  data.tar.gz: 1b374d837cf5050238dac0096866624da70c192e7d03dca63f425cca3f44619f2020cedd441584dd8cc56582829753358c00fc723ee6d8e9f826762611415843

data/README.md

@@ -1,4 +1,10 @@
-### Usage
+## Install
+
+```
+gem install swagger-to-rbs
+```
+
+## Usage
 
 Dowload swagger spec
 
@@ -11,7 +17,7 @@ curl https://petstore3.swagger.io/api/v3/openapi.json > swagger.json
 Generate http client based on [Httparty gem](https://github.com/jnunemaker/httparty)
 
 ```
-swagger-to-rbs generate --name MyApi --spec swagger.json
+swagger-to-rbs generate --name PetApi --spec swagger.json
 ```
 
 Result:
@@ -24,16 +30,20 @@ class PetApi
   base_uri "/api/v3"
   #...
 
-  def getPetById(petId, params, options = {})
-    self.class.get("/pet/#{petId}", params: params.to_json, headers: { 'Content-Type' => 'application/json' }.merge(options))
+  def initialize
+    self.class.headers({ 'Content-Type' => 'application/json' })
+  end
+
+  def getPetById(petId, options = {})
+    self.class.get("/pet/#{petId}", options)
   end
 
   def updatePet(body, options = {})
-    self.class.put("/pet", body: body.to_json, headers: { 'Content-Type' => 'application/json' }.merge(options))
+    self.class.put("/pet", { body: body.to_json }.merge(options))
   end
 
   def addPet(body, options = {})
-    self.class.post("/pet", body: body.to_json, headers: { 'Content-Type' => 'application/json' }.merge(options))
+    self.class.post("/pet", { body: body.to_json }.merge(options))
   end
   #...
 end
@@ -44,7 +54,7 @@ end
 Authorization example:
 
 ```
-api = MyApi.new
+api = PetApi.new
 
 MyApi.headers(Authorization: "Bearer #{access_token}")
 MyApi.base_uri("http://otherurl.test/api/v1)

data/lib/swagger2_rbs/cli.rb

@@ -19,7 +19,21 @@ module Swagger2Rbs
 
       file_name = to_underscore(name)
       File.write("#{file_name}.rb", ::Swagger2Rbs.generate(name, data.dup))
-      File.write("#{file_name}.rbs", ::Swagger2Rbs.generate_rbs(name, data.dup))
+      Dir.mkdir('sig') unless File.exist?("sig")
+      File.write("sig/#{file_name}.rbs", ::Swagger2Rbs.generate_rbs(name, data.dup))
+    end
+
+    desc 'genearte-yaml', 'generate yaml file'
+    option :name, desc: 'Name'
+    option :spec, desc: 'Swagger file path'
+    def generate_yaml
+      @name = options[:name]
+      @swagger_path = options[:spec]
+      @debug = options[:debug]
+      swagger_spec = JSON.parse(File.read(@swagger_path))
+
+      file_name = to_underscore(name)
+      File.write("#{file_name}.yaml", ::Swagger2Rbs.swagger_to_rest_api_yaml(swagger_spec))
     end
 
     private

data/lib/swagger2_rbs/hash_helper.rb

@@ -1,5 +1,40 @@
 module Swagger2Rbs
   class HashHelper
+
+    def self.resolve_special_key(data, special_key)
+      return data unless data
+
+      new_data = data.dup
+      walk(data) do |key, value|
+        if (key.split(".").last == special_key)
+          update_key = key.split(".").reject{|k| k == special_key}.join(".")
+          new_value = yield(key, value)
+          set_value(new_data, update_key, new_value)
+        end
+      end
+      new_data
+    end
+
+    def self.present?(hash)
+      hash && !hash.empty?
+    end
+
+    # https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/hash/keys.rb#L129
+    def self.deep_transform_keys_in_object!(object, &block)
+      case object
+      when Hash
+        object.keys.each do |key|
+          value = object.delete(key)
+          object[yield(key)] = deep_transform_keys_in_object!(value, &block)
+        end
+        object
+      when Array
+        object.map! { |e| deep_transform_keys_in_object!(e, &block) }
+      else
+        object
+      end
+    end
+
     def self.set_value(hash, key, value)
       arr = key.split(".")
       last_key = arr.pop()

data/lib/swagger2_rbs/rbs_type.rb

@@ -0,0 +1,46 @@
+module Swagger2Rbs
+  class RbsType
+    attr_reader :data, :symbolize_keys
+    def initialize(data, symbolize_keys: true)
+      @data = data
+      @symbolize_keys = symbolize_keys
+    end
+
+    def write_types
+      return nil unless HashHelper.present? data
+      typed = (data.is_a?(Array) ? data[0] : data)&.map{ |k, v| to_typed(k, v) }.join(', ')
+      if data.is_a?(Array)
+        "Array[{ #{typed} }]"
+      else
+        "{ #{typed} }"
+      end
+    end
+
+    def type_case(str)
+      case str
+      when "boolean"
+        "bool"
+      when nil
+        "untyped"
+      else
+        str&.capitalize
+      end
+    end
+
+    def key_to_typed(k)
+      return "#{k}:" if @symbolize_keys
+      "\"#{k}\" =>"
+    end
+
+    def to_typed(k, v)
+      return "#{key_to_typed(k)} #{type_case(v)}" unless v.is_a?(Array) || v.is_a?(Hash)
+      return "#{key_to_typed(k)} {#{v.map{ |k2, v2| to_typed(k2, v2) }.join(", ")}}" if v.is_a?(Hash)
+
+      if v[0]&.is_a?(Hash)
+        "#{key_to_typed(k)} Array[{" + v[0].map{ |k, v| to_typed(k, v) }.join(", ") + "}]"
+      else
+        "#{key_to_typed(k)} Array[#{type_case(v[0])}]"
+      end
+    end
+  end
+end

data/lib/swagger2_rbs/rest_endpoint.rb

@@ -1,8 +1,10 @@
 require 'slugify'
+require_relative 'rest_endpoint_typed'
 
 module Swagger2Rbs
   class RestEndpoint
     attr_reader :path, :method, :props
+    include RestEndpointTyped
 
     def initialize(path, method, props)
       @path = path
@@ -13,14 +15,31 @@ module Swagger2Rbs
     def to_h
       {
         path: path_with_parameters,
-        method: method,
-        parameters: parameters,
+        http_method: method,
         parameters_for_method: parameters_for_method,
-        parameters_typed: parameters_typed,
+        typed_parameters_for_method: typed_parameters_for_method,
+        has_body: body?,
+        method_name: method_name,
+        all_responses_typed: all_responses_typed,
+        all_responses_for_return_method: all_responses_for_return_method,
+      }
+    rescue => e
+      raise e, "Context: #{path} #{method} Message: #{e.message}"
+    end
+
+    def body?
+      HashHelper.present? body
+    end
+
+    def to_yaml
+      {
+        path: path,
+        method: method,
+        path_parameters: parameters,
         method_name: method_name,
         body: body,
-        body_typed: body_typed,
-        response_typed: response_typed,
+        response: response("200"),
+        all_responses: all_responses
       }
     rescue => e
       raise e, "Context: #{path} #{method} Message: #{e.message}"
@@ -37,63 +56,55 @@ module Swagger2Rbs
     def parameters
       return [] unless props["parameters"]
 
-      props["parameters"].select{|it| it["in"] == "path"}.map{|it| it["name"]}
+      props["parameters"]&.select{|it| it["in"] == "path"}&.map{|it| it["name"]}
     end
 
-    def response_typed
-      schema = resolve_all_of(@props.dig("responses", "200", "content", "application/json", "schema"))
-      schema_to_typed(schema, {})
-    end
+    def body
+      body_schema = resolve_of(props.dig("requestBody", "content", "application/json", "schema"))
+      return {} unless body_schema
 
-    def parameters_typed
-      return nil if method != "get"
-      parameters.map{|it| "String #{it}" }
-      .push("?Hash[untyped, untyped] options")
-      .join(", ")
+      schema_to_hash(body_schema)
     end
 
-    def body_typed
-      return nil if method != "post"
-
-      return "Hash[String, untyped]" unless body
-      return "Hash[String, untyped]" if body.empty?
-
-    "{" + body.map{ |k, v| to_typed(k, v) }.join(", ") + "}" + " body, ?Hash[untyped, untyped] options"
+    def response(http_code)
+      schema = resolve_all_of(@props.dig("responses", http_code, "content", "application/json", "schema"))
+      schema_to_hash(schema, {})
     end
 
-    def to_typed(k, v)
-      return "#{k}: #{v&.capitalize}" unless v.is_a?(Array) || v.is_a?(Hash)
-      return "#{k}: {#{v.map{ |k2, v2| to_typed(k2, v2) }.join(", ")}}" if v.is_a?(Hash)
-
-      if v[0]&.is_a?(Hash)
-        "#{k}: Array[{" + v[0].map{ |k, v| to_typed(k, v) }.join(", ") + "}]"
-      else
-        "#{k}: Array[#{v[0]&.capitalize}]"
+    def all_responses
+      result = @props.dig("responses").keys.reduce({}) do |memo, key|
+        memo.merge({ key => response(key) })
       end
     end
 
-    def body
-      body_schema = resolve_of(props.dig("requestBody", "content", "application/json", "schema"))
-      return {} unless body_schema
+    def all_responses_for_return_method
+      return '{ "200" => response }' if all_responses.empty?
 
-      schema_to_typed(body_schema)
+      result = all_responses.keys.map{|key| "\"#{key}\" => response" }.join(", ")
+      "{ #{result} }"
     end
 
     def parameters_for_method
-      return parameters.push("options = {}").join(", ") if (method == "get")
+      return parameters.push("options = {}").join(", ") if method == "get"
 
-      parameters.push("body").push("options = {}").join(", ")
+      if body&.empty?
+        parameters.push("options = {}").join(", ")
+      else
+        parameters.push("body").push("options = {}").join(", ")
+      end
     end
 
-    def schema_to_typed(schema, memo = {})
+    def schema_to_hash(schema, memo = {})
       return nil unless schema
 
-      schema["properties"]&.reduce(memo)do |memo, (k,v)|
+      properties = schema["type"] == "array" ? schema["items"]["properties"] : schema["properties"]
+
+      result = properties&.reduce(memo)do |memo, (k,v)|
         if v["type"] == "object"
-          memo.merge({k => schema_to_typed(v, {})})
+          memo.merge({k => schema_to_hash(v, {})})
         elsif v["type"] == "array"
           if v.dig("items", "type") == "object"
-            memo.merge({k => [schema_to_typed(v["items"], {})] })
+            memo.merge({k => [schema_to_hash(v["items"], {})] })
           else
             memo.merge({k => [v.dig("items", "type")] })
           end
@@ -101,6 +112,9 @@ module Swagger2Rbs
           memo.merge({k => v["type"] })
         end
       end
+      return [result] if schema["type"] == "array"
+
+      result
     end
 
     def resolve_of(data)
@@ -115,10 +129,12 @@ module Swagger2Rbs
     end
 
     def resolve_all_of(data)
-      return data unless data
-      return data unless data["allOf"]
-
-      data["allOf"].reduce(&:merge)
+      HashHelper.resolve_special_key(data, "allOf") do |key, value|
+        value.reduce(value[0]) do |memo, it|
+          memo["properties"] = memo["properties"].merge(it["properties"])
+          memo
+        end
+      end
     end
   end
 end

data/lib/swagger2_rbs/rest_endpoint_typed.rb

@@ -0,0 +1,30 @@
+require_relative './rbs_type'
+module Swagger2Rbs
+  module RestEndpointTyped
+    def typed_parameters_for_method
+      options_typed = "?Hash[untyped, untyped] options"
+      return "(#{options_typed})" unless body && parameters
+      return "(#{options_typed})" if body.empty? && parameters.empty?
+
+      typed_parameters = parameters&.map{|it| "String #{it}" } || []
+
+      typed_parameters.push("#{body_typed} body") if body?
+
+      "(#{typed_parameters.push(options_typed).join(', ')})"
+    end
+
+    def body_typed
+      RbsType.new(body).write_types
+    end
+
+    def response_typed(http_code)
+      RbsType.new(response(http_code), symbolize_keys: false).write_types
+    end
+
+    def all_responses_typed
+      return '{ "200" => untyped }' unless @props.dig("responses")
+
+      RbsType.new(all_responses, symbolize_keys: false).write_types
+    end
+  end
+end

data/lib/swagger2_rbs.rb

@@ -5,37 +5,32 @@ require_relative 'swagger2_rbs/hash_helper'
 
 module Swagger2Rbs
 
-  def self.resolve_ref(hash, key, value)
-    ref_key = value.gsub("#/", "").split("/")
-    data = hash.dig(*ref_key)
-    update_key = key.split(".").reject{|k| k == "$ref"}.join(".")
-
-    [update_key, data]
-  end
-
   def self.resolve_all_ref(swagger_spec)
-    new_swagger_spec = swagger_spec.dup
-    HashHelper.walk(swagger_spec) do |key, value|
-      if key.split(".").last == "$ref"
-        update_key, data = resolve_ref(swagger_spec, key, value)
-        HashHelper.set_value(new_swagger_spec, update_key, data)
-      end
+    HashHelper.resolve_special_key(swagger_spec, "$ref") do |key, value|
+      ref_key = value.gsub("#/", "").split("/")
+      swagger_spec.dig(*ref_key)
     end
-    new_swagger_spec
   end
 
-  def self.swagger_to_rest_api(swagger_spec)
+  def self.swagger_to_rest_api(swagger_spec, parse_method = :to_h)
     result = []
     resolve_all_ref(swagger_spec)["paths"].each do |path, data|
       data.each do |method, props|
         rest_data = RestEndpoint.new(path, method, props)
-        result << rest_data.to_h
+        result << rest_data.send(parse_method)
       end
     end
 
     { base_uri: swagger_spec["servers"].first["url"], endpoints: result }
   end
 
+  def self.swagger_to_rest_api_yaml(swagger_spec)
+    response = swagger_to_rest_api(swagger_spec, :to_yaml)
+    YAML.dump(
+      HashHelper.deep_transform_keys_in_object!(response, &:to_s)
+    ).gsub("---\n", "")
+  end
+
   def self.rest_api_all(spec)
     result = []
     spec[:endpoints].each do |endpoint|

data/lib/templates/http_client.rb.erb

@@ -1,5 +1,5 @@
-
-require 'httparty'
+# require 'httparty'
+require 'json'
 
 class <%= @module_name %>
   include HTTParty
@@ -11,13 +11,15 @@ class <%= @module_name %>
   end
   <%- @data[:endpoints].each do |endpoint| -%>
 
-  <%- if endpoint[:method] == 'get' -%>
+  <%- unless endpoint[:has_body] -%>
   def <%= endpoint[:method_name] %>(<%= endpoint[:parameters_for_method] %>)
-    self.class.<%= endpoint[:method] %>("<%= endpoint[:path] %>", options)
+    response = self.class.<%= endpoint[:http_method] %>("<%= endpoint[:path] %>", options)
+    [response, <%= endpoint[:all_responses_for_return_method] %>]
   end
   <%- else -%>
   def <%= endpoint[:method_name] %>(<%= endpoint[:parameters_for_method] %>)
-    self.class.<%= endpoint[:method] %>("<%= endpoint[:path] %>", { body: body.to_json }.merge(options))
+    response = self.class.<%= endpoint[:http_method] %>("<%= endpoint[:path] %>", { body: body.to_json }.merge(options))
+    [response, <%= endpoint[:all_responses_for_return_method] %>]
   end
   <%- end -%>
   <%- end -%>

data/lib/templates/http_client.rbs.erb

@@ -1,16 +1,26 @@
-
 # Classes
 
+module HTTParty
+  class Response
+    def body: -> untyped
+    def success?: -> bool
+    def code: -> Integer
+  end
+end
+
 class <%= @module_name %>
   include HTTParty
 
+  def self.headers: (untyped headers) -> void
+  def self.base_uri: (String uri) -> void
+  def self.get: (String path, untyped options) -> HTTParty::Response
+  def self.post: (String path, untyped options) -> HTTParty::Response
+  def self.put: (String path, untyped options) -> HTTParty::Response
+  def self.delete: (String path, untyped options) -> HTTParty::Response
+
   def initialize: -> void
   <%- @data[:endpoints].each do |endpoint| -%>
 
-  <%- if endpoint[:method] == 'get' -%>
-  def <%= endpoint[:method_name] %>(<%= endpoint[:parameters_typed] %>) -> HTTParty::Response
-  <%- else -%>
-  def <%= endpoint[:method_name] %>(<%= endpoint[:body_typed] %>) -> HTTParty::Response
-  <%- end -%>
+  def <%= endpoint[:method_name] %>: <%= endpoint[:typed_parameters_for_method] %> -> [HTTParty::Response, <%= endpoint[:all_responses_typed] %>]
   <%- end -%>
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: swagger-to-rbs
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Miguel Savignano
@@ -14,14 +14,14 @@ dependencies:
   name: thor
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
@@ -51,7 +51,9 @@ files:
 - lib/swagger2_rbs.rb
 - lib/swagger2_rbs/cli.rb
 - lib/swagger2_rbs/hash_helper.rb
+- lib/swagger2_rbs/rbs_type.rb
 - lib/swagger2_rbs/rest_endpoint.rb
+- lib/swagger2_rbs/rest_endpoint_typed.rb
 - lib/templates/http_client.rb.erb
 - lib/templates/http_client.rbs.erb
 homepage: https://github.com/MiguelSavignano/swagger-to-rbs