osm 0.0.17 → 0.0.18

data/lib/osm/member.rb

@@ -1,88 +1,120 @@
 module Osm
 
   class Member
+    include ::ActiveAttr::MassAssignmentSecurity
+    include ::ActiveAttr::Model
 
-    attr_reader :id, :section_id, :type, :first_name, :last_name, :email1, :email2, :email3, :email4, :phone1, :phone2, :phone3, :phone4, :address, :address2, :date_of_birth, :started, :joining_in_years, :parents, :notes, :medical, :religion, :school, :ethnicity, :subs, :grouping_id, :grouping_leader, :joined, :age, :joined_years
-    # @!attribute [r] id
+    # @!attribute [rw] id
     #   @return [Fixnum] the id for the member
-    # @!attribute [r] section_id
+    # @!attribute [rw] section_id
     #   @return [Fixnum] the section the member belongs to
-    # @!attribute [r] type
-    #   @return [?] ?
-    # @!attribute [r] first_name
+    # @!attribute [rw] type
+    #   @return [String] ?
+    # @!attribute [rw] first_name
     #   @return [String] the member's first name
-    # @!attribute [r] last_name
+    # @!attribute [rw] last_name
     #   @return [String] the member's last name
-    # @!attribute [r] email1
+    # @!attribute [rw] email1
     #   @return [String] the 1st email address for the member
-    # @!attribute [r] email2
+    # @!attribute [rw] email2
     #   @return [String] the 2nd email address for the member
-    # @!attribute [r] email3
+    # @!attribute [rw] email3
     #   @return [String] the 3rd email address for the member
-    # @!attribute [r] email4
+    # @!attribute [rw] email4
     #   @return [String] the 4th email address for the member
-    # @!attribute [r] phone1
+    # @!attribute [rw] phone1
     #   @return [String] the 1st phone number for the member
-    # @!attribute [r] phone2
+    # @!attribute [rw] phone2
     #   @return [String] the 2nd phone number for the member
-    # @!attribute [r] phone3
+    # @!attribute [rw] phone3
     #   @return [String] the 3rd phone number for the member
-    # @!attribute [r] phone4
+    # @!attribute [rw] phone4
     #   @return [String] the 4th phone number for the member
-    # @!attribute [r] address
+    # @!attribute [rw] address
     #   @return [String] the member's address
-    # @!attribute [r] address2
+    # @!attribute [rw] address2
     #   @return [String] the member's 2nd address
-    # @!attribute [r] date_of_birth
+    # @!attribute [rw] date_of_birth
     #   @return [Date] the member's date of birth
-    # @!attribute [r] started
+    # @!attribute [rw] started
     #   @return [Date] when the member started Scouting
-    # @!attribute [r] joining_in_years
+    # @!attribute [rw] joining_in_years
     #   @return [Fixnum] ?
-    # @!attribute [r] parents
+    # @!attribute [rw] parents
     #   @return [String] the member's parent's names
-    # @!attribute [r] notes
+    # @!attribute [rw] notes
     #   @return [String] notes relating to the member
-    # @!attribute [r] medical
+    # @!attribute [rw] medical
     #   @return [String] the member's key medical details
-    # @!attribute [r] religion
+    # @!attribute [rw] religion
     #   @return [String] the member's religion
-    # @!attribute [r] school
+    # @!attribute [rw] school
     #   @return [String] the school the member attends
-    # @!attribute [r] ethnicity
+    # @!attribute [rw] ethnicity
     #   @return [String] the member's ethnicity
-    # @!attribute [r] subs
+    # @!attribute [rw] subs
     #   @return [String] details about the member's subs
-    # @!attribute [r] grouping_id
+    # @!attribute [rw] grouping_id
     #   @return [Fixnum] the grouping within the section that the member belongs to
-    # @!attribute [r] grouping_leader
+    # @!attribute [rw] grouping_leader
     #   @return [Fixnum] wether the member is the grouping leader (0=no, 1=seconder/APL, 2=sixer/PL)
-    # @!attribute [r] joined
+    # @!attribute [rw] joined
     #   @return [Date] when the member joined the section
-    # @!attribute [r] age
+    # @!attribute [rw] age
     #   @return [String] the member's current age (yy/mm)
-    # @!attribute [r] joining_years
+    # @!attribute [rw] joined_years
     #   @return [Fixnum] how many years the member has been in Scouting
 
+    attribute :id, :type => Integer
+    attribute :section_id, :type => Integer
+    attribute :type, :type => String
+    attribute :first_name, :type => String
+    attribute :last_name, :type => String
+    attribute :email1, :type => String, :default => ''
+    attribute :email2, :type => String, :default => ''
+    attribute :email3, :type => String, :default => ''
+    attribute :email4, :type => String, :default => ''
+    attribute :phone1, :type => String, :default => ''
+    attribute :phone2, :type => String, :default => ''
+    attribute :phone3, :type => String, :default => ''
+    attribute :phone4, :type => String, :default => ''
+    attribute :address, :type => String, :default => ''
+    attribute :address2, :type => String, :default => ''
+    attribute :date_of_birth, :type => Date
+    attribute :started, :type => Date
+    attribute :joining_in_years, :type => Integer
+    attribute :parents, :type => String, :default => ''
+    attribute :notes, :type => String, :default => ''
+    attribute :medical, :type => String, :default => ''
+    attribute :religion, :type => String, :default => ''
+    attribute :school, :type => String, :default => ''
+    attribute :ethnicity, :type => String, :default => ''
+    attribute :subs, :type => String, :default => ''
+    attribute :grouping_id, :type => Integer
+    attribute :grouping_leader, :type => Integer
+    attribute :joined, :type => Date
+    attribute :age, :type => String
+    attribute :joined_years, :type => Integer
 
-    # Initialize a new Member
-    # @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, :grouping_leader].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, ':grouping_id must be nil or a Fixnum >= -2' unless attributes[:grouping_id].nil? || (attributes[:grouping_id].is_a?(Fixnum) && attributes[:grouping_id] >= -2)
-      raise ArgumentError, ':joined_years must be nil or a Fixnum >= -1' unless attributes[:joined_years].nil? || (attributes[:joined_years].is_a?(Fixnum) && attributes[:joined_years] >= -1)
-      raise ArgumentError, ':joining_in_years must be nil or a Fixnum' unless attributes[:joining_in_years].nil? || attributes[:joining_in_years].is_a?(Fixnum)
-      [:type, :first_name, :last_name, :email1, :email2, :email3, :email4, :phone1, :phone2, :phone3, :phone4, :address, :address2, :parents, :notes, :medical, :religion, :school, :ethnicity, :subs, :age].each do |attribute|
-        raise ArgumentError, ":#{attribute} must be nil or a String" unless attributes[attribute].nil? || attributes[attribute].is_a?(String)
-      end
-      [:date_of_birth, :started, :joined].each do |attribute|
-        raise ArgumentError, ":#{attribute} must be nil or a Date" unless attributes[attribute].nil? || attributes[attribute].is_a?(Date)
-      end
+    attr_accessible :id, :section_id, :type, :first_name, :last_name, :email1, :email2, :email3, :email4, :phone1, :phone2, :phone3, :phone4, :address, :address2, :date_of_birth, :started, :joining_in_years, :parents, :notes, :medical, :religion, :school, :ethnicity, :subs, :grouping_id, :grouping_leader, :joined, :age, :joined_years
 
-      attributes.each { |k,v| instance_variable_set("@#{k}", v) }
-    end
+    validates_numericality_of :id, :only_integer=>true, :greater_than=>0
+    validates_numericality_of :section_id, :only_integer=>true, :greater_than=>0
+    validates_numericality_of :grouping_id, :only_integer=>true, :greater_than_or_equal_to=>-2
+    validates_numericality_of :grouping_leader, :only_integer=>true, :greater_than_or_equal_to=>0, :less_than_or_equal_to=>2
+    validates_numericality_of :joined_years, :only_integer=>true, :greater_than_or_equal_to=>-1
+    validates_numericality_of :joining_in_years, :only_integer=>true, :greater_than_or_equal_to=>0
+    validates_presence_of :first_name
+    validates_presence_of :last_name
+    validates_presence_of :date_of_birth
+    validates_presence_of :started
+    validates_presence_of :joined
+    validates_format_of :age, :with => /\A[0-9]{2}\/(0[0-9]|1[012])\Z/, :message => 'age is not in the correct format (yy/mm)', :allow_blank => true
+
+
+    # @!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 Member from api data
@@ -125,22 +157,22 @@ module Osm
     # Get the years element of this scout's age
     # @return [Fixnum] the number of years this scout has been alive
     def age_years
-      return @age[0..1].to_i
+      return age[0..1].to_i
     end
 
     # Get the months element of this scout's age
     # @return [Fixnum] the number of months since this scout's last birthday
     def age_months
-      return @age[-2..-1].to_i
+      return age[-2..-1].to_i
     end
 
     # Get the full name
     # @param [String] seperator what to split the scout's first name and last name with
     # @return [String] this scout's full name seperated by the optional seperator
     def name(seperator=' ')
-      return "#{@first_name}#{seperator.to_s}#{@last_name}"
+      return "#{first_name}#{seperator.to_s}#{last_name}"
     end
 
-  end
+  end # Class Member
 
-end
+end # Module

data/lib/osm/register_data.rb

@@ -1,38 +1,47 @@
 module Osm
 
   class RegisterData
+    include ::ActiveAttr::MassAssignmentSecurity
+    include ::ActiveAttr::Model
 
-    attr_reader :member_id, :first_name, :last_name, :section_id, :grouping_id, :total, :attendance
-    # @!attribute [r] member_id
+    # @!attribute [rw] member_id
     #   @return [Fixnum] The OSM ID for the member
-    # @!attribute [r] grouping_id
+    # @!attribute [rw] grouping_id
     #   @return [Fixnum] The OSM ID for the member's grouping
-    # @!attribute [r] section_id
+    # @!attribute [rw] section_id
     #   @return [Fixnum] The OSM ID for the member's section
-    # @!attribute [r] first_name
+    # @!attribute [rw] first_name
     #   @return [String] The member's first name
-    # @!attribute [r] last_name
+    # @!attribute [rw] last_name
     #   @return [String] The member's last name
-    # @!attribute [r] total
-    #   @return [FixNum] Tooltip for the field
-    # @!attribute [r] attendance
+    # @!attribute [rw] total
+    #   @return [FixNum] Total
+    # @!attribute [rw] attendance
     #   @return [Hash] The data for each field - keys are the date, values one of 'Yes' (present), 'No' (known absence) or nil (absent)
 
-    # Initialize a new RegisterData
-    # @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
-    def initialize(attributes={})
-      [:member_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, ':grouping_id must be nil or a Fixnum >= -2' unless attributes[:grouping_id].nil? || (attributes[:grouping_id].is_a?(Fixnum) && attributes[:grouping_id] >= -2)
-      raise ArgumentError, ':total must be a Fixnum >= 0' unless (attributes[:total].is_a?(Fixnum) && attributes[:total] >= 0)
-      [:first_name, :last_name].each do |attribute|
-        raise ArgumentError, "#{attribute} must be nil or a String" unless attributes[attribute].nil? || attributes[attribute].is_a?(String)
-      end
-      raise ArgumentError, ':attendance must be a Hash' unless attributes[:attendance].is_a?(Hash)
+    attribute :member_id, :type => Integer
+    attribute :grouping_id, :type => Integer
+    attribute :section_id, :type => Integer
+    attribute :first_name, :type => String
+    attribute :last_name, :type => String
+    attribute :total, :type => Integer
+    attribute :attendance, :default => {}
 
-      attributes.each { |k,v| instance_variable_set("@#{k}", v) }
-    end
+    attr_accessible :member_id, :first_name, :last_name, :section_id, :grouping_id, :total, :attendance
+
+    validates_numericality_of :member_id, :only_integer=>true, :greater_than=>0
+    validates_numericality_of :grouping_id, :only_integer=>true, :greater_than_or_equal_to=>-2
+    validates_numericality_of :section_id, :only_integer=>true, :greater_than=>0
+    validates_numericality_of :total, :only_integer=>true, :greater_than_or_equal_to=>0
+    validates_presence_of :first_name
+    validates_presence_of :last_name
+
+    validates :attendance, :hash => {:key_type => Date, :value_in => ['Yes', 'No', nil]}
+
+
+    # @!method initialize
+    #   Initialize a new registerData
+    #   @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
 
 
     # Initialize a new RegisterData from api data
@@ -54,6 +63,6 @@ module Osm
       new(attributes)
     end
 
-  end
+  end # Class RegisterData
 
-end
+end # Module

data/lib/osm/register_field.rb

@@ -1,27 +1,30 @@
 module Osm
 
   class RegisterField
+    include ::ActiveAttr::MassAssignmentSecurity
+    include ::ActiveAttr::Model
 
-    attr_reader :id, :name, :tooltip
-    # @!attribute [r] id
+    # @!attribute [rw] id
     #   @return [String] OSM identifier for the field
-    # @!attribute [r] name
+    # @!attribute [rw] name
     #   @return [String] Human readable name for the field
-    # @!attribute [r] tooltip
+    # @!attribute [rw] tooltip
     #   @return [String] Tooltip for the field
 
-    # Initialize a new RegisterField
-    # @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
-    def initialize(attributes={})
-      [:id, :name].each do |attribute|
-        raise ArgumentError, "#{attribute} must be a String" unless attributes[attribute].is_a?(String)
-      end
-      raise ArgumentError, ':tooltip must be a String' unless attributes[:tooltip].nil? || attributes[:tooltip].is_a?(String)
+    attribute :id, :type => String
+    attribute :name, :type => String
+    attribute :tooltip, :type => String, :default => ''
 
-      attributes.each { |k,v| instance_variable_set("@#{k}", v) }
+    attr_accessible :id, :name, :tooltip
 
-      @tooltip ||= ''
-    end
+    validates_presence_of :id
+    validates_presence_of :name
+    validates_presence_of :tooltip, :allow_blank => true
+
+
+    # @!method initialize
+    #   Initialize a new RegisterField
+    #   @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
 
 
     # Initialize a new RegisterField from api data
@@ -34,6 +37,6 @@ module Osm
       })
     end
 
-  end
+  end # Class RegisterField
 
-end
+end # Module

data/lib/osm/role.rb

@@ -1,33 +1,48 @@
 module Osm
 
   class Role
+    include ::ActiveAttr::MassAssignmentSecurity
+    include ::ActiveAttr::Model
+
 
-    attr_reader :section, :group_name, :group_id, :permissions
     # @!attribute [rw] section
-    #   @param [Osm::Section] section the section this role is related to (can only be set once)
+    #   @param [Osm::Section] section the section this role is related to
     #   @return [Osm::Section] the section this role related to
-    # @!attribute [r] group_name
+    # @!attribute [rw] group_name
     #   @return [String] the name of the group the section is in
-    # @!attribute [r] group_id
+    # @!attribute [rw] group_id
     #   @return [Fixnum] the group the section is in
-    # @!attribute [r] permissions
+    # @!attribute [rw] permissions
     #   @return [Hash] the permissions the user has in this role
 
-    # 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, ':group_id must be nil or a Fixnum > 0' unless attributes[:group_id].nil? || (attributes[:group_id].is_a?(Fixnum) && attributes[:group_id] > 0)
-      raise ArgumentError, ':group_name must be nil or a String' unless attributes[:group_name].nil? || attributes[:group_name].is_a?(String)
-      raise ArgumentError, ':permissions must be nil or a Hash' unless attributes[:permissions].nil? || attributes[:permissions].is_a?(Hash)
+    attribute :section, :type => Object
+    attribute :group_name, :type => String
+    attribute :group_id, :type => Integer
+    attribute :permissions, :default => {}
+
+    attr_accessible :section, :group_name, :group_id, :permissions
+
 
-      attributes.each { |k,v| instance_variable_set("@#{k}", v) }
+    validates_presence_of :section
+    validates_numericality_of :group_id, :only_integer=>true, :greater_than=>0
+    validates_presence_of :group_name
+    validates_presence_of :permissions, :unless => Proc.new { |a| a.permissions == {} }
 
-      @name ||= ''
-      @permissions ||= {}
+    validates :permissions, :hash => {:key_type => Symbol, :value_in => [10, 20, 100]}
+
+    validates_each :section do |record, attr, value|
+      unless value.nil?
+        record.errors.add(attr, 'must also be valid') unless value.valid?
+      end
     end
 
 
-    # Initialize a new ApiAccess from api data
+    # @!method initialize
+    #   Initialize a new Role
+    #   @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
+
+
+    # Initialize a new Role from api data
     # @param [Hash] data the hash of data provided by the API
     def self.from_api(data)
       attributes = {}
@@ -42,48 +57,44 @@ module Osm
 
       role = new(attributes.merge(:permissions => permissions))
       role.section = Osm::Section.from_api(data['sectionid'], data['sectionname'], ActiveSupport::JSON.decode(data['sectionConfig']), role)
-      return role
-    end
 
-    def section=(section)
-      raise ArgumentError, 'section must be an Osm::Section' unless section.is_a?(Osm::Section)
-      @section = section if @section.nil?
+      return role
     end
 
     # Determine if this role has read access for the provided permission
     # @param [Symbol] key the permission being queried
     # @return [Boolean] if this role can read the passed permission
     def can_read?(key)
-      return [10, 20, 100].include?(@permissions[key])
+      return [10, 20, 100].include?(permissions[key])
     end
 
     # Determine if this role has write access for the provided permission
     # @param [Symbol] key the permission being queried
     # @return [Boolean] if this role can write the passed permission
     def can_write?(key)
-      return [20, 100].include?(@permissions[key])
+      return [20, 100].include?(permissions[key])
     end
 
     # Get section's long name in a consistent format
     # @return [String] e.g. "Scouts (1st Somewhere)"
     def long_name
-      @group_name.blank? ? @section.name : "#{@section.name} (#{@group_name})"
+      group_name.blank? ? section.name : "#{section.name} (#{group_name})"
     end
 
     # Get section's full name in a consistent format
     # @return [String] e.g. "1st Somewhere Beavers"
     def full_name
-      @group_name.blank? ? @section.name : "#{@group_name} #{@section.name}"
+      group_name.blank? ? section.name : "#{group_name} #{section.name}"
     end
 
     def <=>(another_role)
       begin
-        compare_group_name = self.group_name <=> another_role.group_name
+        compare_group_name = group_name <=> another_role.group_name
         return compare_group_name unless compare_group_name == 0
   
-        return 0 if self.section.type == another_role.section.type
+        return 0 if section.type == another_role.section.type
         [:beavers, :cubs, :scouts, :explorers, :waiting, :adults].each do |type|
-          return -1 if self.section.type == type
+          return -1 if section.type == type
           return 1 if another_role.section.type == type
         end
       rescue NoMethodError
@@ -93,12 +104,30 @@ module Osm
 
     def ==(another_role)
       begin
-        return self.section == another_role.section
+        return section == another_role.section
       rescue NoMethodError
         return false
       end
     end
 
-  end
+    def inspect
+      attribute_descriptions = attributes.merge('section' => section.inspect_without_role(self))
+      return_inspect(attribute_descriptions)
+    end
+
+    def inspect_without_section(exclude_section)
+      attribute_descriptions = (section == exclude_section) ? attributes.merge('section' => 'SET') : attributes
+      return_inspect(attribute_descriptions)
+    end
+
+
+    private
+    def return_inspect(attribute_descriptions)
+      attribute_descriptions.sort.map { |key, value| "#{key}: #{key.eql?('section') ? value : value.inspect}" }.join(", ")
+      separator = " " unless attribute_descriptions.empty?
+      "#<#{self.class.name}#{separator}#{attribute_descriptions}>"
+    end
+
+  end # Class Role
 
-end
+end # Module