canned_soap 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 23355d1c2e66be1f8577a68e8015eab0a1ea1169
+  data.tar.gz: 859ff7e1c8ff6b1cc0386e0173579e54d040c66e
+SHA512:
+  metadata.gz: 37fa359b99059c40aef433b40d7cf83aecc2a8ec5a6125296349a442b1087f10422a2ae860e6c672a943e49a6ed1c0b379d1cda672b271ec023faab59cca55b4
+  data.tar.gz: 638c52370ac7199be8143812d5fb1541d4ec604d06203743912b08f81486ed853c56062e0ebe23cff14fa4600599d220a05a66670a4effe9b0452e9f991a61a0

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+.docker-compose.yml

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+before_install: gem install bundler -v 1.15.1

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in canned_soap.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Canned
+
+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,62 @@
+#CannedSoap
+
+A rewrite version of the [ruby2soap](https://github.com/ericman93/ruby2soap) gem.
+
+##Motivation
+The original gem has a lot of bugs and don't work on Linux environments. I started to maintain an old gem that uses this gem, so I started to maintain this gem too.
+
+#Ruby2Soap Doc
+I started this project when I needed to call a WCF method which required cookies on init. Unfortunalty, I could not find any gem that will help me so, so I implemented it myself.
+
+While working I noticed that I need more features - authentication, for example.
+
+Please post any bugs, questions and feature requests using the 'Issues' page.
+
+Thank you,
+Eric
+
+
+##Examples
+
+###Initialize the handler
+
+```ruby
+handler = WcfHandler.new('http://www.webservicex.net/CurrencyConvertor.asmx')
+```
+
+###Simple objects
+```ruby
+handler.ConversionRate(:FromCurrency => 'ILS', :ToCurrency => 'GBP')
+```
+
+###Statefull
+```ruby
+  handler.Init(:userName => 'ericman93')
+  handler.IncreaseScore() #the cookies saved automaticly
+```
+
+###Complex type
+```ruby
+handler = WcfHandler.new('http://localhost:1659/Service1.svc')
+res = handler.GetDataUsingDataContract(:composite => {:BoolValue => true,:StringValue => "ruby2soap"})
+```
+
+##Result
+The object that the soap service function returns is actually a HTTP response with 'result' function that returns the actual value.
+If the value is a complex object, then it would be represented as a hash
+
+
+##Authentication
+Available authentications
+1. NTLM
+2. Basic
+3. Digest
+
+###NTLM Auth
+```ruby
+handler.ConversionRate({:FromCurrency => 'ILS', :ToCurrency => 'GBP'},SecutryProtocol::NTLM,'user','password')
+```
+###With domain
+```ruby
+handler.ConversionRate({:FromCurrency => 'ILS', :ToCurrency => 'GBP'},SecutryProtocol::NTLM,'user','password','domain')
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "canned_soap"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/canned_soap.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "canned_soap/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "canned_soap"
+  spec.version       = CannedSoap::VERSION
+  spec.authors       = ["Gustavo Canedo"]
+  spec.email         = ["gknedo@gmail.com"]
+
+  spec.summary       = "Communication between ruby and soap services"
+  spec.homepage      = 'https://github.com/gknedo/canned_soap'
+
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_dependency "xml-simple", "~> 1.0"
+  spec.add_dependency "httpi", "~> 2.0"
+end

data/docker-compose.yml

@@ -0,0 +1,9 @@
+version: '3'
+volumes:
+  gems:
+services:
+  gem:
+    image: ruby:2.4.1
+    volumes:
+      - gems:/usr/local/bundle
+      - .:/opt/gem

data/example.rb

@@ -0,0 +1,26 @@
+require 'ruby2soap'
+
+def complex_object_example
+	handler = CannedSoap::Client.new('http://localhost:1659/Service1.svc')
+	res = handler.GetDataUsingDataContract(composite: {
+		BoolValue: true,
+		StringValue: "canned"
+	})
+	res.result['StringValue']
+end
+
+def cookie_state_full_example
+	handler = CannedSoap::Client.new('http://localhost:1659/Service1.svc')
+	handler.Init(userName: 'ericman93')
+	handler.IncreaseScore()
+end
+
+def few_params_example
+	handler = CannedSoap::Client.new('http://www.webservicex.net/CurrencyConvertor.asmx')
+	handler.ConversionRate(FromCurrency: 'ILS', ToCurrency: 'GBP').result
+end
+
+def ntlm_example
+	handler = CannedSoap::Client.new('http://localhost:1659/Service1.svc')
+	handler.AddPoints({points: 6}, CannedSoap::Web::SecutryProtocol::NTLM, 'user', 'password', 'domain')
+end

data/lib/canned_soap/client.rb

@@ -0,0 +1,83 @@
+# Handle the requests to the service
+module CannedSoap
+	class Client
+		# C'tor.
+		# Parse the wsdl and create a method to each WCF/WebService method
+		# Params:
+		# +service_url+:: the url of your service
+		# +save_cookeis+:: should save cookies of the result
+		def initialize(service_url,save_cookeis = true)
+			HTTPI.log = false
+			@cookies = []
+			@save_cookeis = save_cookeis
+
+			@uri = URI("#{service_url}")
+
+			wsdl = WsdlParser.parse(service_url)
+			@service_address = wsdl.location_address
+
+			wsdl.actions.each do |action|
+				define_wcf_action(action)
+			end
+
+			# maybe create class for each service and the function will be there
+		end
+
+		# Return the the current cookie set
+		def cookies
+			@cookies
+		end
+
+		private
+		# Define a method to the +Ruby2Soap+ object base on the method from the WSDL
+		# Params:
+		# +action+:: +SoapAction+ that have all the info about the method from the WSDL
+		def define_wcf_action(action)
+		 	self.class.send(:define_method ,action.name) do |data=nil,*args|
+				body = build_body(action, data)
+
+				res = send_wcf_action(action.soap_action,body,*args)
+				(@cookies << res.headers["Set-Cookie"]) if @save_cookeis
+
+				result = get_wcf_response(res,action.name)
+				res.singleton_class.send(:define_method,:result) do
+					result
+				end
+
+				#if(res.code == '401') # not autorized
+				#	(raise "Please use ntlm") if res['WWW-Authenticate'].include?('NTLM')
+				#end
+
+				res
+			end
+
+			#create new method that takes the data and user and password and user ntlm
+		end
+
+		# Call to wcf method
+		# Params:
+		# +soap_action+:: the value of the SOAPAction header
+		# +body+:: the body of the HTTP request
+		# +args+:: metadata that indicate wich autountication to use
+		def send_wcf_action(soap_action,body,*args)
+			#req = Net::HTTP::Post.new(@uri.path)
+			#req = Net::HTTP::Post.new(@service_address)
+
+			#req["SOAPAction"] = soap_action
+			#req["Content-Type"] = "text/xml; charset=utf-8"
+			#req["Cookie"] = @cookies.join(',') unless @cookies.empty?
+			#req.body = body
+
+			yield(req) if block_given?
+
+			#get_web_response(req,@uri,*args)
+			# "Cookie" => (@cookies.join(',') unless @cookies.empty?)
+			cookies = @cookies.empty? ? "" : @cookies.join(',')
+			send_message_to_wcf(@service_address,
+							 {"SOAPAction" => soap_action,
+							  "Content-Type" => "text/xml; charset=utf-8",
+							  "Cookie" => cookies},
+							  body, *args)
+		end
+	end
+end

data/lib/canned_soap/soap/soap.rb

@@ -0,0 +1,86 @@
+require 'canned_soap/soap/soap_action'
+require 'canned_soap/soap/soap_parameter'
+require 'xmlsimple'
+
+module CannedSoap::Soap
+	# Covert the data to hash
+	# Params:
+	# +object+:: the object to covert to hash
+	def data_to_arr(object)
+		return '' if object.nil?
+		return [object] unless object.is_a? Hash
+
+		params = {}
+		object.each do |key,value|
+			params["#{@name_space}:#{key}"] = data_to_arr(value)
+		end
+
+		params
+	end
+
+	# Build the body that need to be send to the service when calling the soap action and return the result
+	# Params :
+	# +action+:: +SoapAction+ object that keep all the data about the soap action
+	# +data+:: the user data that he want to send to the server
+	def build_body(action , data)
+		@name_space = 'a'
+		body = {
+			'soap:Envelope' => {
+				'xmlns:soap' => 'http://schemas.xmlsoap.org/soap/envelope/',
+				'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+				'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
+				'soap:Body' => {
+					"#{action.name}" => {
+						"xmlns" => WsdlParser.target_namespace
+					}
+				}
+			}
+		}
+
+		if(!data.nil?)
+			data.each do |key, value|
+				build_param(body['soap:Envelope']['soap:Body']["#{action.name}"],action,key,value)
+			end
+		end
+
+		XmlSimple.xml_out(body, 'RootName' => nil)
+	end
+
+	# Parse the server response to hash that the user will work eith
+	# Params:
+	# +res+:: +HTTPI::Response+ object that represent the response from the server
+	# +action_name+:: the name of the action that the response is belongs to
+	def get_wcf_response(res,action_name)
+		#res.error?
+		if res.code.to_i >= 400
+			'error please see body'
+		else
+			result = XmlSimple.xml_in(res.body)['Body'].first["#{action_name}Response"].first["#{action_name}Result"].first
+			if result.class == Hash
+				# I dont want to return the result xml attributes
+				result.select!{|k,v| v.class == Array}
+			end
+
+			result
+		end
+	end
+
+	# Adds to the action element in the +Hash+ and add the user send data to the hash
+	# Params:
+	# +action_element+:: the action element in the hash of the body
+	# +action+:: +SoapAction+ object that keep all the data about the soap action
+	# +key+:: the name of the parameter
+	# +value+:: the value of the parameter
+	def build_param(action_element,action,key,value)
+		if(action.parameters.nil?)
+			action_element["#{key}"] = ((value.is_a? Hash) ? data_to_arr(value) : [value])
+		else
+			current_param = action.parameters.select{|p| p.name.upcase == key.to_s.upcase}.first
+			action_element["#{key}"] = ((value.is_a? Hash) ? data_to_arr(value) : [value])
+
+			if current_param && current_param.namespace
+				action_element["#{key}"].merge!("xmlns:#{@name_space}" => current_param.namespace)
+			end
+		end
+	end
+end

data/lib/canned_soap/soap/soap_action.rb

@@ -0,0 +1,9 @@
+module CannedSoap::Soap
+	class SoapAction
+		attr_accessor :name, :soap_action, :parameters
+
+		def self.parse()
+			#TODO:parse from xml to SoapParamter object
+		end
+	end
+end

data/lib/canned_soap/soap/soap_parameter.rb

@@ -0,0 +1,17 @@
+module CannedSoap::Soap
+	class SoapParamter
+		attr_accessor :name, :nullable, :type, :namespace
+
+		# Gets the xml element of the paramter and parse it to a +SoapParamter+ object
+		# Params:
+		# +param_element+:: +Hash+ that represent the xml element of the paramter
+		def self.parse(param_element)
+			param = SoapParamter.new
+			param.name = param_element['name']
+			param.type = param_element['type'].split(':').last
+			yield param if block_given?
+
+			param
+		end
+	end
+end

data/lib/canned_soap/version.rb

@@ -0,0 +1,3 @@
+module CannedSoap
+  VERSION = "0.1.0"
+end

data/lib/canned_soap/wcf_handler.rb

@@ -0,0 +1,102 @@
+require 'net/http'
+require 'xmlsimple'
+require 'canned_soap/wsdl/wsdl'
+include Wsdl
+#require 'soap/soap'
+#include Soap
+#include WebRequestHandler
+#require_relative 'wsdl.rb'
+#require_relative 'wsdl_parser.rb'
+#require_relative 'soap.rb'
+#include WsdlParser
+#include Soap
+
+#Dir["lib/*.rb"].each {|file|
+#	require file
+#	#require_relative file# if file != 'wcf_handler'
+#	#include file.gsub('.rb','')
+#}
+
+# Handle the requests to the service
+module CannedSoap
+	class WcfHandler
+		# C'tor.
+		# Parse the wsdl and create a method to each WCF/WebService method
+		# Params:
+		# +service_url+:: the url of your service
+		# +save_cookeis+:: should save cookies of the result
+		def initialize(service_url,save_cookeis = true)
+			HTTPI.log = false
+			@cookies = []
+			@save_cookeis = save_cookeis
+
+			@uri = URI("#{service_url}")
+
+			wsdl = Wsdl::WsdlParser.parse(service_url)
+			@service_address = wsdl.location_address
+
+			wsdl.actions.each do |action|
+				define_wcf_action(action)
+			end
+
+			# maybe create class for each service and the function will be there
+		end
+
+		# Return the the current cookie set
+		def cookies
+			@cookies
+		end
+
+		private
+		# Define a method to the +WcfHandler+ object base on the method from the WSDL
+		# Params:
+		# +action+:: +SoapAction+ that have all the info about the method from the WSDL
+		def define_wcf_action(action)
+		 	self.class.send(:define_method ,action.name) do |data=nil,*args|
+				body = build_body(action, data)
+
+				res = send_wcf_action(action.soap_action,body,*args)
+				(@cookies << res.headers["Set-Cookie"]) if @save_cookeis
+
+				result = get_wcf_response(res,action.name)
+				res.singleton_class.send(:define_method,:result) do
+					result
+				end
+
+				#if(res.code == '401') # not autorized
+				#	(raise "Please use ntlm") if res['WWW-Authenticate'].include?('NTLM')
+				#end
+
+				res
+			end
+
+			#create new method that takes the data and user and password and user ntlm
+		end
+
+		# Call to wcf method
+		# Params:
+		# +soap_action+:: the value of the SOAPAction header
+		# +body+:: the body of the HTTP request
+		# +args+:: metadata that indicate wich autountication to use
+		def send_wcf_action(soap_action,body,*args)
+			#req = Net::HTTP::Post.new(@uri.path)
+			#req = Net::HTTP::Post.new(@service_address)
+
+			#req["SOAPAction"] = soap_action
+			#req["Content-Type"] = "text/xml; charset=utf-8"
+			#req["Cookie"] = @cookies.join(',') unless @cookies.empty?
+			#req.body = body
+
+			yield(req) if block_given?
+
+			#get_web_response(req,@uri,*args)
+			# "Cookie" => (@cookies.join(',') unless @cookies.empty?)
+			cookies = @cookies.empty? ? "" : @cookies.join(',')
+			send_message_to_wcf(@service_address,
+							 {"SOAPAction" => soap_action,
+							  "Content-Type" => "text/xml; charset=utf-8",
+							  "Cookie" => cookies},
+							  body, *args)
+		end
+	end
+end

data/lib/canned_soap/web/security_protocol.rb

@@ -0,0 +1,10 @@
+module CannedSoap::Web
+	# the secutry protocols that have support
+	module SecurityProtocol
+		NTLM = 0
+		GGS_API = 1
+		KERBEROS = 1
+		BASIC = 2
+		DIGEST = 3
+	end
+end

data/lib/canned_soap/web/web_request_handler.rb

@@ -0,0 +1,88 @@
+require 'httpi'
+require 'canned_soap/web/security_protocol'
+
+# Handle all the communication to the service
+module CannedSoap::Web
+	# Send Http get rquest to a url and return his result via +HTTPI+
+	# Params:
+	# +url+:: the url to send the request to
+	# +headers+:: hash that keeps the headers that need to be send to the service
+	def get_web_response(url,headers)
+		request = HTTPI::Request.new(url)
+
+		request.headers = headers
+		response = HTTPI.get(request)
+
+		response
+	end
+
+	# Send http request to the service
+	# Params:
+	# +url+:: the url to send the request to
+	# +headers+:: hash that keeps the headers that need to be send to the service
+	# +body+:: the body of the HTTP request
+	# +args+:: metadata that indicate wich autountication to use
+	def send_message_to_wcf(url,headers,body,*args)
+		request = HTTPI::Request.new(url)
+		request.headers = headers
+		request.body = body
+
+		#TODO: change to user self.send('use_'+)
+		case args.first
+		when SecurityProtocol::NTLM
+				use_ntlm(request,*args)
+			when SecurityProtocol::GGS_API
+				use_kerberos(request)
+			when SecurityProtocol::BASIC
+				use_basic(request,*args)
+			when SecurityProtocol::DIGEST
+				use_digest(request,*args)
+		end
+
+		response = HTTPI.post(request)
+		response
+	end
+
+	private
+		# Use ntlm auth in the request
+		# Params:
+		# +request+:: +HTTPI::Request+ request
+		# +args+:: keep the data that need to be uses for the NTLM auth
+		def use_ntlm(request,*args)
+			# the first is the security name
+			user = args[1]
+			password = args[2]
+			domain = args[3]
+
+			request.auth.ntlm(user,password,domain)# if request.auth.ntlm?
+		end
+
+		# Use kerberos auth in the request
+		# Params:
+		# +request+:: +HTTPI::Request+ request
+		def use_kerberos(request)
+			request.auth.gssnegotiate
+		end
+
+		# Use basic auth in the request
+		# Params:
+		# +request+:: +HTTPI::Request+ request
+		# +args+:: keep the data that need to be uses for the basic auth
+		def use_basic(request,*args)
+			user = args[1]
+			password = args[2]
+
+			request.auth.basic(user,password)
+		end
+
+		# Use digest auth in the request
+		# Params:
+		# +request+:: +HTTPI::Request+ request
+		# +args+:: keep the data that need to be uses for the digest auth
+		def use_digest(request,*args)
+			user = args[1]
+			password = args[2]
+
+			request.auth.digest(user,password)
+		end
+end

data/lib/canned_soap/wsdl/wsdl.rb

@@ -0,0 +1,7 @@
+require 'canned_soap/wsdl/wsdl_parser'
+
+module CannedSoap::Wsdl
+	class Wsdl
+		attr_accessor :actions, :target_namespace, :location_address
+	end
+end

data/lib/canned_soap/wsdl/wsdl_parser.rb

@@ -0,0 +1,151 @@
+require 'xmlsimple'
+require 'canned_soap/soap/soap'
+require 'canned_soap/web/web_request_handler'
+include CannedSoap::Soap
+include CannedSoap::Web
+
+module CannedSoap::Wsdl
+	class WsdlParser
+		# Parse the service wsdl to a +Wsdl+ object
+		# Params :
+		# +service+:: the url of the service
+		def self.parse(service)
+			@service = service
+			wsdl_xml = get_serivce_data('wsdl')
+			doc = XmlSimple.xml_in(wsdl_xml)
+
+			res = Wsdl.new
+			res.actions = get_soap_actions(doc)
+			res.location_address = get_location_address(doc)
+			res.target_namespace = doc['targetNamespace']
+
+			res
+		end
+
+		# Return the target namespace of the last wsdl parser.
+		# TODO: Remove this method and user tel +Wsdl+ it self to get the target namespace
+		def self.target_namespace
+			@@target_namespace
+		end
+
+		private
+			# Return the service data for specified extension (wsdl, xsd=xsd0, etc)
+			# Params:
+			# +extension+:: the extension the query the service with (wsdl, xsd=xsd0, etc)
+			def self.get_serivce_data(extension)
+				uri = URI("#{@service}")
+
+				res = get_web_response("#{@service}?#{extension}",
+										{"Accept" => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+										 "Accept-Encoding" => 'gzip,deflate,sdch'})
+				res.body
+			end
+
+			# ???
+			def self.get_action_datacontact(action_name)
+				if @xsd_namespace.nil?
+					xsd0 = get_serivce_data('xsd=xsd0')
+					doc = XmlSimple.xml_in(xsd0)
+
+					import = doc['import']
+					@xsd_namespace = (import.first['namespace'] unless import.nil?)
+				end
+
+				@xsd_namespace
+			end
+
+			# Return list of +SoapAction+
+			# Params:
+			# +doc+:: +Hash+ that represent the wsdl xml
+			def self.get_soap_actions(doc)
+				result = []
+
+				@@target_namespace = doc['targetNamespace']
+				should_read_from_xsd = !doc['types'].first['schema'].first['import'].nil?
+
+				binding = doc['binding'].first
+				binding['operation'].each do |opp|
+					action = SoapAction.new
+
+					action.name = opp['name']
+					action.soap_action = opp['operation'].first['soapAction']
+					action.parameters = get_action_params(action.name, doc, should_read_from_xsd)
+
+					result << action
+				end
+
+				result
+			end
+
+			# Return the location address of the service
+			# Params:
+			# +doc+:: +Hash+ that represent the wsdl xml
+			def self.get_location_address(doc)
+				service = doc['service']
+				location = service.first['port'].first['address'].first['location']
+
+				location
+			end
+
+			# Return the parameters that the soap actiop requires as list of +SoapParamter+ objects
+			# Params :
+			# +action_name+:: the name of the soap action
+			# +doc+:: hash the represent the WSDL
+			# +should_read_from_xsd+:: boolean that indicates whether it should read the parameters from the wsdl or imported xsd
+			def self.get_action_params(action_name,doc,should_read_from_xsd)
+				if(should_read_from_xsd)
+					get_action_params_from_xsd(action_name)
+				else
+					get_action_params_from_wsdl(action_name,doc)
+				end
+			end
+
+			# Parse the soap action element in the wsdl and return the parameters that the soap actiop requires as list of +SoapParamter+ objects
+			# Params:
+			# +action_name+:: the name of the soap action
+			# +doc+:: hash the represent the WSDL
+			def self.get_action_params_from_wsdl(action_name, doc)
+				#puts opp['input'].first
+				if @schema.nil?
+					@schema =  doc['types'].first['schema'].first
+				end
+
+				action_element = @schema['element'].select{|e| e['name'] == action_name}.first
+				action_params_elements = action_element['complexType'].first['sequence'].first['element']
+
+				action_params_elements.map do |element|
+					SoapParamter.parse(element) do |param|
+						param.nullable = ['minOccurs'] == 0
+					end
+				end
+			end
+
+			# Parse the imported xsd and return the parameters that the soap actiop requires as list of +SoapParamter+ objects
+			# Params:
+			# +action_name+:: the name of the soap action
+			def self.get_action_params_from_xsd(action_name)
+				if @elements.nil?
+					#@elements = {}
+					xsd0 = get_serivce_data('xsd=xsd0')
+					doc = XmlSimple.xml_in(xsd0)
+
+					@elements = doc['element']
+
+					# the page dose not have imported shceme
+					return nil if @elements.nil?
+				end
+
+				element = @elements.select{|e| e['name'] == action_name}.first
+				sequence = element['complexType'].first['sequence'].first
+
+				return [] if sequence['element'].nil?
+				sequence['element'].map do |e|
+					SoapParamter.parse(e) do |param|
+						param.nullable = e['nillable']
+						namespace_element = e.select{|key,value| key.match(/xmlns(.*)/)}.first
+						(param.namespace = namespace_element[1]) unless namespace_element.nil?
+					end
+				end
+			end
+	end
+end

data/lib/canned_soap.rb

@@ -0,0 +1,5 @@
+require 'net/http'
+require 'xmlsimple'
+require 'canned_soap/wsdl/wsdl'
+include CannedSoap::Wsdl
+require 'canned_soap/client'

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: canned_soap
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Gustavo Canedo
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-07-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: xml-simple
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: httpi
+  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'
+description: 
+email:
+- gknedo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- canned_soap.gemspec
+- docker-compose.yml
+- example.rb
+- lib/canned_soap.rb
+- lib/canned_soap/client.rb
+- lib/canned_soap/soap/soap.rb
+- lib/canned_soap/soap/soap_action.rb
+- lib/canned_soap/soap/soap_parameter.rb
+- lib/canned_soap/version.rb
+- lib/canned_soap/wcf_handler.rb
+- lib/canned_soap/web/security_protocol.rb
+- lib/canned_soap/web/web_request_handler.rb
+- lib/canned_soap/wsdl/wsdl.rb
+- lib/canned_soap/wsdl/wsdl_parser.rb
+homepage: https://github.com/gknedo/canned_soap
+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.6.12
+signing_key: 
+specification_version: 4
+summary: Communication between ruby and soap services
+test_files: []