rcap 1.3.1 → 2.0.0

data/lib/rcap/cap_1_2/parameter.rb

@@ -1,86 +1,14 @@
 module RCAP
   module CAP_1_2
+
     # A Parameter object is valid if
     # * it has a name
     # * it has a value
-    class Parameter
-      include Validation
-
-      validates_presence_of( :name, :value )
+    class Parameter < RCAP::Base::Parameter
 
       # @return [String]
-      attr_accessor( :name )
-      # @return [String]
-      attr_accessor( :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 }"   
-
-      # @param [Hash] attributes
-      # @option attributes [Symbol] :name Parameter name
-      # @option attributes [Symbol] :value Parameter value
-      def initialize( attributes = {} )
-        @name = attributes[ :name ]
-        @value = attributes[ :value ]
-      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
-      end
-
-      # @return [String]
-      def to_xml 
-        self.to_xml_element.to_s
-      end
-
-      # @return [String]
-      def inspect 
-        "#{ @name }: #{ @value }"
-      end
-
-      # Returns a string representation of the parameter of the form
-      #  name: value
-      #
-      # @return [String]
-      def to_s
-        self.inspect
-      end
-
-      # @param [REXML::Element] parameter_xml_element
-      # @return [Parameter] 
-      def self.from_xml_element( parameter_xml_element ) # :nodoc:
-        self.new( :name  => RCAP.xpath_text( parameter_xml_element, self::NAME_XPATH, Alert::XMLNS ),
-                  :value => RCAP.xpath_text( parameter_xml_element, self::VALUE_XPATH, Alert::XMLNS ))
-      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 ]
-      end
-
-      # @return [Hash]
-      def to_h 
-        RCAP.attribute_values_to_hash(
-          [ @name, @value ])
-      end
-
-      # @param [Hash] hash
-      # @return [Parameter]
-      def self.from_h( hash ) 
-        key = hash.keys.first
-        self.new( :name => key, :value => hash[ key ])
+      def xmlns
+        Alert::XMLNS
       end
     end
   end

data/lib/rcap/cap_1_2/point.rb

@@ -1,69 +1,10 @@
 module RCAP
   module CAP_1_2
+
     # A Point object is valid if
     # * it has a lattitude within the minimum and maximum lattitude values
     # * it has a longitude within the minimum and maximum longitude values
-    class Point
-      include Validation
-
-      MAX_LONGITUDE = 180
-      MIN_LONGITUDE = -180
-      MAX_LATTITUDE = 90
-      MIN_LATTITUDE= -90
-
-      # @return [Numeric]
-      attr_accessor( :lattitude )
-      # @return [Numeric]
-      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)
-
-      # @param [Hash] attributes
-      # @option attributes [Numeric] :lattitude
-      # @option attributes [Numeric] :longitude
-      def initialize( attributes = {} )
-        @lattitude = attributes[ :lattitude ]
-        @longitude = attributes[ :longitude ]
-      end
-
-      # Returns a string representation of the point of the form
-      #  lattitude,longitude
-      #
-      # @return [String]
-      def to_s
-        "#{ @lattitude },#{ @longitude }"
-      end
-
-      # @return [String]
-      def inspect 
-        '('+self.to_s+')'
-      end
-
-      # Two points are equivalent if they have the same lattitude and longitude
-      #
-      # @param [Point] other
-      # @return [true, false]
-      def ==( other )
-        [ @lattitude, @longitude ] == [ other.lattitude, other.longitude ]
-      end
-
-      LATTITUDE_KEY = 'lattitude'  
-      LONGITUDE_KEY = 'longitude'  
-
-      # @return [Hash]
-      def to_h 
-        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( :lattitude => point_hash[ LATTITUDE_KEY ], :longitude => point_hash[ LONGITUDE_KEY ])
-      end
+    class Point < RCAP::Base::Point
     end
   end
 end

data/lib/rcap/cap_1_2/polygon.rb

@@ -1,103 +1,16 @@
 module RCAP
   module CAP_1_2
+
     # A Polygon object is valid if
     # * it has a minimum of three points
     # * each Point object in the points collection is valid
-    class Polygon
-      include Validation
-
-      # @return [Array<Point>] Collection of {Point} objects. 
-      attr_reader( :points )
+    class Polygon < RCAP::Base::Polygon
 
-      validates_collection_of( :points )
       validates_length_of( :points, :minimum => 4 )
-      validates_equality_of_first_and_last( :points )
-
-      XML_ELEMENT_NAME = 'polygon'                   
-      XPATH            = "cap:#{ XML_ELEMENT_NAME }" 
-      
-      # @param [Hash] attributes
-      # @option attributes [Array<Point>] :points Collection of {Point} objects
-      def initialize( attributes = {})
-        @points = Array( attributes[ :points ])
-      end
-
-      # Creates a new Point object and adds it to the points array.
-      #
-      # @see Point#initialize
-      def add_point( point_attributes = {})
-        point = Point.new( point_attributes )
-        @points << point
-        point
-      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( ' ' )
-      end
-
-      # @return [String]
-      def inspect 
-        "(#{ @points.map{|point| point.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
-      end
-
-      # @return [String]
-      def to_xml
-        self.to_xml_element.to_s
-      end
-
-      # Two polygons are equivalent if their collection of points is equivalent.
-      # 
-      # @return [true,false]
-      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 }}
-      end
-
-      # @return [Polygon]
-      def self.from_xml_element( polygon_xml_element ) 
-        if polygon_xml_element.text && !polygon_xml_element.text.empty?
-          coordinates = self.parse_polygon_string( polygon_xml_element.text )
-          points = coordinates.map{ |lattitude, longitude| Point.new( :lattitude => lattitude, :longitude => longitude )}
-          polygon = self.new( :points => points )
-        else
-          self.new
-        end
-      end
-
-      # @return [String]
-      def to_yaml( options = {} ) 
-        @points.map{ |point| [ point.lattitude, point.longitude ]}.to_yaml( options )
-      end
-
-      # @return [Polygon]
-      def self.from_yaml_data( polygon_yaml_data ) 
-        self.new( :points => Array( polygon_yaml_data ).map{ |lattitude, longitude| Point.new( :lattitude => lattitude, :longitude => longitude )})
-      end
-
-      POINTS_KEY  = 'points' 
-
-      # @return [Hash]
-      def to_h 
-        { POINTS_KEY => @points.map{ |point| point.to_h }}
-      end
 
-      # @return [Polygon]
-      def self.from_h( polygon_hash ) 
-        self.new( :points => polygon_hash[ POINTS_KEY ].map{ |point_hash| Point.from_h( point_hash )})
+      # @return [Class]
+      def point_class
+        Point
       end
     end
   end

data/lib/rcap/cap_1_2/resource.rb

@@ -4,59 +4,20 @@ module RCAP
     # A Resource object is valid if
     # * it has a resource description
     # * it has a mime_type
-    class Resource
-      include Validation
+    class Resource < RCAP::Base::Resource
 
-      # @return [String] Resource description 
-      attr_accessor( :resource_desc )
-      # @return [String] MIME type as described in RFC 2046 
-      attr_accessor( :mime_type )
-      # @return [Integer] Expressed in bytes 
-      attr_accessor( :size )
-      # @return [String] Resource location 
-      attr_accessor( :uri )
-      # @return [String] Dereferenced URI - contents of URI Base64 encoded 
+      # @return [String] Dereferenced URI - contents of URI Base64 encoded
       attr_accessor( :deref_uri )
-      # @return [String] SHA-1 hash of contents of resource 
-      attr_accessor( :digest )
 
-      validates_presence_of( :resource_desc )
       validates_presence_of( :mime_type )
 
-      XML_ELEMENT_NAME           = 'resource'     
-      MIME_TYPE_ELEMENT_NAME     = 'mimeType'     
-      SIZE_ELEMENT_NAME          = 'size'         
-      URI_ELEMENT_NAME           = 'uri'          
-      DEREF_URI_ELEMENT_NAME     = 'derefUri'     
-      DIGEST_ELEMENT_NAME        = 'digest'       
-      RESOURCE_DESC_ELEMENT_NAME = 'resourceDesc' 
+      DEREF_URI_ELEMENT_NAME     = 'derefUri'
 
-      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 }"           
-      DEREF_URI_XPATH     = "cap:#{ DEREF_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
-      # @option attributes [Numeric] :size Size in bytes
-      # @option attributes [String] :uri
-      # @option attributes [String] :deref_uri
-      # @option attributes [String] :digest
-      # @option attributes [String] :resource_desc
-      def initialize( attributes = {} )
-        @mime_type     = attributes[ :mime_type ]
-        @size          = attributes[ :size ]
-        @uri           = attributes[ :uri ]
-        @deref_uri     = attributes[ :deref_uri ]
-        @digest        = attributes[ :digest ]
-        @resource_desc = attributes[ :resource_desc ]
-      end
+      DEREF_URI_XPATH     = "cap:#{ DEREF_URI_ELEMENT_NAME }"
 
       # @return [REXML::Element]
-      def to_xml_element 
+      def to_xml_element
+        xml_element = super
         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
@@ -67,32 +28,6 @@ module RCAP
         xml_element
       end
 
-      # If size is defined returns the size in kilobytes
-      # @return [Float]
-      def size_in_kb
-        if @size
-          @size.to_f/1024
-        end
-      end
-
-      # @return [String]
-      def to_xml 
-        self.to_xml_element.to_s
-      end
-
-      # @return [String]
-      def inspect 
-        [ @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
-      #  resource_desc
-      #
-      # @return [String]
-      def to_s
-        @resource_desc
-      end
-
       # Retrieves the content at uri and stores it in deref_uri as Base64 encoded text. It will also
       # calculate the {#digest} on the encoded data using SHA1 and set the {#size}.
       #
@@ -109,47 +44,24 @@ module RCAP
         self.calculate_hash_and_size
       end
 
-      # Calculates the SHA-1 hash and size of the contents of {#deref_uri}.
-      # Returns an array containing the size (in bytes) and SHA-1 hash if
-      # {#deref_uri} is present otherwise returns nil.
-      #
-      # @return [nil,Array(Integer,String)]
-      def calculate_hash_and_size
-        if @deref_uri
-          @digest = Digest::SHA1.hexdigest( @deref_uri )
-          @size = @deref_uri.bytesize
-          [ @size, @digest ]
-        end
-      end
-
-      # The decoded contents of {#deref_uri} if present otherwise nil.
-      #
-      # @return [nil,String]
-      def decoded_deref_uri
-        Base64.decode64( @deref_uri ) if @deref_uri
+      # @return [String]
+      def xmlns
+        Alert::XMLNS
       end
 
       # @param [REXML::Element] resource_xml_element
       # @return [Resource]
-      def self.from_xml_element( resource_xml_element ) 
-        resource = self.new( :resource_desc => RCAP.xpath_text( resource_xml_element, RESOURCE_DESC_XPATH, Alert::XMLNS ),
-                             :uri           => RCAP.xpath_text( resource_xml_element, URI_XPATH, Alert::XMLNS ),
-                             :mime_type     => RCAP.xpath_text( resource_xml_element, MIME_TYPE_XPATH, Alert::XMLNS ),
-                             :deref_uri     => RCAP.xpath_text( resource_xml_element, DEREF_URI_XPATH, Alert::XMLNS ),
-                             :size          => RCAP.xpath_text( resource_xml_element, SIZE_XPATH, Alert::XMLNS ).to_i,
-                             :digest        => RCAP.xpath_text( resource_xml_element, DIGEST_XPATH, Alert::XMLNS ))
+      def self.from_xml_element( resource_xml_element )
+        super.tap do |resource|
+          resource.deref_uri = RCAP.xpath_text( resource_xml_element, DEREF_URI_XPATH, resource.xmlns )
+        end
       end
 
-      RESOURCE_DESC_YAML = "Resource Description" 
-      URI_YAML           = "URI"                  
-      MIME_TYPE_YAML     = "Mime Type"            
-      DEREF_URI_YAML     = "Derefrenced URI Data" 
-      SIZE_YAML          = "Size"                 
-      DIGEST_YAML        = "Digest"               
+      DEREF_URI_YAML     = "Derefrenced URI Data"
 
       # @param [Hash] options
       # @return [String]
-      def to_yaml( options = {} ) 
+      def to_yaml( options = {} )
         RCAP.attribute_values_to_hash(
           [ RESOURCE_DESC_YAML, @resource_desc ],
           [ URI_YAML,           @uri ],
@@ -161,45 +73,30 @@ module RCAP
 
       # @param [Hash] resource_yaml_data
       # @return [Resource]
-      def self.from_yaml_data( resource_yaml_data ) 
-        self.new(
-          :resource_desc => reource_yaml_data[ RESOURCE_DESC_YAML ],
-          :uri           => reource_yaml_data[ URI_YAML ],
-          :mime_type     => reource_yaml_data[ MIME_TYPE_YAML ],
-          :deref_uri     => reource_yaml_data[ DEREF_URI_YAML ],
-          :size          => reource_yaml_data[ SIZE_YAML ],
-          :digest        => reource_yaml_data[ DIGEST_YAML ]
-        )
+      def self.from_yaml_data( resource_yaml_data )
+        super.tap do |resource|
+          resource.deref_uri = resource_yaml_data[ DEREF_URI_YAML ]
+        end
       end
 
-      RESOURCE_DESC_KEY = 'resource_desc' 
-      URI_KEY           = 'uri'           
-      MIME_TYPE_KEY     = 'mime_type'     
-      DEREF_URI_KEY     = 'deref_uri'     
-      SIZE_KEY          = 'size'          
-      DIGEST_KEY        = 'digest'        
+      DEREF_URI_KEY     = 'deref_uri'
 
       # @return [Hash]
-      def to_h 
-        RCAP.attribute_values_to_hash(
-          [ RESOURCE_DESC_KEY, @resource_desc ],
-          [ URI_KEY,           @uri],
-          [ MIME_TYPE_KEY,     @mime_type],
-          [ DEREF_URI_KEY,     @deref_uri],
-          [ SIZE_KEY,          @size ],
-          [ DIGEST_KEY,        @digest ])
+      def to_h
+        RCAP.attribute_values_to_hash( [ RESOURCE_DESC_KEY, @resource_desc ],
+                                       [ URI_KEY,           @uri],
+                                       [ MIME_TYPE_KEY,     @mime_type],
+                                       [ DEREF_URI_KEY,     @deref_uri],
+                                       [ SIZE_KEY,          @size ],
+                                       [ DIGEST_KEY,        @digest ])
       end
 
       # @param [Hash] resource_hash
       # @return [Resource]
-      def self.from_h( resource_hash ) 
-        self.new(
-          :resource_desc => resource_hash[ RESOURCE_DESC_KEY ],
-          :uri           => resource_hash[ URI_KEY ],
-          :mime_type     => resource_hash[ MIME_TYPE_KEY ],
-          :deref_uri     => resource_hash[ DEREF_URI_KEY ],
-          :size          => resource_hash[ SIZE_KEY ],
-          :digest        => resource_hash[ DIGEST_KEY ])
+      def self.from_h( resource_hash )
+        super.tap do |resource|
+          resource.deref_uri = resource_hash[ DEREF_URI_KEY ]
+        end
       end
     end
   end

data/lib/rcap/config.rb

@@ -1,4 +1,7 @@
 module RCAP
   XML_PRETTY_PRINTER = REXML::Formatters::Pretty.new( 2 )
   XML_PRETTY_PRINTER.compact = true
+
+  RCAP_TIME_FORMAT = "%Y-%m-%dT%H:%M:%S"
+  RCAP_ZONE_FORMAT = "%+03i:00"
 end

data/lib/{extensions → rcap/extensions}/array.rb

@@ -1,4 +1,4 @@
-class Array 
+class Array
   # Formats an array into a string suitable for a CAP message.
   #
   # @return [String]

data/lib/rcap/extensions/date.rb

@@ -0,0 +1,11 @@
+class Date
+  alias inspect to_s
+
+  # Returns a string representaion of the time suitable for CAP.
+  # @return [String]
+  # @example
+  #   Date.today.to_s_for_cap # => "2011-10-26T00:00:00+00:00"
+  def to_s_for_cap
+    self.to_datetime.to_s_for_cap
+  end
+end

data/lib/{extensions → rcap/extensions}/date_time.rb

@@ -1,15 +1,12 @@
 class DateTime
-  RCAP_TIME_FORMAT = "%Y-%m-%dT%H:%M:%S"
-  RCAP_ZONE_FORMAT = "%+03i:00"
-
   alias inspect to_s
 
   # Returns a string representaion of the time suitable for CAP.
   # @return [String]
-  # @example 
+  # @example
   #   DateTime.now.to_s_for_cap # => "2011-10-26T21:45:00+02:00"
   def to_s_for_cap
-    t = self.strftime( RCAP_TIME_FORMAT ) + format( RCAP_ZONE_FORMAT , utc_hours_offset )
+    t = self.strftime( RCAP::RCAP_TIME_FORMAT ) + format( RCAP::RCAP_ZONE_FORMAT , utc_hours_offset )
     t.sub(/\+(00:\d\d)$/, '-\1')
   end
 

data/lib/{extensions → rcap/extensions}/string.rb

@@ -2,7 +2,7 @@ class String
   CAP_LIST_REGEX = Regexp.new( '"([\w\s]+)"|(\S+)' )
   WHITESPACE_REGEX = Regexp.new('^\s+$')
 
-  # Reformats string for a CAP list. If the string contains whitespace it will 
+  # Reformats string for a CAP list. If the string contains whitespace it will
   # enclose the contents in quotation marks.
   #
   # @return [String]

data/lib/{extensions → rcap/extensions}/time.rb

@@ -1,13 +1,11 @@
 class Time
-  RCAP_TIME_FORMAT = "%Y-%m-%dT%H:%M:%S"
-  RCAP_ZONE_FORMAT = "%+03i:00"
 
   # Returns a string representaion of the time suitable for CAP.
   # @return [String]
-  # @example 
+  # @example
   #   Time.now.to_s_for_cap # => "2011-10-26T21:45:00+02:00"
   def to_s_for_cap
-    t = self.strftime( RCAP_TIME_FORMAT ) + format( RCAP_ZONE_FORMAT , utc_hours_offset )
+    t = self.strftime( RCAP::RCAP_TIME_FORMAT ) + format( RCAP::RCAP_ZONE_FORMAT , utc_hours_offset )
     t.sub(/\+(00:\d\d)$/, '-\1')
   end
 

data/lib/rcap/utilities.rb

@@ -1,6 +1,6 @@
-ALLOWED_CHARACTERS = /[^\s&<]+/ 
+ALLOWED_CHARACTERS = /[^\s&<]+/
 
-module RCAP  
+module RCAP
   # Returns a randomly generated UUID string
   #
   # @return [String] UUID string
@@ -13,8 +13,8 @@ module RCAP
   #
   # @param [REXML::Element] xml_element Element to start matching from.
   # @param [String] xpath XPath expression
-  # @param [String] namepsace Namespace in which to do the matching
-  # @return [String,nil] Text content of element matching XPath query or nil 
+  # @param [String] namespace Namespace in which to do the matching
+  # @return [String,nil] Text content of element matching XPath query or nil
   def self.xpath_text( xml_element, xpath, namespace )
     element = self.xpath_first( xml_element, xpath, namespace )
     element.text if element
@@ -24,7 +24,7 @@ module RCAP
   #
   # @param [REXML::Element] xml_element Element to start matching from.
   # @param [String] xpath XPath expression
-  # @param [String] namepsace Namespace in which to do the matching
+  # @param [String] namespace Namespace in which to do the matching
   # @return [REXML::Element,nil] Element matching XPath query or nil
   def self.xpath_first( xml_element, xpath, namespace )
     REXML::XPath.first( xml_element, xpath, { 'cap' => namespace })
@@ -34,8 +34,8 @@ module RCAP
   #
   # @param [REXML::Element] xml_element Element to start matching from.
   # @param [String] xpath XPath expression
-  # @param [String] namepsace Namespace in which to do the matching
-  # @return [Array<REXML::Element>] Collection of elements matching XPath query 
+  # @param [String] namespace Namespace in which to do the matching
+  # @return [Array<REXML::Element>] Collection of elements matching XPath query
   def self.xpath_match( xml_element, xpath, namespace )
     REXML::XPath.match( xml_element, xpath, { 'cap' => namespace })
   end
@@ -47,7 +47,7 @@ module RCAP
   # @return [String] Formatted output for inspect
   #
   # @example
-  #  RCAP.format_lines_for_inspect( 'Test', 'one\ntwo\nthree' ) 
+  #  RCAP.format_lines_for_inspect( 'Test', 'one\ntwo\nthree' )
   #  # returns
   #  # .-------.
   #  # | Test  |
@@ -67,7 +67,7 @@ module RCAP
 
   # Converts an array of key value pairs into a hash, excluding any value that is nil or empty
   #
-  # @param [Array<Array(Object,Object)>] attribte_values An array of arrays of key/value pairs
+  # @param [Array<Array(Object,Object)>] attribute_values An array of arrays of key/value pairs
   # @return [Hash] Hash of attributes
   #
   # @example
@@ -78,7 +78,7 @@ module RCAP
 
   # Calls #to_s_for_cap on the object it it responds to that otherwise just calls #to_s
   #
-  # @param [#to_s, #to_s_for_cap] 
+  # @param [#to_s, #to_s_for_cap] object
   # @return [String]
   def self.to_s_for_cap( object )
     if object
@@ -92,7 +92,7 @@ module RCAP
 
   # If the parameter is a string the datetime is parsed out of it, otherwise returns nil.
   #
-  # @param [String] date_string String to parse 
+  # @param [String] date_string String to parse
   # @return [String,nil]
   def self.parse_datetime( date_string )
     if date_string.is_a?( String )

data/lib/rcap/validations.rb

@@ -1,9 +1,11 @@
-module Validation  
-  module ClassMethods 
+module Validation
+  module ClassMethods
 
     CAP_NUMBER_REGEX  = Regexp.new( '^-{0,1}\d*\.{0,1}\d+$' )
     CAP_INTEGER_REGEX = Regexp.new( '\-{0,1}A[+-]?\d+\Z' )
 
+    # @example
+    #   validates_inclusion_of( :status, :in => VALID_STATUSES )
     def validates_inclusion_of( *attributes )
       options = {
         :message => 'is not in the required range'
@@ -17,6 +19,9 @@ module Validation
       end
     end
 
+    # Will validate all members of a collection are found in a given collection.
+    # @example
+    #   validates_inclusion_of_members_of( :categories, :in => VALID_CATEGORIES )
     def validates_inclusion_of_members_of( *attributes )
       options = {
         :message => 'contains members that are not valid'

data/lib/rcap/version.rb

@@ -1,3 +1,3 @@
 module RCAP
-  VERSION = '1.3.1'
+  VERSION = '2.0.0'
 end