shapewear 0.0.2 → 0.0.3

data/README.md

@@ -31,6 +31,8 @@ class MyFirstService
   wsdl_namespace 'http://services.example.com/v1'
   schema_namespace 'http://schemas.example.com/v1'
 
+  endpoint_url 'http://localhost:3000/my_first_service'
+
   operation :hello, :parameters => [[:name, String]], :returns => String
   def hello(name)
     "hello, #{name}"

data/lib/shapewear.rb

@@ -1,13 +1,24 @@
 require 'nokogiri'
 
 require 'shapewear/version'
+require 'shapewear/logging'
 require 'shapewear/dsl'
 require 'shapewear/wsdl'
+require 'shapewear/request'
 
 module Shapewear
   def self.included(receiver)
+    receiver.extend(Shapewear::Logging)
     receiver.extend(Shapewear::DSL)
     receiver.extend(Shapewear::WSDL)
+    receiver.extend(Shapewear::Request)
+
+    class << receiver
+      def method_added(m)
+        # automatically creates an operation for each method added
+        operation m
+      end
+    end
   end
 end
 

data/lib/shapewear/dsl.rb

@@ -1,29 +1,43 @@
 require 'builder'
 
-module Shapewear
-  module DSL
-    private
+module Shapewear::DSL
+  private
 
-    def options
-      @options ||= {}
-    end
+  def options
+    @options ||= {}
+  end
+
+  def operations
+    options[:operations] ||= {}
+  end
+
+  def namespaces
+    options[:namespaces] ||=
+      Hash.new { |_, k| raise "Namespace not defined: #{k}" } \
+        .merge! 'tns' => "http://services.example.com/#{self.name}",
+                'xsd1' => "http://schema.example.com/#{self.name}",
+                'wsdl' => 'http://schemas.xmlsoap.org/wsdl/',
+                'soap' => 'http://schemas.xmlsoap.org/wsdl/soap/',
+                'xsd' => 'http://www.w3.org/2000/10/XMLSchema',
+                'env' => 'http://schemas.xmlsoap.org/soap/envelope/'
+  end
 
-    protected
+  protected
 
-    def wsdl_namespace(ns)
-      options[:wsdl_namespace] = ns
-    end
+  def wsdl_namespace(ns)
+    namespaces['tns'] = ns
+  end
 
-    def schema_namespace(ns)
-      options[:schema_namespace] = ns
-    end
+  def schema_namespace(ns)
+    namespaces['xsd1'] = ns
+  end
 
-    def endpoint_url(url)
-      options[:endpoint_url] = url
-    end
+  def endpoint_url(url)
+    options[:endpoint_url] = url
+  end
 
-    def operation(name, ops = {})
-      (options[:operations] ||= {})[name] = ops
-    end
+  def operation(name, ops = {})
+    h = (operations[name] ||= {}).merge! ops
+    h[:public_name] ||= name.to_s.camelize
   end
 end

data/lib/shapewear/logging.rb

@@ -0,0 +1,9 @@
+module Shapewear::Logging
+  def logger
+    @logger ||= (::Rails.logger rescue Logger.new(STDOUT))
+  end
+
+  def logger=(logger)
+    @logger = logger
+  end
+end

data/lib/shapewear/request.rb

@@ -0,0 +1,66 @@
+module Shapewear::Request
+  # @param request [Rack::Request, Hash]
+  def serve(request)
+    op_node = find_soap_operation_node(request)
+
+    begin
+      call_soap_operation(op_node)
+    rescue => e
+      serialize_soap_fault e
+    end
+  end
+
+  private
+
+  def find_soap_operation_node(request)
+    body ||= request.body if request.respond_to? :body
+    body ||= request[:body] if request.is_a?(Hash)
+    body ||= request.to_s
+
+    raise "Request body could not be found" if body.nil?
+
+    doc = Nokogiri::XML(body) { |c| c.strict } rescue raise("Request body is not a valid XML")
+
+    raise "Request is not a SOAP::Envelope: #{body}" if doc.at('/env:Envelope', namespaces).nil?
+
+    # find the operation element, or raise if not found
+    doc.at("/env:Envelope/env:Body/tns:*", namespaces) or raise "Operation not found"
+  end
+
+  def call_soap_operation(node)
+    operations.each do |k, v|
+      if v[:public_name] == node.name
+        params = extract_parameters(node)
+        logger.debug "Calling #{k} with args: #{params.map(&:inspect) * ', '}"
+        r = self.new.send(k, *params)
+        logger.debug "Result: #{r.inspect}"
+        return serialize_soap_result v, r
+      end
+    end
+
+    raise "Operation not found: #{node.name}"
+  end
+
+  def extract_parameters(node)
+    # TODO: use the metadata collected from the DSL to reoder the parameters and perform the appropriate conversions
+    node.children.map { |n| n.text }
+  end
+
+  #noinspection RubyArgCount
+  def serialize_soap_result(op_options, r)
+    xb = Builder::XmlMarkup.new
+    xb.instruct!
+
+    xb.Envelope :xmlns => namespaces['env'] do |xenv|
+      xenv.Body do |xbody|
+        xbody.tag! "#{op_options[:public_name]}Response", :xmlns => namespaces['xsd1'] do |xres|
+          xres.body r
+        end
+      end
+    end
+  end
+
+  def serialize_soap_fault(ex)
+    raise ex
+  end
+end

data/lib/shapewear/version.rb

@@ -1,5 +1,5 @@
 module Shapewear
 
-  Version = "0.0.2"
+  Version = "0.0.3"
 
 end

data/lib/shapewear/wsdl.rb

@@ -1,127 +1,137 @@
 require 'builder'
 
-module Shapewear
-  #noinspection RubyArgCount,RubyResolve
-  module WSDL
-    # reference: http://www.w3.org/TR/wsdl
-    def to_wsdl
-      tns = options[:wsdl_namespace] || "http://shapewear.elementarsistemas.com.br/auto/#{self.name}.wsdl"
-      xsd = options[:schema_namespace] || "http://shapewear.elementarsistemas.com.br/auto/#{self.name}.xsd"
+#noinspection RubyArgCount,RubyResolve
+module Shapewear::WSDL
+  # reference: http://www.w3.org/TR/wsdl
+  def to_wsdl
+    xm = Builder::XmlMarkup.new
 
-      xm = Builder::XmlMarkup.new
+    xm.instruct!
+    xm.definitions :name => self.name, 'targetNamespace' => namespaces['tns'],
+                   'xmlns' => namespaces['wsdl'],
+                   'xmlns:soap' => namespaces['soap'],
+                   'xmlns:xsd1' => namespaces['xsd1'],
+                   'xmlns:tns' => namespaces['tns'] do |xdef|
 
-      xm.instruct!
-      xm.definitions :name => self.name, 'targetNamespace' => tns,
-                     'xmlns' => 'http://schemas.xmlsoap.org/wsdl/',
-                     'xmlns:soap' => 'http://schemas.xmlsoap.org/wsdl/soap/',
-                     'xmlns:xsd1' => xsd, 'xmlns:tns' => tns do |xdef|
+      xdef.types do |xtypes|
+        xtypes.schema 'xmlns' => namespaces['xsd'], 'targetNamespace' => namespaces['xsd1'] do |xschema|
 
-        xdef.types do |xtypes|
-          xtypes.schema 'xmlns' => 'http://www.w3.org/2000/10/XMLSchema', 'targetNamespace' => xsd do |xschema|
-
-            # define elements for each defined method
-            instance_methods(false).each do |m|
-              build_type_elements_for_method(m, xschema)
-            end
+          # define elements for each defined method
+          instance_methods(false).each do |m|
+            build_type_elements_for_method(m, xschema)
           end
         end
+      end
 
-        instance_methods(false).each do |m|
-          xdef.message :name => "#{m.camelize}Input" do |xmsg|
-            xmsg.part :name => :body, :element => "xsd1:#{m.camelize}Request"
-          end unless instance_method(m).arity == 0
-          xdef.message :name => "#{m.camelize}Output" do |xmsg|
-            xmsg.part :name => :body, :element => "xsd1:#{m.camelize}"
-          end
+      instance_methods(false).each do |m|
+        xdef.message :name => "#{m.camelize}Input" do |xmsg|
+          xmsg.part :name => :body, :element => "xsd1:#{m.camelize}Request"
+        end unless instance_method(m).arity == 0
+        xdef.message :name => "#{m.camelize}Output" do |xmsg|
+          xmsg.part :name => :body, :element => "xsd1:#{m.camelize}Response"
         end
+      end
 
-        xdef.portType :name => "#{self.name}PortType" do |xpt|
-          instance_methods(false).each do |m|
-            xpt.operation :name => m.camelize do |xop|
-              xop.input :message => "tns:#{m.camelize}Input" unless instance_method(m).arity == 0
-              xop.output :message => "tns:#{m.camelize}Output"
-            end
+      xdef.portType :name => "#{self.name}PortType" do |xpt|
+        instance_methods(false).each do |m|
+          xpt.operation :name => m.camelize do |xop|
+            xop.input :message => "tns:#{m.camelize}Input" unless instance_method(m).arity == 0
+            xop.output :message => "tns:#{m.camelize}Output"
           end
         end
+      end
 
-        xdef.binding :name => "#{self.name}Binding", :type => "tns:#{self.name}PortType" do |xbind|
-          xbind.tag! 'soap:binding', :style => 'document', :transport => 'http://schemas.xmlsoap.org/soap/http'
-          instance_methods(false).each do |m|
-            xbind.operation :name => m.camelize do |xop|
-              xop.tag! 'soap:operation', :soapAction => "#{tns}/#{m.camelize}"
-              xop.input { |xin| xin.tag! 'soap:body', :use => 'literal' } unless instance_method(m).arity == 0
-              xop.output { |xin| xin.tag! 'soap:body', :use => 'literal' }
-            end
+      xdef.binding :name => "#{self.name}Binding", :type => "tns:#{self.name}PortType" do |xbind|
+        xbind.tag! 'soap:binding', :style => 'document', :transport => 'http://schemas.xmlsoap.org/soap/http'
+        operations.each do |op, op_opts|
+          xbind.operation :name => op_opts[:public_name] do |xop|
+            doc = op_opts[:documentation] rescue nil
+            xop.documentation doc unless doc.nil?
+            xop.tag! 'soap:operation', :soapAction => "#{namespaces['tns']}/#{op_opts[:public_name]}"
+            xop.input { |xin| xin.tag! 'soap:body', :use => 'literal' } unless instance_method(op).arity == 0
+            xop.output { |xin| xin.tag! 'soap:body', :use => 'literal' }
           end
         end
+      end
 
-        xdef.service :name => self.name do |xsrv|
-          xsrv.documentation "WSDL auto-generated by shapewear."
-          xsrv.port :name => "#{self.name}Port", :binding => "#{self.name}Binding" do |xport|
-            xport.tag! 'soap:address', :location => options[:endpoint_url]
-          end
+      xdef.service :name => self.name do |xsrv|
+        xsrv.documentation "WSDL auto-generated by shapewear."
+        xsrv.port :name => "#{self.name}Port", :binding => "#{self.name}Binding" do |xport|
+          xport.tag! 'soap:address', :location => options[:endpoint_url]
         end
       end
     end
+  end
 
-    def build_type_elements_for_method(m, xschema)
-      # element for method arguments
-      um = instance_method(m)
-      op_options = options[:operations][m.to_sym] rescue nil
+  def build_type_elements_for_method(m, xschema)
+    # element for method arguments
+    um = instance_method(m)
+    op_options = options[:operations][m.to_sym] rescue nil
 
-      if um.arity > 0
-        xschema.element :name => "#{m.camelize}Request" do |xreq|
-          xreq.complexType do |xct|
-            xct.all do |xall|
-              params = op_options[:parameters] rescue nil
-              if params.nil?
-                if um.respond_to?(:parameters)
-                  # with Ruby 1.9, we can create the parameters with the correct names
-                  params = um.parameters.select { |p| p.first == :in }.map { |p| [p.first, Object] }
-                else
-                  params = (0..um.arity).map { |i| ["arg#{i}", Object] }
-                end
+    if um.arity > 0
+      xschema.element :name => "#{op_options[:public_name]}Request" do |xreq|
+        xreq.complexType do |xct|
+          xct.all do |xall|
+            params = op_options[:parameters] rescue nil
+            if params.nil?
+              if um.respond_to?(:parameters)
+                # with Ruby 1.9, we can create the parameters with the correct names
+                params = um.parameters.select { |p| p.first == :in }.map { |p| [p.first, Object] }
+              else
+                params = (0..um.arity).map { |i| ["arg#{i}", Object] }
               end
+            end
 
-              params.each do |p|
-                xall.element :name => p.first, :type => to_xsd_type(p.last)
+            params.each do |p|
+              t = p.last
+              if t.nil?
+                xall.element :name => p.first, :type => 'xsd:any'
+              elsif t.is_a?(Class)
+                xall.element :name => p.first, :type => to_xsd_type(t)
+              elsif t.is_a?(Hash)
+                xall.complexType do |xct2|
+                  xct2.all do |xall2|
+                    t.each do |name, type|
+                      xall2.element :name => name, :type => to_xsd_type(type)
+                    end
+                  end
+                end
+              else
+                raise "Could not interpret #{t.inspect} as a return type definition"
               end
             end
           end
         end
       end
+    end
 
-      # element for method result
-      xschema.element :name => "#{m.camelize}" do |xreq|
-        xreq.complexType do |xct|
-          xct.all do |xall|
-            ret = op_options[:returns] rescue nil
-            if ret.nil?
-              xall.element :name => 'result', :type => 'xsd:any'
-            elsif ret.is_a?(Class)
-              xall.element :name => 'result', :type => to_xsd_type(ret)
-            elsif ret.is_a?(Hash)
-              ret.each do |name, type|
-                xall.element :name => name, :type => to_xsd_type(type)
-              end
-            else
-              raise "Could not interpret #{ret.inspect} as a return type definition"
+    # element for method result
+    xschema.element :name => "#{op_options[:public_name]}" do |xreq|
+      xreq.complexType do |xct|
+        xct.all do |xall|
+          ret = op_options[:returns] rescue nil
+          if ret.nil?
+            xall.element :name => 'result', :type => 'xsd:any'
+          elsif ret.is_a?(Class)
+            xall.element :name => 'result', :type => to_xsd_type(ret)
+          elsif ret.is_a?(Hash)
+            ret.each do |name, type|
+              xall.element :name => name, :type => to_xsd_type(type)
             end
+          else
+            raise "Could not interpret #{ret.inspect} as a return type definition"
           end
         end
       end
     end
+  end
 
-    def to_xsd_type(t)
-      if t.is_a?(Class)
-        return 'xsd:string' if t == String
-        return 'xsd:integer' if t == Fixnum
-        return 'xsd:dateTime' if t == DateTime
-        return 'xsd:any' if t == Object
-        raise "Could not convert type #{t} to a valid XSD type"
-      elsif t.is_a?(Hash)
-        '??'
-      end
-    end
+  # @param t [Class]
+  def to_xsd_type(t)
+    return 'xsd:string' if t == String
+    return 'xsd:integer' if t == Fixnum
+    return 'xsd:dateTime' if t == DateTime
+    return 'xsd:any' if t.nil? || t == Object
+    raise "Could not convert type #{t} to a valid XSD type"
   end
 end

data/shapewear.gemspec

@@ -19,6 +19,10 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency "rake",  "~> 0.9.2"
   s.add_development_dependency "rspec", "~> 2.7.0"
+  s.add_development_dependency "rack-test"
+  s.add_development_dependency "savon"
+  s.add_development_dependency "wasabi"
+  s.add_development_dependency "webmock"
 
   s.files = `git ls-files`.split("\n")
   s.require_path = "lib"

data/spec/shapewear/dsl_spec.rb

@@ -5,48 +5,38 @@ describe Shapewear::DSL do
   let(:xmlns) { {'wsdl' => 'http://schemas.xmlsoap.org/wsdl/', 'soap' => 'http://schemas.xmlsoap.org/wsdl/soap/'} }
 
   describe "basic DSL" do
-    it "should describe parameterless, 'hello world' services" do
-      class ParameterlessHelloWorldService
-        include Shapewear
-
-        def hello_world
-          "hello"
-        end
-      end
-
-      wsdl = ParameterlessHelloWorldService.to_wsdl
+    it "should describe a minimal working service" do
+      wsdl = MinimalWorkingService.to_wsdl
       puts wsdl
-      wsdl_doc = nil
-      expect { wsdl_doc = Nokogiri::XML(wsdl) { |c| c.strict } }.not_to raise_error
 
-      # there should be a definition with the class' name
-      wsdl_def = wsdl_doc.xpath("/wsdl:definitions[@name='ParameterlessHelloWorldService']", xmlns)
-      wsdl_def.should have(1).node
-      wsdl_def.xpath("wsdl:service[@name='ParameterlessHelloWorldService']/wsdl:port[@name='ParameterlessHelloWorldServicePort']/soap:address", xmlns).should have(1).node
+      # wsdl should be valid XML (duh!)
+      expect { Nokogiri::XML(wsdl) { |c| c.strict } }.not_to raise_error
 
-      # the message element for the input should not be there, as the method does not accept parameters
-      wsdl_def.xpath("wsdl:message[@name='HelloWorldInput']", xmlns).should have(0).node
+      # wasabi should be able to parse it
+      wdoc = nil
+      expect { wdoc = Wasabi.document wsdl }.not_to raise_error
 
-      # the message element for the output must be there, as a simple string
-      wsdl_def.xpath("wsdl:message[@name='HelloWorldOutput']/wsdl:part[@name='body']", xmlns).should have(1).node
+      wdoc.namespace.should match /MinimalWorkingService/
+      wdoc.soap_actions.should == [:hello_world]
 
-      # there must be an operation named 'HelloWorld'
-      wsdl_def.xpath("wsdl:portType/wsdl:operation[@name='HelloWorld']", xmlns).should have(1).node
-      wsdl_def.xpath("wsdl:binding/wsdl:operation[@name='HelloWorld']", xmlns).should have(1).node
+      wdoc.operations[:hello_world].should_not be_nil
+      wdoc.operations[:hello_world][:input].should == 'HelloWorld'
+      wdoc.operations[:hello_world][:input].should match /HelloWorld$/
     end
-    it "should describe services with basic parameters and return values"
-    it "should describe services with array parameters"
   end
 
   describe "complex types DSL" do
-    it "should allow definition of complex types using class introspection"
-    it "should allow definition of complex types using a builder-like DSL"
     it "should accept complex types as input"
     it "should accept complex types as output"
+    it "should accept arrays as input"
+    it "should accept arrays as output"
+    it "should allow definition of complex types using class introspection"
+    it "should allow definition of complex types using a DSL"
   end
 
   describe "WSDL customization" do
-    it "should allow customization of namespace"
+    it "should allow customization of target namespace"
+    it "should allow customization of schema namespace"
   end
 
   describe "existing WSDL" do

data/spec/shapewear/savon_usage_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+describe Shapewear do
+  describe "usage with SOAP clients" do
+    before do
+      stub_request(:get, "http://services.example.com/complete/soap/wsdl") \
+        .to_return :body => CompleteService.to_wsdl, :headers => {'Content-Type' => 'application/xml'}
+
+      stub_request(:post, "http://services.example.com/complete/soap") \
+        .to_return :body => lambda { |r| CompleteService.serve(r) }, :headers => {'Content-Type' => 'application/xml'}
+    end
+
+    it "should work with Savon" do
+      client = Savon::Client.new 'http://services.example.com/complete/soap/wsdl'
+      response = client.request :echo_in_uppercase, :xmlns => 'http://services.example.com/v1' do
+        soap.body = {:text => 'uppercase text'}
+      end
+
+      puts response.inspect
+      puts response.body.inspect
+
+      response.body[:echo_in_uppercase_response][:body].should == 'UPPERCASE TEXT'
+    end
+  end
+end

data/spec/shapewear/service_definitions/complete_service.rb

@@ -0,0 +1,56 @@
+# This class represents a fully customized service.
+# It is used to test the extensiveness of the Shapewear DSL.
+class CompleteService
+  include Shapewear
+
+  wsdl_namespace 'http://services.example.com/v1'
+  schema_namespace 'http://schemas.example.com/v1'
+
+  endpoint_url 'http://services.example.com/complete/soap'
+
+  operation :echo_in_uppercase, :documentation => 'Echoes back the parameter, in uppercase',
+            :parameters => [[:text, String]], :returns => String
+
+  operation :sum, :documentation => 'Adds two numbers',
+            :parameters => [[:x, Fixnum], [:y, Fixnum]],
+            :returns => Fixnum
+
+  operation :get_structured_data, :documentation => 'Returns structured data. 0 uses a Hash, 1 uses a struct, any other value raises a fault',
+            :parameters => [[:id, Fixnum]],
+            :returns => {:text => String, :random_value => Fixnum, :created_at => DateTime}
+
+  def echo_in_uppercase(text)
+    text.upcase
+  end
+
+  def sum(x, y)
+    x + y
+  end
+
+  def get_structured_data(id)
+    case id
+      when 0 then
+        Structured.new('text from the struct')
+      when 1 then
+        {:text => 'text from a hash', :random_value => rand(999), @created_at => DateTime.now}
+      else
+        raise "ID must be 0 or 1"
+    end
+  end
+
+  def reset(chave)
+    raise "Operação não permitida" if ::Rails.env.production?
+    c = Conector::Registro.find_by_chave_registro(chave)
+    c.reset!
+
+    'ok'
+  end
+
+  class Structured < Struct.new(:text, :random_value, :created_at)
+    def initialize(text)
+      @text = text
+      @random_value = rand(999)
+      @created_at = DateTime.now
+    end
+  end
+end

data/spec/shapewear/service_definitions/minimal_working_service.rb

@@ -0,0 +1,9 @@
+# This class represents a minimal working service, without the use of any of the Shapewear specific DSL.
+# It is used to test the Convention-over-Configuration-ness of Shapewear.
+class MinimalWorkingService
+  include Shapewear
+
+  def hello_world
+    "hello"
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,9 @@
 require "bundler"
 Bundler.require :default, :development
 
+require 'webmock/rspec'
+
 RSpec.configure do |config|
 end
+
+Dir[File.join File.dirname(__FILE__), 'shapewear', 'service_definitions', '*.rb'].each { |f| require f }

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: shapewear
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - "F\xC3\xA1bio Batista"
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-03 00:00:00 Z
+date: 2012-01-05 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: builder
@@ -81,6 +81,62 @@ dependencies:
         version: 2.7.0
   type: :development
   version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rack-test
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: savon
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: wasabi
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: webmock
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id008
 description: Shapewear is a Ruby library for handling SOAP requests from within your Rails or Sinatra application. It makes your fat services look skinny.
 email: fabio@elementarsistemas.com.br
 executables: []
@@ -101,10 +157,15 @@ files:
 - Rakefile
 - lib/shapewear.rb
 - lib/shapewear/dsl.rb
+- lib/shapewear/logging.rb
+- lib/shapewear/request.rb
 - lib/shapewear/version.rb
 - lib/shapewear/wsdl.rb
 - shapewear.gemspec
 - spec/shapewear/dsl_spec.rb
+- spec/shapewear/savon_usage_spec.rb
+- spec/shapewear/service_definitions/complete_service.rb
+- spec/shapewear/service_definitions/minimal_working_service.rb
 - spec/spec_helper.rb
 homepage: https://github.com/elementar/shapewear
 licenses: []