open_api_import 0.12.1 → 0.12.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1bdc8574c5269031de67696726c02074c76f9984fce636eaf30975d4e2f68f7
-  data.tar.gz: 5fe961eea45418c8d304dea541c6eb50e62a6bb7284ebfe6b4a427e3359dc3b1
+  metadata.gz: 74cd0d1b3fe72eae2aad945df578673832e5a2a58ad938e065abe70db5edc161
+  data.tar.gz: f5e13c3fc110c404c14065aeb5d626ddea4a8171ae1a4174b492cbf19c0f0660
 SHA512:
-  metadata.gz: 06132d15447601dab341129865b759ea4d723bd93463f1d3ac8a9f105ee2d4a8d6f704a8f200dcbd7a29e81587690c6f0e05dc5446284d7f4eb83cd528e937fa
-  data.tar.gz: 55f730d08221bb65e4481688a9f84390d70695a0f2d5902de376807ff2b7fc19666015f8cad9551fcf51e0c9450d171bfb1f34807c3f7b231c8449c569a43fc0
+  metadata.gz: 67225ba813dfd134e16fd7682704259397281f77f81f0641f8181830af10c8b025d75f6afa5b5a20a8407baf39c38762c69d2dbdd240ee321faa577554f5967d
+  data.tar.gz: 1ac239ef7256b100a920ca79f3766a6b3bddfad3effce4ce745225a89da55275e379fad9833c788bb6e430a5be8e424602d1f68e400dcbc6ac1b54d9e1b55ca6

data/lib/open_api_import/get_examples.rb

@@ -8,6 +8,7 @@ module LibOpenApiImport
     example << "{" unless properties.empty? || (type == :only_value)
     properties.each do |prop, val|
       unless remove_readonly && val.key?(:readOnly) && (val[:readOnly] == true)
+        key = ruby_hash_key(prop)
         effective_type = val[:type]
         if val.key?(:properties) && !val.key?(:example) && !val.key?(:type)
           effective_type = "object"
@@ -23,23 +24,23 @@ module LibOpenApiImport
 
         if effective_example
           if effective_example.is_a?(Array) && val.key?(:type) && (val[:type] == "string")
-            example << " #{prop.to_sym}: \"#{effective_example[0]}\", "
+            example << " #{key} #{effective_example[0].to_s.inspect}, "
           elsif effective_example.is_a?(String)
             escaped = effective_example.include?("'") ? effective_example : effective_example.gsub('"', "'")
-            example << " #{prop.to_sym}: \"#{escaped}\", "
+            example << " #{key} #{escaped.inspect}, "
           elsif effective_example.is_a?(Time)
-            example << " #{prop.to_sym}: \"#{effective_example}\", "
+            example << " #{key} #{effective_example.to_s.inspect}, "
           else
-            example << " #{prop.to_sym}: #{effective_example}, "
+            example << " #{key} #{effective_example.inspect}, "
           end
         elsif effective_type
           format = val[:format]
           format = effective_type if format.to_s == ""
           case effective_type.downcase
           when "string"
-            example << " #{prop.to_sym}: \"#{format}\", "
+            example << " #{key} #{format.to_s.inspect}, "
           when "integer"
-            example << " #{prop.to_sym}: 0, "
+            example << " #{key} 0, "
           when "number"
             format_name = format.to_s.downcase
             number_value = if %w[float double decimal].include?(format_name)
@@ -47,9 +48,9 @@ module LibOpenApiImport
                            else
                              "0"
                            end
-            example << " #{prop.to_sym}: #{number_value}, "
+            example << " #{key} #{number_value}, "
           when "boolean"
-            example << " #{prop.to_sym}: true, "
+            example << " #{key} true, "
           when "array"
             items_enum = if val.key?(:items) && val[:items].is_a?(Hash) && (val[:items].size == 1) && val[:items].key?(:type)
                            [val[:items][:type]]
@@ -59,15 +60,9 @@ module LibOpenApiImport
 
             if items_enum
               if type == :only_value
-                if items_enum[0].is_a?(String)
-                  example << " [\"#{items_enum[0]}\"] "
-                else
-                  example << " [#{items_enum[0]}] "
-                end
-              elsif items_enum[0].is_a?(String)
-                example << " #{prop.to_sym}: [\"#{items_enum[0]}\"], "
+                example << " #{[items_enum[0]].inspect} "
               else
-                example << " #{prop.to_sym}: [#{items_enum[0]}], "
+                example << " #{key} #{[items_enum[0]].inspect}, "
               end
             else
               examplet = get_response_examples({ schema: val }, remove_readonly).join("\n")
@@ -75,7 +70,7 @@ module LibOpenApiImport
               if type == :only_value
                 example << examplet
               else
-                example << " #{prop.to_sym}: #{examplet}, "
+                example << " #{key} #{examplet}, "
               end
             end
           when "object"
@@ -85,9 +80,9 @@ module LibOpenApiImport
             else
               res_ex = res_ex.join("\n")
             end
-            example << " #{prop.to_sym}: #{res_ex}, "
+            example << " #{key} #{res_ex}, "
           else
-            example << " #{prop.to_sym}: \"#{format}\", "
+            example << " #{key} #{format.to_s.inspect}, "
           end
         end
       end

data/lib/open_api_import/get_patterns.rb

@@ -7,43 +7,36 @@ module LibOpenApiImport
     data_pattern = []
     effective_type = dpv[:type]
     effective_type = Array(effective_type).reject { |t| t == "null" }.first if effective_type.is_a?(Array)
+    key = ruby_hash_key(dpk)
 
     if dpv.keys.include?(:pattern)
-      if dpv[:pattern].include?('\\\\/')
-        data_pattern << "'#{dpk}': /#{dpv[:pattern].to_s.gsub('\/', "/")}/"
-      elsif dpv[:pattern].match?(/\\x[0-9ABCDEF][0-9ABCDEF]-/)
-        data_pattern << "'#{dpk}': /#{dpv[:pattern].to_s.gsub('\\x', '\\u00')}/"
-      elsif dpv[:pattern].include?('\\x')
-        data_pattern << "'#{dpk}': /#{dpv[:pattern].to_s.gsub('\\x', '\\u')}/"
-      else
-        data_pattern << "'#{dpk}': /#{dpv[:pattern]}/"
-      end
+      pattern = dpv[:pattern].to_s
+      pattern = pattern.gsub('\/', "/") if pattern.include?('\\\\/')
+      pattern = pattern.gsub('\\x', '\\u00') if pattern.match?(/\\x[0-9ABCDEF][0-9ABCDEF]-/)
+      pattern = pattern.gsub('\\x', '\\u') if pattern.include?('\\x')
+      data_pattern << "#{key} #{Regexp.new(pattern).inspect}"
     elsif dpv.key?(:minLength) && dpv.key?(:maxLength)
-      data_pattern << "'#{dpk}': :'#{dpv[:minLength]}-#{dpv[:maxLength]}:LN$'"
+      data_pattern << "#{key} #{ruby_symbol_literal("#{dpv[:minLength]}-#{dpv[:maxLength]}:LN$")}"
     elsif dpv.key?(:minLength) && !dpv.key?(:maxLength)
-      data_pattern << "'#{dpk}': :'#{dpv[:minLength]}:LN$'"
+      data_pattern << "#{key} #{ruby_symbol_literal("#{dpv[:minLength]}:LN$")}"
     elsif !dpv.key?(:minLength) && dpv.key?(:maxLength)
-      data_pattern << "'#{dpk}': :'0-#{dpv[:maxLength]}:LN$'"
+      data_pattern << "#{key} #{ruby_symbol_literal("0-#{dpv[:maxLength]}:LN$")}"
     elsif dpv.key?(:minimum) && dpv.key?(:maximum) && (effective_type == "string")
-      data_pattern << "'#{dpk}': :'#{dpv[:minimum]}-#{dpv[:maximum]}:LN$'"
+      data_pattern << "#{key} #{ruby_symbol_literal("#{dpv[:minimum]}-#{dpv[:maximum]}:LN$")}"
     elsif dpv.key?(:minimum) && dpv.key?(:maximum)
-      data_pattern << "'#{dpk}': #{dpv[:minimum]}..#{dpv[:maximum]}"
+      data_pattern << "#{key} #{dpv[:minimum].inspect}..#{dpv[:maximum].inspect}"
     elsif dpv.key?(:minimum) && !dpv.key?(:maximum)
-      if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.6.0")
-        data_pattern << "'#{dpk}': #{dpv[:minimum]}.. "
-      else
-        data_pattern << "#'#{dpk}': #{dpv[:minimum]}.. # INFINITE only working on ruby>=2.6.0"
-      end
+      data_pattern << "#{key} #{dpv[:minimum].inspect}.. "
     elsif !dpv.key?(:minimum) && dpv.key?(:maximum)
-      data_pattern << "'#{dpk}': 0..#{dpv[:maximum]}"
+      data_pattern << "#{key} 0..#{dpv[:maximum].inspect}"
     elsif dpv[:format] == "date-time"
-      data_pattern << "'#{dpk}': DateTime"
+      data_pattern << "#{key} DateTime"
     elsif effective_type == "boolean"
-      data_pattern << "'#{dpk}': Boolean"
+      data_pattern << "#{key} Boolean"
     elsif dpv.key?(:enum)
-      data_pattern << "'#{dpk}': :'#{dpv[:enum].join("|")}'"
+      data_pattern << "#{key} #{dpv[:enum].join("|").to_sym.inspect}"
     elsif (effective_type == "array") && dpv.key?(:items) && dpv[:items].is_a?(Hash) && dpv[:items].key?(:enum) && dpv[:items][:enum].is_a?(Array)
-      data_pattern << "'#{dpk}': [:'#{dpv[:items][:enum].join("|")}']"
+      data_pattern << "#{key} [#{dpv[:items][:enum].join("|").to_sym.inspect}]"
     elsif (effective_type == "array") && dpv.key?(:items) && dpv[:items].is_a?(Hash) && !dpv[:items].key?(:enum) && dpv[:items].key?(:properties)
       dpv[:items][:properties].each do |dpkk, dpvv|
         if dpk == ""
@@ -58,9 +51,9 @@ module LibOpenApiImport
       if result.empty?
         item_type = dpv[:items][:type]
         item_type = Array(item_type).reject { |t| t == "null" }.first if item_type.is_a?(Array)
-        data_pattern << "'#{dpk}': [:'#{item_type}']"
+        data_pattern << "#{key} [#{item_type.to_s.to_sym.inspect}]"
       else
-        data_pattern << "'#{dpk}': [ #{result.join[4..]} ]"
+        data_pattern << "#{key} [ #{result.join[4..]} ]"
       end
     elsif (effective_type == "object") && dpv.key?(:properties)
       dpv[:properties].each do |dpkk, dpvv|

data/lib/open_api_import/get_response_examples.rb

@@ -15,22 +15,13 @@ module LibOpenApiImport
       v = v[:content][:"application/json"].dup
     end
     if v.key?(:examples) && v[:examples].is_a?(Hash) && v[:examples].key?(:"application/json")
-      if v[:examples][:"application/json"].is_a?(String)
-        response_example << v[:examples][:"application/json"]
-      elsif v[:examples][:"application/json"].is_a?(Hash)
-        exs = v[:examples][:"application/json"].to_s
-        exs.gsub!(/:(\w+)=>/, "\n\\1: ")
-        response_example << exs
-      elsif v[:examples][:"application/json"].is_a?(Array)
+      example = v[:examples][:"application/json"]
+      if example.is_a?(Array)
         response_example << "["
-        v[:examples][:"application/json"].each do |ex|
-          exs = ex.to_s
-          if ex.is_a?(Hash)
-            exs.gsub!(/:(\w+)=>/, "\n\\1: ")
-          end
-          response_example << "#{exs}, "
-        end
+        example.each { |item| response_example << "#{item.inspect}, " }
         response_example << "]"
+      else
+        response_example << example.inspect
       end
       # for open api 3.0. examples on reponses, for example: api-with-examples.yaml
     elsif v.key?(:content) && v[:content].is_a?(Hash) && v[:content].key?(:"application/json") &&
@@ -43,22 +34,12 @@ module LibOpenApiImport
         else
           tresp = ""
         end
-        if tresp.is_a?(String)
-          response_example << tresp
-        elsif tresp.is_a?(Hash)
-          exs = tresp.to_s
-          exs.gsub!(/:(\w+)=>/, "\n\\1: ")
-          response_example << exs
-        elsif tresp.is_a?(Array)
+        if tresp.is_a?(Array)
           response_example << "["
-          tresp.each do |ex|
-            exs = ex.to_s
-            if ex.is_a?(Hash)
-              exs.gsub!(/:(\w+)=>/, "\n\\1: ")
-            end
-            response_example << "#{exs}, "
-          end
+          tresp.each { |item| response_example << "#{item.inspect}, " }
           response_example << "]"
+        else
+          response_example << tresp.inspect
         end
         break # only the first one it is considered
       end
@@ -91,7 +72,7 @@ module LibOpenApiImport
       end
     elsif v.key?(:schema) && v[:schema].key?(:items) && v[:schema][:items].is_a?(Hash) && v[:schema][:items].key?(:type)
       # for the case only type supplied but nothing else for the array
-      response_example << "[\"#{v[:schema][:items][:type]}\"]"
+      response_example << [v[:schema][:items][:type].to_s].inspect
     end
     response_example.each do |rs|
       # (@type Google) for the case in example the key is something like: @type:

data/lib/open_api_import/open_api_import.rb

@@ -5,7 +5,7 @@ using OpenApiImportStringExt
 class OpenApiImport
   class ParseError < StandardError; end
 
-  VERSION = "0.12.1"
+  VERSION = "0.12.2"
 
   extend LibOpenApiImport
 
@@ -81,18 +81,16 @@ class OpenApiImport
 
       raw[:host] if raw.key?(:host)
       base_path = raw[:basePath] if raw.key?(:basePath)
-      module_name = raw[:info][:title].camel_case
-      module_version = "V#{raw[:info][:version].to_s.snake_case}"
+      module_name = ruby_constant_name(raw[:info][:title])
+      module_version = ruby_module_version(raw[:info][:version])
 
       output = []
       output_header = []
       output_header << ("#" * 50)
-      output_header << "# #{raw[:info][:title]}"
-      output_header << "# version: #{raw[:info][:version]}"
+      output_header.concat comment_lines(raw[:info][:title])
+      output_header.concat comment_lines(raw[:info][:version], prefix: "# version: ")
       output_header << "# description: "
-      raw[:info][:description].to_s.split("\n").each do |d|
-        output_header << "#     #{d}" unless d == ""
-      end
+      output_header.concat comment_lines(raw[:info][:description], prefix: "#     ")
       output_header << ("#" * 50)
 
       output_header << "module Swagger"
@@ -124,7 +122,7 @@ class OpenApiImport
           if %w[get post put delete patch].include?(met.to_s.downcase)
             params = []
             params_path = []
-            params_query = []
+            params_query = {}
             params_required = []
             params_data = []
             description_parameters = []
@@ -145,9 +143,9 @@ class OpenApiImport
               method_name.chop! if method_name[-1] == "_"
             elsif create_method_name == :operation_id
               if ((name_for_module == :tags) || (name_for_module == :tags_file)) && cont.key?(:tags) && cont[:tags].is_a?(Array) && cont[:tags].size.positive?
-                metnametmp = cont[:operationId].gsub(/^#{cont[:tags].join}[\s_]*/, "")
+                metnametmp = cont[:operationId].gsub(/^#{Regexp.escape(cont[:tags].join)}[\s_]*/, "")
                 cont[:tags].join.split.each do |tag|
-                  metnametmp = metnametmp.gsub(/^#{tag}[\s_]*/i, "")
+                  metnametmp = metnametmp.gsub(/^#{Regexp.escape(tag)}[\s_]*/i, "")
                 end
                 metnametmp = met if metnametmp == ""
               else
@@ -155,14 +153,15 @@ class OpenApiImport
               end
               method_name = metnametmp.to_s.snake_case
             elsif ((name_for_module == :tags) || (name_for_module == :tags_file)) && cont.key?(:tags) && cont[:tags].is_a?(Array) && cont[:tags].size.positive?
-              method_name = cont[:operationId].gsub(/^#{cont[:tags].join}[\s_]*/, "")
+              method_name = cont[:operationId].gsub(/^#{Regexp.escape(cont[:tags].join)}[\s_]*/, "")
               cont[:tags].join.split.each do |tag|
-                method_name = method_name.gsub(/^#{tag}[\s_]*/i, "")
+                method_name = method_name.gsub(/^#{Regexp.escape(tag)}[\s_]*/i, "")
               end
               method_name = met if method_name == ""
             else
               method_name = cont[:operationId]
             end
+            method_name = ruby_method_name(method_name, preserve_case: create_method_name == :operationId)
             path_txt = path.path.dup.to_s
             if [:path, :path_file, :tags, :tags_file].include?(name_for_module)
               old_module_requests = module_requests
@@ -173,17 +172,20 @@ class OpenApiImport
                   module_requests = "Root"
                 else
                   res_path = path_requests.scan(/(\w+)/)
-                  module_requests = res_path[0][0].camel_case
+                  module_requests = ruby_constant_name(res_path[0][0])
                 end
               elsif cont.key?(:tags) && cont[:tags].is_a?(Array) && cont[:tags].size.positive?
-                module_requests = cont[:tags].join(" ").camel_case
+                module_requests = ruby_constant_name(cont[:tags].join(" "))
               else
                 module_requests = "Undefined"
               end
 
               if /^(?<vers>v\d+)/i =~ method_name
                 method_name = method_name.gsub(/^#{vers}_?/, "")
-                module_requests = (vers.capitalize + module_requests).camel_case unless module_requests.start_with?(vers)
+                method_name = ruby_method_name(method_name, preserve_case: create_method_name == :operationId)
+                unless module_requests.start_with?(vers)
+                  module_requests = ruby_constant_name(vers.capitalize + module_requests)
+                end
               end
 
               if old_module_requests != module_requests
@@ -204,16 +206,16 @@ class OpenApiImport
             end
 
             output << ""
-            output << "# operationId: #{cont[:operationId]}, method: #{met}"
-            output << "# summary: #{cont[:summary].split("\n").join("\n#          ")}" if cont.key?(:summary)
-            if cont[:description].to_s.split("\n").empty?
-              output << "# description: #{cont[:description]}"
-            else
-              output << "# description: "
-              cont[:description].to_s.split("\n").each do |d|
-                output << "#     #{d}" unless d == ""
+            output.concat comment_lines("#{cont[:operationId]}, method: #{met}", prefix: "# operationId: ")
+            if cont.key?(:summary)
+              summary_lines = cont[:summary].to_s.split(/\R/)
+              output << "# summary: #{summary_lines[0]}" unless summary_lines.empty?
+              summary_lines.drop(1).each do |line|
+                output << "#          #{line}" unless line.empty?
               end
             end
+            output << "# description: "
+            output.concat comment_lines(cont[:description], prefix: "#     ")
 
             mock_example = []
 
@@ -223,18 +225,19 @@ class OpenApiImport
 
                 data_pattern += get_patterns("", v[:schema]) if v.key?(:schema)
                 data_pattern.uniq!
-                resp_description = v[:description].to_s.gsub("'", %q(\\\'))
+                response_key = ruby_symbol_key(k)
+                resp_description = v[:description].to_s.inspect
                 if response_example.empty?
-                  responses << "'#{k}': { message: '#{resp_description}'}, "
+                  responses << "#{response_key} { message: #{resp_description}}, "
                 else
-                  responses << "'#{k}': { "
-                  responses << "message: '#{resp_description}', "
+                  responses << "#{response_key} { "
+                  responses << "message: #{resp_description}, "
                   responses << "data: "
                   responses << response_example
                   responses << "},"
                   if mock_response && mock_example.empty?
-                    mock_example << "code: '#{k}',"
-                    mock_example << "message: '#{resp_description}',"
+                    mock_example << "code: #{k.to_s.inspect},"
+                    mock_example << "message: #{resp_description},"
                     mock_example << "data: "
                     mock_example << response_example
                   end
@@ -262,43 +265,40 @@ class OpenApiImport
                 end
 
                 if p[:in] == "path"
-                  if create_method_name == :operationId
-                    param_name = p[:name]
-                    path_txt = path_txt.gsub("{#{param_name}}", "\#{#{param_name}}")
-                  else
-                    param_name = p[:name].to_s.snake_case
-                    path_txt = path_txt.gsub("{#{p[:name]}}", "\#{#{param_name}}")
-                  end
+                  param_name = ruby_parameter_name(p[:name])
+                  path_txt = path_txt.gsub("{#{p[:name]}}", "\#{#{param_name}}")
                   unless params_path.include?(param_name)
                     if create_constants
-                      params_path << "#{param_name}: #{param_name.upcase}"
-                      required_constants << param_name.upcase
+                      constant_name = ruby_environment_constant(param_name)
+                      params_path << "#{param_name}: #{constant_name}"
+                      required_constants << constant_name
                     else
                       params_path << param_name
                     end
                     @logger.warn "Description key is missing for #{met} #{path.path} #{p[:name]}" if p[:description].nil?
-                    description_parameters << "#    #{p[:name]}: (#{type}) #{"(required)" if p[:required].to_s == "true"} #{p[:description].to_s.split("\n").join("\n#\t\t\t")}"
+                    description_parameters.concat parameter_comment_lines(p[:name], type, p[:required], p[:description])
                   end
                 elsif p[:in] == "query"
-                  params_query << p[:name]
-                  params_required << p[:name] if p[:required].to_s == "true"
+                  param_name = ruby_parameter_name(p[:name])
+                  params_query[param_name] = p[:name].to_s
+                  params_required << param_name if p[:required].to_s == "true"
                   @logger.warn "Description key is missing for #{met} #{path.path} #{p[:name]}" if p[:description].nil?
-                  description_parameters << "#    #{p[:name]}: (#{type}) #{"(required)" if p[:required].to_s == "true"} #{p[:description].to_s.split("\n").join("\n#\t\t\t")}"
+                  description_parameters.concat parameter_comment_lines(p[:name], type, p[:required], p[:description])
                 elsif (p[:in] == "formData") || (p[:in] == "formdata")
-                  description_parameters << "#    #{p[:name]}: (#{p[:type]}) #{p[:description].split("\n").join("\n#\t\t\t")}"
+                  description_parameters.concat parameter_comment_lines(p[:name], p[:type], p[:required], p[:description])
 
                   case p[:type]
                   when /^string$/i
-                    data_form << "#{p[:name]}: ''"
+                    data_form << "#{ruby_hash_key(p[:name])} ''"
                     data_form_hash[p[:name].to_sym] = ""
                   when /^boolean$/i
-                    data_form << "#{p[:name]}: true"
+                    data_form << "#{ruby_hash_key(p[:name])} true"
                     data_form_hash[p[:name].to_sym] = true
                   when /^number$/i
-                    data_form << "#{p[:name]}: 0"
+                    data_form << "#{ruby_hash_key(p[:name])} 0"
                     data_form_hash[p[:name].to_sym] = 0
                   when /^integer$/i
-                    data_form << "#{p[:name]}: 0"
+                    data_form << "#{ruby_hash_key(p[:name])} 0"
                     data_form_hash[p[:name].to_sym] = 0
                   else
                     puts "! on formData not supported type #{p[:type]}"
@@ -356,7 +356,7 @@ class OpenApiImport
                           end
 
                           if dpv.keys.include?(:description)
-                            description_parameters << "#    #{dpk}: (#{dpv[:type]}) #{dpv[:description].split("\n").join("\n#\t\t\t")}"
+                            description_parameters.concat parameter_comment_lines(dpk, dpv[:type], false, dpv[:description])
                           end
 
                           data_pattern += get_patterns(dpk, dpv)
@@ -377,13 +377,7 @@ class OpenApiImport
                             data_read_only << dpk
                           end
                           if dpv.keys.include?(:default)
-                            if dpv[:default].nil?
-                              data_default << "#{dpk}: nil"
-                            elsif dpv.type != "string"
-                              data_default << "#{dpk}: #{dpv[:default]}"
-                            else
-                              data_default << "#{dpk}: '#{dpv[:default]}'"
-                            end
+                            data_default << "#{ruby_hash_key(dpk)} #{dpv[:default].inspect}"
                           end
 
                           params_data_hash[dpk] = build_example_value(dpv)
@@ -392,13 +386,13 @@ class OpenApiImport
                             params_data << get_examples({ dpk => dpv }, :only_value, true).join
                             params_data[-1].chop!.chop! if params_data[-1].to_s[-2..] == ", "
                             params_data.pop if params_data[-1].match?(/^\s*$/im)
+                          elsif dpv.keys.include?(:example)
+                            raw = dpv[:example].is_a?(Array) && dpv.type != "array" ? dpv[:example][0] : dpv[:example]
+                            params_data << "#{ruby_hash_key(dpk)} #{raw.inspect}"
+                          elsif valv.to_s.empty?
+                            params_data << "#{ruby_hash_key(dpk)} \"\""
                           else
-                            if valv.to_s == ""
-                              valv = '""'
-                            elsif valv.include?('"')
-                              valv = valv.gsub('"', "'") unless valv.include?("'")
-                            end
-                            params_data << "#{dpk}: #{valv}"
+                            params_data << "#{ruby_hash_key(dpk)} #{valv}"
                           end
                         end
                         if params_data.size.positive?
@@ -420,7 +414,7 @@ class OpenApiImport
 
                     unless data_required.empty?
                       data_required.uniq!
-                      output << "# required data: #{data_required.inspect}"
+                      output.concat comment_lines(data_required.inspect, prefix: "# required data: ")
                     end
                   end
                 elsif p[:in] == "header"
@@ -438,32 +432,34 @@ class OpenApiImport
                   if create_constants
                     if params_query.include?(pr)
                       if create_method_name == :operationId
-                        path_txt += "#{pr}=\#{#{pr}}&"
-                        params << "#{pr}: #{pr.upcase}"
-                        required_constants << pr.upcase
+                        constant_name = ruby_environment_constant(pr)
+                        path_txt += "#{params_query[pr]}=\#{#{pr}}&"
+                        params << "#{pr}: #{constant_name}"
                       else
-                        path_txt += "#{pr}=\#{#{pr.to_s.snake_case}}&"
-                        params << "#{pr.to_s.snake_case}: #{pr.to_s.snake_case.upcase}"
-                        required_constants << pr.to_s.snake_case.upcase
+                        parameter_name = ruby_parameter_name(pr)
+                        constant_name = ruby_environment_constant(parameter_name)
+                        path_txt += "#{params_query[pr]}=\#{#{parameter_name}}&"
+                        params << "#{parameter_name}: #{constant_name}"
                       end
+                      required_constants << constant_name
                     end
                   elsif params_query.include?(pr)
                     if create_method_name == :operationId
-                      path_txt += "#{pr}=\#{#{pr}}&"
+                      path_txt += "#{params_query[pr]}=\#{#{pr}}&"
                       params << pr.to_s
                     else
-                      path_txt += "#{pr}=\#{#{pr.to_s.snake_case}}&"
+                      path_txt += "#{params_query[pr]}=\#{#{pr.to_s.snake_case}}&"
                       params << pr.to_s.snake_case.to_s
                     end
                   end
                 end
-                params_query.each do |pq|
+                params_query.each do |pq, query_name|
                   unless params_required.include?(pq)
                     if create_method_name == :operationId
-                      path_txt += "#{pq}=\#{#{pq}}&"
+                      path_txt += "#{query_name}=\#{#{pq}}&"
                       params << "#{pq}: ''"
                     else
-                      path_txt += "#{pq}=\#{#{pq.to_s.snake_case}}&"
+                      path_txt += "#{query_name}=\#{#{pq.to_s.snake_case}}&"
                       params << "#{pq.to_s.snake_case}: ''"
                     end
                   end
@@ -480,8 +476,9 @@ class OpenApiImport
               paramst = []
               prms = path_txt.scan(/[^#]{(\w+)}/)
               prms.each do |p|
-                paramst << p[0].to_s.snake_case
-                path_txt = path_txt.gsub("{#{p[0]}}", "\#{#{p[0].to_s.snake_case}}")
+                param_name = ruby_parameter_name(p[0])
+                paramst << param_name
+                path_txt = path_txt.gsub("{#{p[0]}}", "\#{#{param_name}}")
               end
               paramst.concat params
               params = paramst
@@ -491,20 +488,21 @@ class OpenApiImport
 
             output << "{"
 
-            output << "name: \"#{module_requests}.#{method_name}\","
+            output << "name: #{"#{module_requests}.#{method_name}".inspect},"
 
-            output << "path: \"#{base_path}#{path_txt}\","
+            interpolation_names = path_txt.scan(/#\{([A-Za-z_][A-Za-z0-9_]*)\}/).flatten
+            output << "path: #{ruby_interpolated_string("#{base_path}#{path_txt}", interpolation_names)},"
 
             output << "method: :#{met}," if met.to_s != ""
 
             unless data_required.empty?
               output << "data_required: ["
-              output << ":'#{data_required.uniq.join("', :'")}'"
+              output << data_required.uniq.inspect[1..-2]
               output << "],"
             end
             unless data_read_only.empty?
               output << "data_read_only: ["
-              output << ":'#{data_read_only.uniq.join("', :'")}'"
+              output << data_read_only.uniq.inspect[1..-2]
               output << "],"
             end
             unless data_default.empty?
@@ -552,7 +550,7 @@ class OpenApiImport
                 data_examples[0].each do |edata|
                   read_only = false
                   data_read_only.each do |rdata|
-                    if edata.scan(/^#{rdata}:/).size.positive?
+                    if edata.scan(/^#{Regexp.escape(rdata.to_s)}:/).size.positive?
                       read_only = true
                       break
                     elsif edata.scan(":").empty?
@@ -632,7 +630,8 @@ class OpenApiImport
           output = output_header + out_mod + output_footer
           output_txt = output.join("\n")
           requests_file_path = "#{file_to_convert}_#{mod}.rb"
-          requires_txt += "require_relative '#{File.basename(swagger_file)}_#{mod}'\n"
+          required_path = "#{File.basename(swagger_file)}_#{mod}"
+          requires_txt += "require_relative #{required_path.inspect}\n"
           if return_data
             generated_files[requests_file_path] = output_txt
           else

data/lib/open_api_import/pretty_hash_symbolized.rb

@@ -10,10 +10,10 @@ module LibOpenApiImport
     hash.each do |kr, kv|
       if kv.is_a?(Hash)
         restv = pretty_hash_symbolized(kv)
-        restv[0] = "#{kr}: {"
+        restv[0] = "#{ruby_hash_key(kr)} {"
         output += restv
       else
-        output << "#{kr}: #{kv.inspect}, "
+        output << "#{ruby_hash_key(kr)} #{kv.inspect}, "
       end
     end
     output << "},"

data/lib/open_api_import/safe_codegen.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+using OpenApiImportStringExt
+
+module LibOpenApiImport
+  RUBY_KEYWORDS = %w[
+    BEGIN END alias and begin break case class def defined? do else elsif end
+    ensure false for if in module next nil not or redo rescue retry return self
+    super then true undef unless until when while yield
+  ].freeze
+
+  private
+
+  # Prefix every physical line so spec text cannot terminate a Ruby comment.
+  def comment_lines(text, prefix: "# ")
+    text.to_s.split(/\R/).reject(&:empty?).map { |line| "#{prefix}#{line}" }
+  end
+
+  def ruby_constant_name(text, fallback: "Untitled")
+    name = text.to_s.camel_case.gsub(/[^A-Za-z0-9_]/, "")
+    name = fallback if name.empty?
+    name = "C#{name}" unless name.match?(/\A[A-Z]/)
+    name
+  end
+
+  def ruby_module_version(text, fallback: "V0")
+    name = "V#{text.to_s.snake_case}".gsub(/[^A-Za-z0-9_]/, "")
+    name = fallback if name.empty? || name == "V"
+    name
+  end
+
+  def ruby_method_name(text, preserve_case: false, fallback: "undefined")
+    source = text.to_s.split(/\R/).join("_")
+    name = if preserve_case
+             source.gsub(/[^A-Za-z0-9_]/, "")
+           else
+             source.snake_case.gsub(/[^a-z0-9_]/, "")
+           end
+    name = fallback if name.empty?
+    name = "_#{name}" unless name.match?(/\A[A-Za-z_]/)
+    name = "#{name}_" if RUBY_KEYWORDS.include?(name)
+    name
+  end
+
+  def ruby_parameter_name(text, fallback: "parameter")
+    ruby_method_name(text, fallback: fallback)
+  end
+
+  def ruby_environment_constant(text)
+    name = ruby_parameter_name(text).upcase
+    name = "C#{name}" unless name.match?(/\A[A-Z]/)
+    name
+  end
+
+  def ruby_hash_key(text)
+    name = text.to_s
+    if name.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/) && !RUBY_KEYWORDS.include?(name)
+      "#{name}:"
+    else
+      "#{name.inspect} =>"
+    end
+  end
+
+  def ruby_symbol_key(text)
+    "#{text.to_s.inspect}:"
+  end
+
+  def ruby_symbol_literal(text)
+    text.to_s.to_sym.inspect
+  end
+
+  # String#inspect escapes interpolation. Re-enable only placeholders that were
+  # generated from identifiers already reduced to Ruby local-variable syntax.
+  def ruby_interpolated_string(text, variable_names)
+    literal = text.to_s.inspect
+    variable_names.uniq.each do |name|
+      token = format("\#{%s}", name)
+      literal = literal.gsub("\\#{token}", token)
+    end
+    literal
+  end
+
+  def parameter_comment_lines(name, type, required, description)
+    required_label = required.to_s == "true" ? "(required) " : ""
+    rendered = "#{name}: (#{type}) #{required_label}#{description}".rstrip
+    comment_lines(rendered, prefix: "#    ")
+  end
+end

data/lib/open_api_import/utils.rb

@@ -11,7 +11,7 @@ module OpenApiImportStringExt
     end
 
     def camel_case
-      return self if self !~ /_/ && self !~ /-/ && self !~ /\s/ && self =~ /^[A-Z]+.*/
+      return self if self =~ /\A[A-Z][A-Za-z0-9]*\z/
 
       gsub(/\W/, "_")
         .split("_").map(&:capitalize).join

data/lib/open_api_import.rb

@@ -3,6 +3,7 @@
 require "fileutils"
 
 require_relative "open_api_import/utils"
+require_relative "open_api_import/safe_codegen"
 require_relative "open_api_import/filter"
 require_relative "open_api_import/pretty_hash_symbolized"
 require_relative "open_api_import/get_patterns"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: open_api_import
 version: !ruby/object:Gem::Version
-  version: 0.12.1
+  version: 0.12.2
 platform: ruby
 authors:
 - Mario Ruiz
@@ -129,6 +129,7 @@ files:
 - lib/open_api_import/get_response_examples.rb
 - lib/open_api_import/open_api_import.rb
 - lib/open_api_import/pretty_hash_symbolized.rb
+- lib/open_api_import/safe_codegen.rb
 - lib/open_api_import/utils.rb
 homepage: https://github.com/MarioRuiz/open_api_import
 licenses: