osm 0.0.17 → 0.0.18

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+## Version 0.0.18
+
+  * Term's end attribute is now finish
+  * Event's end attribute is now finish
+  * Evening's evening\_id attribute is now id
+  * DueBadge's totals attribute is now a method (totals are calculated each time rather than during initialization)
+  * Added exception ArgumentIsInvalid (raised when argument.valid? is false when updating through the API)
+  * The following models now use active\_attr:
+    * Activity, Activity::File, Activity::Badge and Activity::Version
+    * ApiAccess
+    * DueBadges
+    * Evening and Evening::Activity
+    * Event
+    * Grouping
+    * Member
+    * RegisterData
+    * RegisterField
+    * Role
+    * Section and Section::FlexiRecord
+    * Term
+
 ## Version 0.0.17
 
   * Fix try method is undefined

data/README.md

@@ -7,6 +7,10 @@ Master [![Build Status](https://secure.travis-ci.org/robertgauld/osm.png?branch=
 
 Staging [![Build Status](https://secure.travis-ci.org/robertgauld/osm.png?branch=staging)](http://travis-ci.org/robertgauld/osm)
 
+This project also uses gemnasium to help ensure that the current version of libraries are being used.
+
+Master [![Dependency Status](https://gemnasium.com/robertgauld/osm.png)](https://gemnasium.com/robertgauld/osm)
+
 
 ## OSM
 

data/lib/array_of_validator.rb

@@ -0,0 +1,15 @@
+class ArrayOfValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    record.errors.add(attribute, 'must be an Array') unless value.is_a?(Array)
+    value.each do |value_item|
+      unless value_item.is_a?(options[:item_type])
+        record.errors.add(attribute, "items in the Array must be a #{options[:item_type].name}")
+      else
+        # We don't want to check the item is valid if it's the wrong type
+        if !options[:item_valid].nil? && (value_item.valid? != options[:item_valid])
+          record.errors.add(attribute, 'contains an invalid item')
+        end
+      end
+    end
+  end
+end

data/lib/hash_validator.rb

@@ -0,0 +1,24 @@
+class HashValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    record.errors.add(attribute, 'must be a Hash') unless value.is_a?(Hash)
+
+    value.each do |k, v|
+      if options[:key_type]
+        record.errors.add(attribute, "keys must be a #{options[:key_type].name}") unless k.is_a?(options[:key_type])
+      end
+
+      if options[:key_in]
+        record.errors.add(attribute, "keys must be in #{options[:key_in].inspect}") unless options[:key_in].include?(k)
+      end
+
+
+      if options[:value_type]
+        record.errors.add(attribute, "values must be a #{options[:value_type].name}") unless v.is_a?(options[:value_type])
+      end
+
+      if options[:value_in]
+        record.errors.add(attribute, "values must be in #{options[:value_in].inspect}") unless options[:value_in].include?(v)
+      end
+    end
+  end
+end

data/lib/osm.rb

@@ -1,17 +1,22 @@
-require File.join(File.dirname(__FILE__), '..', 'version')
-Dir[File.join(File.dirname(__FILE__) , 'osm', '*.rb')].each {|file| require file }
-
+require 'active_attr'
 require 'date'
 
-
 module Osm
   OSM_EPOCH_S = '1970-01-01'
   OSM_DATE_FORMAT = '%Y-%m-%d'
   OSM_DATETIME_FORMAT = '%Y-%m-%d %H:%M:%S'
+  OSM_TIME_REGEX = /\A(?:[0-1][0-9]|2[0-3]):[0-5][0-9]\Z/
+end
+
+require File.join(File.dirname(__FILE__), '..', 'version')
+Dir[File.join(File.dirname(__FILE__) , '*_validator.rb')].each {|file| require file }
+Dir[File.join(File.dirname(__FILE__) , 'osm', '*.rb')].each {|file| require file }
 
+
+module Osm
   class Error < Exception; end
   class ConnectionError < Error; end
-
+  class ArgumentIsInvalid < ArgumentError; end
 
   private  
   def self.make_array_of_symbols(array)
@@ -81,12 +86,4 @@ module Osm
     hash_out
   end
 
-  def self.is_array_of?(ar, ty)
-    return false unless ar.is_a?(Array)
-    ar.each do |it|
-      return false unless it.is_a?(ty)
-    end
-    return true
-  end
-
-end
+end # Module

data/lib/osm/activity.rb

@@ -1,83 +1,105 @@
 module Osm
 
   class Activity
+    class Badge; end # Ensure the constant exists for the validators
+    class File; end # Ensure the constant exists for the validators
+    class Version; end # Ensure the constant exists for the validators
 
-    attr_reader :id, :version, :group_id, :user_id, :title, :description, :resources, :instructions, :running_time, :location, :shared, :rating, :editable, :deletable, :used, :versions, :sections, :tags, :files, :badges
-    # @!attribute [r] id
+    include ::ActiveAttr::MassAssignmentSecurity
+    include ::ActiveAttr::Model
+
+    # @!attribute [rw] id
     #   @return [Fixnum] the id for the activity
-    # @!attribute [r] version
+    # @!attribute [rw] version
     #   @return [Fixnum] the version of the activity
-    # @!attribute [r] group_id
+    # @!attribute [rw] group_id
     #   @return [Fixnum] the group_id
-    # @!attribute [r] user_id
+    # @!attribute [rw] user_id
     #   @return [Fixnum] the user_id of the creator of the activity
-    # @!attribute [r] title
+    # @!attribute [rw] title
     #   @return [String] the activity's title
-    # @!attribute [r] description
+    # @!attribute [rw] description
     #   @return [String] the description of the activity
-    # @!attribute [r] resources
+    # @!attribute [rw] resources
     #   @return [String] resources required to do the activity
-    # @!attribute [r] instructions
+    # @!attribute [rw] instructions
     #   @return [String] instructions for doing the activity
-    # @!attribute [r] running_time
+    # @!attribute [rw] running_time
     #   @return [Fixnum] duration of the activity in minutes
-    # @!attribute [r] location
+    # @!attribute [rw] location
     #   @return [Symbol] :indoors, :outdoors or :both
-    # @!attribute [r] shared
+    # @!attribute [rw] shared
     #   @return [Fixnum] 2 - Public, 0 - Private
-    # @!attribute [r] rating
+    # @!attribute [rw] rating
     #   @return [Fixnum] ?
-    # @!attribute [r] editable
+    # @!attribute [rw] editable
     #   @return [Boolean] Wether the current API user can edit this activity
-    # @!attribute [r] deletable
+    # @!attribute [rw] deletable
     #   @return [Boolean] Wether the current API user can delete this activity
-    # @!attribute [r] used
+    # @!attribute [rw] used
     #   @return [Fixnum] How many times this activity has been used (total accross all of OSM)
-    # @!attribute [r] versions
+    # @!attribute [rw] versions
     #   @return [Array<Osm::Activity::Version>]
-    # @!attribute [r] sections
+    # @!attribute [rw] sections
     #   @return [Array<Symbol>] the sections the activity is appropriate for
-    # @!attribute [r] tags
+    # @!attribute [rw] tags
     #   @return [Array<String>] the tags attached to the activity
-    # @!attribute [r] files
+    # @!attribute [rw] files
     #   @return [Array<Osm::Activity::File>
-    # @!attribute [r] badges
+    # @!attribute [rw] badges
     #   @return [Array<Osm::Activity::Badge>
 
+    attribute :id, :type => Integer
+    attribute :version, :type => Integer
+    attribute :group_id, :type => Integer
+    attribute :user_id, :type => Integer
+    attribute :title, :type => String
+    attribute :description, :type => String
+    attribute :resources, :type => String
+    attribute :instructions, :type => String
+    attribute :running_time, :type => Integer
+    attribute :location
+    attribute :shared, :type => Integer
+    attribute :rating, :type => Integer
+    attribute :editable, :type => Boolean
+    attribute :deletable, :type => Boolean
+    attribute :used, :type => Integer
+    attribute :versions, :default => []
+    attribute :sections, :default => []
+    attribute :tags, :default => []
+    attribute :files, :default => []
+    attribute :badges, :default => []
 
-    # Initialize a new Activity
-    # @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
-    def initialize(attributes={})
-      [:id, :group_id, :user_id].each do |attribute|
-        it = attributes[attribute]
-        raise ArgumentError, ":#{attribute} must be nil or a Fixnum > 0" unless it.nil? || (it.is_a?(Fixnum) && it > 0)
-      end
-      [:version, :running_time, :shared].each do |attribute|
-        it = attributes[attribute]
-        raise ArgumentError, ":#{attribute} must be nil or a Fixnum >= 0" unless it.nil? || (it.is_a?(Fixnum) && it >= 0)
-      end
+    attr_accessible :id, :version, :group_id, :user_id, :title, :description, :resources, :instructions, :running_time, :location, :shared, :rating, :editable, :deletable, :used, :versions, :sections, :tags, :files, :badges
 
-      [:title, :description, :resources, :instructions].each do |attribute|
-        it = attributes[attribute]
-        raise ArgumentError, ":#{attribute} must be nil or a String" unless it.nil? || it.is_a?(String)
-      end
+    validates_numericality_of :id, :only_integer=>true, :greater_than=>0
+    validates_numericality_of :version, :only_integer=>true, :greater_than_or_equal_to=>0
+    validates_numericality_of :group_id, :only_integer=>true, :greater_than=>0
+    validates_numericality_of :user_id, :only_integer=>true, :greater_than=>0
+    validates_numericality_of :running_time, :only_integer=>true, :greater_than_or_equal_to=>0
+    validates_numericality_of :shared, :only_integer=>true, :greater_than_or_equal_to=>0
+    validates_numericality_of :rating, :only_integer=>true
+    validates_numericality_of :used, :only_integer=>true
+    validates_presence_of :title
+    validates_presence_of :description
+    validates_presence_of :resources
+    validates_presence_of :instructions
+    validates_inclusion_of :editable, :in => [true, false]
+    validates_inclusion_of :deletable, :in => [true, false]
+    validates_inclusion_of :location, :in => [:indoors, :outdoors, :both], :message => 'is not a valid location'
 
-      raise ArgumentError, ':location must be either :indoors, :outdoors or :both' unless [:indoors, :outdoors, :both].include?(attributes[:location])
 
-      raise ArgumentError, ':editable must be a Boolean' unless attributes[:editable].is_a?(TrueClass) || attributes[:editable].is_a?(FalseClass)
-      raise ArgumentError, ':deletable must be a Boolean' unless attributes[:deletable].is_a?(TrueClass) || attributes[:deletable].is_a?(FalseClass)
+    validates :sections, :array_of => {:item_type => Symbol}
+    validates :tags, :array_of => {:item_type => String}
+    validates :badges, :array_of => {:item_type => Osm::Activity::Badge, :item_valid => true}
+    validates :files, :array_of => {:item_type => Osm::Activity::File, :item_valid => true}
+    validates :versions, :array_of => {:item_type => Osm::Activity::Version, :item_valid => true}
 
-      raise ArgumentError, ':rating must be a FixNum' unless attributes[:rating].is_a?(Fixnum)
-      raise ArgumentError, ':used must be a FixNum' unless attributes[:used].is_a?(Fixnum)
 
-      raise ArgumentError, ':sections must be an Array of Symbol' unless Osm::is_array_of?(attributes[:sections], Symbol)
-      raise ArgumentError, ':tags must be an Array of String' unless Osm::is_array_of?(attributes[:tags], String)
-      raise ArgumentError, ':versions must be an Array of Osm::Activity::Version' unless Osm::is_array_of?(attributes[:versions], Osm::Activity::Version)
-      raise ArgumentError, ':files must be an Array of Osm::Activity::File' unless Osm::is_array_of?(attributes[:files], Osm::Activity::File)
-      raise ArgumentError, ':badges must be an Array of Osm::Activity::Badge' unless Osm::is_array_of?(attributes[:badges], Osm::Activity::Badge)
+    # @!method initialize
+    #   Initialize a new Term
+    #   @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
 
-      attributes.each { |k,v| instance_variable_set("@#{k}", v) }
-    end
 
     # Initialize a new Activity from api data
     # @param [Hash] data the hash of data provided by the API
@@ -121,29 +143,35 @@ module Osm
 
     private
     class File
-      attr_reader :id, :activity_id, :file_name, :name
-      # @!attribute [r] id
+      include ::ActiveAttr::MassAssignmentSecurity
+      include ::ActiveAttr::Model
+
+      # @!attribute [rw] id
       #   @return [Fixnum] the OSM ID for the file
-      # @!attribute [r] activity_id
+      # @!attribute [rw] activity_id
       #   @return [Fixnum] the OSM ID for the activity
-      # @!attribute [r] file_name
+      # @!attribute [rw] file_name
       #   @return [String] the file name of the file
-      # @!attribute [r] name
+      # @!attribute [rw] name
       #   @return [String] the name of the file (more human readable than file_name)
 
-      # Initialize a new File
-      # @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
-      def initialize(attributes={})
-        [:file_name, :name].each do |attribute|
-          raise ArgumentError, ":#{attribute} must a String" unless attributes[attribute].is_a?(String)
-        end
-        [:id, :activity_id].each do |attribute|
-          it = attributes[attribute]
-          raise ArgumentError, ":#{attribute} must be nil or a Fixnum > 0" unless it.nil? || (it.is_a?(Fixnum) && it > 0)
-        end
-
-        attributes.each { |k,v| instance_variable_set("@#{k}", v) }
-      end
+      attribute :id, :type => Integer
+      attribute :activity_id, :type => Integer
+      attribute :file_name, :type => String
+      attribute :name, :type => String
+
+      attr_accessible :id, :activity_id, :file_name, :name
+
+      validates_numericality_of :id, :only_integer=>true, :greater_than=>0
+      validates_numericality_of :activity_id, :only_integer=>true, :greater_than=>0
+      validates_presence_of :file_name
+      validates_presence_of :name
+
+
+      # @!method initialize
+      #   Initialize a new Term
+      #   @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
+
 
       # Initialize a new File from api data
       # @param [Hash] data the hash of data provided by the API
@@ -156,37 +184,49 @@ module Osm
         })
       end
 
-    end # Activity::File
+    end # Class Activity::File
 
     class Badge
-      attr_reader :activity_id, :section_type, :type, :badge, :requirement, :label
-      # @!attribute [r] activity_id
+      include ::ActiveAttr::MassAssignmentSecurity
+      include ::ActiveAttr::Model
+
+      # @!attribute [rw] activity_id
       #   @return [Fixnum] the activity being done
-      # @!attribute [r] section_type
+      # @!attribute [rw] section_type
       #   @return [Symbol] the section the badge 'belongs' to
-      # @!attribute [r] type
+      # @!attribute [rw] type
       #   @return [Symbol] the type of badge
-      # @!attribute [r] badge
+      # @!attribute [rw] badge
       #   @return [String] short name of the badge
-      # @!attribute [r] requirement
+      # @!attribute [rw] requirement
       #   @return [String] OSM reference to this badge requirement
-      # @!attribute [r] label
+      # @!attribute [rw] label
       #   @return [String] human readable label for the requirement
 
-      # Initialize a new Badge
-      # @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
-      def initialize(attributes={})
-        raise ArgumentError, ':activity_id must be nil or a Fixnum > 0' unless attributes[:activity_id].nil? || (attributes[:activity_id].is_a?(Fixnum) && attributes[:activity_id] > 0)
-        [:type, :section_type].each do |attribute|
-          raise ArgumentError, ":#{attribute} must be a Symbol" unless attributes[attribute].is_a?(Symbol)
-        end
-        [:label, :requirement, :badge].each do |attribute|
-          raise ArgumentError, ":#{attribute} must a String" unless attributes[attribute].is_a?(String)
-        end
-
-        attributes.each { |k,v| instance_variable_set("@#{k}", v) }
+      attribute :activity_id, :type => Integer
+      attribute :section_type
+      attribute :type
+      attribute :badge, :type => String
+      attribute :requirement, :type => String
+      attribute :label, :type => String
+
+      attr_accessible :activity_id, :section_type, :type, :badge, :requirement, :label
+
+      validates_numericality_of :activity_id, :only_integer=>true, :greater_than=>0
+      validates_presence_of :badge
+      validates_presence_of :requirement
+      validates_presence_of :label
+
+      validates_each :type, :section_type do |record, attr, value|
+        record.errors.add(attr, 'must be a Symbol') unless value.is_a?(Symbol)
       end
 
+
+      # @!method initialize
+      #   Initialize a new Badge
+      #   @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
+
+
       # Initialize a new Badge from api data
       # @param [Hash] data the hash of data provided by the API
       def self.from_api(data)
@@ -200,29 +240,38 @@ module Osm
         })
       end
 
-    end # Activity::Badge
+    end # Class Activity::Badge
 
     class Version
-      attr_reader :version, :created_by, :created_by_name, :label
-      # @!attribute [r] version
+      include ::ActiveAttr::MassAssignmentSecurity
+      include ::ActiveAttr::Model
+
+      # @!attribute [rw] version
       #   @return [Fixnum] the version of the activity
-      # @!attribute [r] created_by
+      # @!attribute [rw] created_by
       #   @return [Fixnum] the OSM user ID of the person who created this version
-      # @!attribute [r] created_by_name
+      # @!attribute [rw] created_by_name
       #   @return [String] the aname of the OSM user who created this version
-      # @!attribute [r] label
+      # @!attribute [rw] label
       #   @return [String] the human readable label to use for this version
 
-      # Initialize a new Version
-      # @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
-      def initialize(attributes={})
-        raise ArgumentError, ':version must be nil or a Fixnum > 0' unless attributes[:version].nil? || (attributes[:version].is_a?(Fixnum) && attributes[:version] >= 0)
-        raise ArgumentError, ':created_by must be nil or a Fixnum >= 0' unless attributes[:created_by].nil? || (attributes[:created_by].is_a?(Fixnum) && attributes[:created_by] > 0)
-        raise ArgumentError, ':created_by_name must be nil or a String' unless attributes[:created_by_name].nil?  || attributes[:created_by_name].is_a?(String)
-        raise ArgumentError, ':label must be nil or a String' unless attributes[:label].nil?  || attributes[:label].is_a?(String)
+      attribute :version, :type => Integer
+      attribute :created_by, :type => Integer
+      attribute :created_by_name, :type => String
+      attribute :label, :type => String
+
+      attr_accessible :version, :created_by, :created_by_name, :label
+
+      validates_numericality_of :version, :only_integer=>true, :greater_than_or_equal_to=>0
+      validates_numericality_of :created_by, :only_integer=>true, :greater_than=>0
+      validates_presence_of :created_by_name
+      validates_presence_of :label
+
+
+      # @!method initialize
+      #   Initialize a new Version
+      #   @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
 
-        attributes.each { |k,v| instance_variable_set("@#{k}", v) }
-      end
 
       # Initialize a new Version from api data
       # @param [Hash] data the hash of data provided by the API
@@ -235,8 +284,8 @@ module Osm
         })
       end
 
-    end # Activity::Version
+    end # Class Activity::Version
 
-  end # Activity
+  end # Class Activity
 
 end # Module