rcap 2.4.1 → 2.7.3

data/lib/rcap/base/parameter.rb

@@ -1,46 +1,48 @@
+# frozen_string_literal: true
+
 module RCAP
   module Base
     class Parameter
       include Validation
 
-      validates_presence_of( :name, :value )
+      validates_presence_of(:name)
 
       # @return [String]
-      attr_accessor( :name )
+      attr_accessor(:name)
       # @return [String]
-      attr_accessor( :value )
+      attr_accessor(:value)
 
-      XML_ELEMENT_NAME   = "parameter"
-      NAME_ELEMENT_NAME  = "valueName"
-      VALUE_ELEMENT_NAME = "value"
+      XML_ELEMENT_NAME   = 'parameter'
+      NAME_ELEMENT_NAME  = 'valueName'
+      VALUE_ELEMENT_NAME = 'value'
 
-      XPATH       = "cap:#{ XML_ELEMENT_NAME }"
-      NAME_XPATH  = "cap:#{ NAME_ELEMENT_NAME }"
-      VALUE_XPATH = "cap:#{ VALUE_ELEMENT_NAME }"
+      XPATH       = "cap:#{XML_ELEMENT_NAME}"
+      NAME_XPATH  = "cap:#{NAME_ELEMENT_NAME}"
+      VALUE_XPATH = "cap:#{VALUE_ELEMENT_NAME}"
 
       # @param [Hash] attributes
       # @option attributes [Symbol] :name Parameter name
       # @option attributes [Symbol] :value Parameter value
       def initialize
-        yield( self ) if block_given?
+        yield(self) if block_given?
       end
 
       # @return [REXML::Element]
       def to_xml_element
-        xml_element = REXML::Element.new( self.class::XML_ELEMENT_NAME )
-        xml_element.add_element( self.class::NAME_ELEMENT_NAME ).add_text( @name )
-        xml_element.add_element( self.class::VALUE_ELEMENT_NAME ).add_text( @value )
+        xml_element = REXML::Element.new(self.class::XML_ELEMENT_NAME)
+        xml_element.add_element(self.class::NAME_ELEMENT_NAME).add_text(@name)
+        xml_element.add_element(self.class::VALUE_ELEMENT_NAME).add_text(@value)
         xml_element
       end
 
       # @return [String]
       def to_xml
-        self.to_xml_element.to_s
+        to_xml_element.to_s
       end
 
       # @return [String]
       def inspect
-        "#{ @name }: #{ @value }"
+        "#{@name}: #{@value}"
       end
 
       # Returns a string representation of the parameter of the form
@@ -48,41 +50,40 @@ module RCAP
       #
       # @return [String]
       def to_s
-        self.inspect
+        inspect
       end
 
       # Two parameters are equivalent if they have the same name and value.
       #
       # @param [Parameter] other
       # @return [true, false]
-      def ==( other )
-        [ @name, @value ] == [ other.name, other.value ]
+      def ==(other)
+        [@name, @value] == [other.name, other.value]
       end
 
       # @param [REXML::Element] parameter_xml_element
       # @return [Parameter]
-      def self.from_xml_element( parameter_xml_element )
-        self.new do |parameter|
-           parameter.name  = RCAP.xpath_text( parameter_xml_element, self::NAME_XPATH, parameter.xmlns )
-           parameter.value = RCAP.xpath_text( parameter_xml_element, self::VALUE_XPATH, parameter.xmlns )
+      def self.from_xml_element(parameter_xml_element)
+        new do |parameter|
+          parameter.name  = RCAP.xpath_text(parameter_xml_element, self::NAME_XPATH, parameter.xmlns)
+          parameter.value = RCAP.xpath_text(parameter_xml_element, self::VALUE_XPATH, parameter.xmlns)
         end
       end
 
       # @return [Hash]
       def to_h
-        RCAP.attribute_values_to_hash( [ @name, @value ])
+        RCAP.attribute_values_to_hash([@name, @value])
       end
 
       # @param [Hash] hash
       # @return [Parameter]
-      def self.from_h( hash )
+      def self.from_h(hash)
         key = hash.keys.first
-        self.new do |parameter|
-          parameter.name  = RCAP.strip_if_given( key )
-          parameter.value = RCAP.strip_if_given( hash[ key ])
+        new do |parameter|
+          parameter.name  = RCAP.strip_if_given(key)
+          parameter.value = RCAP.strip_if_given(hash[key])
         end
       end
     end
   end
 end
-

data/lib/rcap/base/point.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RCAP
   module Base
     class Point
@@ -6,22 +8,22 @@ module RCAP
       MAX_LONGITUDE = 180
       MIN_LONGITUDE = -180
       MAX_LATTITUDE = 90
-      MIN_LATTITUDE= -90
+      MIN_LATTITUDE = -90
 
       # @return [Numeric]
-      attr_accessor( :lattitude )
+      attr_accessor(:lattitude)
       # @return [Numeric]
-      attr_accessor( :longitude )
+      attr_accessor(:longitude)
 
-      validates_numericality_of( :lattitude, :longitude )
-      validates_inclusion_of( :lattitude, :in => MIN_LATTITUDE..MAX_LATTITUDE )
-      validates_inclusion_of( :longitude, :in => MIN_LONGITUDE..MAX_LONGITUDE)
+      validates_numericality_of(:lattitude, :longitude)
+      validates_inclusion_of(:lattitude, in: MIN_LATTITUDE..MAX_LATTITUDE)
+      validates_inclusion_of(:longitude, in: MIN_LONGITUDE..MAX_LONGITUDE)
 
       # @param [Hash] attributes
       # @option attributes [Numeric] :lattitude
       # @option attributes [Numeric] :longitude
       def initialize
-        yield( self ) if block_given?
+        yield(self) if block_given?
       end
 
       # Returns a string representation of the point of the form
@@ -29,20 +31,20 @@ module RCAP
       #
       # @return [String]
       def to_s
-        "#{ self.lattitude },#{ self.longitude }"
+        "#{lattitude},#{longitude}"
       end
 
       # @return [String]
       def inspect
-        '('+self.to_s+')'
+        '(' + to_s + ')'
       end
 
       # Two points are equivalent if they have the same lattitude and longitude
       #
       # @param [Point] other
       # @return [true, false]
-      def ==( other )
-        [ self.lattitude, self.longitude ] == [ other.lattitude, other.longitude ]
+      def ==(other)
+        [lattitude, longitude] == [other.lattitude, other.longitude]
       end
 
       LATTITUDE_KEY = 'lattitude'
@@ -50,16 +52,16 @@ module RCAP
 
       # @return [Hash]
       def to_h
-        RCAP.attribute_values_to_hash( [ LATTITUDE_KEY, self.lattitude ],
-                                       [ LONGITUDE_KEY, self.longitude ])
+        RCAP.attribute_values_to_hash([LATTITUDE_KEY, lattitude],
+                                      [LONGITUDE_KEY, longitude])
       end
 
       # @param [Hash] point_hash
       # @return [Point]
-      def self.from_h( point_hash )
-        self.new do |point|
-          point.lattitude = point_hash[ LATTITUDE_KEY ].to_f
-          point.longitude = point_hash[ LONGITUDE_KEY ].to_f
+      def self.from_h(point_hash)
+        new do |point|
+          point.lattitude = point_hash[LATTITUDE_KEY].to_f
+          point.longitude = point_hash[LONGITUDE_KEY].to_f
         end
       end
 
@@ -68,18 +70,18 @@ module RCAP
 
       # @return [Array(Numeric, Numeric)]
       def to_a
-        Array.new.tap do |array|
-          array[ LATTITUDE_INDEX ] = self.lattitude
-          array[ LONGITUDE_INDEX ] = self.longitude
+        [].tap do |array|
+          array[LATTITUDE_INDEX] = lattitude
+          array[LONGITUDE_INDEX] = longitude
         end
       end
 
       # @param [Array(Numeric, Numeric)] point_array
       # @return [Point]
-      def self.from_a( point_array )
-        self.new do |point|
-          point.lattitude = point_array[ LATTITUDE_INDEX ].to_f
-          point.longitude = point_array[ LONGITUDE_INDEX ].to_f
+      def self.from_a(point_array)
+        new do |point|
+          point.lattitude = point_array[LATTITUDE_INDEX].to_f
+          point.longitude = point_array[LONGITUDE_INDEX].to_f
         end
       end
     end

data/lib/rcap/base/polygon.rb

@@ -1,56 +1,64 @@
+# frozen_string_literal: true
+
 module RCAP
   module Base
     class Polygon
       include Validation
 
       # @return [Array<Point>] Collection of {Point} objects
-      attr_reader( :points )
+      attr_reader(:points)
 
-      validates_collection_of( :points )
-      validates_length_of( :points, :minimum => 3 )
-      validates_equality_of_first_and_last( :points )
+      validates_collection_of(:points)
+      validates_length_of(:points, minimum: 3, allow_blank: true)
+      validates_equality_of_first_and_last(:points, allow_empty: true)
 
       XML_ELEMENT_NAME = 'polygon'
-      XPATH            = "cap:#{ XML_ELEMENT_NAME }"
+      XPATH            = "cap:#{XML_ELEMENT_NAME}"
 
       # @param [Hash] attributes
       # @option attributes [Array<Point>] :points Collection of {Point} objects
       def initialize
-        @points =  []
-        yield( self ) if block_given?
+        @points = []
+        yield(self) if block_given?
       end
 
       def add_point
-        point = self.point_class.new
-        yield( point ) if block_given?
-        self.points << point
+        point = point_class.new
+        yield(point) if block_given?
+        points << point
         point
       end
 
+      # Returns GeoJSON representation of the polygon
+      def to_geojson
+        coordinates = @points.map { |point| [point.longitude, point.lattitude] }
+        { 'type' => 'Polygon', 'coordinates' => [coordinates] }.to_json
+      end
+
       # Returns a string representation of the polygon of the form
       #  points[0] points[1] points[2] ...
       # where each point is formatted with Point#to_s
       def to_s
-        @points.join( ' ' )
+        @points.join(' ')
       end
 
       # @return [String]
       def inspect
-        "(#{ @points.map{|point| point.inspect}.join(', ')})"
+        "(#{@points.map(&:inspect).join(', ')})"
       end
 
       # @return [REXML::Element]
       def to_xml_element
-        xml_element = REXML::Element.new( XML_ELEMENT_NAME )
-        xml_element.add_text( self.to_s )
+        xml_element = REXML::Element.new(XML_ELEMENT_NAME)
+        xml_element.add_text(to_s)
         xml_element
       end
 
       # @return [Polygon]
-      def self.from_xml_element( polygon_xml_element )
+      def self.from_xml_element(polygon_xml_element)
         if !polygon_xml_element.text.nil? && !polygon_xml_element.text.empty?
-          coordinates = self.parse_polygon_string( polygon_xml_element.text )
-          self.new do |polygon|
+          coordinates = parse_polygon_string(polygon_xml_element.text)
+          new do |polygon|
             coordinates.each do |lattitude, longitude|
               polygon.add_point do |point|
                 point.lattitude = lattitude.to_f
@@ -59,31 +67,31 @@ module RCAP
             end
           end
         else
-          self.new
+          new
         end
       end
 
       # @return [String]
       def to_xml
-        self.to_xml_element.to_s
+        to_xml_element.to_s
       end
 
       # Two polygons are equivalent if their collection of points is equivalent.
       #
       # @return [true,false]
-      def ==( other )
+      def ==(other)
         @points == other.points
       end
 
       # @return [Array<Array(Numeric,Numeric)>]
-      def self.parse_polygon_string( polygon_string )
-        polygon_string.split( ' ' ).map{ |coordinate_string| coordinate_string.split( ',' ).map{|coordinate| coordinate.to_f }}
+      def self.parse_polygon_string(polygon_string)
+        polygon_string.split(' ').map { |coordinate_string| coordinate_string.split(',').map(&:to_f) }
       end
 
       # @return [Polygon]
-      def self.from_yaml_data( polygon_yaml_data )
-        self.new do |polygon|
-          Array( polygon_yaml_data ).each do |lattitude, longitude|
+      def self.from_yaml_data(polygon_yaml_data)
+        new do |polygon|
+          Array(polygon_yaml_data).each do |lattitude, longitude|
             polygon.add_point do |point|
               point.lattitude = lattitude.to_f
               point.longitude = longitude.to_f
@@ -94,23 +102,23 @@ module RCAP
 
       # @return [Hash]
       def to_yaml_data
-        @points.map{ |point| [ point.lattitude, point.longitude ]}
+        @points.map { |point| [point.lattitude, point.longitude] }
       end
 
       # @return [String]
-      def to_yaml( options = {} )
-        self.to_yaml_data.to_yaml( options )
+      def to_yaml(options = {})
+        to_yaml_data.to_yaml(options)
       end
 
-      POINTS_KEY  = 'points'
+      POINTS_KEY = 'points'
 
       # @return [Polygon]
-      def self.from_h( polygon_hash )
-        self.new do |polygon|
-          Array( polygon_hash[ POINTS_KEY ]).each do |point_array|
+      def self.from_h(polygon_hash)
+        new do |polygon|
+          Array(polygon_hash[POINTS_KEY]).each do |point_array|
             polygon.add_point do |point|
-              point.lattitude = point_array[ Point::LATTITUDE_INDEX ].to_f
-              point.longitude = point_array[ Point::LONGITUDE_INDEX ].to_f
+              point.lattitude = point_array[Point::LATTITUDE_INDEX].to_f
+              point.longitude = point_array[Point::LONGITUDE_INDEX].to_f
             end
           end
         end
@@ -118,7 +126,7 @@ module RCAP
 
       # @return [Hash]
       def to_h
-        { POINTS_KEY => @points.map{ |point| point.to_a }}
+        { POINTS_KEY => @points.map(&:to_a) }
       end
     end
   end

data/lib/rcap/base/resource.rb

@@ -1,20 +1,22 @@
+# frozen_string_literal: true
+
 module RCAP
   module Base
     class Resource
       include Validation
 
       # @return [String] Resource Description
-      attr_accessor( :resource_desc )
+      attr_accessor(:resource_desc)
       # @return [String]
-      attr_accessor( :mime_type )
+      attr_accessor(:mime_type)
       # @return [Integer] Expressed in bytes
-      attr_accessor( :size )
+      attr_accessor(:size)
       # @return [String] Resource location
-      attr_accessor( :uri )
+      attr_accessor(:uri)
       # @return [String] SHA-1 hash of contents of resource
-      attr_accessor( :digest )
+      attr_accessor(:digest)
 
-      validates_presence_of( :resource_desc )
+      validates_presence_of(:resource_desc)
 
       XML_ELEMENT_NAME           = 'resource'
       MIME_TYPE_ELEMENT_NAME     = 'mimeType'
@@ -23,12 +25,12 @@ module RCAP
       DIGEST_ELEMENT_NAME        = 'digest'
       RESOURCE_DESC_ELEMENT_NAME = 'resourceDesc'
 
-      XPATH               = "cap:#{ XML_ELEMENT_NAME }"
-      MIME_TYPE_XPATH     = "cap:#{ MIME_TYPE_ELEMENT_NAME }"
-      SIZE_XPATH          = "cap:#{ SIZE_ELEMENT_NAME }"
-      URI_XPATH           = "cap:#{ URI_ELEMENT_NAME }"
-      DIGEST_XPATH        = "cap:#{ DIGEST_ELEMENT_NAME }"
-      RESOURCE_DESC_XPATH = "cap:#{ RESOURCE_DESC_ELEMENT_NAME }"
+      XPATH               = "cap:#{XML_ELEMENT_NAME}"
+      MIME_TYPE_XPATH     = "cap:#{MIME_TYPE_ELEMENT_NAME}"
+      SIZE_XPATH          = "cap:#{SIZE_ELEMENT_NAME}"
+      URI_XPATH           = "cap:#{URI_ELEMENT_NAME}"
+      DIGEST_XPATH        = "cap:#{DIGEST_ELEMENT_NAME}"
+      RESOURCE_DESC_XPATH = "cap:#{RESOURCE_DESC_ELEMENT_NAME}"
 
       # @param [Hash{Symbol => Object}] attributes
       # @option attributes [String] :mime_type
@@ -37,29 +39,29 @@ module RCAP
       # @option attributes [String] :digest
       # @option attributes [String] :resource_desc
       def initialize
-        yield( self ) if block_given?
+        yield(self) if block_given?
       end
 
       # @return [REXML::Element]
       def to_xml_element
-        xml_element = REXML::Element.new( XML_ELEMENT_NAME )
-        xml_element.add_element( RESOURCE_DESC_ELEMENT_NAME ).add_text( @resource_desc )
-        xml_element.add_element( MIME_TYPE_ELEMENT_NAME ).add_text( @mime_type ) if @mime_type
-        xml_element.add_element( SIZE_ELEMENT_NAME ).add_text( @size.to_s )      if @size
-        xml_element.add_element( URI_ELEMENT_NAME ).add_text( @uri )             if @uri
-        xml_element.add_element( DIGEST_ELEMENT_NAME ).add_text( @digest )       if @digest
+        xml_element = REXML::Element.new(XML_ELEMENT_NAME)
+        xml_element.add_element(RESOURCE_DESC_ELEMENT_NAME).add_text(@resource_desc)
+        xml_element.add_element(MIME_TYPE_ELEMENT_NAME).add_text(@mime_type) if @mime_type
+        xml_element.add_element(SIZE_ELEMENT_NAME).add_text(@size.to_s)      if @size
+        xml_element.add_element(URI_ELEMENT_NAME).add_text(@uri)             if @uri
+        xml_element.add_element(DIGEST_ELEMENT_NAME).add_text(@digest)       if @digest
         xml_element
       end
 
       # @param [REXML::Element] resource_xml_element
       # @return [Resource]
-      def self.from_xml_element( resource_xml_element )
-        resource = self.new do |resource|
-          resource.resource_desc = RCAP.xpath_text( resource_xml_element, RESOURCE_DESC_XPATH, resource.xmlns )
-          resource.uri           = RCAP.xpath_text( resource_xml_element, URI_XPATH, resource.xmlns )
-          resource.mime_type     = RCAP.xpath_text( resource_xml_element, MIME_TYPE_XPATH, resource.xmlns )
-          resource.size          = RCAP.xpath_text( resource_xml_element, SIZE_XPATH, resource.xmlns ).to_i
-          resource.digest        = RCAP.xpath_text( resource_xml_element, DIGEST_XPATH, resource.xmlns )
+      def self.from_xml_element(resource_xml_element)
+        resource = new do |resource|
+          resource.resource_desc = RCAP.xpath_text(resource_xml_element, RESOURCE_DESC_XPATH, resource.xmlns)
+          resource.uri           = RCAP.xpath_text(resource_xml_element, URI_XPATH, resource.xmlns)
+          resource.mime_type     = RCAP.xpath_text(resource_xml_element, MIME_TYPE_XPATH, resource.xmlns)
+          resource.size          = RCAP.xpath_text(resource_xml_element, SIZE_XPATH, resource.xmlns).to_i
+          resource.digest        = RCAP.xpath_text(resource_xml_element, DIGEST_XPATH, resource.xmlns)
         end
       end
 
@@ -70,9 +72,9 @@ module RCAP
       # @return [nil,Array(Integer,String)]
       def calculate_hash_and_size
         if @deref_uri
-          @digest = Digest::SHA1.hexdigest( @deref_uri )
+          @digest = Digest::SHA1.hexdigest(@deref_uri)
           @size = @deref_uri.bytesize
-          [ @size, @digest ]
+          [@size, @digest]
         end
       end
 
@@ -80,25 +82,23 @@ module RCAP
       #
       # @return [nil,String]
       def decoded_deref_uri
-        Base64.decode64( @deref_uri ) if @deref_uri
+        Base64.decode64(@deref_uri) if @deref_uri
       end
 
       # If size is defined returns the size in kilobytes
       # @return [Float]
       def size_in_kb
-        if @size
-          @size.to_f/1024
-        end
+        @size.to_f / 1024 if @size
       end
 
       # @return [String]
       def to_xml
-        self.to_xml_element.to_s
+        to_xml_element.to_s
       end
 
       # @return [String]
       def inspect
-        [ @resource_desc, @uri, @mime_type, @size ? format( "%.1fKB", self.size_in_kb ) : nil ].compact.join(' - ')
+        [@resource_desc, @uri, @mime_type, @size ? format('%.1fKB', size_in_kb) : nil].compact.join(' - ')
       end
 
       # Returns a string representation of the resource of the form
@@ -109,35 +109,35 @@ module RCAP
         @resource_desc
       end
 
-      RESOURCE_DESC_YAML = "Resource Description"
-      URI_YAML           = "URI"
-      MIME_TYPE_YAML     = "Mime Type"
-      SIZE_YAML          = "Size"
-      DIGEST_YAML        = "Digest"
+      RESOURCE_DESC_YAML = 'Resource Description'
+      URI_YAML           = 'URI'
+      MIME_TYPE_YAML     = 'Mime Type'
+      SIZE_YAML          = 'Size'
+      DIGEST_YAML        = 'Digest'
 
       def to_yaml_data
-        RCAP.attribute_values_to_hash( [ RESOURCE_DESC_YAML, @resource_desc ],
-                                       [ URI_YAML,           @uri ],
-                                       [ MIME_TYPE_YAML,     @mime_type ],
-                                       [ SIZE_YAML,          @size ],
-                                       [ DIGEST_YAML,        @digest ])
+        RCAP.attribute_values_to_hash([RESOURCE_DESC_YAML, @resource_desc],
+                                      [URI_YAML,           @uri],
+                                      [MIME_TYPE_YAML,     @mime_type],
+                                      [SIZE_YAML,          @size],
+                                      [DIGEST_YAML,        @digest])
       end
 
       # @param [Hash] options
       # @return [String]
-      def to_yaml( options = {} )
-        self.to_yaml_data.to_yaml( options )
+      def to_yaml(options = {})
+        to_yaml_data.to_yaml(options)
       end
 
       # @param [Hash] resource_yaml_data
       # @return [Resource]
-      def self.from_yaml_data( resource_yaml_data )
-        self.new do |resource|
-          resource.resource_desc = resource_yaml_data[ RESOURCE_DESC_YAML ]
-          resource.uri           = resource_yaml_data[ URI_YAML ]
-          resource.mime_type     = resource_yaml_data[ MIME_TYPE_YAML ]
-          resource.size          = resource_yaml_data[ SIZE_YAML ]
-          resource.digest        = resource_yaml_data[ DIGEST_YAML ]
+      def self.from_yaml_data(resource_yaml_data)
+        new do |resource|
+          resource.resource_desc = resource_yaml_data[RESOURCE_DESC_YAML]
+          resource.uri           = resource_yaml_data[URI_YAML]
+          resource.mime_type     = resource_yaml_data[MIME_TYPE_YAML]
+          resource.size          = resource_yaml_data[SIZE_YAML]
+          resource.digest        = resource_yaml_data[DIGEST_YAML]
         end
       end
 
@@ -149,22 +149,22 @@ module RCAP
 
       # @return [Hash]
       def to_h
-        RCAP.attribute_values_to_hash( [ RESOURCE_DESC_KEY, @resource_desc ],
-                                       [ URI_KEY,           @uri],
-                                       [ MIME_TYPE_KEY,     @mime_type],
-                                       [ SIZE_KEY,          @size ],
-                                       [ DIGEST_KEY,        @digest ])
+        RCAP.attribute_values_to_hash([RESOURCE_DESC_KEY, @resource_desc],
+                                      [URI_KEY,           @uri],
+                                      [MIME_TYPE_KEY,     @mime_type],
+                                      [SIZE_KEY,          @size],
+                                      [DIGEST_KEY,        @digest])
       end
 
       # @param [Hash] resource_hash
       # @return [Resource]
-      def self.from_h( resource_hash )
-        self.new do |resource|
-          resource.resource_desc = RCAP.strip_if_given( resource_hash[ RESOURCE_DESC_KEY ])
-          resource.uri           = RCAP.strip_if_given( resource_hash[ URI_KEY ])
-          resource.mime_type     = RCAP.strip_if_given( resource_hash[ MIME_TYPE_KEY ])
-          resource.size          = RCAP.to_i_if_given( resource_hash[ SIZE_KEY ])
-          resource.digest        = RCAP.strip_if_given( resource_hash[ DIGEST_KEY ])
+      def self.from_h(resource_hash)
+        new do |resource|
+          resource.resource_desc = RCAP.strip_if_given(resource_hash[RESOURCE_DESC_KEY])
+          resource.uri           = RCAP.strip_if_given(resource_hash[URI_KEY])
+          resource.mime_type     = RCAP.strip_if_given(resource_hash[MIME_TYPE_KEY])
+          resource.size          = RCAP.to_i_if_given(resource_hash[SIZE_KEY])
+          resource.digest        = RCAP.strip_if_given(resource_hash[DIGEST_KEY])
         end
       end
     end