actionservice 0.2.99

data/lib/action_service/base.rb

@@ -0,0 +1,74 @@
+require 'action_service/support/class_inheritable_options'
+
+module ActionService
+  class ActionServiceError < StandardError
+  end
+
+  class Base
+    class_inheritable_option :export_name_mangling, true
+    class_inheritable_option :report_exceptions, true
+    class_inheritable_option :logger
+
+    class << self
+      def export(name, options={})
+        validate_options([:expects, :returns, :expects_and_returns], options.keys)
+        if options[:expects_and_returns]
+          expects = options[:expects_and_returns]
+          returns = options[:expects_and_returns]
+        else
+          expects = options[:expects]
+          returns = options[:returns]
+        end
+        if expects.nil?
+          arity = instance_method(name).arity
+          expects = [Object] * arity if arity > 0
+        end
+        if returns.nil?
+          returns = [NilClass]
+        end
+
+        name = name.to_sym
+        public_name = public_export_name(name)
+        info = { :expects => expects, :returns => returns }
+        write_inheritable_hash("action_service_exports", name => info)
+        write_inheritable_hash("action_service_public_exports", public_name => name)
+      end
+
+      def has_export?(name)
+        exports.has_key?(name)
+      end
+
+      def has_public_export?(name)
+        public_exports.has_key?(name)
+      end
+
+      def public_export_name(export_name)
+        if export_name_mangling
+          Inflector.camelize(export_name.to_s)
+        else
+          export_name.to_s
+        end
+      end
+
+      def internal_export_name(public_name)
+        public_exports[public_name]
+      end
+
+      def exports
+        read_inheritable_attribute("action_service_exports") || {}
+      end
+
+      private
+        def public_exports
+          read_inheritable_attribute("action_service_public_exports") || {}
+        end
+
+        def validate_options(valid_option_keys, supplied_option_keys)
+          unknown_option_keys = supplied_option_keys - valid_option_keys
+          unless unknown_option_keys.empty?
+            raise(ActionServiceError, "Unknown options: #{unknown_option_keys}")
+          end
+        end
+    end
+  end
+end

data/lib/action_service/container.rb

@@ -0,0 +1,69 @@
+module ActionService
+  module Container
+    class ContainerError < ActionService::ActionServiceError
+    end
+
+    def self.append_features(base)
+      super
+      base.extend(ClassMethods)
+      base.send(:include, ActionService::Container::InstanceMethods)
+    end
+
+    module ClassMethods
+      def service(name, object=nil, options={}, &block)
+        if (object && block_given?) || (object.nil? && block.nil?)
+          raise(ContainerError, "either service, or a block must be given")
+        end
+        name = name.to_sym
+        if block_given?
+          info = { name => { :block => block } }
+        else
+          info = { name => { :object => object } }
+        end
+        write_inheritable_hash("action_services", info)
+        call_service_definition_callbacks(self, name, info)
+      end
+
+      def add_service_definition_callback(&block)
+        write_inheritable_array("action_service_definition_callbacks", [block])
+      end
+
+      def has_service?(name)
+        services.has_key?(name.to_sym)
+      end
+
+      def services
+        read_inheritable_attribute("action_services") || {}
+      end
+
+      def service_object(service_name)
+        info = services[service_name.to_sym]
+        unless info
+          raise(ContainerError, "no such service '#{service_name}'")
+        end
+        service = info[:block]
+        service ? instance_eval(&service) : info[:object]
+      end
+
+      private
+        def call_service_definition_callbacks(container_klass, service_name, service_info)
+          (read_inheritable_attribute("action_service_definition_callbacks") || []).each do |block|
+            block.call(container_klass, service_name, service_info)
+          end
+        end
+    end
+
+    module InstanceMethods
+      private
+        def dispatch_service_invocation_request(protocol, info)
+          service = self.class.service_object(info.service_name)
+          method_name = service.class.internal_export_name(info.public_method_name)
+          export_info = service.class.exports[method_name]
+          params = protocol.unmarshal_request(info, export_info)
+          result = service.perform_invocation(method_name, params)
+          protocol.marshal_response(info, export_info, result)
+        end
+
+    end
+  end
+end

data/lib/action_service/invocation.rb

@@ -0,0 +1,172 @@
+module ActionService
+  module Invocation
+    class InvocationError < ActionService::ActionServiceError
+    end
+
+    def self.append_features(base) # :nodoc:
+      super
+      base.extend(ClassMethods)
+      base.send(:include, ActionService::Invocation::InstanceMethods)
+    end
+
+    module ClassMethods
+      def append_before_invocation(*interceptors, &block)
+        conditions = extract_conditions!(interceptors)
+        interceptors << block if block_given?
+        add_interception_conditions(interceptors, conditions)
+        append_interceptors_to_chain("before", interceptors)
+      end
+
+      def prepend_before_invocation(*interceptors, &block)
+        conditions = extract_conditions!(interceptors)
+        interceptors << block if block_given?
+        add_interception_conditions(interceptors, conditions)
+        prepend_interceptors_to_chain("before", interceptors)
+      end
+
+      alias :before_invocation :append_before_invocation
+
+      def append_after_invocation(*interceptors, &block)
+        conditions = extract_conditions!(interceptors)
+        interceptors << block if block_given?
+        add_interception_conditions(interceptors, conditions)
+        append_interceptors_to_chain("after", interceptors)
+      end
+
+      def prepend_after_invocation(*interceptors, &block)
+        conditions = extract_conditions!(interceptors)
+        interceptors << block if block_given?
+        add_interception_conditions(interceptors, conditions)
+        prepend_interceptors_to_chain("after", interceptors)
+      end
+
+      alias :after_invocation :append_after_invocation
+
+      def before_invocation_interceptors
+        read_inheritable_attribute("before_invocation_interceptors")
+      end
+
+      def after_invocation_interceptors
+        read_inheritable_attribute("after_invocation_interceptors")
+      end
+
+      def included_intercepted_methods
+        read_inheritable_attribute("included_intercepted_methods") || {}
+      end
+      
+      def excluded_intercepted_methods
+        read_inheritable_attribute("excluded_intercepted_methods") || {}
+      end
+
+      private
+        
+        def append_interceptors_to_chain(condition, interceptors)
+          write_inheritable_array("#{condition}_invocation_interceptors", interceptors)
+        end
+
+        def prepend_interceptors_to_chain(condition, interceptors)
+          interceptors = interceptors + read_inheritable_attribute("#{condition}_invocation_interceptors")
+          write_inheritable_attribute("#{condition}_invocation_interceptors", interceptors)
+        end
+
+        def extract_conditions!(interceptors)
+          return nil unless interceptors.last.is_a? Hash
+          interceptors.pop
+        end
+
+        def add_interception_conditions(interceptors, conditions)
+          return unless conditions
+          included, excluded = conditions[:only], conditions[:except]
+          write_inheritable_hash("included_intercepted_methods", condition_hash(interceptors, included)) && return if included
+          write_inheritable_hash("excluded_intercepted_methods", condition_hash(interceptors, excluded)) if excluded
+        end
+
+        def condition_hash(interceptors, *methods)
+          interceptors.inject({}) {|hash, interceptor| hash.merge(interceptor => methods.flatten.map {|method| method.to_s})}
+        end
+    end
+
+    module InstanceMethods # :nodoc:
+      def self.append_features(base)
+        super
+        base.class_eval do
+          alias_method :perform_invocation_without_interception, :perform_invocation
+          alias_method :perform_invocation, :perform_invocation_with_interception
+        end
+      end
+
+      def perform_invocation_with_interception(name, args=nil, &block)
+        return if before_invocation(name, args, &block) == false
+        result = perform_invocation_without_interception(name, args)
+        after_invocation(name, args, result)
+        result
+      end
+
+      def perform_invocation(name, args=nil)
+        unless self.respond_to?(name) and self.class.has_export?(name)
+          raise InvocationError, "no such exported method '#{name}'"
+        end
+        args ||= []
+        self.send(name, *args)
+      end
+
+      def before_invocation(name, args, &block)
+        call_interceptors(self.class.before_invocation_interceptors, [name, args], &block)
+      end
+
+      def after_invocation(name, args, result)
+        call_interceptors(self.class.after_invocation_interceptors, [name, args, result])
+      end
+
+      private
+
+        def call_interceptors(interceptors, interceptor_args, &block)
+          if interceptors and not interceptors.empty?
+            interceptors.each do |interceptor|
+              next if method_exempted?(interceptor, interceptor_args[0].to_s)
+              result = case
+                when interceptor.is_a?(Symbol)
+                  self.send(interceptor, *interceptor_args)
+                when interceptor_block?(interceptor)
+                  interceptor.call(self, *interceptor_args)
+                when interceptor_class?(interceptor)
+                  interceptor.intercept(self, *interceptor_args)
+                else
+                  raise(
+                    InvocationError,
+                    "Interceptors need to be either a symbol, proc/method, or a class implementing a static intercept method"
+                  )
+              end
+              reason = nil
+              if result.is_a?(Array)
+                reason = result[1] if result[1]
+                result = result[0]
+              end
+              if result == false
+                block.call(reason) if block && reason
+                return false
+              end
+            end
+          end
+        end
+
+        def interceptor_block?(interceptor)
+          interceptor.respond_to?("call") && (interceptor.arity == 3 || interceptor.arity == -1)
+        end
+        
+        def interceptor_class?(interceptor)
+          interceptor.respond_to?("intercept")
+        end
+
+        def method_exempted?(interceptor, method_name)
+          case
+            when self.class.included_intercepted_methods[interceptor]
+              !self.class.included_intercepted_methods[interceptor].include?(method_name)
+            when self.class.excluded_intercepted_methods[interceptor] 
+              self.class.excluded_intercepted_methods[interceptor].include?(method_name)
+          end
+        end
+
+    end
+  end
+end

data/lib/action_service/protocol/abstract.rb

@@ -0,0 +1,61 @@
+module ActionService
+  module Protocol
+    class ProtocolError < ActionService::ActionServiceError
+    end
+
+    class AbstractProtocol
+      attr :container_klass
+
+      def initialize(container_klass)
+        @container_klass = container_klass
+      end
+
+      def unmarshal_request(request_info, export_info)
+        raise NotImplementedError
+      end
+
+      def marshal_response(request_info, export_info, return_value)
+        raise NotImplementedError
+      end
+
+      def marshal_exception(exception)
+        raise NotImplementedError
+      end
+
+      def request_info(request)
+        raise NotImplementedError
+      end
+
+      def request_supported?(request)
+        raise NotImplementedError
+      end
+    end
+
+    class ServiceRequestInfo
+      attr :service_name
+      attr :public_method_name
+      attr :raw_body
+      attr :content_type
+      attr :protocol_info
+
+      def initialize(service_name, public_method_name, raw_body, content_type, protocol_info)
+        @service_name = service_name
+        @public_method_name = public_method_name
+        @raw_body = raw_body
+        @content_type = content_type
+        @protocol_info = protocol_info
+      end
+    end
+
+    class ServiceResponseInfo
+      attr :raw_body
+      attr :content_type
+
+      def initialize(raw_body, content_type)
+        @raw_body = raw_body
+        @content_type = content_type
+      end
+    end
+
+  end
+end

data/lib/action_service/protocol/registry.rb

@@ -0,0 +1,49 @@
+module ActionService
+  module Protocol
+    HeaderAndBody = :header_and_body
+    BodyOnly      = :body_only
+
+    module Registry
+      def self.append_features(base)
+        super
+        base.extend(ClassMethods)
+        base.send(:include, ActionService::Protocol::Registry::InstanceMethods)
+      end
+
+      module ClassMethods
+        def register_protocol(type, klass)
+          case type
+          when HeaderAndBody
+            write_inheritable_array("header_and_body_protocols", [klass])
+          when BodyOnly
+            write_inheritable_array("body_only_protocols", [klass])
+          else
+            raise(ProtocolError, "unknown protocol type #{type}")
+          end
+        end
+      end
+
+      module InstanceMethods
+        private
+          def probe_request_protocol(action_pack_request)
+            (header_and_body_protocols + body_only_protocols).each do |klass|
+              protocol = klass.new(self.class)
+              if protocol.request_supported?(action_pack_request)
+                return protocol
+              end
+            end
+            raise(ProtocolError, "unsupported request message format")
+          end
+          
+          def header_and_body_protocols
+            self.class.read_inheritable_attribute("header_and_body_protocols") || []
+          end
+
+          def body_only_protocols
+            self.class.read_inheritable_attribute("body_only_protocols") || []
+          end
+      end
+
+    end
+  end
+end

data/lib/action_service/protocol/soap.rb

@@ -0,0 +1,386 @@
+require 'soap/processor'
+require 'soap/mapping'
+require 'soap/rpc/element'
+require 'xsd/datatypes'
+require 'xsd/ns'
+
+module ActionService
+  module Protocol
+    module Soap
+      class ProtocolError < ActionService::ActionServiceError
+      end
+
+      def self.append_features(base)
+        super
+        base.register_protocol(HeaderAndBody, SoapProtocol)
+        base.extend(ClassMethods)
+        base.wsdl_service_name('ActionService')
+      end
+
+      module ClassMethods
+        def wsdl_service_name(name)
+          write_inheritable_attribute("soap_mapper", SoapMapper.new("urn:#{name}"))
+        end
+
+        def soap_mapper
+          read_inheritable_attribute("soap_mapper")
+        end
+      end
+
+      class SoapProtocol < AbstractProtocol
+        def unmarshal_request(request_info, export_info)
+          expects = export_info[:expects]
+          map_types(expects) if expects
+          envelope = SOAP::Processor.unmarshal(request_info.raw_body)
+          request = envelope.body.request
+          params = request.collect{|k, v| request[k]}
+          params = soap_to_ruby_array(params)
+          validate_types(request_info.public_method_name, expects, params, :in) if expects
+          params
+        end
+
+        def marshal_response(request_info, export_info, return_value)
+          returns = export_info[:returns]
+          if returns
+            map_types(returns)
+            mapping = mapper.lookup(returns[0])
+            return_value = fixup_array_types(mapping, return_value)
+          end
+          validate_types(request_info.public_method_name, returns, [return_value], :out)
+          return_value = ruby_to_soap(return_value)
+          param_def = returns ? [['retval', 'return', mapping.registry_mapping]] : []
+          qname = XSD::QName.new(mapper.custom_namespace, request_info.public_method_name)
+          response = SOAP::RPC::SOAPMethodResponse.new(qname, param_def)
+          response.retval = return_value
+          ServiceResponseInfo.new(create_response(response), 'text/xml')
+        end
+
+        def marshal_exception(exception)
+          ServiceResponseInfo.new(create_exception_response(exception), 'text/xml')
+        end
+
+        def request_info(request)
+          soap_action = extract_soap_action(request)
+          service_name = request.parameters['action']
+          public_method_name = soap_action.gsub(/^[\/]+/, '').split(/[\/]+/)[-1]
+          ServiceRequestInfo.new(service_name,
+            public_method_name,
+            request.raw_post,
+            request.env['HTTP_CONTENT_TYPE'] || 'text/xml',
+            :soap => { :action => soap_action })
+        end
+
+        def request_supported?(request)
+          extract_soap_action(request) ? true : false
+        end
+
+        private
+          def mapper
+            container_klass.soap_mapper
+          end
+
+          def fixup_array_types(mapping, obj)
+            mapping.each_attribute do |name, type, attr_mapping|
+              if attr_mapping.custom_type?
+                attr_obj = obj.send(name)
+                new_obj = fixup_array_types(attr_mapping, attr_obj)
+                obj.send("#{name}=", new_obj) unless new_obj.equal?(attr_obj)
+              end
+            end
+            if mapping.is_a?(SoapArrayMapping)
+              obj = mapping.ruby_klass.new(obj)
+            else
+              obj
+            end
+          end
+
+          def extract_soap_action(request)
+            return nil unless request.method == :post
+            content_type = request.env['HTTP_CONTENT_TYPE'] || 'text/xml'
+            return nil unless content_type
+            soap_action = request.env['HTTP_SOAPACTION']
+            return nil unless soap_action
+            soap_action.gsub!(/^"/, '')
+            soap_action.gsub!(/"$/, '')
+            soap_action.strip!
+            return nil if soap_action.empty?
+            soap_action
+          end
+
+          def map_types(types)
+            types.collect{|type| mapper.map(type)}
+          end
+
+          def validate_types(method_name, signature, params, kind)
+            unless signature.length == params.length
+              raise(ProtocolError, "signature/parameter mismatch")
+            end
+            case kind
+            when :in
+              extra_msg = ' (Input parameter %d of method "%s")'
+            when :out
+              extra_msg = ' (Return value %d of method "%s")'
+            end
+            i = 0
+            signature.each do |klass|
+              check_compatibility(params[i].class, klass, extra_msg % [i, method_name])
+              i += 1
+            end
+          end
+
+          def check_compatibility(klass1, klass2, extra_msg=nil)
+            if (klass1 == TrueClass or klass1 == FalseClass) and \
+               (klass2 == TrueClass or klass2 == FalseClass)
+              return true
+            end
+            unless klass1.ancestors.include?(klass2) || \
+                   klass2.ancestors.include?(klass1)
+              raise(ProtocolError, "value of type #{klass1.name} is not compatible " +
+                                   "with expected type #{klass2.name}" +
+                                   (extra_msg ? extra_msg : ''))
+            end
+          end
+
+          def create_response(body, is_error=false)
+            header = SOAP::SOAPHeader.new
+            body = SOAP::SOAPBody.new(body)
+            envelope = SOAP::SOAPEnvelope.new(header, body)
+            message = SOAP::Processor.marshal(envelope)
+          end
+  
+          def create_exception_response(exc)
+            detail = SOAP::Mapping::SOAPException.new(exc)
+            body = SOAP::SOAPFault.new(
+              SOAP::SOAPString.new('Server'),
+              SOAP::SOAPString.new(exc.to_s),
+              SOAP::SOAPString.new(self.class.name),
+              SOAP::Mapping.obj2soap(detail))
+            create_response(body, true)
+          end
+
+          def ruby_to_soap(obj)
+            SOAP::Mapping.obj2soap(obj, mapper.registry)
+          end
+
+          def soap_to_ruby(obj)
+            SOAP::Mapping.soap2obj(obj, mapper.registry)
+          end
+
+          def soap_to_ruby_array(array)
+            array.map{|x| soap_to_ruby(x)}
+          end
+      end
+
+      class SoapMapper
+        attr :registry
+        attr :custom_namespace
+        attr :custom_types
+
+        def initialize(custom_namespace)
+          @custom_namespace = custom_namespace
+          @registry = SOAP::Mapping::Registry.new
+          @klass2map = {}
+          @custom_types = {}
+        end
+
+        def lookup(klass)
+          return @klass2map[klass] if @klass2map.has_key?(klass)
+  
+          custom_type = false
+  
+          ruby_klass = select_class(klass.is_a?(Array) ? klass[0] : klass)
+          type_name = Inflector.camelize(ruby_klass.name.split(/::/)[-1])
+  
+          # Array signatures generate a double-mapping and require generation
+          # of an Array subclass to represent the mapping in the SOAP
+          # registry
+          array_klass = nil
+          if klass.is_a?(Array)
+            array_klass = Class.new(Array) do
+              module_eval <<-END
+              def self.name
+                "#{type_name}Array"
+              end
+              END
+            end
+          end
+  
+          mapping = @registry.find_mapped_soap_class(ruby_klass) rescue nil
+          unless mapping
+            # Custom structured type, generate a mapping
+            info = { :type => XSD::QName.new(@custom_namespace, type_name) }
+            @registry.add(ruby_klass,
+                          SOAP::SOAPStruct, 
+                          SOAP::Mapping::Registry::TypedStructFactory,
+                          info)
+            mapping = ensure_mapped(ruby_klass)
+            custom_type = true
+          end
+  
+          array_mapping = nil
+          if array_klass
+            # Typed array always requires a custom type. The info of the array
+            # is the info of its element type (in mapping[2]), falling back
+            # to SOAP base types.
+            info = mapping[2]
+            info ||= {}
+            info[:type] ||= soap_base_type_qname(mapping[0])
+            @registry.add(array_klass,
+                          SOAP::SOAPArray,
+                          SOAP::Mapping::Registry::TypedArrayFactory,
+                          info)
+            array_mapping = ensure_mapped(array_klass)
+          end
+  
+          if array_mapping
+            @klass2map[ruby_klass] = SoapMapping.new(self,
+                                                     type_name,
+                                                     ruby_klass,
+                                                     mapping[0],
+                                                     mapping,
+                                                     custom_type)
+            @klass2map[klass] = SoapArrayMapping.new(self,
+                                                     type_name,
+                                                     array_klass,
+                                                     array_mapping[0],
+                                                     array_mapping,
+                                                     @klass2map[ruby_klass])
+            @custom_types[klass] = @klass2map[klass]
+            @custom_types[ruby_klass] = @klass2map[ruby_klass] if custom_type
+          else
+            @klass2map[klass] = SoapMapping.new(self,
+                                                type_name,
+                                                ruby_klass,
+                                                mapping[0],
+                                                mapping,
+                                                custom_type)
+            @custom_types[klass] = @klass2map[klass] if custom_type
+          end
+  
+          @klass2map[klass]
+        end
+        alias :map :lookup
+        
+        def map_container_services(container_klass, &block)
+          container_klass.services.each do |service_name, service_info|
+            object = container_klass.service_object(service_name)
+            service_klass = object.class
+            service_exports = {}
+            object.class.exports.each do |export_name, export_info|
+              expects = export_info[:expects]
+              lookup_proc = lambda do |klass|
+                mapping = lookup(klass)
+                custom_mapping = nil
+                if mapping.respond_to?(:element_mapping)
+                  custom_mapping = mapping.element_mapping
+                else
+                  custom_mapping = mapping
+                end
+                if custom_mapping && custom_mapping.custom_type?
+                  # What gives? This is required so that structure types
+                  # referenced only by structures (and not signatures) still
+                  # have a custom type mapping in the registry (needed for WSDL
+                  # generation).
+                  custom_mapping.each_attribute{}
+                end
+                mapping 
+              end
+              expects_signature = expects ? expects.map{|klass| lookup_proc.call(klass)} : nil
+              returns_signature = export_info[:returns].map{|klass| lookup_proc.call(klass)}
+              service_exports[export_name] = {
+                :expects => expects_signature,
+                :returns => returns_signature
+              }
+            end
+            yield service_name, service_klass, service_exports if block_given?
+          end
+        end
+
+        private
+          def select_class(klass)
+            return Integer if klass == Fixnum
+            klass
+          end
+
+          def ensure_mapped(klass)
+            mapping = @registry.find_mapped_soap_class(klass) rescue nil
+            raise(ProtocolError, "failed to register #{klass.name}") unless mapping
+            mapping
+          end
+
+          def soap_base_type_qname(base_type)
+            xsd_type = base_type.ancestors.find{|c| c.const_defined? 'Type'}
+            xsd_type ? xsd_type.const_get('Type') : XSD::XSDAnySimpleType::Type
+          end
+      end
+
+      class SoapMapping
+        attr :ruby_klass
+        attr :soap_klass
+        attr :registry_mapping
+  
+        def initialize(mapper, type_name, ruby_klass, soap_klass, registry_mapping,
+                       custom_type=false)
+          @mapper = mapper
+          @type_name = type_name
+          @ruby_klass = ruby_klass
+          @soap_klass = soap_klass
+          @registry_mapping = registry_mapping
+          @custom_type = custom_type
+        end
+  
+        def type_name
+          @type_name
+        end
+  
+        def custom_type?
+          @custom_type
+        end
+  
+        def qualified_type_name
+          name = type_name
+          if custom_type?
+            "typens:#{name}"
+          else
+            xsd_type_for(@soap_klass)
+          end
+        end
+  
+        def each_attribute(&block)
+          if @ruby_klass.respond_to?(:members)
+            @ruby_klass.members.each do |name, klass|
+              name = name.to_s
+              mapping = @mapper.lookup(klass)
+              yield name, mapping.qualified_type_name, mapping
+            end
+          end
+        end
+
+        def is_xsd_type?(klass)
+          klass.ancestors.include?(XSD::NSDBase)
+        end
+  
+        def xsd_type_for(klass)
+          ns = XSD::NS.new
+          ns.assign(XSD::Namespace, SOAP::XSDNamespaceTag)
+          xsd_klass = klass.ancestors.find{|c| c.const_defined?('Type')}
+          return ns.name(XSD::AnyTypeName) unless xsd_klass
+          ns.name(xsd_klass.const_get('Type'))
+        end
+      end
+  
+      class SoapArrayMapping < SoapMapping
+        attr :element_mapping
+  
+        def initialize(mapper, type_name, ruby_klass, soap_klass, registry_mapping, element_mapping)
+          super(mapper, type_name, ruby_klass, soap_klass, registry_mapping, true)
+          @element_mapping = element_mapping
+        end
+  
+        def type_name
+          super + "Array"
+        end
+      end
+    end
+  end
+end