notches 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed673601115b4a08c8c6f46ac1ba576217d16d5a
-  data.tar.gz: 65eb69efd2001ce4f544e70f6e5db92fd5f73781
+  metadata.gz: ece48dfc0a167d9cf7a227b28b9cb3c175da32d4
+  data.tar.gz: b0d3cc05b279bcda628d1d4efaf82ba67631ee8e
 SHA512:
-  metadata.gz: 887a3b48a25567423d9b1bb38c4f72f93e7824eb2c391db65ad7decebb6b2f5cb854ef817733fd00ce6a13c30962140edaac39e29ccddebbdaca50158d35e6de
-  data.tar.gz: 01eb20fe4cba9d8a82f7b4c48d7cd316377c13e1182e0d40061c8c42d6ee6d222ccd74e95f1c9f10b6432b212845bf1707e24c8ff2d3576fa27ac0ea83670d07
+  metadata.gz: ac4177237dfb759d2c001a94bf8967806ccf72ba4ced6ac596d774d6baac75b51bca94168141c6b85d259395a592efcc6f99d93994ac062a9573dd180ac45a3d
+  data.tar.gz: 0f83367e1b5ce4f2f8372e140a87bbc6c039c9fe061213d7d7331bccf113dff1b1242222f10e6bdb54241ad5d4eb8b595630eca8e7e92ce65b812fba80c699bd

data/README.md

@@ -59,19 +59,25 @@ To get a better idea of how Notches is setup check out the
 Recording events
 ----------------
 
-To record events make the following call, the scope is optional.
+To record events make the following call:
 
-    Notches::Event.log(name: 'An important event', scope: 'A scope')
+    Notches::Event.log(name: 'An event')
+
+Events can have one or two optional scopes:
+
+    Notches::Event.log(name: 'An event', scope: 'A person')
+    Notches::Event.log(name: 'An event', scope: ['A person', 'An object'])
 
 Counting events
 -------------
 
 For a name:
 
-    Notches::Event.joins(:name).where('name like ?', 'An important event').count
+    Notches::Event.joins(:name).where('name = ?', 'An event').count
 
 For a name and scope:
 
     Notches::Event.joins(:name, :scope).where(
-      'name like = ? and scope like ?', 'An important event', 'A scope'
+      'name = ? and scopes.primary = ? and scopes.secondary = ?',
+      'An event', 'A person', 'An object'
     ).count

data/app/models/notches/event.rb

@@ -2,21 +2,22 @@ class Notches::Event < ActiveRecord::Base
   self.table_name = "notches_events"
 
   validates :name, presence: true
+  validates :scope, presence: true
 
   validates_associated :name, :scope
 
   belongs_to :date,  foreign_key: :notches_date_id
-  belongs_to :name,  foreign_key: :notches_name_id, :class_name => Name.to_s
-  belongs_to :scope, foreign_key: :notches_scope_id, :class_name => Scope.to_s
+  belongs_to :name,  foreign_key: :notches_name_id, :class_name => Notches::Name.to_s
+  belongs_to :scope, foreign_key: :notches_scope_id, :class_name => Notches::Scope.to_s
   belongs_to :time,  foreign_key: :notches_time_id
 
   def self.log(attributes)
     event = self.new
     event.transaction do
       Rails.logger.info("[Notches] Tracking #{attributes.inspect} at #{Date.today} #{Time.now}")
-      now            = Time.zone.now
+      now         = Time.zone.now
       event.name  = Notches::Name.find_or_create_by(name: attributes[:name])
-      event.scope = Notches::Scope.find_or_create_by(scope: attributes[:scope]) if attributes[:scope].present?
+      event.scope = Notches::Scope.find_or_create_by(scope_attributes_for(attributes[:scope]))
       event.date  = Notches::Date.find_or_create_by(date: now.to_date)
       event.time  = Notches::Time.find_or_create_by_time(now)
 
@@ -28,4 +29,12 @@ class Notches::Event < ActiveRecord::Base
     end
     event
   end
+
+  def self.scope_attributes_for(scope)
+    scope = [scope] if !scope.is_a?(Array)
+    {
+      primary:   scope.first.to_s,
+      secondary: scope.second.to_s
+    }
+  end
 end

data/app/models/notches/scope.rb

@@ -4,5 +4,19 @@ class Notches::Scope < ActiveRecord::Base
   has_many :events, class_name: Notches::Event.to_s,
                     foreign_key: "notches_scope_id"
 
-  validates :scope, presence: true
+  validate :no_nulls
+  validate :no_secondary_scope_without_primary
+
+  private
+
+  def no_nulls
+    errors[:primary] << "can't be null"   if primary.nil?
+    errors[:secondary] << "can't be null" if secondary.nil?
+  end
+
+  def no_secondary_scope_without_primary
+    if secondary.present? && primary.blank?
+      errors[:secondary] << "is invalid"
+    end
+  end
 end

data/db/migrate/20160815100820_add_secondary_to_notches_scopes.rb

@@ -0,0 +1,13 @@
+class AddSecondaryToNotchesScopes < ActiveRecord::Migration
+  def up
+    rename_column :notches_scopes, :scope, :primary
+    add_column    :notches_scopes, :secondary, :string
+    change_column_null :notches_events, :notches_scope_id, false
+  end
+
+  def down
+    change_column_null :notches_events, :notches_scope_id, true
+    remove_column :notches_scopes, :secondary
+    rename_column :notches_scopes, :primary, :scope
+  end
+end

data/lib/notches/version.rb

@@ -1,3 +1,3 @@
 module Notches
-  VERSION = '0.6.0'
+  VERSION = '0.7.0'
 end

data/spec/models/notches/event_spec.rb

@@ -4,8 +4,8 @@ describe Notches::Event do
   describe "validations" do
     let(:event) do
       Notches::Event.new(
-        name: Notches::Name.new(name: 'An important event'),
-        scope: Notches::Scope.new(scope: 'An important person')
+        name: Notches::Name.new(name: 'An event'),
+        scope: Notches::Scope.new(primary: 'A person', secondary: '')
       )
     end
 
@@ -19,10 +19,10 @@ describe Notches::Event do
       expect(event.errors[:name]).to eq(["can't be blank"])
     end
 
-    it "does not require a scope" do
+    it "requires a scope" do
       event.scope = nil
       event.valid?
-      expect(event).to be_valid
+      expect(event.errors[:scope]).to eq(["can't be blank"])
     end
 
     it "does not validate if its Name's name is blank" do
@@ -31,72 +31,101 @@ describe Notches::Event do
       expect(event.errors[:name]).to eq(["is invalid"])
     end
 
-    it "does not validate if it has a Scope but it's invalid" do
-      event.scope.scope = nil
+    it "does not validate if it has a scope but it's value is nil" do
+      event.scope.primary = nil
+      event.valid?
+      expect(event.errors[:scope]).to eq(["is invalid"])
+    end
+
+    it "does not validate if it has a secondary scope but no primary scope" do
+      event.scope.primary = nil
+      event.scope.secondary = 'Secondary scope'
       event.valid?
       expect(event.errors[:scope]).to eq(["is invalid"])
     end
   end
 
   describe ".log" do
+    let(:now) { Time.zone.now }
+    let(:existing_event) { Notches::Event.log(name: "An event", scope: "A person") }
 
-    context "with valid attributes" do
-      let(:now) { Time.zone.now }
-      before do
-        allow(Time).to receive_message_chain(:zone, :now).and_return(now)
-      end
+    before do
+      allow(Time).to receive_message_chain(:zone, :now).and_return(now)
+    end
 
+    context "with valid attributes" do
       it "creates a event for today and current time with those attributes" do
-        Notches::Event.log(name: "An important event")
+        Notches::Event.log(name: "An event")
         event = Notches::Event.first
         expect(event).to be_present
-        expect(event.name.name).to eq("An important event")
-        expect(event.scope).to be_nil
+        expect(event.name.name).to eq("An event")
+        expect(event.scope.primary).to eq("")
+        expect(event.scope.secondary).to eq("")
         expect(event.date.date).to eq(now.to_date)
         expect(event.time.time.strftime('%H:%M:%S')).to eq(now.strftime('%H:%M:%S'))
       end
     end
 
-    let(:existing_event) {
-      Notches::Event.log(
-        name: "An important event",
-        scope: "An important person"
-      )
-    }
-
     it "does not create a new Name record if there's a record for that Name already" do
-      event = Notches::Event.log(name: "An important event")
+      event = Notches::Event.log(name: "An event")
       expect(event.name.id).to eq(existing_event.name.id)
     end
 
     it "does not create a new Scope record if there's a record for that Scope already" do
-      event = Notches::Event.log(
-        name: "An important event",
-        scope: "An important person"
-      )
+      event = Notches::Event.log(name: "An event", scope: "A person")
       expect(event.scope.id).to eq(existing_event.scope.id)
     end
 
     it "does not create a new Date record there's a record for that Date already" do
-      event = Notches::Event.log(name: "Another important event")
+      event = Notches::Event.log(name: "Another event")
       expect(event.date.id).to eq(existing_event.date.id)
     end
 
     it "does not create a new Time record if there's a record for that Time already even if date was different" do
-      existing_event.time.update_attributes!(time: Time.parse('2016-08-03 14:15:59 UTC'))
-      allow(Time).to receive_message_chain(:zone, :now).and_return(Time.parse('2016-08-04 14:15:59 UTC'))
-      event = Notches::Event.log(name: "Another important event")
+      event = Notches::Event.log(name: "Another event")
       expect(event.time.id).to eq(existing_event.time.id)
     end
 
     context "a event with the same name, scope, date and time exists already" do
       it "does not log the event" do
-        allow(Time).to receive_message_chain(:zone, :now).and_return(existing_event.time.time)
+        event_attributes = {
+          name: "An event",
+          scope: "A person"
+        }
+        Notches::Event.log(event_attributes)
+
+        expect {
+          Notches::Event.log(event_attributes)
+        }.to_not change { Notches::Event.count }
+      end
+    end
+
+    context "logging an event with a primary and secondary scope" do
+      it do
+        event = Notches::Event.log(
+          name: "An event",
+          scope: ["A person", "An object"]
+        )
+
+        expect(event).to be_persisted
+        expect(event.name.name).to eq("An event")
+        expect(event.scope.primary).to eq("A person")
+        expect(event.scope.secondary).to eq("An object")
+        expect(event.date.date).to eq(now.to_date)
+        expect(event.time.time.strftime('%H:%M:%S')).to eq(now.strftime('%H:%M:%S'))
+      end
+    end
+
+    context "logging an event with a primary and secondary scope when a event with same name, scope, date and time exists already" do
+      it "does not log the event" do
+        event_attributes = {
+          name: "An event",
+          scope: ["A person", "An object"]
+        }
+        Notches::Event.log(event_attributes)
+
         expect {
-          event = Notches::Event.log(
-            name: "An important event",
-            scope: "An important person"
-          )
+          Notches::Event.log(event_attributes)
         }.to_not change { Notches::Event.count }
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: notches
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Cillian O'Ruanaidh
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-04 00:00:00.000000000 Z
+date: 2016-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -100,6 +100,7 @@ files:
 - db/migrate/20120910093652_add_index_to_user_agents.rb
 - db/migrate/20130918115023_create_notches_user_sessions.rb
 - db/migrate/20160804111320_create_notches_events.rb
+- db/migrate/20160815100820_add_secondary_to_notches_scopes.rb
 - lib/notches.rb
 - lib/notches/engine.rb
 - lib/notches/version.rb