osm 0.0.17 → 0.0.18

data/lib/osm/section.rb

@@ -1,59 +1,74 @@
 module Osm
 
   class Section
+    class FlexiRecord; end # Ensure the constant exists for the validators
 
-    attr_reader :id, :name, :subscription_level, :subscription_expires, :type, :num_scouts, :column_names, :fields, :intouch_fields, :mobile_fields, :flexi_records, :role
-    # @!attribute [r] id
+    include ::ActiveAttr::MassAssignmentSecurity
+    include ::ActiveAttr::Model
+
+    # @!attribute [rw] id
     #   @return [Fixnum] the id for the section
-    # @!attribute [r] name
+    # @!attribute [rw] name
     #   @return [String] the section name
-    # @!attribute [r] subscription_level
+    # @!attribute [rw] subscription_level
     #   @return [Symbol] what subscription the section has to OSM (:bronze, :silver or :gold)
-    # @!attribute [r] subscription_expires
+    # @!attribute [rw] subscription_expires
     #   @return [Date] when the section's subscription to OSM expires
-    # @!attribute [r] type
+    # @!attribute [rw] type
     #   @return [Symbol] the section type (:beavers, :cubs, :scouts, :exporers, :adults, :waiting, :unknown)
-    # @!attribute [r] num_scouts
+    # @!attribute [rw] num_scouts
     #   @return [Fixnum] how many members the section has
-    # @!attribute [r] column_names
+    # @!attribute [rw] column_names
     #   @return [Hash] custom names to use for the data columns
-    # @!attribute [r] fields
+    # @!attribute [rw] fields
     #   @return [Hash] which columns are shown in OSM
-    # @!attribute [r] intouch_fields
+    # @!attribute [rw] intouch_fields
     #   @return [Hash] which columns are shown in OSM's in touch reports
-    # @!attribute [r] mobile_fields
+    # @!attribute [rw] mobile_fields
     #   @return [Hash] which columns are shown in the OSM mobile app
-    # @!attribute [r] flexi_records
+    # @!attribute [rw] flexi_records
     #   @return [Array<FlexiRecord>] list of the extra records the section has
-    # @!attribute [r] role
+    # @!attribute [rw] role
     #   @return [Osm::Role] the role linking the user to this section
 
-
-    # Initialize a new Section
-    # @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 nil or a Fixnum > 0' unless attributes[:id].nil? || (attributes[:id].is_a?(Fixnum) && attributes[:id] > 0)
-      raise ArgumentError, ':section_name must be nil or a String' unless attributes[:section_name].nil? || attributes[:section_name].is_a?(String)
-      raise ArgumentError, ':num_scouts must be nil or a Fixnum >= 0' unless attributes[:num_scouts].nil? || (attributes[:num_scouts].is_a?(Fixnum) && attributes[:num_scouts] >= 0)
-      [:column_names, :fields, :intouch_fields, :mobile_fields].each do |attribute|
-        raise ArgumentError, ":#{attribute} must be nil or a Hash" unless attributes[attribute].nil? || attributes[attribute].is_a?(Hash)
-      end
-      [:type, :subscription_level].each do |attribute|
-        raise ArgumentError, ":#{attribute} must be nil or a Symbol" unless attributes[attribute].nil? || attributes[attribute].is_a?(Symbol)
-      end
-      raise ArgumentError, ':flexi_records must be nil or an Array' unless attributes[:flexi_records].nil? || attributes[:flexi_records].is_a?(Array)
-
-      attributes.each { |k,v| instance_variable_set("@#{k}", v) }
-
-      @section_name ||= ''
-      @column_names ||= {}
-      @fields ||= {}
-      @intouch_fields ||= {}
-      @mobile_fields ||= {}
-      @flexi_records ||= []
-      @subscription_level ||= :unknown
-      @type ||= :unknown
-    end
+    attribute :id, :type => Integer
+    attribute :name, :type => String
+    attribute :subscription_level, :default => :unknown
+    attribute :subscription_expires, :type => Date
+    attribute :type, :default => :unknown
+    attribute :num_scouts, :type => Integer
+    attribute :column_names, :default => {}
+    attribute :fields, :default => {}
+    attribute :intouch_fields, :default => {}
+    attribute :mobile_fields, :default => {}
+    attribute :flexi_records, :default => []
+    attribute :role
+
+    attr_accessible :id, :name, :subscription_level, :subscription_expires, :type, :num_scouts, :column_names, :fields, :intouch_fields, :mobile_fields, :flexi_records, :role
+
+    validates_numericality_of :id, :only_integer=>true, :greater_than=>0, :allow_nil => true
+    validates_numericality_of :num_scouts, :only_integer=>true, :greater_than_or_equal_to=>0
+    validates_presence_of :subscription_level
+    validates_presence_of :subscription_expires
+    validates_presence_of :type
+    validates_presence_of :column_names, :unless => Proc.new { |a| a.column_names == {} }
+    validates_presence_of :fields, :unless => Proc.new { |a| a.fields == {} }
+    validates_presence_of :intouch_fields, :unless => Proc.new { |a| a.intouch_fields == {} }
+    validates_presence_of :mobile_fields, :unless => Proc.new { |a| a.mobile_fields == {} }
+    validates_presence_of :flexi_records, :unless => Proc.new { |a| a.flexi_records == [] }
+    validates_presence_of :role
+
+    validates_inclusion_of :subscription_level, :in => [:bronze, :silver, :gold, :unknown], :message => 'is not a valid level'
+
+    validates :column_names, :hash => {:key_type => Symbol, :value_type => String}
+    validates :fields, :hash => {:key_type => Symbol, :value_type => String}
+    validates :intouch_fields, :hash => {:key_type => Symbol, :value_type => String}
+    validates :mobile_fields, :hash => {:key_type => Symbol, :value_type => String}
+
+
+    # @!method initialize
+    #   Initialize a new Section
+    #   @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
 
 
     # Initialize a new Sections from api data
@@ -80,12 +95,10 @@ module Osm
         :flexi_records => [],
       }
 
-
       # Populate arrays
       (data['extraRecords'].is_a?(Array) ? data['extraRecords'] : []).each do |record_data|
         attributes[:flexi_records].push FlexiRecord.from_api(record_data)
       end
-      attributes[:flexi_records].freeze
 
       new(attributes)
     end
@@ -93,7 +106,7 @@ module Osm
     # Check if this section is one of the youth sections
     # @return [Boolean]
     def youth_section?
-      [:beavers, :cubs, :scouts, :explorers].include?(@type)
+      [:beavers, :cubs, :scouts, :explorers].include?(type)
     end
 
     # Custom section type checkers
@@ -117,7 +130,7 @@ module Osm
     #   @return (Boolean)
     [:beavers, :cubs, :scouts, :explorers, :adults, :waiting].each do |attribute|
       define_method "#{attribute}?" do
-        @type == attribute
+        type == attribute
       end
     end
 
@@ -136,29 +149,49 @@ module Osm
         return false
       end
     end
+    
+    def inspect
+      attribute_descriptions = attributes.merge('role' => role.inspect_without_section(self))
+      return_inspect(attribute_descriptions)
+    end
 
+    def inspect_without_role(exclude_role)
+      attribute_descriptions = (role == exclude_role) ? attributes.merge('role' => 'SET') : attributes
+      return_inspect(attribute_descriptions)
+    end
 
 
     private
+    def return_inspect(attribute_descriptions)
+      attribute_descriptions.sort.map { |key, value| "#{key}: #{key.eql?('role') ? value : value.inspect}" }.join(", ")
+      separator = " " unless attribute_descriptions.empty?
+      "#<#{self.class.name}#{separator}#{attribute_descriptions}>"
+    end
+
     class FlexiRecord
+      include ::ActiveAttr::MassAssignmentSecurity
+      include ::ActiveAttr::Model
 
-      attr_reader :id, :name
-      # @!attribute [r] id
+      # @!attribute [rw] id
       #   @return [Fixnum] the aid of the flexi-record
-      # @!attribute [r] name
+      # @!attribute [rw] name
       #   @return [String] the name given to the flexi-record
-  
-      # 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)
-  
-        attributes.each { |k,v| instance_variable_set("@#{k}", v) }
-      end
-  
-  
-      # Initialize a new ApiAccess from api data
+
+      attribute :id, :type => Integer
+      attribute :name, :type => String
+
+      attr_accessible :id, :name
+
+      validates_numericality_of :id, :only_integer=>true, :greater_than=>0
+      validates_presence_of :name
+
+
+      # @!method initialize
+      #   Initialize a new FlexiRecord
+      #   @param [Hash] attributes the hash of attributes (see attributes for descriptions, use Symbol of attribute name as the key)
+
+
+      # Initialize a new FlexiRecord from api data
       # @param [Hash] data the hash of data provided by the API
       def self.from_api(data)
         # Expect item to be: {:name=>String, :extraid=>Fixnum}
@@ -170,8 +203,8 @@ module Osm
           :name => data['name'],
         })
       end
-    end # FlexiRecord
+    end # Class Section::FlexiRecord
 
-  end # Section
+  end # Class Section
 
 end # Module

data/lib/osm/term.rb

@@ -1,30 +1,38 @@
 module Osm
 
   class Term
+    include ::ActiveAttr::MassAssignmentSecurity
+    include ::ActiveAttr::Model
 
-    attr_reader :id, :section_id, :name, :start, :end
-    # @!attribute [r] id
+    # @!attribute [rw] id
     #   @return [Fixnum] the id for the term
-    # @!attribute [r] section_id
+    # @!attribute [rw] section_id
     #   @return [Fixnum] the section the term belongs to
-    # @!attribute [r] name
+    # @!attribute [rw] name
     #   @return [Fixnum] the name of the term
-    # @!attribute [r] start
+    # @!attribute [rw] start
     #   @return [Date] when the term starts
-    # @!attribute [r] end
-    #   @return [Date] when the term ends
-
-    # Initialize a new Term
-    # @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 nil or a Fixnum > 0' unless attributes[:id].nil? || (attributes[:id].is_a?(Fixnum) && attributes[:id] > 0)
-      raise ArgumentError, ':section_id must be nil or a Fixnum > 0' unless attributes[:section_id].nil? || (attributes[:section_id].is_a?(Fixnum) && attributes[:section_id] > 0)
-      raise ArgumentError, ':name must be nil or a String' unless attributes[:name].nil? || attributes[:name].is_a?(String)
-      raise ArgumentError, ':start must be nil or a Date' unless attributes[:start].nil? || attributes[:start].is_a?(Date)
-      raise ArgumentError, ':end must be nil or a Date' unless attributes[:end].nil? || attributes[:end].is_a?(Date)
-
-      attributes.each { |k,v| instance_variable_set("@#{k}", v) }
-    end
+    # @!attribute [rw] finish
+    #   @return [Date] when the term finishes
+
+    attribute :id, :type => Integer
+    attribute :section_id, :type => Integer
+    attribute :name, :type => String
+    attribute :start, :type => Date
+    attribute :finish, :type => Date
+
+    attr_accessible :id, :section_id, :name, :start, :finish
+
+    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
+    validates_presence_of :start
+    validates_presence_of :finish
+
+
+    # @!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 Term from api data
@@ -35,7 +43,7 @@ module Osm
         :section_id => Osm::to_i_or_nil(data['sectionid']),
         :name => data['name'],
         :start => Osm::parse_date(data['startdate']),
-        :end => Osm::parse_date(data['enddate']),
+        :finish => Osm::parse_date(data['enddate']),
       )
     end
 
@@ -43,39 +51,39 @@ module Osm
     # @param [Date] date
     # @return [Boolean] if the term is completly before the passed date
     def before?(date)
-      return @end < date.to_date
+      return finish < date.to_date
     end
 
     # Determine if the term is completly after the passed date
     # @param [Date] date
     # @return [Boolean] if the term is completly after the passed date
     def after?(date)
-      return @start > date.to_date
+      return start > date.to_date
     end
 
     # Determine if the term is in the future
     # @return [Boolean] if the term starts after today
     def future?
-      return @start > Date.today
+      return start > Date.today
     end
 
     # Determine if the term is in the past
     # @return [Boolean] if the term finished before today
     def past?
-      return @end < Date.today
+      return finish < Date.today
     end
 
     # Determine if the term is current
     # @return [Boolean] if the term started before today and finishes after today
     def current?
-      return (@start <= Date.today) && (@end >= Date.today)
+      return (start <= Date.today) && (finish >= Date.today)
     end
 
     # Determine if the provided date is within the term
     # @param [Date] date the date to test
     # @return [Boolean] if the term started before the date and finishes after the date
     def contains_date?(date)
-      return (@start <= date) && (@end >= date)
+      return (start <= date) && (finish >= date)
     end
 
     def <=>(another_term)
@@ -100,6 +108,6 @@ module Osm
       end
     end
 
-  end
+  end # Class Term
 
-end
+end # Module

data/osm.gemspec

@@ -20,6 +20,8 @@ Gem::Specification.new do |s|
 
   s.add_runtime_dependency 'activesupport', '>= 3.2'  # Used to parse JSON from OSM
   s.add_runtime_dependency 'httparty'                 # Used to make web requests to the API
+  s.add_runtime_dependency 'active_attr'
+  s.add_runtime_dependency 'activemodel'
 
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec'

data/spec/osm/activity_spec.rb

@@ -86,6 +86,8 @@ describe "Activity" do
     activity.badges[0].badge.should == 'badge'
     activity.badges[0].requirement.should == 'col_name'
     activity.badges[0].label.should == 'This is a label'
+
+    activity.valid?.should be_true
   end
 
 end

data/spec/osm/api_access_spec.rb

@@ -8,13 +8,14 @@ describe "API Access" do
     data = {
       'apiid' => '1',
       'name' => 'Name',
-      'permissions' => {'permission' => '100'},
+      'permissions' => {'permission' => '10'},
     }
     api_access = Osm::ApiAccess.from_api(data)
 
     api_access.id.should == 1
     api_access.name.should == 'Name'
-    api_access.permissions.should == {:permission => 100}
+    api_access.permissions.should == {:permission => 10}
+    api_access.valid?.should be_true
   end
 
 

data/spec/osm/api_spec.rb

@@ -419,7 +419,7 @@ describe "API" do
         'token' => @api_config[:api_token],
         'userid' => 'user',
         'secret' => 'secret',
-        'eveningid' => nil, 'sectionid' => nil, 'meetingdate' => '2000-01-02', 'starttime' => nil,
+        'eveningid' => 1, 'sectionid' => 2, 'meetingdate' => '2000-01-02', 'starttime' => nil,
         'endtime' => nil, 'title' => 'Unnamed meeting', 'notesforparents' =>'', 'prenotes' => '',
         'postnotes' => '', 'games' => '', 'leaders' => '', 'activity' => '[]',
       }
@@ -427,7 +427,7 @@ describe "API" do
       api.stub(:get_terms) { [] }
       HTTParty.should_receive(:post).with(url, {:body => post_data}) { DummyHttpResult.new(:response=>{:code=>'200', :body=>'{"result":0}'}) }
 
-      evening = Osm::Evening.new({:meeting_date => Date.new(2000, 01, 02)})
+      evening = Osm::Evening.new(:id=>1, :section_id=>2, :meeting_date=>Date.new(2000, 01, 02))
       api.update_evening(evening).should be_true
     end
 
@@ -438,7 +438,7 @@ describe "API" do
         'token' => @api_config[:api_token],
         'userid' => 'user',
         'secret' => 'secret',
-        'eveningid' => nil, 'sectionid' => nil, 'meetingdate' => '2000-01-02', 'starttime' => nil,
+        'eveningid' => 1, 'sectionid' => 2, 'meetingdate' => '2000-01-02', 'starttime' => nil,
         'endtime' => nil, 'title' => 'Unnamed meeting', 'notesforparents' =>'', 'prenotes' => '',
         'postnotes' => '', 'games' => '', 'leaders' => '', 'activity' => '[]',
       }
@@ -446,10 +446,15 @@ describe "API" do
       api.stub(:get_terms) { [] }
       HTTParty.should_receive(:post).with(url, {:body => post_data}) { DummyHttpResult.new(:response=>{:code=>'200', :body=>'{"result":1}'}) }
 
-      evening = Osm::Evening.new({:meeting_date => Date.new(2000, 01, 02)})
+      evening = Osm::Evening.new(:id=>1, :section_id=>2, :meeting_date=>Date.new(2000, 01, 02))
       api.update_evening(evening).should be_false
     end
-  end
+
+    it "Update an evening (invalid evening)" do
+      api = Osm::Api.new('user', 'secret')
+      evening = Osm::Evening.new
+      expect{ api.update_evening(evening) }.to raise_error(Osm::ArgumentIsInvalid)
+    end  end
 
 
   describe "Options Hash" do

data/spec/osm/due_badges_spec.rb

@@ -52,6 +52,7 @@ describe "DueBadge" do
     db.descriptions.should == {:badge_name=>{:name=>"Badge Name", :section=>:cubs, :type=>:activity, :badge=>"badge_name"}, :cubs_core_participation=>{:name=>"Participation", :section=>:cubs, :type=>:core, :badge=>"participation"}}
     db.by_member.should == {"John Doe"=>[{:badge=>:badge_name, :extra_information=>""}, {:badge=>:cubs_core_participation, :extra_information=>"Lvl 2"}], "Jane Doe"=>[{:badge=>:cubs_core_participation, :extra_information=>"Lvl 3"}]}
     db.totals.should == {:badge_name=>{""=>1}, :cubs_core_participation=>{"Lvl 3"=>1, "Lvl 2"=>1}}
+    db.valid?.should be_true
   end
 
 end

data/spec/osm/evening_spec.rb

@@ -6,7 +6,7 @@ describe "Evening" do
 
   before :each do
     @attributes = {
-      :evening_id => 1,
+      :id => 1,
       :section_id => 2,
       :title => 'Evening Name',
       :notes_for_parents => 'Notes for parents',
@@ -15,7 +15,7 @@ describe "Evening" do
       :post_notes => 'After',
       :leaders => 'Leaders',
       :start_time => '19:00',
-      :end_time => '21:00',
+      :finish_time => '21:00',
       :meeting_date => Date.new(2000, 01, 02),
     }
   end
@@ -42,7 +42,7 @@ describe "Evening" do
     }]
     e = Osm::Evening.from_api(data, activities)
 
-    e.evening_id.should == 1
+    e.id.should == 1
     e.section_id.should == 2
     e.title.should == 'Evening Name'
     e.notes_for_parents.should == 'Notes for parents'
@@ -51,30 +51,15 @@ describe "Evening" do
     e.post_notes.should == 'After'
     e.leaders.should == 'Leaders'
     e.start_time.should == '19:00'
-    e.end_time.should == '21:00'
+    e.finish_time.should == '21:00'
     e.meeting_date.should == Date.new(2000, 1, 2)
 
     ea = e.activities[0]
     ea.activity_id.should == 2
     ea.title.should == 'Activity Name'
     ea.notes.should == 'Notes'
-  end
-
-
-  it "Raises exceptions when trying to set invalid times" do
-    e = Osm::Evening.new(@attributes)
-    
-    expect{ e.start_time = 'abcde' }.to raise_error(ArgumentError)
-    expect{ e.start_time = '24:00' }.to raise_error(ArgumentError)
-    expect{ e.start_time = '10:61' }.to raise_error(ArgumentError)
-    e.start_time = '12:34'
-    e.start_time.should == '12:34'
 
-    expect{ e.end_time = 'abcde' }.to raise_error(ArgumentError)
-    expect{ e.end_time = '24:00' }.to raise_error(ArgumentError)
-    expect{ e.end_time = '10:61' }.to raise_error(ArgumentError)
-    e.end_time = '23:45'
-    e.end_time.should == '23:45'
+    e.valid?.should be_true
   end