washout_builder 0.14.1 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 802bd845220cba1431d3e914c831885a808f409b
-  data.tar.gz: 01217f8a74c7d265fa154f92ae9935331676448a
+  metadata.gz: 3bf03886cb1c9afca96b057708fef231782db00a
+  data.tar.gz: 432614b7d5788c094053614d678c530e33520bc9
 SHA512:
-  metadata.gz: 893d39b63b0a4c07d84437b1962a6490cc83e361d528fb67e7f4e1ae8550f6fc8b137b9c3a45db6d68cbb033e58e06119b6f857231b9d77e90f4349416e18bbe
-  data.tar.gz: 5fc32ae9c7b33126937e4793169effa58f0d9ec9f842e49e6c528a508f569f7d12614dc56cdd26c35f91e9ec5bc9818914126b9019335a0293706664cac61d6e
+  metadata.gz: 5f82065358b685fd0be21b39209f538a62094727d2a21426445fea15df6007524dec39e34f47dab97caeb3b7bd94fb827586f5453e9cafa285257630ed94d603
+  data.tar.gz: 8fc71e4d273114de1552e743ce6a3c8f6cd242d5256eee671597a3579d56f9986dccb2886912d719681e5369a3f0947b05f47dd28f7cf422a23037635d547e52

data/.gitignore

@@ -9,9 +9,8 @@ pkg/
 spec/dummy/db/*.sqlite3
 spec/dummy/log/*.log
 spec/dummy/tmp/
-gemfiles
 coverage
 tags
 Gemfile.lock
 /nbproject/
-/.git-rewrite/
+/.git-rewrite/

data/.rubocop.yml

@@ -0,0 +1,68 @@
+AllCops:
+  Exclude:
+    - washout_builder.gemspec
+    - bin/**/*
+    - Guardfile
+
+Documentation:
+  Enabled: false
+
+Encoding:
+  Enabled: false
+
+LineLength:
+  Max: 200
+
+AccessModifierIndentation:
+  EnforcedStyle: outdent
+
+IfUnlessModifier:
+  Enabled: false
+
+CaseIndentation:
+  IndentWhenRelativeTo: case
+  IndentOneStep: true
+
+MethodLength:
+  CountComments: false
+  Max: 20
+
+SignalException:
+  Enabled: false
+
+ColonMethodCall:
+  Enabled: false
+
+AsciiComments:
+  Enabled: false
+
+RegexpLiteral:
+  Enabled: false
+
+AssignmentInCondition:
+  Enabled: false
+
+ParameterLists:
+  CountKeywordArgs: false
+
+SingleLineBlockParams:
+  Methods:
+    - reduce:
+      - memo
+      - item
+
+Metrics/AbcSize:
+  Enabled: false
+
+Style/CollectionMethods:
+  Enabled: true
+
+Style/SymbolArray:
+  Enabled: true
+
+Style/ExtraSpacing:
+  Enabled: true
+
+Style/FileName:
+  Enabled: false
+

data/.travis.yml

@@ -9,4 +9,4 @@ rvm:
 env:
  - RAILS_ENV=test RACK_ENV=test
 notifications:
-  email: false
+  email: false

data/Appraisals

@@ -20,4 +20,12 @@ end
 
 appraise "rails-4.1.4" do
   gem "rails", "4.1.4"
-end
+end
+
+appraise "rails-4.1.9" do
+  gem "rails", "4.1.9"
+end
+
+appraise "rails-4.2.0" do
+  gem "rails", "4.2.0"
+end

data/Gemfile

@@ -1,6 +1,5 @@
-source "http://rubygems.org"
+source 'http://rubygems.org'
 
 gemspec
 
-
-gem 'wash_out',  git: 'git://github.com/inossidabile/wash_out.git'
+gem 'wash_out', git: 'git://github.com/inossidabile/wash_out.git'

data/Rakefile

@@ -6,41 +6,38 @@ require 'coveralls/rake/task'
 Coveralls::RakeTask.new
 
 RSpec::Core::RakeTask.new(:spec) do |spec|
-  # spec.rspec_opts = ['--backtrace '] 
+  spec.rspec_opts = ['--backtrace '] if ENV['DEBUG']
 end
 
-#desc "Prepare dummy application"
-#task :prepare do
+# desc "Prepare dummy application"
+# task :prepare do
 #  ENV["RAILS_ENV"] ||= 'test'
-#
 #  require File.expand_path("./spec/dummy/config/environment", File.dirname(__FILE__))
 #  Dummy::Application.load_tasks
-#
 #  Rake::Task["db:test:prepare"].invoke
-#end
+# end
 
-unless ENV["TRAVIS"]
+unless ENV['TRAVIS']
   require 'rvm-tester'
   RVM::Tester::TesterTask.new(:suite) do |t|
     t.rubies = %w(1.9.3 2.0.0 2.1.0) # which versions to test (required!)
-    t.bundle_install = true                # updates Gemfile.lock, default is true
-    t.use_travis = true                    # looks for Rubies in .travis.yml (on by default)
-    t.command = "bundle exec rake"    # runs plain "rake" by default
-    t.env = {"VERBOSE" => "1", "RAILS_ENV"=>"test", "RACK_ENV"=> "test" }             # set any ENV vars
-    t.num_workers = 5                      # defaults to 3
-    t.verbose = true                       # shows more output, off by default
+    t.bundle_install = true # updates Gemfile.lock, default is true
+    t.use_travis = true # looks for Rubies in .travis.yml (on by default)
+    t.command = 'bundle exec rake' # runs plain "rake" by default
+    t.env = { 'VERBOSE' => '1', 'RAILS_ENV' => 'test', 'RACK_ENV' => 'test' } # set any ENV vars
+    t.num_workers = 5 # defaults to 3
+    t.verbose = true # shows more output, off by default
   end
 end
 
-
-desc "Default: run the unit tests."
-task :default => [:all]
+desc 'Default: run the unit tests.'
+task default: [:all]
 
 desc 'Test the plugin under all supported Rails versions.'
-task :all   do |t|
-  if ENV["TRAVIS"]
-    exec(' bundle exec appraisal install && bundle exec rake appraisal spec && bundle exec rake coveralls:push')
+task :all do |_t|
+  if ENV['TRAVIS']
+    exec(' bundle exec phare &&  bundle exec appraisal install && bundle exec rake appraisal spec && bundle exec rake coveralls:push')
   else
-    exec(' bundle exec appraisal install && bundle exec rake appraisal spec')
+    exec(' bundle exec phare &&  bundle exec appraisal install && bundle exec rake appraisal spec')
   end
 end

data/app/controllers/washout_builder/washout_builder_controller.rb

@@ -1,89 +1,89 @@
-require_relative "../../../lib/washout_builder/document/generator"
-class WashoutBuilder::WashoutBuilderController < ActionController::Base
-  protect_from_forgery
+require_relative '../../../lib/washout_builder/document/generator'
+module WashoutBuilder
+  class WashoutBuilderController < ActionController::Base
+    protect_from_forgery
 
-  # Will show all api services if no name parameter is receiverd
-  # If a name parameter is present wiill try to use that and find a controller 
-  # that was that name by camelcasing the name . 
-  # IF a name is provided will show the documentation page for that controller 
-  def all
-    route = params[:name].present? ? controller_is_a_service?(params[:name]) : nil
-    if route.present?
-      @document =  WashoutBuilder::Document::Generator.new(route.defaults[:controller])
-      render :template => "wash_with_html/doc", :layout => false,
-        :content_type => 'text/html'
-    else
-      all_services
+    # Will show all api services if no name parameter is receiverd
+    # If a name parameter is present wiill try to use that and find a controller
+    # that was that name by camelcasing the name .
+    # IF a name is provided will show the documentation page for that controller
+    def all
+      route = params[:name].present? ? controller_is_a_service?(params[:name]) : nil
+      if route.present?
+        @document = WashoutBuilder::Document::Generator.new(route.defaults[:controller])
+        render template: 'wash_with_html/doc', layout: false,
+               content_type: 'text/html'
+      else
+        all_services
+      end
     end
-  end
-  
-  
+
   private
-  
-  # tries to find all services by searching through the rails controller 
-  # and returns their namespace, endpoint and a documentation url
-  def all_services
-    @map_controllers = map_controllers do |route|  route.defaults[:controller]   end
-    @services = @map_controllers.blank? ? [] : @map_controllers.map do |controller_name|
-      {
-        'service_name' =>   controller_naming(controller_name)  ,
-        'namespace' => service_namespace(controller_name),
-        'endpoint' => service_endpoint(controller_name),
-        'documentation_url' => service_documentation_url(controller_name),
-      }
+
+    # tries to find all services by searching through the rails controller
+    # and returns their namespace, endpoint and a documentation url
+    def all_services
+      @map_controllers = map_controllers { |route| route.defaults[:controller] }
+      @services = @map_controllers.blank? ? [] : @map_controllers.map do |controller_name|
+        {
+          'service_name' => controller_naming(controller_name),
+          'namespace' => service_namespace(controller_name),
+          'endpoint' => service_endpoint(controller_name),
+          'documentation_url' => service_documentation_url(controller_name)
+        }
+      end
+
+      render template: 'wash_with_html/all_services', layout: false,
+             content_type: 'text/html'
     end
-      
-    render :template => "wash_with_html/all_services", :layout => false,
-      :content_type => 'text/html'
-  end
-  
-  # the way of converting from controller string in downcase in camelcase 
-  def controller_naming(controller)
-    controller.camelize
-  end
-  
-  # checking if a route has the action for generating WSDL
-  def route_can_generate_wsdl?(route)
-    route.defaults[:action] == "_generate_wsdl"
-  end
-  
-  # method for getting all controllers that have the generate wsdl action or finding out
-  # if a single controller is a soap service
-  def map_controllers(action = "map")
-    res =  Rails.application.routes.routes.send(action) do |route|
-      if route_can_generate_wsdl?(route)
-        yield route if block_given?
+
+    # the way of converting from controller string in downcase in camelcase
+    def controller_naming(controller)
+      controller.camelize
+    end
+
+    # checking if a route has the action for generating WSDL
+    def route_can_generate_wsdl?(route)
+      route.defaults[:action] == '_generate_wsdl'
+    end
+
+    # method for getting all controllers that have the generate wsdl action or finding out
+    # if a single controller is a soap service
+    def map_controllers(action = 'map')
+      res = Rails.application.routes.routes.send(action) do |route|
+        if route_can_generate_wsdl?(route)
+          yield route if block_given?
+        end
       end
+      res = res.uniq.compact if action == 'map'
+      res
     end
-    res = res.uniq.compact if action == "map"
-    return res
-  end
-  
-  # checking if a controller is a soap service
-  def  controller_is_a_service?(controller)
-    map_controllers("detect") do |route|
-      controller_naming(route.defaults[:controller]) == controller_naming(controller) 
+
+    # checking if a controller is a soap service
+    def controller_is_a_service?(controller)
+      map_controllers('detect') do |route|
+        controller_naming(route.defaults[:controller]) == controller_naming(controller)
+      end
     end
-  end
 
-  # getting the controller class from the controller string
-  def controller_class(controller)
-    controller_naming("#{controller}_controller").constantize
-  end
-  
-  # retrieves the service namespace
-  def service_namespace(controller_name)
-    controller_class(controller_name).soap_config.namespace
-  end
-  
-  # the endpoint is based on the namespace followed by /action suffix 
-  def service_endpoint(controller_name)
-    service_namespace(controller_name).gsub("/wsdl", "/action")
-  end
-  
-  # constructs the documentation url for a specific web service 
-  def service_documentation_url(controller_name)
-    "#{washout_builder.root_url}#{controller_naming(controller_name)}"
-  end
+    # getting the controller class from the controller string
+    def controller_class(controller)
+      controller_naming("#{controller}_controller").constantize
+    end
+
+    # retrieves the service namespace
+    def service_namespace(controller_name)
+      controller_class(controller_name).soap_config.namespace
+    end
 
+    # the endpoint is based on the namespace followed by /action suffix
+    def service_endpoint(controller_name)
+      service_namespace(controller_name).gsub('/wsdl', '/action')
+    end
+
+    # constructs the documentation url for a specific web service
+    def service_documentation_url(controller_name)
+      "#{washout_builder.root_url}#{controller_naming(controller_name)}"
+    end
+  end
 end

data/app/helpers/washout_builder_complex_type_helper.rb

@@ -1,30 +1,23 @@
 module WashoutBuilderComplexTypeHelper
-  
-   # this method is for printing the attributes of a complex type
-   # if the attributes are primitives this will show the attributes with  blue color
-   # otherwise will call another method for printing the complex attribute
+  # this method is for printing the attributes of a complex type
+  # if the attributes are primitives this will show the attributes with  blue color
+  # otherwise will call another method for printing the complex attribute
   def create_element_type_html(pre, element)
-    element.type = "string" if element.type == "text"
-    element.type = "integer" if element.type == "int"
-     if WashoutBuilder::Type::BASIC_TYPES.include?(element.type)
-        pre << "<span class='blue'>#{element.type}</span>&nbsp;<span class='bold'>#{element.name}</span>"
-      else
-        create_complex_element_type_html(pre, element)
-      end
+    element.type = 'string' if element.type == 'text'
+    element.type = 'integer' if element.type == 'int'
+    if WashoutBuilder::Type::BASIC_TYPES.include?(element.type)
+      pre << "<span class='blue'>#{element.type}</span>&nbsp;<span class='bold'>#{element.name}</span>"
+    else
+      create_complex_element_type_html(pre, element)
+    end
   end
-  
- 
+
   # checks if a complex attribute of a complex type is a array or not
-  # and retrieves the complex class name of the attribute and prints it 
+  # and retrieves the complex class name of the attribute and prints it
   def create_complex_element_type_html(pre, element)
-    complex_class = element.get_complex_class_name
-    unless  complex_class.nil?
-      complex_class_content =  element.multiplied == false ? "#{complex_class}" : "Array of #{complex_class}"
-      pre << "<a href='##{complex_class}'><span class='lightBlue'>#{complex_class_content}</span></a>&nbsp;<span class='bold'>#{element.name}</span>"
-    end
+    complex_class = element.find_complex_class_name
+    return if complex_class.nil?
+    complex_class_content = element.multiplied == false ? "#{complex_class}" : "Array of #{complex_class}"
+    pre << "<a href='##{complex_class}'><span class='lightBlue'>#{complex_class_content}</span></a>&nbsp;<span class='bold'>#{element.name}</span>"
   end
-
 end
-
-
-  

data/app/helpers/washout_builder_fault_type_helper.rb

@@ -1,5 +1,4 @@
 module WashoutBuilderFaultTypeHelper
-  
   # checks if a complex attribute of a complex type SoapFault is array or not
   # if the attribute is an array will print also the type of the elements contained in the array
   # otherwise will show the complex class of the attribute
@@ -7,35 +6,35 @@ module WashoutBuilderFaultTypeHelper
     attribute_primitive = array == true ? "Array of #{attr_primitive}" : "#{attr_primitive}"
     pre << "<a href='##{attr_primitive}'><span class='lightBlue'> #{attribute_primitive}</span></a>&nbsp;<span class='bold'>#{attribute}</span>"
   end
-  
+
   # if the attribute is an array  this method is used to identify the type of the elements inside the array
   def member_type_is_basic?(attr_details)
     WashoutBuilder::Type::BASIC_TYPES.include?(attr_details[:member_type].to_s.downcase) ? attr_details[:member_type].to_s.downcase : attr_details[:member_type]
   end
   # checks is the attribute has a primitive value or a complex value
   def primitive_type_is_basic?(attr_details)
-    WashoutBuilder::Type::BASIC_TYPES.include?(attr_details[:primitive].to_s.downcase) 
+    WashoutBuilder::Type::BASIC_TYPES.include?(attr_details[:primitive].to_s.downcase)
   end
 
-  # if the attribute value is of type nil the documentation will show string 
+  # if the attribute value is of type nil the documentation will show string
   # otherwise the primitive value
   def get_primitive_type_string(attr_details)
-    attr_details[:primitive].to_s.downcase == "nilclass" ? "string" : attr_details[:primitive].to_s.downcase
-  end  
-  
+    attr_details[:primitive].to_s.downcase == 'nilclass' ? 'string' : attr_details[:primitive].to_s.downcase
+  end
+
   # if the attribute is of type array the method identifies the type of the elements inside the array
   def get_member_type_string(attr_details)
-    attr_details[:primitive].to_s.downcase == "array" ? member_type_is_basic?(attr_details) :  attr_details[:primitive]
+    attr_details[:primitive].to_s.downcase == 'array' ? member_type_is_basic?(attr_details) : attr_details[:primitive]
   end
-  
-  # this method is used to print all attributes of a SoapFault element 
+
+  # this method is used to print all attributes of a SoapFault element
   # if the attribute value is a primitve value it will be shown in blue and will also show the type of the primitive
-  # if is a complex type will use another method for finding out the complex class 
+  # if is a complex type will use another method for finding out the complex class
   def create_html_fault_model_element_type(pre, attribute, attr_details)
-    if primitive_type_is_basic?(attr_details) || attr_details[:primitive] == "nilclass" 
+    if primitive_type_is_basic?(attr_details) || attr_details[:primitive] == 'nilclass'
       pre << "<span class='blue'>#{get_primitive_type_string(attr_details)}</span>&nbsp;<span class='bold'>#{attribute}</span>"
     else
-      create_fault_model_complex_element_type(pre, get_member_type_string(attr_details), attribute, true )
+      create_fault_model_complex_element_type(pre, get_member_type_string(attr_details), attribute, true)
     end
   end
 end