import_postman 1.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 25eac0e93409e3b9416aeed345a08766a975e5973b63cae485e74abbb9789863
+  data.tar.gz: f2c232428dd79b968abaa8b313f24ab534203b331077ad5b7a641873be36ad8e
+SHA512:
+  metadata.gz: 596871c561d69c0f9bcb14d74dcf6fbe92a3e589335395619a188b3e3a8102a02983d474483d04cafce189fc6bbb6b1f117d00559f1c5896bf0a3578dc59e68d
+  data.tar.gz: af43a59b80d66a63ad93343dd1f31d231a328be49e60314bdab9bc1c2622a7ca33e1f40ae53fd2810b27e1535a4685454a6b48184819411082b12717474afe72

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Mario Ruiz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,124 @@
+# ImportPostman
+## Description
+Using import_postman method you will be able to import a postman collection and create a Ruby Requests Hash containing the path, headers, data...
+
+You can also generate the Ruby tests from the tests you have declared on your collection by using the ImportPostman::Parsers module
+
+Feel free to add more parsers or improve existing ones
+
+## Input parameters
+
+The import_postman method has these arguments: 
+
+    postman_collection_file_path: (positional) (String)
+        Specify just the name of the collection without the extension and in case we have on the same folder the environment and/or the global variable files they will be imported automatically also.
+        It is necessary in that case to use the default extensions from Postman: .postman_collection, .postman_environment, .postman_globals.
+        The postman collection need to be exported as v1
+        
+    env_file: (optional) (keyword) (String) 
+        Path to the environment postman file
+
+    global_file: (optional)  (keyword) (String)
+        Path to the global postman file
+        
+    output_file: (optional)  (keyword) (String)
+        Path to output file
+
+    mock_vars: (optional)  (keyword) (Hash) 
+        Hash including all postman variables we want to mock for example: {"requestId": "return_requestId_method"}
+
+
+## Output
+In case output_file is supplied the file will be exported to that location and name. In case not .rb extension it will be added.
+
+In case a output_file is not supplied then automatically will create one with the same name as postman_collection_file_path and .rb extension on the same path
+
+The postman environments variables will be added as global variables at the beginning of the resultant file
+
+The postman global variables will be added as global variables at the beginning of the resultant file
+
+All other postman variables will be added as parameters on the request methods created
+
+The file when converted will be possible to be used in your code, for example:
+
+```ruby
+request=RESTRequests::Customer.addAlias()
+```
+
+The Postman Dynamic Variables will be converted into Ruby variables. Added $guid, $timestamp and $randomint
+
+## Examples of Use
+
+### Case #1
+
+Only one parameter, the collection name with relative path and no extension supplied.
+
+The file on the folder would be: MyCustomer.json.postman_collection
+
+In case a MyCustomer.json.postman_environment and/or MyCustomer.json.postman_globals found on the same folder, they will be automatically imported also
+
+```ruby
+     import_postman "./interfaces/rest/postman/MyCustomer.json"
+```
+
+### Case #2
+     
+Relative paths, collection, environmental variables and global variables, with different extensions that the default ones
+
+```ruby
+     import_postman "./interfaces/rest/postman/collection.json.txt", 
+       env_file: "./interfaces/rest/postman/env.json.txt", 
+       global_file: "./interfaces/rest/postman/global.json.txt"
+```
+
+### Case #3
+
+Full path for collection, environmental variables and global variables. relative path for resultant string. Different names and extensions
+
+```ruby
+     import_postman "c:/MyPostManFiles/MyCustomer_postman_collection.json", 
+     env_file: "c:/MyPostManFiles/MyCustomer_env", 
+     global_file: "c:/MyPostManFiles/MyCustomer_global", 
+     output_file: "./interfaces/rest/customer_postman.rb"
+```
+
+### Case #4
+Change the value of an environmental variable and create tests (mini-test) using the rest-client library
+
+```ruby
+  require 'string_pattern' #to generate the random value for requestId
+
+  require 'import_postman/parsers/rest_client' #to generate the tests
+  include ImportPostman::Parsers::RestClient
+  
+  require 'import_postman'
+  import_postman "./my_collections/MyCustomer.json",
+                  mock_vars: {"requestId": " '6:/Nx/'.gen"}
+```
+
+### Case #5
+Change the value of an environmental variable and create tests (test-unit) using the rest-client library
+
+```ruby
+  require 'string_pattern' #to generate the random value for requestId
+
+  IP_TEST_FRAMEWORK='test-unit'
+  require 'import_postman/parsers/rest_client' #to generate the tests
+  include ImportPostman::Parsers::RestClient
+  
+  require 'import_postman'
+  import_postman "./my_collections/MyCustomer.json",
+                  mock_vars: {"requestId": " '6:/Nx/'.gen"}
+```
+
+The tests file will be generated on the same folder than the output_file with the same name but finish by _tests
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/marioruiz/import_postman.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/lib/import_postman.rb

@@ -0,0 +1,312 @@
+
+require 'nice_hash'
+
+##################################################################################
+# This method import a postman collection to be used as RequestHash object
+# Input:
+#   postman_collection_file_path: specify just the name of the collection without the extension and in case we have on the same folder the environment and/or the global variable files they will be imported automatically also.
+#     It is necessary in that case to use the default extensions from Postman: .postman_collection, .postman_environment, .postman_globals.
+#   env_file: (optional) path to the environment postman file
+#   global_file: (optional) path to the global postman file
+#   output_file: (optional) path to output file
+#   mock_vars: (optional) Hash including all postman variables we want to mock for example: {"requestId": "return_requestId_method"}
+# Output:
+#   In case output_file is supplied the file will be exported to that location and name. In case not .rb extension it will be added.
+#   In case a output_file is not supplied then automatically will create one with the same name as postman_collection_file_path and .rb extension on the same path
+#   The postman environments variables will be added as global variables at the beginning of the resultant file
+#   The postman global variables will be added as global variables at the beginning of the resultant file
+#   All other postman variables will be added as parameters for the request
+#   The file when converted will be possible to be used in your code, for example:
+#     request=RESTRequests::Customer.addAlias()
+#   The Postman Dynamic Variables will be converted into Ruby variables. Added $guid, $timestamp and $randomint
+# examples:
+#   only one parameter, the collection name with relative path and no extension supplied.
+#   The file on the folder would be: MyCustomer.json.postman_collection
+#   In case a MyCustomer.json.postman_environment and/or MyCustomer.json.postman_globals found on the same folder, they will be automatically imported also
+#     import_postman "./interfaces/rest/postman/MyCustomer.json"
+#   relative paths, collection, environmental variables and global variables, with different extensions that the default ones
+#     import_postman "./interfaces/rest/postman/collection.json.txt", env_file: "./interfaces/rest/postman/env.json.txt", global_file: "./interfaces/rest/postman/global.json.txt"
+#   full path for collection, environmental variables and global variables. relative path for resultant string. Different names and extensions
+#     import_postman "c:/MyPostManFiles/MyCustomer_postman_collection.json", env_file: "c:/MyPostManFiles/MyCustomer_env", global_file: "c:/MyPostManFiles/MyCustomer_global", output_file: "./interfaces/rest/customer_postman.rb"
+##################################################################################
+def import_postman(postman_collection_file_path, env_file: postman_collection_file_path+".postman_environment", global_file: postman_collection_file_path+".postman_globals", output_file: postman_collection_file_path+".rb", mock_vars: Hash.new())
+  #.postman_collection, .postman_environment, .postman_globals
+  require 'json'
+  postman_env_file_path = env_file
+  postman_global_file_path = global_file
+  output_file_path = output_file
+
+  if postman_collection_file_path["./"].nil? then
+    file_to_convert=postman_collection_file_path
+  else
+    file_to_convert=Dir.pwd.to_s() + "/" + postman_collection_file_path.gsub("./", "")
+  end
+
+  unless File.exist?(file_to_convert)
+    file_to_convert+=".postman_collection"
+  end
+
+  if output_file_path['.rb'].nil? then
+    output_file_path+=".rb"
+  end
+
+  unless output_file_path["./"].nil? then
+    output_file_path=Dir.pwd.to_s() + "/" + output_file_path.gsub("./", "")
+  end
+  env_vars = {}
+
+  if defined?(parse_postman_test)
+    test_output_file_path = output_file_path.gsub(/\.rb$/, "_tests.rb")
+    tests = ""
+    num_test = 0
+  end
+
+
+  unless postman_global_file_path==""
+    unless postman_global_file_path["./"].nil? then
+      postman_global_file_path=Dir.pwd.to_s() + "/" + postman_global_file_path.gsub("./", "")
+    end
+    if File.exist?(postman_global_file_path) then
+      begin
+        file=File.read(postman_global_file_path)
+        puts "** Postman Global file imported: #{postman_global_file_path}"
+      rescue Exception => stack
+        warn "* It seems there was a problem reading the Global file #{postman_global_file_path}"
+        warn stack.to_s()
+        return false
+      end
+
+      val=JSON.parse(file, {symbolize_names: true})
+      if val.keys.include?(:values) then
+        val=val[:values]
+      end
+      val.each {|v|
+        env_vars[v[:key]]=v[:value] if v[:key]!="url" and v[:key]!=:url and v[:key]!="host" and v[:key]!=:host
+      }
+    end
+  end
+
+  unless postman_env_file_path==""
+    unless postman_env_file_path["./"].nil? then
+      postman_env_file_path=Dir.pwd.to_s() + "/" + postman_env_file_path.gsub("./", "")
+    end
+    if File.exist?(postman_env_file_path) then
+      begin
+        file=File.read(postman_env_file_path)
+        puts "** Postman Env file imported: #{postman_env_file_path}"
+      rescue Exception => stack
+        warn "* It seems there was a problem reading the Env file #{postman_env_file_path}"
+        warn stack.to_s()
+        return false
+      end
+
+      val=JSON.parse(file, {symbolize_names: true})
+      val[:values].each {|v|
+        env_vars[v[:key]]=v[:value] if v[:key]!="url" and v[:key]!=:url and v[:key]!="host" and v[:key]!=:host
+      }
+    end
+  end
+
+  begin
+    if File.exist?(file_to_convert) then
+      file=File.read(file_to_convert)
+      puts "** Postman Collection file imported: #{file_to_convert}"
+    else
+      warn "* It seems the collection file #{file_to_convert} doesn't exist"
+      return false
+    end
+  rescue Exception => stack
+    warn "* It seems there was a problem reading the collection file #{file_to_convert}"
+    warn stack.to_s()
+    return false
+  end
+
+  val=JSON.parse(file, {symbolize_names: true})
+
+  module_main_name=val[:name].gsub(/^[\d\s\W]+/, "")
+  module_main_name=module_main_name.gsub(/\W+/, "_")
+  module_main_name=module_main_name[0, 1].upcase + module_main_name[1..-1] #to be sure first character is in capitalize
+  if defined?(parse_postman_test_headers)
+    tests="require './#{File.basename output_file_path}'\n"
+    tests+=parse_postman_test_headers(module_main_name)
+  end
+
+  requests={}
+  if val.keys.include?(:folders) and val.keys.include?(:requests) then
+    requests_added=[]
+    val[:folders].each {|folder|
+      folder[:order].each {|reqnum|
+        request=val[:requests].select {|f| f[:id]==reqnum}
+        if request.size==1 #found one
+          module_name=folder[:name].gsub(/^[\d\s\W]+/, "")
+          module_name=module_name.gsub(/\W+/, "_")
+          module_name=module_name[0, 1].upcase + module_name[1..-1] #to be sure first character is in capitalize
+          requests[module_name]=Array.new() unless requests.keys.include?(module_name)
+          requests[module_name].push(request[0])
+          requests_added.push(reqnum)
+        end
+      }
+    }
+    module_main_name="" if requests.keys.size>0 #there are folders
+    if val[:requests].size>requests_added.size then #if there are some requests that are not in folders
+      requests[""]=Array.new()
+      val[:requests].each {|req|
+        if !requests_added.include?(req[:id]) then
+          requests[""].push(req)
+        end
+      }
+    end
+  elsif val.keys.include?(:requests) then
+    requests[""]=Array.new()
+    val[:requests].each {|req|
+      requests[""].push(req)
+    }
+  end
+
+
+  rest_methods=""
+  all_variables_on_path=[]
+  all_variables_on_headers=[]
+  requests.each {|folder, requests_folder|
+    rest_methods+="\n   \tmodule #{folder}\n\n" unless folder==""
+
+    requests_folder.each {|request|
+      #url, host or server are the postman variables for the testserver
+      path=request[:url].gsub(/\{\{url\}\}/, "").gsub(/\{\{server\}\}/, "").gsub(/\{\{host\}\}/, "").gsub(/https?:\/\//, "").gsub("{{", "\#{").gsub("}}", "}")
+      variables_on_path=path.scan(/{(\w+)}/)
+      variables_on_path.uniq!
+      if request[:rawModeData].to_s()!="" then
+        data=request[:rawModeData].gsub("\r", "")
+        variables_on_data=Array.new
+        begin
+          JSON.parse(data.gsub("{{",'"').gsub("}}",'"'))
+          data.gsub!(/"([^"]+)"\s*:/, '\1:')
+          variables_on_data=data.scan(/{([\w\-]+)}/)
+          variables_on_data.uniq!
+          if variables_on_data.size>0 and variables_on_data[0].size>0
+            variables_on_data[0].each {|v|
+              #for the case it is not a string
+              data.gsub!(": {{#{v}}}", ": #{v.gsub("-", "_").downcase}")
+              #for the case it is a string
+              data.gsub!("{{#{v}}}", "{{#{v.gsub("-", "_").downcase}}}")
+              v.gsub!("-", "_")
+            }
+          end
+          data.gsub!("{{", "\#{")
+          data.gsub!("}}", "}")
+          data.gsub!(/:\s*null/, ": nil")
+        rescue
+          data='"'+request[:rawModeData].gsub("\r", "") + '"'
+        end
+      else
+        data=""
+        variables_on_data=[]
+      end
+      all_variables_on_path+=variables_on_path
+      all_variables_on_path.uniq!
+      header=request[:headers].gsub(/\{\{url\}\}/, "").gsub(/\{\{server\}\}/, "").gsub(/\{\{host\}\}/, "").gsub(/https?:\/\//, "").gsub('"','\"')
+      #remove headers starting by //
+      header.gsub!(/^\/\/.+$/,'')
+      #remove empty lines
+      header.gsub!(/^\s*$\n/,'')
+      variables_on_header=header.scan(/{([\w\-]+)}/)
+      variables_on_header.uniq!
+      if variables_on_header.size>0 and variables_on_header[0].size>0
+        variables_on_header[0].each {|v|
+          header.gsub!("{{#{v}}}", "{{#{v.gsub("-", "_")}}}")
+          v.gsub!("-", "_")
+        }
+      end
+      header.gsub!("{{", '#{$')
+      header.gsub!('}}', '}')
+      header.gsub!("\n", '", ')
+      header.gsub!(/([^:,\s]+):\s+/, '"\1"=>"')
+      header.gsub!(/=>([^,"]+)/, '=>"\1"')
+      header.gsub!(/,\s*$/, '')
+      header+='"' if header.length>0 and header[-1]!='"'
+      all_variables_on_headers+=variables_on_header
+      all_variables_on_headers.uniq!
+      variables_txt=""
+      variables_on_path.each {|var|
+        variables_txt+="#{var.join}:$#{var.join}, "
+      }
+      if variables_on_data.size>0 then
+        variables_on_data.each {|var|
+          if !variables_on_path.include?(var) then
+            if env_vars.keys.include?(var.join) then
+              variables_txt+="#{var.join.downcase}:$#{var.join.downcase}, "
+            else
+              variables_txt+="#{var.join.downcase}:'', "
+            end
+          end
+        }
+      end
+      variables_txt.chop!
+      variables_txt.chop!
+      method_name=request[:name].gsub(/\W+/, "_")
+      method_name.chop! if method_name[-1]=="_"
+      method_name=method_name[0, 1].downcase + method_name[1..-1] #to be sure first character is in downcase
+      unless request[:description].to_s==""
+        request[:description].to_s.lines.each{|desc|
+          rest_methods+="\t\t# #{desc}"
+        }
+        rest_methods+="\n"
+      end
+      rest_methods+="\t\tdef self.#{method_name}(#{variables_txt})\n\t\t\treturn {\n"
+      rest_methods+="\t\t\t\tpath: \"#{path}\",\n"
+      rest_methods+="\t\t\t\theaders: {#{header}},\n"
+      if data!="" then
+        rest_methods+="\t\t\t\tdata: #{data.split("\n").join("\n\t\t\t\t")}"
+      end
+      rest_methods+="\n\t\t\t}\n\t\tend\n\n"
+      if request[:tests]!="" and defined?(parse_postman_test)
+        num_test+=1
+        #todo: add here preRequestScript or in the parse_postman_test method, decide
+        method_to_call= "RESTRequests"
+        method_to_call+="::#{module_main_name}" unless module_main_name.to_s()==""
+        method_to_call+="::#{folder}" unless folder.to_s()==""
+        method_to_call+=".#{method_name}"
+        method_to_call="#{request[:method].downcase}(#{method_to_call})"
+        rcode = parse_postman_test(request[:tests].to_s, num_test, method_name, method_to_call)
+        tests+=rcode
+      end
+    }
+    rest_methods+="\n   \tend\n\n" unless folder==''
+  }
+  rest_methods+="   end" unless module_main_name.to_s()==""
+  rest_methods+="\nend"
+  header_vars="# Postman variables\n"
+  env_vars.each {|key, value|
+    header_vars+="   $#{key.gsub("-", "_").downcase}='#{value}'\n"
+  }
+  header_vars+="\n\nmodule RESTRequests\n"
+  header_vars+="\n   module #{module_main_name}\n\n" if module_main_name.to_s()!=""
+
+  rest_methods= header_vars + rest_methods
+
+  #Postman dynamic variables
+  rest_methods.gsub!(/\$randomInt([^a-zA-Z=])/i, 'rand(1001)\1')
+  rest_methods.gsub!(/\$timestamp([^a-zA-Z=])/i, 'Time.now.strftime(\'%Y-%m-%dT%H:%M:%S.000Z\')\1')
+  rest_methods.gsub!(/\$guid([^a-zA-Z=])/i, 'SecureRandom.uuid\1')
+  mock_vars.each {|mvar, mvalue|
+    rest_methods.gsub!(/\$#{mvar}([^a-zA-Z=])/i, mvalue+'\1')
+  }
+  rest_methods.gsub!(/\s+,$/, ",") #to avoid orphan lines with only one comma
+  tests+="end" if defined?(parse_postman_test)
+  if output_file_path!=""
+    File.open(output_file_path, 'w').write(rest_methods)
+    puts "** Requests file: #{output_file_path} that contains the code of the requests and the environment variables after importing the Postman file"
+    if defined?(parse_postman_test)
+      File.open(test_output_file_path, 'w').write(tests)
+      puts "** Tests file: #{test_output_file_path} that contains the code of the tests after importing the Postman file"
+    end
+  end
+
+  begin
+    eval(rest_methods)
+  rescue Exception => stack
+    warn "* It seems there was a problem importing the postman file #{postman_collection_file_path}"
+    warn stack.to_s()
+  end
+
+end

data/lib/import_postman/parsers/rest_client.rb

@@ -0,0 +1,219 @@
+
+module ImportPostman
+  module Parsers
+    module RestClient
+	  #can be test-unit or minitest
+	  IP_TEST_FRAMEWORK='minitest' unless defined?(IP_TEST_FRAMEWORK)
+	  
+      def parse_postman_test_headers(module_main_name)
+        headers="require 'test-unit'\n" if IP_TEST_FRAMEWORK=='test-unit'
+        headers="require 'minitest/autorun'\n" if IP_TEST_FRAMEWORK=='minitest'
+        headers+="require 'json'\n"
+        headers+="require 'nice_hash'\n"
+        headers+="require 'rest-client'\n\n"
+
+        headers+="
+        class String
+          def json(*keys)
+            require 'json'
+            return JSON.parse(self, {symbolize_names: true})
+          end
+          def ==(par)
+            if par.kind_of?(Integer) or par.nil? or par.kind_of?(Float) then
+              super(par.to_s())
+            else
+              super(par)
+            end
+          end
+        end\n\n"
+        headers+="class Test#{module_main_name} < Test::Unit::TestCase\n\n" if IP_TEST_FRAMEWORK=='test-unit'
+        headers+="class Test#{module_main_name} < Minitest::Test\n\n" if IP_TEST_FRAMEWORK=='minitest'
+		headers+="i_suck_and_my_tests_are_order_dependent!\n\n" if IP_TEST_FRAMEWORK=='minitest'
+		headers+="\tdef setup\n\t\t"
+        headers+='@http=RestClient::Resource.new("http://#{$host}")'
+        headers+="\n\tend\n"
+        return headers
+      end
+
+      def parse_postman_test(js, num_test, test_name, method_to_call)
+        rcode_lines=Array.new
+        rcode_txt="\tdef test_#{num_test.to_s.rjust(3, "0")}_#{test_name}\n"
+        res=method_to_call.scan(/(\w+)\((.+)\)/)
+        met=res[0][0]
+        req=res[0][1]
+        if met=='post' or met=='put'
+          method_to_call="#{met} req[:data].to_json, req.headers"
+        else
+          method_to_call="#{met} req.headers"
+        end
+
+        rcode_txt+="\t\treq=#{req}\n"
+        rcode_txt+="\t\tbegin\n"
+        rcode_txt+="\t\t\tresponse=@http[req.path].#{method_to_call}\n"
+        rcode_txt+="\t\trescue RestClient::ExceptionWithResponse => res\n"
+        rcode_txt+="\t\t\tresponse=res.response\n"
+        rcode_txt+="\t\tend\n"
+
+        var_data=""
+        blocks=Array.new
+        blocks_add=Array.new
+        js.split(/$/).each {|line|
+
+          line_orig=line.dup
+          rcode=""
+          line.gsub!("===", "==")
+          line.gsub!(/;$/, "")
+          line.gsub!('\"','"')
+          line.gsub!("responseCode.code", "response.code")
+          line.gsub!(" : ", ": ")
+          #pm.environment.set("coupon_id_dgrd", jsonData.coupons[0].primaryCouponId)
+          if line.scan(/pm\.environment\.set\(\"(\w+)\",\s*(.+)\)/).size>0
+            rcode=line.gsub!(/pm\.environment\.set\(\"(\w+)\",\s*(.+)\)/, '$\1 = \2')
+          end
+          line.gsub!(/environment\["(\w+)"\]/, '$\1')
+          line.gsub!(/environment\./, '$')
+          line.gsub!(/postman.getEnvironmentVariable\(['"](\w+)['"]\)/, '$\1')
+          #postman.getResponseHeader('WWW-Authenticate')
+          line.gsub!(/postman\.getResponseHeader\(['"]([\w-]+)['"]\)/, 'response.headers["\1"]')
+          line.gsub!(/parseInt\(([\w\$\-]+)\)/, '\1.to_i')
+          line.gsub!(".indexOf", ".include?")
+          line.gsub!(/\.include\?\((\w+)\)==\s*-1\s*/, '.include?(\1)==false')
+          line.gsub!(/\.include\?\((\w+)\)\s*==\s*0/, '.include?(\1)==true')
+          line.gsub!("responseBody", "response.body")
+          line.gsub!(".has(", ".include?(")
+          line.gsub!(/(['"\w\s]+) in (\w+)/, '\1.include?(\2)') if line.scan(/for\s*\(/).size==0
+
+          #typeof jsonData.guaranteedPrizeData[0].gpData== "string"
+          if line.scan(/typeof (.+)\s*==\s*"(\w+)"/).size>0
+            res=line.scan(/typeof (.+)\s*==\s*"(\w+)"/)
+            var=res[0][0]
+            type=res[0][1].capitalize
+            line.gsub!(/typeof (.+)\s*==\s*"(\w+)"/, "#{var}.kind_of?(#{type})")
+          end
+
+          if blocks[-1]==:if_one_line and line.strip.scan(/\s*{/).size>0 #'if' is a block not a line
+            blocks[-1]=:if_block
+          end
+
+          if line.strip=="" or
+              (line.strip=="{" and (blocks[-1]==:if_one_line or blocks[-1]==:if_block or blocks[-1]==:for))
+            next
+          elsif blocks[-1]==:if_one_line and line.scan(/^\s*if\s+/).size==0 #we are in the next line after if
+            rcode="#{line.strip}\n\t\tend"
+            blocks.pop
+          elsif line.scan(/\s*\/\//).size>0
+            rcode="# #{line.scan(/\s*\/\/(.+)/).join}"
+          elsif blocks[-1]==:comment
+            rcode="# #{line.lstrip}"
+            if line.scan(/\s*\*\//).size>0
+              blocks.pop
+            end
+          elsif line.scan(/\s*\/\*/).size>0
+            rcode="# #{line.scan(/\s*\/\*(.+)/).join}"
+            unless line.scan(/\s*\*\//).size>0
+              blocks<<:comment
+            end
+          elsif line.scan(/^\s*try\s*{/).size>0
+            blocks<<:try
+            rcode="begin"
+          elsif line.strip.scan("}").size>0 and blocks[-1]==:try
+            blocks.pop
+            rcode=""
+          elsif line.scan(/^\s*catch\s*\((\w+)\)\s*{/).size>0
+            rcode="rescue Exception =>#{line.scan(/^\s*catch\s*\((\w+)\)\s*{/).join}"
+            if line.scan(/}\s*$/).size>0 #ends in one line
+              rcode+="\n\t\tend\n"
+            end
+            blocks<<:catch
+          elsif line.strip.scan("}").size>0 and blocks[-1]==:try
+            blocks.pop
+            rcode=""
+          elsif line.strip.scan(/else if\s*/).size>0 and rcode_lines.size>0 and rcode_lines[-1].strip=="end"
+            rcode_lines.pop
+            rcode=line.gsub("else if","elsif").strip.gsub(/\s*\{$/, '')
+            blocks<<:if_block
+          elsif line.strip.scan(/else\s*\{/).size>0 and rcode_lines.size>0 and rcode_lines[-1].strip=="end"
+            rcode_lines.pop
+            rcode="else"
+            blocks<<:if_block
+          elsif line.scan(/^\s*\w+\.push/).size>0
+            #arrayOfValuesFromhighestNumber4Comparing.push(highestNumber4Comparing[j][key])
+            rcode=line.strip.gsub(/;\s*$/, "")
+          elsif line.scan(/^\s*if\s*/).size>0
+            #if ( key === numberCount && numberCount4Comparing[k][key] != jsonData.games[i].properties.numberCount)\n"
+            if line.scan(/{\s*$/).size==0 #only one like for the if on next line, not a block
+              blocks<<:if_one_line
+            else
+              blocks<<:if_block
+            end
+            rcode=line.strip.gsub(/\s*\{$/, '')
+          elsif line.strip=="}"
+            if blocks[-1]==:for
+              rcode="#{blocks_add[blocks.size-1]}\t\tend"
+              blocks_add[blocks.size-1]=""
+              blocks.pop
+            else
+              rcode="end"
+              blocks_add[blocks.size-1]=""
+              blocks.pop
+            end
+          elsif line.scan(/for\s*\(var (\w+)\s+in/).size>0
+            #for(var key in highestNumber4Comparing[j])
+            var=line.scan(/for\s*\(var (\w+)\s+in\s+([^\)]+)\)/)
+            variab=var[0][0]
+            compar=var[0][1]
+            #for i in 0..jsonData.games.length-1
+            rcode="for #{variab} in #{compar}"
+            blocks<<:for
+          elsif line.scan(/for\s*\(var (\w+\s*=\s*\d+);([^;]+)/).size>0
+            #for(var i=0;i<jsonData.games.length;i++){
+            var=line.scan(/for\s*\(var (\w+\s*=\s*\d+);([^;]+)/)
+            variab=var[0][0]
+            compar=var[0][1]
+            rcode="#{variab}\n\t\twhile #{compar}\n"
+            blocks<<:for
+            blocks_add[blocks.size-1]="\t\t#{variab.scan(/(\w+)\s*=/).join}+=1\n"
+          elsif line.scan(/\w\s*;\s*\w/).size>0
+            #any line with more than one instruction
+            rcode="#Line not added: #{line.lstrip}"
+          elsif var_data=="" and line.scan(/var\s(\w+)\s*=\s*JSON\.parse\(response.body\)/).size>0
+            var_data = line.scan(/var\s(\w+)\s*=\s*JSON\.parse\(response.body\)/).join
+            rcode="#{var_data} = response.body.json"
+          elsif line.scan(/postman\.setEnvironmentVariable\(/).size>0
+            vart=line.scan(/postman\.setEnvironmentVariable\("(\w+)"/).join
+            valt=line.scan(/postman\.setEnvironmentVariable\("\w+",\s*(.+)\)$/).join
+            rcode="$#{vart} = #{valt}"
+          elsif line.scan(/var \w+\s*=/).size>0
+            vart=line.scan(/var\s+(\w+)\s*/).join
+            valt=line.scan(/var\s+\w+\s*=\s*(.+)$/).join
+            valt[-1]="" if valt[-1]=="," #multiple assigment
+            rcode="#{vart} = #{valt}"
+          elsif line.scan(/^\s*\w+\s*=\s*/).size>0
+            vart=line.scan(/^\s*(\w+)\s*/).join
+            valt=line.scan(/^\s*\w+\s*=\s*(.+)$/).join
+            valt[-1]="" if valt[-1]=="," #multiple assigment
+            rcode="#{vart} = #{valt}"
+          elsif line.scan(/tests\[/).size>0
+            msg=line.scan(/tests\["([^=]*)"\]/).join
+            val=line.scan(/tests\["[^=]*"\]\s*=\s*(.+)/).join
+            if msg==""
+              msg=line.scan(/tests\[(.*)\]\s=\s/).join
+              val=line.scan(/tests\[.*\]\s=\s(.+)/).join
+            else
+              msg="\"#{msg}\""
+            end
+            rcode="assert(#{val}, #{msg})"
+          elsif rcode==""
+            rcode="#Line not added: #{line_orig.lstrip}"
+          end
+          rcode_lines.push("\t\t#{rcode.to_s.lstrip}\n") unless rcode==""
+        }
+        rcode_txt+=rcode_lines.join
+        rcode_txt+="\tend\n\n"
+        return rcode_txt
+      end
+
+    end
+
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: import_postman
+version: !ruby/object:Gem::Version
+  version: 1.5.0
+platform: ruby
+authors:
+- Mario Ruiz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-05-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nice_hash
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+description: This gem imports a postman collection to be used as RequestHash object
+email: marioruizs@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- LICENSE
+- README.md
+- lib/import_postman.rb
+- lib/import_postman/parsers/rest_client.rb
+homepage: https://github.com/MarioRuiz/import_postman
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: This gem imports a postman collection to be used as RequestHash object
+test_files: []