washout_builder 0.9.12 → 0.10.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    Mzk1MTAyYzkzMjllNWU3Mjk5NTMxOTAyZTUwMDI0M2IzN2Y2NDNlMg==
+    MmE2OGFhZGZhMjA3NzMzZDRiNjU0MmM0MGZjYmZiZmViMTEzYzNhOA==
   data.tar.gz: !binary |-
-    NzdmNzEwNGMzZTY4YTMzMDBiMjZlZTU2ZWE1MGE3YTQyMDk2NmJhZQ==
+    MzA0NGQ4MmQ5YjY2N2VlZmYxMjc4ZmZmYjBjZmQ4ZjdkMjg4ZDc5ZA==
 SHA512:
   metadata.gz: !binary |-
-    YTE0ZjE0OTQzNjBhNGM2MmMxZDQzZTUzMzZhMjYxZWRiZDU2MWFkYzkzNzcy
-    OGQ4YzEwMjg1MTE3MjgwYTdhM2ZlZDYwOWYzZTBjYjA0MGQ3YWQ4ZDBmZTRm
-    N2ZjNTk4OTc1ZThjMDEyNTYwYjhmZDc0ZmJlYWNlY2YxM2U3NDk=
+    ZjRlMmVlNzhlOTcwM2RmZWI1NDdiMWNiM2NmZTVhODg4ZjliZjNlYTU2OWY5
+    MzhkOTMwODZmZDRmNjAxODk5MTgwNjczYjRiMTU3MmQwNDlkMTJjZGM3YzZj
+    MmMwOTkxYTVmNTQ4MGZjYjgyMzkzNGI5YmQwN2FhYTYwNzBkMmU=
   data.tar.gz: !binary |-
-    ZDg0ZjJmNThlM2E2YjhmMGY3NDdmMDYxNDVkOWMwMTMxZDY4YTZmNTdhNThh
-    NTkwNWM5MWU5Y2I2NmMxMTY3OTA5ODJhYWVkYjc2YWE2NDJkZjM5NTIwMDZk
-    YmE5ZmI0ODA0MmY1ZTc0Yjg4N2E4YmU5MDQ0YTNlMTRlN2JkM2Y=
+    YTA2MDI1NWNjYmYyNDMyZDI2ZDlhYjMwZTgzYmQ3N2Q5YWFhYjgxNTYwMzQ5
+    OTNlNWE4ZjAwYzY4ZTgxZjc4MGFmYWMxMDBjNWIzNmZkMDg1M2VkZjk3NTRh
+    YmM0NmNmZGMxMjRlZDQ1YTdmNDE4N2YyMDEyMTNlNWQzMjFiOWI=

data/.travis.yml

@@ -6,3 +6,9 @@ rvm:
   - 1.9.3
   - jruby-19mode
   - 2.0.0
+env:
+  - RAILS_ENV=test RACK_ENV=test
+branches:
+  only:
+    - master
+    - develop 

data/Gemfile

@@ -18,4 +18,15 @@ gem 'tzinfo'
 gem 'pry'
 gem 'simplecov'
 gem 'simplecov-summary'
+gem 'nori'
+gem 'nokogiri'
+gem 'capybara', '1.1.4'
+gem 'selenium-webdriver', '~> 2.37.0'
+gem 'headless'
+gem 'capybara-firebug'
+gem 'mocha', '~> 0.13.3', :require => false
+gem 'factory_girl_rails'
+gem 'forgery'
+gem 'webmock'
+gem 'rspec-instafail'
 

data/README.rdoc

@@ -111,7 +111,8 @@ You can also specify complex types like this:
   
    end
 
-<b>The class MyCustomModel must include +Virtus.model+ if you want it to show up in the documentation!</b> 
+<b>The class MyCustomModel must include +Virtus.model+ or +Virtus.value_object+ or it must include at least one module that includes +Virtus.module+ if you want it to show up in the documentation! 
+Please checkout {Virtus Gem}[https://github.com/solnic/virtus] for further documentation!</b> 
 
 You can also use aggregation with another fault class exception like this:
 

data/Rakefile

@@ -3,7 +3,9 @@ require 'bundler/gem_tasks'
 require 'appraisal'
 require 'rspec/core/rake_task'
 
-RSpec::Core::RakeTask.new(:spec)
+RSpec::Core::RakeTask.new(:spec) do |spec|
+ # spec.rspec_opts = ['--backtrace '] 
+end
 
 desc "Default: run the unit tests."
 task :default => [:all]

data/app/helpers/washout_builder_helper.rb

@@ -1,167 +1,5 @@
 module WashoutBuilderHelper
 
-  def get_complex_class_name(p, defined = [])
-    complex_class =  p.struct? ? p.basic_type : nil
-    complex_class =  complex_class.include?(".") ? complex_class.gsub(".","/").camelize : complex_class.to_s.classify    unless complex_class.nil?
-     
-    unless complex_class.nil? || defined.blank?
-     
-      complex_obj_found = defined.detect {|hash|   hash[:class] == complex_class}
-    
-      if !complex_obj_found.nil? && p.struct?  &&  !p.classified? && p.source_class_name.blank?
-        raise RuntimeError, "Duplicate use of `#{p.basic_type}` type name. Consider using classified types."
-      end
-    end
-   
-    return complex_class
-  end
-
-  
-  def get_param_structure(param)
-    param.map.inject({}) {|h,element|  h[element.name] = element.type;h }
-  end
-  
-  
-  def remove_type_inheritable_elements(param, keys)
-    param.map.delete_if{|element|  keys.include?(element.name) }
-  end
-  
-  
-  def  same_structure_as_ancestor?(param, ancestor)
-    param_structure = get_param_structure(param)
-    ancestor_structure = get_param_structure(ancestor)
-    if  param_structure.keys == ancestor_structure.keys
-      return true
-    else 
-      remove_type_inheritable_elements(param, ancestor_structure.keys)
-      return false
-    end
-  end
-  
-  
-  
-  
-  def get_class_ancestors(param,class_name, defined)
-    bool_the_same = false
-    param_class = class_name.is_a?(Class) ? class_name : class_name.constantize rescue nil
-    unless param_class.nil?
-      ancestors  = (param_class.ancestors - param_class.included_modules).delete_if{ |x| x.to_s.downcase == class_name.to_s.downcase  ||  x.to_s == "ActiveRecord::Base" ||  x.to_s == "Object" || x.to_s =="BasicObject" || x.to_s == "WashOut::Type" }
-      unless ancestors.blank?
-        ancestor_structure =  { ancestors[0].to_s.downcase =>  ancestors[0].columns_hash.inject({}) {|h, (k,v)|  h["#{k}"]="#{v.type}".to_sym; h } }
-        ancestor_object =  WashOut::Param.parse_def(@soap_config,ancestor_structure)[0]
-        bool_the_same = same_structure_as_ancestor?(param, ancestor_object)
-        unless bool_the_same
-          top_ancestors = get_class_ancestors(ancestor_object,ancestors[0], defined)
-          defined << {:class =>ancestors[0], :obj =>ancestor_object ,  :ancestors => top_ancestors   }
-        end
-      end
-      ancestors unless  bool_the_same
-    end
-  end
-  
-  
-  def fix_descendant_wash_out_type(param, complex_class)
-    param_class = complex_class.is_a?(Class) ? complex_class : complex_class.constantize rescue nil
-    if !param_class.nil? && param_class.ancestors.include?(WashOut::Type) && !param.map[0].nil? 
-      descendant = WashOut::Param.parse_def(@soap_config, param_class.wash_out_param_map)[0]
-      param.name =  descendant.name 
-      param.map = descendant.map
-    end
-  end
-
-  def get_nested_complex_types(param, defined)
-    defined = [] if defined.blank?
-    complex_class = get_complex_class_name(param, defined)
-    fix_descendant_wash_out_type(param, complex_class)
-    defined << {:class =>complex_class, :obj => param, :ancestors => param.classified?  ?  get_class_ancestors(param, complex_class, defined) : nil } unless complex_class.nil?
-    if param.struct?
-      c_names = []
-      param.map.each { |obj|   c_names.concat(get_nested_complex_types(obj, defined))  }        
-      defined.concat(c_names)
-    end
-    defined.sort_by { |hash| hash[:class].downcase }.uniq unless defined.blank?
-  end
-
-
-  def get_complex_types(map)
-    defined = []
-    map.each do |operation, formats|
-      (formats[:in] + formats[:out]).each do |p|
-        defined.concat(get_nested_complex_types(p, defined))
-      end
-    end
-    defined.sort_by { |hash| hash[:class].downcase }.uniq unless defined.blank?
-  end
-
-  
-  def remove_fault_type_inheritable_elements(param, keys)
-    get_virtus_model_structure(param).delete_if{|key,value|  keys.include?(key) }
-  end
-  
-  
- 
-  
-  
-  def get_fault_class_ancestors(fault, defined, debug = false)
-    bool_the_same = false
-    unless fault.nil?
-      ancestors  = (fault.ancestors - fault.included_modules).delete_if{ |x| x.to_s.downcase == fault.to_s.downcase  ||  x.to_s == "ActiveRecord::Base" ||  x.to_s == "Object" || x.to_s =="BasicObject"   || x.to_s == "Exception" }
-      if  ancestors.blank?
-        defined << {:fault => fault,:structure =>get_virtus_model_structure(fault)  ,:ancestors => []   }
-      else
-        fault_structure =  remove_fault_type_inheritable_elements(fault,  get_virtus_model_structure(ancestors[0]).keys)
-        defined << {:fault => fault,:structure =>fault_structure  ,:ancestors => ancestors  }
-        get_fault_class_ancestors(ancestors[0], defined)
-      end
-      ancestors unless  bool_the_same
-    end
-  end
-  
-  def get_virtus_model_structure(fault)
-    fault.attribute_set.inject({}) {|h, elem|  h["#{elem.name}"]= { :primitive => "#{elem.primitive}", :options => elem.options }; h }
-  end
- 
-  
-  def get_fault_types(map)
-    defined = map.select{|operation, formats| !formats[:raises].blank? }
-    defined = defined.collect {|operation, formats|  formats[:raises].is_a?(Array)  ? formats[:raises] : [formats[:raises]] }.flatten.select { |x| x.is_a?(Class) && x.ancestors.include?(WashOut::SOAPError) }  unless defined.blank?
-    fault_types = []
-    if defined.blank?
-      defined = [WashOut::SOAPError] 
-    else
-      defined  << WashOut::SOAPError
-    end
-    defined.each{ |item|  get_fault_class_ancestors(item, fault_types, true)}  unless   defined.blank?
-    
-    complex_types = []
-    fault_types.each do |hash| 
-      hash[:structure].each do |attribute, attr_details|
-        if  attr_details[:primitive].to_s.downcase == "array" &&  !WashoutBuilder::Type::BASIC_TYPES.include?(attr_details[:options][:member_type].primitive.to_s.downcase)
-          complex_class = attr_details[:options][:member_type].primitive
-        elsif attr_details[:primitive].to_s.downcase != "array" &&  !WashoutBuilder::Type::BASIC_TYPES.include?(attr_details[:primitive].to_s.downcase)
-          complex_class = attr_details[:primitive]
-        end
-       
-        param_class = complex_class.is_a?(Class) ? complex_class : complex_class.constantize rescue nil
-        if !param_class.nil? && param_class.ancestors.include?(Virtus::Model::Core)
-          get_fault_class_ancestors(param_class, complex_types)
-        elsif !param_class.nil? && !param_class.ancestors.include?(Virtus::Model::Core)
-          raise RuntimeError, "Non-existent use of `#{param_class}` type name or this class does not use Virtus.model. Consider using classified types that include Virtus.mode for exception atribute types."
-        end
-        
-      end 
-    end
-    complex_types.delete_if{ |hash|  fault_types << hash if  hash[:fault].ancestors.include?(WashOut::SOAPError) } unless complex_types.blank?
-    fault_types = fault_types.sort_by { |hash| hash[:fault].to_s.downcase }.uniq unless fault_types.blank?  
-    complex_types = complex_types.sort_by { |hash| hash[:fault].to_s.downcase }.uniq unless complex_types.blank?
-    [fault_types, complex_types]
-  end
-
-  def get_soap_action_names(map)
-    map.map{|operation, formats| operation.to_s }.sort_by { |name| name.downcase }.uniq unless map.blank?
-  end
-
-
   def create_html_complex_types(xml, types)
     types.each  { |hash| create_complex_type_html(xml, hash[:obj], hash[:class], hash[:ancestors]) }
   end
@@ -181,9 +19,10 @@ module WashoutBuilderHelper
             # raise YAML::dump(element) if class_name.include?("ype") and element.name == "members"
             xml.li { |pre|
               if WashoutBuilder::Type::BASIC_TYPES.include?(element.type)
+                element.type = "integer" if element.type == "int"
                 pre << "<span class='blue'>#{element.type}</span>&nbsp;<span class='bold'>#{element.name}</span>"
               else
-                complex_class = get_complex_class_name(element)
+                complex_class = element.get_complex_class_name
                 unless  complex_class.nil?
                   if  element.multiplied == false
                     pre << "<a href='##{complex_class}'><span class='lightBlue'>#{complex_class}</span></a>&nbsp;<span class='bold'>#{element.name}</span>"
@@ -228,9 +67,8 @@ module WashoutBuilderHelper
               
             else
               if  attr_details[:primitive].to_s.downcase == "array"
-                attr_primitive = attr_details[:options][:member_type].primitive.to_s
                 
-                attr_primitive =  WashoutBuilder::Type::BASIC_TYPES.include?(attr_primitive.downcase) ? attr_primitive.downcase : attr_primitive
+                attr_primitive =  WashoutBuilder::Type::BASIC_TYPES.include?(attr_details[:member_type].to_s.downcase) ? attr_details[:member_type].to_s.downcase : attr_details[:member_type]
                 pre << "<a href='##{attr_primitive}'><span class='lightBlue'>Array of #{attr_primitive}</span></a>&nbsp;<span class='bold'>#{attribute}</span>"
               else
                 pre << "<a href='##{attr_details[:primitive] }'><span class='lightBlue'>#{attr_details[:primitive]}</span></a>&nbsp;<span class='bold'>#{attribute}</span>"
@@ -259,7 +97,7 @@ module WashoutBuilderHelper
 
     xml.p("class" => "pre"){ |pre|
       unless formats[:out].nil?
-        complex_class = get_complex_class_name(formats[:out][0])  
+        complex_class = formats[:out][0].get_complex_class_name  
         if WashoutBuilder::Type::BASIC_TYPES.include?(formats[:out][0].type)
           xml.span("class" => "blue") { |y| y<<  "#{formats[:out][0].type}" }
         else
@@ -274,7 +112,7 @@ module WashoutBuilderHelper
       else
         pre << "void"
       end
-
+      
       xml.span("class" => "bold") {|y|  y << "#{operation} (" }
       mlen = formats[:in].size
       xml.br if mlen > 1
@@ -283,7 +121,7 @@ module WashoutBuilderHelper
         j=0
         while j<mlen
           param = formats[:in][j]
-          complex_class = get_complex_class_name(param)  
+          complex_class = param.get_complex_class_name  
           use_spacer =  mlen > 1 ? true : false
           if WashoutBuilder::Type::BASIC_TYPES.include?(param.type)
             pre << "#{use_spacer ? spacer: ''}<span class='blue'>#{param.type}</span>&nbsp;<span class='bold'>#{param.name}</span>"
@@ -321,7 +159,7 @@ module WashoutBuilderHelper
       mlen = formats[:in].size
       while j<mlen
         param = formats[:in][j]
-        complex_class = get_complex_class_name(param)  
+        complex_class = param.get_complex_class_name  
         xml.li("class" => "pre") { |pre|
           if WashoutBuilder::Type::BASIC_TYPES.include?(param.type)
             pre << "<span class='blue'>#{param.type}</span>&nbsp;<span class='bold'>#{param.name}</span>"

data/app/views/wash_with_html/doc.builder

@@ -5,7 +5,7 @@ xml.html( "xmlns" => "http://www.w3.org/1999/xhtml" ) {
 
   xml.head {
 
-    xml.title "#{@service} interface description"
+    xml.title "#{@document.service} interface description"
 
     xml.style( "type"=>"text/css" ,"media" => "all" ) { xml.text! "
     body{font-family:Calibri,Arial;background-color:#fefefe;}
@@ -31,27 +31,27 @@ xml.html( "xmlns" => "http://www.w3.org/1999/xhtml" ) {
 
   xml.body {
 
-    xml.h1 "#{ @service} Soap WebService interface description"
+    xml.h1 "#{ @document.service} Soap WebService interface description"
 
     xml.p{ |y| y << "Endpoint URI:";
-      xml.span( "class" => "pre") { |y| y << "#{@endpoint}"};
+      xml.span( "class" => "pre") { |y| y << "#{@document.endpoint}"};
     }
 
     xml.p{ |y| y << "WSDL URI:";
       xml.span( "class" => "pre") {
-        xml.a( "href" => "#{@namespace}") { |y| y << "#{@namespace}" }
+        xml.a( "href" => "#{@document.namespace}") { |y| y << "#{@document.namespace}" }
       };}
 
-    unless @soap_config.description.blank?
-      xml.h1 "#{@service}"
-      xml.p "#{@soap_config.description}"
+    unless @document.service_description.blank?
+      xml.h1 "#{@document.service}"
+      xml.p "#{@document.service_description}"
     end
 
     xml.div("class" => "noprint") {
 
       xml.h2 "Index "
-      @complex_types =  get_complex_types(@map)
-      @fault_types, @fault_complex_types = get_fault_types(@map)
+      @complex_types =  @document.complex_types
+      @fault_types, @fault_complex_types = @document.fault_types
       unless @complex_types.blank?
         xml.p  "Complex Types: "
       
@@ -78,7 +78,7 @@ xml.html( "xmlns" => "http://www.w3.org/1999/xhtml" ) {
         end
       end
 
-      @methods = get_soap_action_names(@map)
+      @methods = @document.get_soap_action_names
       unless @methods.blank?
         xml.p  "Public Methods:"
 
@@ -104,7 +104,7 @@ xml.html( "xmlns" => "http://www.w3.org/1999/xhtml" ) {
     end
     unless @methods.blank?
       xml.h2 "Public methods:"
-      create_html_public_methods(xml, @map)
+      create_html_public_methods(xml, @document.soap_actions)
     end
     
     if @complex_types.blank? && @fault_types.blank? &&  @methods.blank?

data/lib/washout_builder.rb

@@ -2,8 +2,12 @@ require 'wash_out'
 require 'virtus'
 require 'washout_builder/soap'
 require 'washout_builder/engine'
+require 'washout_builder/document/complex_type'
+require 'washout_builder/document/virtus_model'
+require 'washout_builder/document/generator'
 require 'washout_builder/dispatcher'
 require 'washout_builder/type'
+require 'washout_builder/version'
 
 
 module ActionDispatch::Routing
@@ -23,17 +27,32 @@ module ActionDispatch::Routing
   end
 end
 
+Virtus::InstanceMethods::Constructor.class_eval do
+  alias_method  :original_initialize,:initialize
+  def initialize(attributes = nil)
+    if  self.class.ancestors.include?(WashOut::SOAPError) || self.is_a?(WashOut::SOAPError)
+      attributes = {:message => attributes} unless attributes.is_a?(Hash) 
+    end
+    original_initialize(attributes)
+  end
+end
 
 
+WashOut::Param.send :include, WashoutBuilder::Document::ComplexType
 
-WashOut::SOAPError.class_eval do
-  include Virtus.model
-  attribute :code, Integer
-  attribute :message, String
-  attribute :backtrace, String
+[WashOut::SOAPError, SOAPError].each do |exception_class|
+  exception_class.class_eval do
+    extend WashoutBuilder::Document::VirtusModel
+     include Virtus.model
+      attribute :code, Integer
+      attribute :message, String
+      attribute :backtrace, String
+  end
 end
 
 
+
+
 ActionController::Base.class_eval do
 
   # Define a SOAP service. The function has no required +options+:

data/lib/washout_builder/dispatcher.rb

@@ -6,13 +6,12 @@ module WashoutBuilder
   module Dispatcher
     
     def _generate_doc
-      @map       = self.class.soap_actions
-      @namespace = soap_config.namespace
-      @name      = controller_path.gsub('/', '_')
-      @service = self.class.name.underscore.gsub("_controller", "").camelize
-      @endpoint  = @namespace.gsub("/wsdl", "/action")
-      @soap_config = soap_config
-
+      @document = WashoutBuilder::Document::Generator.new(
+        :config => soap_config, 
+        :service_class => self.class,  
+        :soap_actions => self.class.soap_actions
+      )
+      
       render :template => "wash_with_html/doc", :layout => false,
         :content_type => 'text/html'
     end

data/lib/washout_builder/document/complex_type.rb

@@ -0,0 +1,102 @@
+module WashoutBuilder
+  module Document
+    module ComplexType
+      extend ActiveSupport::Concern
+      
+      
+      def get_complex_class_name(defined = [])
+        complex_class =  struct? ? basic_type : nil
+        complex_class =  complex_class.include?(".") ? complex_class.gsub(".","/").camelize : complex_class.classify    unless complex_class.nil?
+     
+        unless complex_class.nil? || defined.blank?
+     
+          complex_obj_found = defined.detect {|hash|   hash[:class] == complex_class}
+    
+          if !complex_obj_found.nil? && struct?  &&  !classified?
+            raise RuntimeError, "Duplicate use of `#{basic_type}` type name. Consider using classified types."
+          end
+        end
+   
+        return complex_class
+      end
+      
+      def get_param_structure
+        map.inject({}) {|h,element|  h[element.name] = element.type;h }
+      end
+  
+  
+      def remove_type_inheritable_elements( keys)
+        self.map =  self.map.delete_if{|element|  keys.include?(element.name) }
+      end
+  
+      #      def get_ancestor_structure
+      #        {self.class.to_s.downcase =>  self.class.columns_hash.inject({}) {|h, (k,v)|  h["#{k}"]="#{v.type}".to_sym; h } }
+      #      end
+      
+      
+      def fix_descendant_wash_out_type(config, complex_class)
+        param_class = complex_class.is_a?(Class) ? complex_class : complex_class.constantize rescue nil
+        if !param_class.nil? && param_class.ancestors.include?(WashOut::Type) && !map[0].nil? 
+          descendant = WashOut::Param.parse_def(config, param_class.wash_out_param_map)[0]
+          self.name =  descendant.name 
+          self.map = descendant.map
+        end
+      end
+      
+     
+      def  same_structure_as_ancestor?(ancestor)
+        param_structure = get_param_structure
+        ancestor_structure = ancestor.get_param_structure
+        if  param_structure.keys == ancestor_structure.keys
+          return true
+        else 
+          remove_type_inheritable_elements( ancestor_structure.keys)
+          return false
+        end
+      end
+  
+         
+      def get_ancestors(class_name)
+        param_class = class_name.is_a?(Class) ? class_name : class_name.constantize rescue nil
+        if  param_class.nil?
+          return nil
+        else
+          (param_class.ancestors - param_class.included_modules).delete_if{ |x| x.to_s.downcase == class_name.to_s.downcase  ||  x.to_s == "ActiveRecord::Base" ||  x.to_s == "Object" || x.to_s =="BasicObject" || x.to_s == "WashOut::Type" }
+        end
+      end
+  
+      
+    
+      def get_nested_complex_types(config,defined)
+        defined = [] if defined.blank?
+        complex_class = get_complex_class_name( defined)
+        fix_descendant_wash_out_type( config, complex_class)
+        defined << {:class =>complex_class, :obj => self, :ancestors => classified?  ?  get_class_ancestors(config, complex_class, defined) : nil } unless complex_class.nil?
+        if struct?
+          c_names = []
+          map.each { |obj|   c_names.concat(obj.get_nested_complex_types(config, defined))  }        
+          defined.concat(c_names)
+        end
+        defined.sort_by { |hash| hash[:class].to_s.downcase }.uniq unless defined.blank?
+      end
+     
+    
+      def get_class_ancestors( config, class_name, defined)
+        bool_the_same = false
+        ancestors   = get_ancestors(class_name)
+        unless ancestors.blank?
+          ancestor_structure =   { ancestors[0].to_s.downcase => ancestors[0].wash_out_param_map }
+          ancestor_object =  WashOut::Param.parse_def(config,ancestor_structure)[0]
+          bool_the_same = same_structure_as_ancestor?( ancestor_object)
+          unless bool_the_same
+            top_ancestors = get_class_ancestors(config, ancestors[0], defined)
+            defined << {:class =>ancestors[0], :obj =>ancestor_object ,  :ancestors => top_ancestors   }
+          end
+          ancestors unless  bool_the_same
+        end
+      end
+  
+  
+    end
+  end
+end