washout_builder 0.14.1 → 0.15.0

data/lib/washout_builder/document/exception_model.rb

@@ -1,86 +1,81 @@
-require_relative "./shared_complex_type"
+require_relative './shared_complex_type'
 module WashoutBuilder
   module Document
     module ExceptionModel
       extend ActiveSupport::Concern
-      include WashoutBuilder::Document::SharedComplexType  
-      
+      include WashoutBuilder::Document::SharedComplexType
+
       def self.included(base)
         base.send :include, WashoutBuilder::Document::SharedComplexType
       end
-      
-      def get_fault_class_ancestors( defined, debug = false)
+
+      def get_fault_class_ancestors(defined, _debug = false)
         bool_the_same = false
-        ancestors  = fault_ancestors
-        if  ancestors.blank?
-          defined << fault_ancestor_hash(get_fault_model_structure, []) 
+        ancestors = fault_ancestors
+        if ancestors.blank?
+          defined << fault_ancestor_hash(find_fault_model_structure, [])
         else
           defined << fault_ancestor_hash(fault_without_inheritable_elements(ancestors), ancestors)
-          ancestors[0].get_fault_class_ancestors( defined)
+          ancestors[0].get_fault_class_ancestors(defined)
         end
-        ancestors unless  bool_the_same
+        ancestors unless bool_the_same
       end
-      
-           
+
       def fault_without_inheritable_elements(ancestors)
-        remove_fault_type_inheritable_elements(  ancestors[0].get_fault_model_structure.keys)
+        remove_fault_type_inheritable_elements(ancestors[0].find_fault_model_structure.keys)
       end
-      
+
       def fault_ancestors
-        get_complex_type_ancestors(self, ["ActiveRecord::Base", "Object", "BasicObject",  "Exception" ])
+        get_complex_type_ancestors(self, ['ActiveRecord::Base', 'Object', 'BasicObject', 'Exception'])
       end
-      
-      def fault_ancestor_hash( structure, ancestors)
-        {:fault => self,:structure =>structure  ,:ancestors => ancestors   }
+
+      def fault_ancestor_hash(structure, ancestors)
+        { fault: self, structure: structure, ancestors: ancestors }
       end
-      
-      def remove_fault_type_inheritable_elements( keys)
-        get_fault_model_structure.delete_if{|key,value|  keys.include?(key) }
+
+      def remove_fault_type_inheritable_elements(keys)
+        find_fault_model_structure.delete_if { |key, _value| keys.include?(key) }
       end
-       
+
       def check_valid_fault_method?(method)
         method != :== && method != :! &&
-          (  self.instance_methods.include?(:"#{method}=") || 
-            self.instance_methods.include?(:"#{method}")  
+          (instance_methods.include?(:"#{method}=") ||
+            instance_methods.include?(:"#{method}")
         )
-      end      
-      
-      
-      def get_fault_attributes
+      end
+
+      def find_fault_attributes
         attrs = []
-        attrs = self.instance_methods(nil).collect do |method|
-            method.to_s  if check_valid_fault_method?(method)
+        attrs = instance_methods(nil).map do |method|
+          method.to_s if check_valid_fault_method?(method)
         end
-        attrs = attrs.delete_if {|method|  method.end_with?("=")  &&  attrs.include?(method.gsub("=",'')) }
-        attrs.concat(["message", "backtrace"])
+        attrs = attrs.delete_if { |method| method.end_with?('=') && attrs.include?(method.gsub('=', '')) }
+        attrs.concat(%w(message backtrace))
       end
-      
+
       def get_fault_type_method(method_name)
         case method_name.to_s.downcase
-        when "code" 
-          "integer"
-        when "message", "backtrace"
-          "string"
-        else
-          "string"
-        end
+          when 'code'
+            'integer'
+          when 'message', 'backtrace'
+            'string'
+          else
+            'string'
+          end
       end
-      
-      
-      def get_fault_model_structure
+
+      def find_fault_model_structure
         h = {}
-        get_fault_attributes.each do |method_name|
-          method_name = method_name.to_s.end_with?("=") ? method_name.to_s.gsub("=", '') : method_name
+        find_fault_attributes.each do |method_name|
+          method_name = method_name.to_s.end_with?('=') ? method_name.to_s.gsub('=', '') : method_name
           primitive_type = get_fault_type_method(method_name)
-          h["#{method_name}"]= {
-            :primitive => "#{primitive_type}", 
-            :member_type => nil
+          h["#{method_name}"] = {
+            primitive: "#{primitive_type}",
+            member_type: nil
           }
         end
-        return h
+        h
       end
-      
-          
     end
   end
 end

data/lib/washout_builder/document/generator.rb

@@ -1,67 +1,61 @@
-require_relative "./exception_model"
+require_relative './exception_model'
 module WashoutBuilder
   module Document
     class Generator
-       
-      @attrs = [:soap_actions, :config, :controller_name]
-      
-      attr_reader *@attrs
-      attr_accessor  *@attrs
-      
+      attr_accessor :soap_actions, :config, :controller_name
+
       def initialize(controller)
-          controller_class_name = controller_class(controller)
-          self.config =controller_class_name.soap_config
-          self.soap_actions = controller_class_name.soap_actions
-          self.controller_name = controller
+        controller_class_name = controller_class(controller)
+        self.config = controller_class_name.soap_config
+        self.soap_actions = controller_class_name.soap_actions
+        self.controller_name = controller
       end
-     
+
       def namespace
         config.respond_to?(:namespace) ? config.namespace : nil
       end
-      
+
       def controller_class(controller)
         "#{controller}_controller".camelize.constantize
       end
-  
-      def endpoint 
-        namespace.blank? ? nil : namespace.gsub("/wsdl", "/action")
+
+      def endpoint
+        namespace.blank? ? nil : namespace.gsub('/wsdl', '/action')
       end
-      
-      def service 
+
+      def service
         controller_name.blank? ? nil : controller_name.camelize
       end
-      
+
       def service_description
         config.respond_to?(:description) ? config.description : nil
       end
-      
+
       def operations
-        soap_actions.map { |operation, formats| operation }
+        soap_actions.map { |operation, _formats| operation }
       end
-      
+
       def sorted_operations
-          soap_actions.sort_by { |operation, formats| operation.downcase }.uniq unless soap_actions.blank?
+        soap_actions.sort_by { |operation, _formats| operation.downcase }.uniq unless soap_actions.blank?
       end
-      
+
       def operation_exceptions(operation_name)
-        hash_object = soap_actions.detect {|operation, formats|  operation.to_s.downcase == operation_name.to_s.downcase}
-        unless hash_object.blank?
-          faults =  hash_object[1][:raises] 
-          faults = faults.is_a?(Array) ? faults :  [faults]
-          faults.select { |x| WashoutBuilder::Type.valid_fault_class?(x)  }
-        end
+        hash_object = soap_actions.find { |operation, _formats| operation.to_s.downcase == operation_name.to_s.downcase }
+        return if hash_object.blank?
+        faults = hash_object[1][:raises]
+        faults = faults.is_a?(Array) ? faults : [faults]
+        faults.select { |x| WashoutBuilder::Type.valid_fault_class?(x) }
       end
-      
+
       def sort_complex_types(types, type)
-        types.sort_by { |hash| hash[type.to_sym].to_s.downcase }.uniq {|hash| hash[type.to_sym] } unless types.blank?
+        types.sort_by { |hash| hash[type.to_sym].to_s.downcase }.uniq { |hash| hash[type.to_sym] } unless types.blank?
       end
-      
-      
+
       def argument_types(type)
-        format_type = (type == "input") ? "builder_in" : "builder_out"
+        format_type = (type == 'input') ? 'builder_in' : 'builder_out'
         types = []
         unless soap_actions.blank?
-          soap_actions.each do |operation, formats|
+          soap_actions.each do |_operation, formats|
             (formats[format_type.to_sym]).each do |p|
               types << p
             end
@@ -69,56 +63,52 @@ module WashoutBuilder
         end
         types
       end
-      
+
       def input_types
-        argument_types("input")
+        argument_types('input')
       end
-      
+
       def output_types
-        argument_types("output")
+        argument_types('output')
       end
-      
-      def get_soap_action_names
-        operations.map(&:to_s).sort_by { |name| name.downcase }.uniq unless soap_actions.blank?
+
+      def all_soap_action_names
+        operations.map(&:to_s).sort_by(&:downcase).uniq unless soap_actions.blank?
       end
-      
-      
+
       def complex_types
         defined = []
         (input_types + output_types).each do |p|
-          defined.concat(p.get_nested_complex_types(config,  defined))
+          defined.concat(p.get_nested_complex_types(config, defined))
         end
-        defined =  sort_complex_types(defined, "class")
+        defined = sort_complex_types(defined, 'class')
       end
-            
-       
+
       def actions_with_exceptions
-        soap_actions.select{|operation, formats| !formats[:raises].blank? }
+        soap_actions.select { |_operation, formats| !formats[:raises].blank? }
       end
-      
+
       def exceptions_raised
-        actions_with_exceptions.collect {|operation, formats|  formats[:raises].is_a?(Array)  ? formats[:raises] : [formats[:raises]] }.flatten
+        actions_with_exceptions.map { |_operation, formats| formats[:raises].is_a?(Array) ? formats[:raises] : [formats[:raises]] }.flatten
       end
-     
-     
+
       def filter_exceptions_raised
-        exceptions_raised.select { |x|  WashoutBuilder::Type.valid_fault_class?(x)  }  unless actions_with_exceptions.blank?
+        exceptions_raised.select { |x| WashoutBuilder::Type.valid_fault_class?(x) } unless actions_with_exceptions.blank?
       end
-      
+
       def get_complex_fault_types(base_fault_array)
-        fault_types =[]
-        defined  = filter_exceptions_raised
-        defined = defined.blank? ?  base_fault_array  :  defined.concat(base_fault_array)
-        defined.each{ |exception_class|  exception_class.get_fault_class_ancestors( fault_types, true)}  unless   defined.blank?
-        fault_types 
+        fault_types = []
+        defined = filter_exceptions_raised
+        defined = defined.blank? ? base_fault_array : defined.concat(base_fault_array)
+        defined.each { |exception_class| exception_class.get_fault_class_ancestors(fault_types, true) } unless defined.blank?
+        fault_types
       end
-      
+
       def fault_types
-         base_fault =[WashoutBuilder::Type.get_fault_classes.first]
+        base_fault = [WashoutBuilder::Type.all_fault_classes.first]
         fault_types = get_complex_fault_types(base_fault)
-        sort_complex_types(fault_types, "fault")
+        sort_complex_types(fault_types, 'fault')
       end
-      
     end
   end
-end
+end

data/lib/washout_builder/document/shared_complex_type.rb

@@ -1,11 +1,9 @@
 module WashoutBuilder
   module Document
     module SharedComplexType
-      
       def get_complex_type_ancestors(class_name, array)
-        (class_name.ancestors - class_name.included_modules).delete_if{ |x| x.to_s.downcase == class_name.to_s.downcase  ||  array.include?(x.to_s)  }
+        (class_name.ancestors - class_name.included_modules).delete_if { |x| x.to_s.downcase == class_name.to_s.downcase || array.include?(x.to_s) }
       end
-      
     end
   end
-end
+end

data/lib/washout_builder/engine.rb

@@ -1,8 +1,7 @@
 module WashoutBuilder
   class Engine < ::Rails::Engine
     isolate_namespace WashoutBuilder
-    initializer "washout_builder.configuration" do |app|
-      
+    initializer 'washout_builder.configuration' do |_app|
     end
   end
 end

data/lib/washout_builder/soap.rb

@@ -5,8 +5,7 @@ module WashoutBuilder
     extend ActiveSupport::Concern
     include WashOut::SOAP if defined?(WashOut::SOAP)
     include WashOut::Rails::Controller if defined?(WashOut::Rails::Controller)
-    
-    
+
     module ClassMethods
       attr_accessor :soap_actions
       # Define a SOAP action +action+. The function has two required +options+:
@@ -15,9 +14,9 @@ module WashoutBuilder
       #
       # An optional option :to can be passed to allow for names of SOAP actions
       # which are not valid Ruby function names.
-      def soap_action(action, options={})
+      def soap_action(action, options = {})
         original_soap_action(action, options)
-       
+
         if action.is_a?(Symbol)
           if soap_config.camelize_wsdl.to_s == 'lower'
             action = action.to_s.camelize(:lower)
@@ -25,19 +24,16 @@ module WashoutBuilder
             action = action.to_s.camelize
           end
         end
-        
-        
-        current_action = self.soap_actions[action]
+
+        current_action = soap_actions[action]
         current_action[:builder_in] = WashOut::Param.parse_builder_def(soap_config, options[:args])
         current_action[:builder_out] = WashOut::Param.parse_builder_def(soap_config, options[:return])
-         
       end
     end
-    
 
     included do
       include WashOut::Configurable if defined?(WashOut::Configurable)
-      include  WashOut::Dispatcher if defined?(WashOut::Dispatcher)
+      include WashOut::Dispatcher if defined?(WashOut::Dispatcher)
       self.soap_actions = {}
     end
   end

data/lib/washout_builder/type.rb

@@ -1,35 +1,21 @@
 module WashoutBuilder
-  class Type 
+  class Type
+    BASIC_TYPES = %w(string integer double boolean date datetime float time int)
 
-    BASIC_TYPES=[
-      "string",
-      "integer",
-      "double",
-      "boolean",
-      "date",
-      "datetime",
-      "float",
-      "time",
-      "int"
-    ]
-
-    def self.get_fault_classes
+    def self.all_fault_classes
       faults = []
       faults << WashOut::SOAPError if defined?(WashOut::SOAPError)
       faults << WashOut::Dispatcher::SOAPError if defined?(WashOut::Dispatcher::SOAPError)
       faults << SOAPError if defined?(SOAPError)
-      return faults
+      faults
     end
-    
-      
-    def self.has_ancestor_fault?(fault_class)
-      fault_class.ancestors.detect{ |fault|  get_fault_classes.include?(fault)  }.present?
+
+    def self.ancestor_fault?(fault_class)
+      fault_class.ancestors.find { |fault| all_fault_classes.include?(fault) }.present?
     end
-      
+
     def self.valid_fault_class?(fault)
-      fault.is_a?(Class) &&   ( has_ancestor_fault?(fault) ||  get_fault_classes.include?(fault)) 
+      fault.is_a?(Class) && (ancestor_fault?(fault) || all_fault_classes.include?(fault))
     end
-    
-    
   end
 end

data/lib/washout_builder/version.rb

@@ -1,14 +1,14 @@
-module WashoutBuilder   # Returns the version of the currently loaded Rails as a <tt>Gem::Version</tt>
+module WashoutBuilder # Returns the version of the currently loaded Rails as a <tt>Gem::Version</tt>
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
     MAJOR = 0
-    MINOR = 14
-    TINY  = 1
-    PRE   = nil
+    MINOR = 15
+    TINY = 0
+    PRE = nil
 
-    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
   end
 end

data/spec/app/controllers/washout_builder_controller_spec.rb

@@ -1,50 +1,48 @@
 require 'spec_helper'
 mock_controller do
-  soap_action 'dispatcher_method', :args => nil, :return => nil
- 
+  soap_action 'dispatcher_method', args: nil, return: nil
+
   def dispatcher_method
-    #nothing
+    # nothing
   end
 end
-describe WashoutBuilder::WashoutBuilderController, :type => :controller  do
+describe WashoutBuilder::WashoutBuilderController, type: :controller do
   routes { WashoutBuilder::Engine.routes }
- 
-  let(:soap_config) { OpenStruct.new(
+
+  let(:soap_config) do
+    OpenStruct.new(
       camelize_wsdl: false,
-      namespace: "/api/wsdl",
-    ) }
-  
-  let(:washout_builder) { stub(:root_url => "#{request.protocol}#{request.host_with_port}/")}
-  let(:route) {stub(:defaults => {:controller => "api"})}
-    let(:params) {{:name => "some_name"  }}
-   
+      namespace: '/api/wsdl'
+    )
+  end
+
+  let(:washout_builder) { stub(root_url: "#{request.protocol}#{request.host_with_port}/") }
+  let(:route) { stub(defaults: { controller: 'api' }) }
+  let(:params) { { name: 'some_name' } }
+
   before(:each) do
     ApiController.stubs(:soap_config).returns(soap_config)
     controller.stubs(:washout_builder).returns(washout_builder)
   end
 
-  it "gets the services" do
+  it 'gets the services' do
     get :all
-    assigns(:services).should eq([{'service_name'=>"Api", 'namespace'=>"/api/wsdl", 'endpoint'=>"/api/action", 'documentation_url'=>"http://test.host/Api"}])
+    assigns(:services).should eq([{ 'service_name' => 'Api', 'namespace' => '/api/wsdl', 'endpoint' => '/api/action', 'documentation_url' => 'http://test.host/Api' }])
   end
-  
-  it "renders the template" do
+
+  it 'renders the template' do
     get :all
-    response.should render_template("wash_with_html/all_services")
+    response.should render_template('wash_with_html/all_services')
   end
- 
-  
-  it "checks it controller is a service" do
-    controller.send(:controller_is_a_service?,"api").should_not eq nil
+
+  it 'checks it controller is a service' do
+    controller.send(:controller_is_a_service?, 'api').should_not eq nil
   end
-   
-  it "render a service documentation" do
+
+  it 'render a service documentation' do
     controller.expects(:controller_is_a_service?).with(params[:name]).returns(route)
     WashoutBuilder::Document::Generator.expects(:new).with(route.defaults[:controller])
     get :all, params
-    response.should render_template "wash_with_html/doc"
+    response.should render_template 'wash_with_html/doc'
   end
-  
-     
-     
 end