osm 0.0.17 → 0.0.18

data/lib/osm/api.rb

@@ -529,6 +529,7 @@ module Osm
     # @!macro options_api_data
     # @return [Boolean] if the operation suceeded or not
     def update_evening(evening, api_data={})
+      raise ArgumentIsInvalid, 'evening is invalid' unless evening.valid?
       response = perform_query("programme.php?action=editEvening", api_data.merge(evening.to_api))
 
       # The cached programmes for the section will be out of date - remove them
@@ -679,6 +680,6 @@ module Osm
       return term.nil? ? Osm::find_current_term_id(self, id_for_section(section), api_data) : id_for(Osm::Term, term, 'term')
     end
 
-  end
+  end # Class Api
 
-end
+end # Module

data/lib/osm/api_access.rb

@@ -1,24 +1,31 @@
 module Osm
 
   class ApiAccess
+    include ::ActiveAttr::MassAssignmentSecurity
+    include ::ActiveAttr::Model
 
-    attr_reader :id, :name, :permissions
-    # @!attribute [r] id
+    # @!attribute [rw] id
     #   @return [Fixnum] the id for the API
-    # @!attribute [r] name
+    # @!attribute [rw] name
     #   @return [String] the name of the API
-    # @!attribute [r] permissions
+    # @!attribute [rw] permissions
     #   @return [Hash] the permissions assigned to this API by the user in OSM
 
-    # Initialize a new ApiAccess
-    # @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
-    def initialize(attributes={})
-      raise ArgumentError, ':id must be a Fixnum > 0' unless (attributes[:id].is_a?(Fixnum) && attributes[:id] > 0)
-      raise ArgumentError, ':name must be a String' unless attributes[:name].is_a?(String)
-      raise ArgumentError, ':permissions must be a Hash' unless attributes[:permissions].is_a?(Hash)
+    attribute :id, :type => Integer
+    attribute :name, :type => String
+    attribute :permissions, :default => {}
 
-      attributes.each { |k,v| instance_variable_set("@#{k}", v) }
-    end
+    attr_accessible :id, :name, :permissions
+
+    validates_numericality_of :id, :only_integer=>true, :greater_than=>0
+    validates_presence_of :name
+
+    validates :permissions, :hash => {:key_type => Symbol, :value_in => [10, 20]}
+
+
+    # @!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 ApiAccess from api data
@@ -43,22 +50,22 @@ module Osm
     # @param [Symbol] key the permission being queried
     # @return [Boolean] if this API can read the passed permission
     def can_read?(key)
-      return [20, 10].include?(@permissions[key])
+      return [20, 10].include?(permissions[key])
     end
 
     # Determine if this API has write access for the provided permission
     # @param [Symbol] key the permission being queried
     # @return [Boolean] if this API can write the passed permission
     def can_write?(key)
-      return [20].include?(@permissions[key])
+      return [20].include?(permissions[key])
     end
 
     # Determine if this API is the API being used to make requests
     # @return [Boolean] if this is the API being used
     def our_api?
-      return @id == Osm::Api.api_id.to_i
+      return id == Osm::Api.api_id.to_i
     end
 
-  end # Class
+  end # Class ApiAccess
 
 end # Module

data/lib/osm/due_badges.rb

@@ -1,38 +1,51 @@
 module Osm
 
   class DueBadges
+    include ::ActiveAttr::MassAssignmentSecurity
+    include ::ActiveAttr::Model
 
-    attr_reader :descriptions, :by_member, :totals
-    # @!attribute [r] descriptions
+    # @!attribute [rw] descriptions
     #   @return [Hash] descriptions for each of the badges
-    # @!attribute [r] by_member
+    # @!attribute [rw] by_member
     #   @return [Hash] the due badges grouped by member
-    # @!attribute [r] totals
-    #   @return [Hash] the total number of each badge which is due
-
-    # Initialize a new DueBadges
-    # @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key, exclude total as this is calculated for you)
-    def initialize(attributes={})
-      [:descriptions, :by_member].each do |attribute|
-        raise ArgumentError, ":#{attribute} must be a Hash" unless attributes[attribute].is_a?(Hash)
-      end
 
-      attributes.each { |k,v| instance_variable_set("@#{k}", v) }
+    attribute :descriptions, :default => {}
+    attribute :by_member, :default => {}
 
-      # Calculate totals
-      @totals = {}
-      @by_member.keys.each do |member_name|
-        @by_member[member_name].each do |badge_record|
-          badge_symbol = badge_record[:badge]
-          badge_extra = badge_record[:extra_information]
-          @totals[badge_record[:badge]] ||= {}
-          @totals[badge_symbol][badge_extra] ||= 0
-          @totals[badge_symbol][badge_extra] += 1
+    attr_accessible :descriptions, :by_member
+
+    validates_each :descriptions do |record, attr, value|
+      record.errors.add(attr, 'must be a Hash') unless value.is_a?(Hash)
+      value.each do |k, v|
+        record.errors.add(attr, 'keys must be Symbols') unless k.is_a?(Symbol)
+        record.errors.add(attr, 'values must be Hashes') unless v.is_a?(Hash)
+        [:name, :section, :type, :badge].each do |key|
+          record.errors.add(attr, "values must include the key #{key}") unless v.keys.include?(key)
+        end
+      end
+    end
+
+    validates_each :by_member do |record, attr, value|
+      record.errors.add(attr, 'must be a Hash') unless value.is_a?(Hash)
+      value.each do |k, v|
+        record.errors.add(attr, 'keys must be String') unless k.is_a?(String)
+        record.errors.add(attr, 'values must be Arrays') unless v.is_a?(Array)
+        v.each do |vv|
+          record.errors.add(attr, 'internal values must be Hashes') unless vv.is_a?(Hash)
+          record.errors.add(attr, 'internal values must include the key :badge') unless vv.keys.include?(:badge)
+          record.errors.add(attr, 'internal values :badge value must be a Symbol') unless vv[:badge].is_a?(Symbol)
+          record.errors.add(attr, 'internal values must include the key :extra_information') unless vv.keys.include?(:extra_information)
+          record.errors.add(attr, 'internal values :extra_information value must be a String') unless vv[:extra_information].is_a?(String)
         end
       end
     end
 
 
+    # @!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 DueBadges from api data
     # @param [Hash] data the hash of data provided by the API
     def self.from_api(data)
@@ -75,9 +88,25 @@ module Osm
     # Check if there are no badges due
     # @return [Boolean]
     def empty?
-      return @by_member.empty?
+      return by_member.empty?
+    end
+
+    # Calculate the total number of badges needed
+    # @return [Hash] the total number of each badge which is due
+    def totals(attributes={})
+      totals = {}
+      by_member.keys.each do |member_name|
+        by_member[member_name].each do |badge_record|
+          badge_symbol = badge_record[:badge]
+          badge_extra = badge_record[:extra_information]
+          totals[badge_record[:badge]] ||= {}
+          totals[badge_symbol][badge_extra] ||= 0
+          totals[badge_symbol][badge_extra] += 1
+        end
+      end
+      return totals
     end
 
-  end # Class
+  end # Class DueBadges
 
 end # Module

data/lib/osm/evening.rb

@@ -1,10 +1,12 @@
 module Osm
 
   class Evening
+    class Activity; end # Ensure the constant exists for the validators
 
-    attr_accessor :evening_id, :section_id, :title, :notes_for_parents, :games, :pre_notes, :post_notes, :leaders, :meeting_date, :activities
-    attr_reader :start_time, :end_time
-    # @!attribute [rw] evening_id
+    include ::ActiveAttr::MassAssignmentSecurity
+    include ::ActiveAttr::Model
+
+    # @!attribute [rw] id
     #   @return [Fixnum] the id of the evening
     # @!attribute [rw] section_id
     #   @return [Fixnum] the section the evening belongs to
@@ -26,29 +28,36 @@ module Osm
     #   @return [Array<Activity>] list of activities being done during the evening
     # @!attribute [rw] start_time
     #   @return [String] the start time (hh:mm)
-    # @!attribute [rw] end_time
+    # @!attribute [rw] finish_time
     #   @return [String] the end time (hh:mm)
 
-    # Initialize a new Evening
-    # @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
-    def initialize(attributes={})
-      [:evening_id, :section_id].each do |attribute|
-        raise ArgumentError, ":#{attribute} must be nil or a Fixnum > 0" unless attributes[attribute].nil? || (attributes[attribute].is_a?(Fixnum) && attributes[attribute] > 0)
-      end
-      [:title, :notes_for_parents, :games, :pre_notes, :post_notes, :leaders].each do |attribute|
-        raise ArgumentError, ":#{attribute} must be nil or a String" unless (attributes[attribute].nil? || attributes[attribute].is_a?(String))
-      end
-      raise ArgumentError, ':meeting_date must be a Date' unless attributes[:meeting_date].is_a?(Date)
-      raise ArgumentError, ':activities must be nil or an Array of Osm::Evening::Activity' unless (attributes[:activities].nil? || Osm::is_array_of?(attributes[:activities], Osm::Evening::Activity))
+    attribute :id, :type => Integer
+    attribute :section_id, :type => Integer
+    attribute :title, :type => String, :default => 'Unnamed meeting'
+    attribute :notes_for_parents, :type => String, :default => ''
+    attribute :games, :type => String, :default => ''
+    attribute :pre_notes, :type => String, :default => ''
+    attribute :post_notes, :type => String, :default => ''
+    attribute :leaders, :type => String, :default => ''
+    attribute :meeting_date, :type => Date
+    attribute :start_time, :type => String
+    attribute :finish_time, :type => String
+    attribute :activities, :default => []
 
-      attributes.each { |k,v| send("#{k}=", v) }
+    attr_accessible :id, :section_id, :title, :notes_for_parents, :games, :pre_notes, :post_notes, :leaders, :meeting_date, :activities, :start_time, :finish_time
 
-      @activities ||= []
-      @title ||= 'Unnamed meeting'
-      [:notes_for_parents, :games, :pre_notes, :post_notes, :leaders].each do |attribute|
-        instance_variable_set("@#{attribute}", '') if instance_variable_get("@#{attribute}").nil?
-      end
-    end
+    validates_numericality_of :id, :only_integer=>true, :greater_than=>0
+    validates_numericality_of :section_id, :only_integer=>true, :greater_than=>0
+    validates_presence_of :title
+    validates_presence_of :meeting_date
+    validates_format_of :start_time, :with => Osm::OSM_TIME_REGEX, :message => 'is not in the correct format (HH:MM)', :allow_blank => true
+    validates_format_of :finish_time, :with => Osm::OSM_TIME_REGEX, :message => 'is not in the correct format (HH:MM)', :allow_blank => true
+
+    validates :activities, :array_of => {:item_type => Osm::Evening::Activity, :item_valid => true}
+
+    # @!method initialize
+    #   Initialize a new Evening
+    #   @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
 
 
     # Initialize a new Evening from api data
@@ -56,7 +65,7 @@ module Osm
     # @param activities an array of hashes to generate the list of ProgrammeActivity objects
     def self.from_api(data, activities)
       attributes = {}
-      attributes[:evening_id] = Osm::to_i_or_nil(data['eveningid'])
+      attributes[:id] = Osm::to_i_or_nil(data['eveningid'])
       attributes[:section_id] = Osm::to_i_or_nil(data['sectionid'])
       attributes[:title] = data['title'] || 'Unnamed meeting'
       attributes[:notes_for_parents] = data['notesforparents'] || ''
@@ -65,7 +74,7 @@ module Osm
       attributes[:post_notes] = data['postnotes'] || ''
       attributes[:leaders] = data['leaders'] || ''
       attributes[:start_time] = data['starttime'].nil? ? nil : data['starttime'][0..4]
-      attributes[:end_time] = data['endtime'].nil? ? nil : data['endtime'][0..4]
+      attributes[:finish_time] = data['endtime'].nil? ? nil : data['endtime'][0..4]
       attributes[:meeting_date] = Osm::parse_date(data['meetingdate'])
 
       attributes[:activities] = Array.new
@@ -78,26 +87,15 @@ module Osm
       new(attributes)
     end
 
-    # Custom setters for times
-    [:start, :end].each do |attribute|
-      define_method "#{attribute}_time=" do |value|
-        unless value.nil?
-          value = value.strftime('%H:%M') unless value.is_a?(String)
-          raise ArgumentError, 'invalid time' unless /\A(?:[0-1][0-9]|2[0-3]):[0-5][0-9]\Z/.match(value)
-        end
-        instance_variable_set("@#{attribute}_time", value)
-      end
-    end
-
     # Get the evening's data for use with the API
     # @return [Hash]
     def to_api
       {
-        'eveningid' => evening_id,
+        'eveningid' => id,
         'sectionid' => section_id,
         'meetingdate' => meeting_date.strftime(Osm::OSM_DATE_FORMAT),
         'starttime' => start_time,
-        'endtime' => end_time,
+        'endtime' => finish_time,
         'title' => title,
         'notesforparents' => notes_for_parents,
         'prenotes' => pre_notes,
@@ -114,7 +112,7 @@ module Osm
     # @return [String]
     def activities_for_to_api
       to_save = Array.new
-      @activities.each do |activity|
+      activities.each do |activity|
         this_activity = {
           'activityid' => activity.activity_id,
           'notes' => activity.notes,
@@ -126,26 +124,31 @@ module Osm
 
 
     class Activity
+      include ::ActiveAttr::MassAssignmentSecurity
+      include ::ActiveAttr::Model
 
-      attr_reader :activity_id, :title, :notes
-      # @!attribute [r] activity_id
+      # @!attribute [rw] activity_id
       #   @return [Fixnum] the activity being done
-      # @!attribute [r] title
+      # @!attribute [rw] title
       #   @return [String] the activity's title
-      # @!attribute [r] notes
+      # @!attribute [rw] notes
       #   @return [String] notes relevant to doing this activity on this evening
-  
-      # Initialize a new Evening::Activity
-      # @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 a Fixnum > 0' unless (attributes[:activity_id].is_a?(Fixnum) && attributes[:activity_id] > 0)
-        raise ArgumentError, ':title must be nil or a String' unless (attributes[:title].nil? || attributes[:title].is_a?(String))
-        raise ArgumentError, ':notes must be nil or a String' unless (attributes[:notes].nil? || attributes[:notes].is_a?(String))
-  
-        attributes.each { |k,v| instance_variable_set("@#{k}", v) }
-      end
 
+      attribute :activity_id, :type => Integer
+      attribute :title, :type => String
+      attribute :notes, :type => String, :default => ''
+
+      attr_accessible :activity_id, :title, :notes
+
+      validates_numericality_of :activity_id, :only_integer=>true, :greater_than=>0
+      validates_presence_of :title
 
+
+      # @!method initialize
+      #   Initialize a new Evening::Activity
+      #   @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
+
+  
       # Initialize a new Evening::Activity from api data
       # @param [Hash] data the hash of data provided by the API
       def self.from_api(data)
@@ -156,9 +159,8 @@ module Osm
         })
       end
 
-    end
-
+    end # Class Evening::Activity
 
-  end
+  end # Class Evening
 
-end
+end # Module

data/lib/osm/event.rb

@@ -1,8 +1,9 @@
 module Osm
 
   class Event
+    include ::ActiveAttr::MassAssignmentSecurity
+    include ::ActiveAttr::Model
 
-    attr_reader :id, :section_id, :name, :start, :end, :cost, :location, :notes
     # @!attribute [r] id
     #   @return [Fixnum] the id for the event
     # @!attribute [r] section_id
@@ -11,7 +12,7 @@ module Osm
     #   @return [String] the name of the event
     # @!attribute [r] start
     #   @return [DateTime] when the event starts
-    # @!attribute [r] end
+    # @!attribute [r] finish
     #   @return [DateTime] when the event ends
     # @!attribute [r] cost
     #   @return [String] the cost of the event
@@ -20,22 +21,25 @@ module Osm
     # @!attribute [r] notes
     #   @return [String] notes about the event
 
-    # Initialize a new Event
-    # @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
-    def initialize(attributes={})
-      [:id, :section_id].each do |attribute|
-        raise ArgumentError, ":#{attribute} must be nil or a Fixnum > 0" unless attributes[attribute].nil? || (attributes[attribute].is_a?(Fixnum) && attributes[attribute] > 0)
-      end
-      raise ArgumentError, ':name must be a String' unless attributes[:name].is_a?(String)
-      raise ArgumentError, ':start must be nil or a DateTime' unless attributes[:start].nil? || attributes[:start].is_a?(DateTime)
-      raise ArgumentError, ':end must be nil or a DateTime' unless attributes[:end].nil? || attributes[:end].is_a?(DateTime)
-      [:cost, :location, :notes].each do |attribute|
-        raise ArgumentError, ":#{attribute} must be nil or a String" unless attributes[attribute].nil? || attributes[attribute].is_a?(String)
-      end
-
-      attributes.each { |k,v| instance_variable_set("@#{k}", v) }
-    end
+    attribute :id, :type => Integer
+    attribute :section_id, :type => Integer
+    attribute :name, :type => String
+    attribute :start, :type => DateTime
+    attribute :finish, :type => DateTime
+    attribute :cost, :type => String, :default => ''
+    attribute :location, :type => String, :default => ''
+    attribute :notes, :type => String, :default => ''
+
+    attr_accessible :id, :section_id, :name, :start, :finish, :cost, :location, :notes
+
+    validates_numericality_of :id, :only_integer=>true, :greater_than=>0
+    validates_numericality_of :section_id, :only_integer=>true, :greater_than=>0
+    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 Event from api data
     # @param [Hash] data the hash of data provided by the API
@@ -52,6 +56,6 @@ module Osm
       })
     end
 
-  end
+  end # Class Event
 
-end
+end # Module

data/lib/osm/grouping.rb

@@ -1,27 +1,34 @@
 module Osm
 
   class Grouping
+    include ::ActiveAttr::MassAssignmentSecurity
+    include ::ActiveAttr::Model
 
-    attr_reader :id, :name, :active, :points
-    # @!attribute [r] id
+    # @!attribute [rw] id
     #   @return [Fixnum] the id for grouping
-    # @!attribute [r] name
+    # @!attribute [rw] name
     #   @return [String] the name of the grouping
-    # @!attribute [r] active
+    # @!attribute [rw] active
     #   @return [Boolean] wether the grouping is active
-    # @!attribute [r] points
+    # @!attribute [rw] points
     #   @return [Fixnum] the points awarded to the grouping
 
-    # Initialize a new Grouping
-    # @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
-    def initialize(attributes={})
-      raise ArgumentError, ':id must be a Fixnum >= -2' unless (attributes[:id].is_a?(Fixnum) && attributes[:id] >= -2)
-      raise ArgumentError, ':name must be a String' unless attributes[:name].is_a?(String)
-      raise ArgumentError, ':active must be nil or a Boolean' unless attributes[:active].nil? || [true, false].include?(attributes[:active])
-      raise ArgumentError, ':points must be nil or a Fixnum >= 0' unless attributes[:points].nil? || (attributes[:points].is_a?(Fixnum) && attributes[:points] >= 0)
+    attribute :id, :type => Integer
+    attribute :name, :type => String
+    attribute :active, :type => Boolean
+    attribute :points, :type => Integer
 
-      attributes.each { |k,v| instance_variable_set("@#{k}", v) }
-    end
+    attr_accessible :id, :name, :active, :points
+
+    validates_numericality_of :id, :only_integer=>true, :greater_than_or_equal_to=>-2
+    validates_presence_of :name
+    validates_numericality_of :points, :only_integer=>true
+    validates_presence_of :active
+
+
+    # @!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 Grouping from api data
@@ -35,6 +42,6 @@ module Osm
       })
     end
 
-  end
+  end # Class Grouping
 
-end
+end # Module