goalkeeper 0.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 151b87201e8fbaa657d6aad6ef7aed33f8bf328a
-  data.tar.gz: 5a2b70b08cc0aa919d13cd3283300240d1895cdc
+  metadata.gz: 131ffcb82da5ac820f63710b94d5139cf249bc9d
+  data.tar.gz: d0ccd33c05701a7b3c5bb669008eb5bea1eedf32
 SHA512:
-  metadata.gz: 2bb9d5d7819f6f778525ce4d1fbb638ac986f4a3644b26c306e07292396d8207adbb9499421fd33ce5f17034f03dc71c97cb3e893be537b3e761af16da1b3270
-  data.tar.gz: 55e43ca0fe7926ef24984da40b29f82af3dd8e9ff48d111b01e932e130a73dc9379ec16b59044d2802b6d1bdaf3bdbd016fde60bef2863cb0f65f8ac85c4dccd
+  metadata.gz: ced9ac47bf52311689d02ded1b17c59067c9bd55906de495f53a4c3a59cf7242b8b3dce7f0eafb662326c6c8c3ab050d5377718dad07d95c221704fc4e2953d3
+  data.tar.gz: 928f802e2557c64bb046e9eec2769e66c9d4f075d34fc6b8b202111cd7b703693dfa4ac44e2bea08966ab2af33bc543e2a8172c0de9f397e5a60a84c761fc332

data/.gitignore

@@ -11,4 +11,6 @@
 *.so
 *.o
 *.a
+*.gem
 mkmf.log
+

data/README.md

@@ -5,8 +5,7 @@ Goalkeeper is a simple system for tracking if system wide requirements have been
 An example usage would be validating if each customer was sent a daily report.
 
 
-
-## Installation
+##### Installation
 
 Add this line to your application's Gemfile:
 
@@ -24,7 +23,34 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+### Goal
+| method     | description                                                | example                                  |
+| --------   | ------                                                     | -----                                    |
+| new(label) | Creates a new Goal with the unique label                   | `g = Goal.new('process')`                |
+| met?       | Returns true if the Goal has been met                      | `g.met? #=> false`                       |
+| met!       | Marks the goal as completed with a timestamp               | `g.met! #=> Time.now`                    |
+| met\_at    | Nil if unmet, otherwise returns the time the Goal was met. | `g.met_at #=> 2015-02-09 22:24:07 -0500` |
+| ttl        | The Redis ttl value if there is a record for the goal.     | `g.ttl #=> 86400`                       |
+| key        | The key used to store the record in Redis.                 | `g.key #=> "Goalkeeper:process"`         |
+| clear!     | Deletes the `met` record.  Goal is now unmet.              | `g.clear!`                               |
+
+
+### Set
+| method     | description                                                             | example                                  |
+| --------   | ------                                                                  | -----                                    |
+| new        | creates an empty set of goals.                                          | `s = set.new`                            |
+| add(label) | Adds a new Goal the Set. _chainable_                                    | `s.add('process.a').add('process.b')`    |
+| met?       | Returns true if _all_ the Set's Goals have been met.                    | `s.met? #=> false`                       |
+| met!       | Calls `met!` on all Goals.                                              | `s.met! #=> Time.now`                    |
+| met\_at    | Returns the most recent met_at for the Set's Goals. Nil if no Goal met. | `s.met_at #=> 2015-02-09 22:24:07 -0500` |
+| clear!     | Calls `clear!` on all Goals.                                            | `s.clear!`                               |
+| met        | Returns a new Set with all Goals which have been met.                   | `s.met #=> Set(...)`                     |
+| unmet      | Returns a new Set with all Goals which have not been met.               | `s.unmet` #=> Set(...)                   |
+
+### Goalkeeper
+| method        | description                          | example |
+| --------      | ------                               | -----   |
+| ::met!(label) | Creates a new Goal and marks it met. | `Goalkeeper.met!('process') #=> <Goalkeepr::Goal>`
 
 ## Contributing
 

data/Rakefile

@@ -5,6 +5,6 @@ task default: [:test]
 
 Rake::TestTask.new do |t|
   t.libs << 'test'
-  t.pattern = "test/*_test.rb"
+  t.pattern = "test/**/*_test.rb"
 end
 

data/lib/goalkeeper.rb

@@ -1,27 +1,64 @@
-require "goalkeeper/version"
 require 'forwardable'
 require 'redis'
 require 'time' # for Time.parse
 
-# Goalkeeper provides methods to track if specific events(Goals) have been completed(met).
+# Goalkeeper provides methods to track if specific events(Goals) have been
+# completed(met).
 #
-# It is not a complicated system and it is easy enough to roll your own.  This
-# is an extraction from a system Pharos EI has been using.
+# Its goes likes this..
+#    
+# Lets ensure we wakeup New Years Day 2020.  The goal will be called 'wakeup:2020-01-01'
+#   g = Goalkeeper::Goal.new('wakeup:2020-01-01')
+#   g.met? #=> false
 #
-# A Goal is just a unique string. It is up to your application to
-# define any schema for the Goal's label.
+# Time flies... it is New Years Day 2020.
+#   g.met! # or Goalkeeper.met!('wakeup:2020-01-01')
+#   g.met? #=> true
+#   g.met_at #=> 2020-01-01 05:01:31 -0500
 #
-# For example you might have your Goals labeled by date and company id:
-#   "job:2016-01-17:company:7"
+# Now if our application checks our goal, it will be met.
+#   Goalkeeper::Goal.new('wakeup:2020-01-01').met? #=> true
+#   Goalkeeper.met?('wakeup:2020-01-01') #=> true
+#   
+# Note: Once a Goal is 'met' the 'met_at' timestamp will not change, unless
+# 'clear!' is called.
 #
-# When a Goal is met a record is created in Redis with a timestamp, this is the only
-# persistent layer.
-#   Goalkeeper.met!("jobkey")
-#   # or
-#   Goalkeeper::Goal.new("jobkey").met!
+# We are probably only interested in this goal being complete for a limited
+# time, so it will expire and be removed from Redis.
+#   g.ttl #=> 86400 (1 day)
 #
-# To check if a Goal as been met
-#   Goalkeeper::Goal.new("jobkey").met?
+# If you need to reference the Redis key
+#   g.key #=> Goalkeeper:wakeup:2020-01-01
+#
+# Finally clear the Goal is simple
+#   g.clear!
+#
+# === Sets
+#
+# Perhaps you have a series of Goals you want to track, and see if they all have been met, or not.
+#
+#   set = Goalkeeper::Set.new
+#   set.add('goal1').add('goal2')
+#   set.met? #=> false
+#
+# Lets have 1 goal met:
+#   Goalkeeper.met!('goal1')
+#
+# But our set is not met yet
+#   set.met? #=> false
+#
+# See which goals are met, or unmet
+#   set.met #=> [#<Goalkeeper::Goal @label="goal1">]
+#   set.unmet #=> [#<Goalkeeper::Goal @label="goal2">]
+#
+# Lets complete our set.
+#   Goalkeeper.met!('goal1')
+#   set.met? #=> true
+#
+# See the time the final goal was met
+#   set.met_at #=> 2015-01-01 08:02:15 -0500
+#
+# === Customization
 #
 # Customize the redis client by setting it in your application
 #   Goalkeeper.redis = your_redis_client
@@ -29,11 +66,14 @@ require 'time' # for Time.parse
 # Each record has a default expiration of 24 hours, but this can be modified.
 #   Goalkeeper.expiration = number_of_seconds
 #
-# Redis keys are stored under the default namespace of "Goalkeeper:". The namespace can be configured:
-#
+# Redis keys are stored under the default namespace of "Goalkeeper:". The
+# namespace can be configured:
 #   Goalkeeper.namespace = string
 #
-class Goalkeeper
+module Goalkeeper
+  require "goalkeeper/version"
+  require "goalkeeper/goal"
+  require "goalkeeper/set"
 
   # Set the Redis client to a non default setting
   def self.redis=(redis)
@@ -49,6 +89,10 @@ class Goalkeeper
     Goal.new(label).met!
   end
 
+  def self.met?(label)
+    Goal.new(label).met?
+  end
+
   # The TTL set for each met Goal record created in Redis
   # Default is 24 hours
   def self.expiration
@@ -67,118 +111,4 @@ class Goalkeeper
   def self.namespace=(ns)
     @namespace = ns
   end
-
-  # List is a collection of Goals to simplify tracking multiple goals.
-  #
-  # Create a new list
-  #   mylist = Goalkeeper::List.new
-  #
-  # Add Goals you want to check for completion
-  #   mylist.add("job1").add("job2")
-  #   mylist.size
-  #   #=> 2
-  #
-  # Check if all the goals are completed
-  #   mylist.met?
-  #   #=> false
-  #
-  # Get the unmet Goals
-  #   mylist.unmet
-  #   #=> [...]
-  #
-  # Get the met Goals
-  #   mylist.met
-  #   #=> [...]
-  #
-  # Iterate all Goals
-  #   myslist.each {|goal| ...}
-  #   myslist.map  {|goal| ...}
-  class List
-    extend Forwardable
-    def_delegators :@list, :size, :[], :each, :map
-
-    def initialize
-      @list = []
-    end
-
-    # Creates a new Goal.
-    # see Goal#new for usage
-    def add(label, ref: nil)
-      @list.push(Goal.new(label, ref: ref))
-      self
-    end
-
-    # met? returns true if all Goals in the set have been met.
-    def met?
-      unmet.empty?
-    end
-
-    def unmet
-      @list.select {|g| ! g.met?}
-    end
-
-    def met
-      @list.select {|g| g.met?}
-    end
-  end
-
-  class Goal
-    # The unique label to identify this Goal
-    attr_reader :label
-
-    # An optional object refrence which allows an application author to
-    # associate this goal to an object. The +ref+ is not used by Goalkeeper.
-    attr_reader :ref
-
-    # the TTL value for the Redis record.  Defalts to Goalkeeper.expiration
-    attr_reader :expiration
-
-    # +label+ is a unique string to identify this Goal.
-    # There is no checking if it is truly unique.
-    #
-    # +ref+ is an optional reference to any object.  This
-    # would be used by the end user's application.
-    #
-    # +expiration+ can be set to override the gobal expiratin.
-    def initialize(label, ref: nil, expiration: Goalkeeper.expiration)
-      @label = label
-      @ref = ref
-      @expiration = expiration
-    end
-
-    def met!
-      write
-      self
-    end
-
-    def met?
-      ! read.nil?
-    end
-
-    # Time the goal was completed.
-    # WARNING retuns nil if the job is not met
-    def met_at
-      if met?
-        Time.parse(read)
-      else
-        nil
-      end
-    end
-
-    # a namespaced key for the goal
-    def key
-      "#{Goalkeeper.namespace}:#{label}"
-    end
-
-    protected
-
-    def write
-      Goalkeeper.redis.set(self.key, Time.now)
-      Goalkeeper.redis.expire(self.key, self.expiration)
-    end
-
-    def read
-      Goalkeeper.redis.get self.key
-    end
-  end
 end

data/lib/goalkeeper/goal.rb

@@ -0,0 +1,66 @@
+module Goalkeeper
+  # Goal represents a label which has either been +met+ or not.
+  # 
+  class Goal
+    # The unique label to identify this Goal. There is no logic to check that the
+    # label is unique.
+    attr_reader :label
+
+    # the TTL value for the Redis record.  Defalts to Goalkeeper.expiration
+    attr_reader :expiration
+
+    # +label+ is a unique string to identify this Goal.
+    # +expiration+ number secconds. This can be set to override the gobal expiration.
+    def initialize(label, expiration: Goalkeeper.expiration)
+      @label = label
+      @expiration = expiration
+    end
+
+    def met!
+      write unless met?
+      self
+    end
+
+    def met?
+      !read.nil?
+    end
+
+    # Time the goal was completed.
+    # WARNING retuns nil if the job is not met
+    def met_at
+      return Time.parse(read) if met?
+      nil
+    end
+
+    # clear! removes the met state of the Goal.
+    def clear!
+      Goalkeeper.redis.del(key)
+    end
+
+    # a namespaced key for the goal
+    def key
+      "#{Goalkeeper.namespace}:#{label}"
+    end
+
+    # ttl returns the time to live on the redis key
+    def ttl
+      Goalkeeper.redis.ttl(key)
+    end
+
+    # All Goalkeeper::Goals with the same label are equal
+    def ==(other)
+      other.is_a?(Goalkeeper::Goal) && other.label == label
+    end
+
+    protected
+
+    def write
+      Goalkeeper.redis.set(key, Time.now)
+      Goalkeeper.redis.expire(key, expiration)
+    end
+
+    def read
+      Goalkeeper.redis.get(key)
+    end
+  end
+end

data/lib/goalkeeper/set.rb

@@ -0,0 +1,87 @@
+module Goalkeeper
+  # Set is an Array of Goals to simplify tracking multiple goals.
+  # Since Set is an array, you have all Array methods available.
+  #
+  # Create a new set
+  #   myset = Goalkeeper::Set.new
+  #
+  # Add Goals you want to check for completion
+  #   myset.add("job1").add("job2")
+  #   myset.size
+  #   #=> 2
+  #
+  # Check if all the goals are completed
+  #   myset.met?
+  #   #=> false
+  #
+  # Get the unmet Goals
+  #   myset.unmet
+  #   #=> [...]
+  #
+  # Get the met Goals
+  #   myset.met
+  #   #=> [...]
+  #
+  # Iterate all Goals
+  #   myset.each {|goal| ...}
+  #   myset.map  {|goal| ...}
+  class Set < Array
+    def initialize
+      super
+    end
+
+    # Creates a new Goal.
+    # see Goal#initialize for usage
+    def add(*args)
+      push(Goal.new(*args))
+      self
+    end
+
+    # met? returns true if all Goals in the set have been met.
+    def met?
+      unmet.empty?
+    end
+
+    # unmet returns a Set with the all the Goals that have not been met.
+    def unmet
+      subset(select { |g| !g.met? })
+    end
+
+    # met returns a Set with the all the Goals that have been met.
+    def met
+      subset(select { |g| g.met? })
+    end
+
+    # nil if this set is not met?
+    # otherwise returns the met_at Time for the last met goal
+    def met_at
+      if met?
+        self.map(&:met_at).sort.last
+      else
+        nil
+      end
+    end
+
+    def <<(other)
+      if other.is_a?(Goal) && !include?(other)
+        super 
+      else
+        false
+      end
+    end
+
+    def push(*others)
+      others.each do |o|
+        self << o
+      end
+    end
+
+    protected
+
+    def subset(set)
+      Goalkeeper::Set.new.tap do |s|
+        set.each {|i| s << i}
+      end
+    end
+  end
+end

data/lib/goalkeeper/version.rb

@@ -1,3 +1,3 @@
-class Goalkeeper
-  VERSION = "0.2"
+module Goalkeeper
+  VERSION = "0.3.0"
 end

data/test/goalkeeper/goal_test.rb

@@ -0,0 +1,103 @@
+require 'test_helper'
+
+describe Goalkeeper::Goal do
+  before do
+    Goalkeeper.redis.flushdb
+  end
+
+  let(:goal) { Goalkeeper::Goal.new("test") }
+
+  it "has a label" do
+    assert_equal "test", goal.label
+  end
+
+  it "has a namespaced key" do
+    assert_equal "Goalkeeper:test", goal.key
+  end
+
+  it "is met? if the label has a Redis record" do
+    assert !goal.met?
+    Goalkeeper.redis.set goal.key, Time.now
+    assert goal.met?
+  end
+
+  describe "met_at" do
+    it "is nil if the Goal is not met" do
+      assert_equal nil, goal.met_at
+    end
+
+    it "is the timestamp that the Goal was met" do
+      @t = Time.parse(Time.now.to_s)
+      goal.met!
+      assert_equal @t, goal.met_at
+    end
+  end
+
+  describe "#met!" do
+    it "creates a timestamp record with the Goal's key" do
+      Time.stub(:now, 'timestamp') do
+        assert_equal nil, Goalkeeper.redis.get(goal.key)
+        goal.met!
+        assert_equal 'timestamp', Goalkeeper.redis.get(goal.key)
+      end
+    end
+
+    it "has a default ttl expiration" do
+      goal.met!
+      assert_equal goal.expiration, Goalkeeper.redis.ttl(goal.key)
+    end
+
+    it "does nothing if the goal is already met" do
+      t = Time.now
+      Time.stub(:now, t) do
+        goal.met!
+        assert_equal Time.parse(t.to_s), goal.met_at
+      end
+
+      Time.stub(:now, t + 1000) do
+        goal.met!
+        assert_equal Time.parse(t.to_s), goal.met_at
+      end
+    end
+  end
+
+  describe "#clear!" do
+    it "removes the met state of the Goal" do
+      goal.met!
+      assert_equal true, goal.met?
+      goal.clear!
+      assert_equal false, goal.met?
+    end
+  end
+
+  describe "#expiration" do
+    it "has a default of 24 hours" do
+      assert_equal 24 * 60 * 60, goal.expiration
+    end
+
+    it "can be set at initialization" do
+      g = Goalkeeper::Goal.new("x", expiration: 60)
+      assert_equal 60, g.expiration
+    end
+  end
+
+  describe "equality" do
+    it "should be true when the labels are the same" do
+      a = Goalkeeper::Goal.new("a")
+      b = Goalkeeper::Goal.new("b")
+      a2 = Goalkeeper::Goal.new("a")
+
+      assert_equal a, a2
+      assert a != b
+    end
+  end
+
+  describe "#ttl" do
+    it "returns the ttl on the Redis record" do
+      a = Goalkeeper::Goal.new("a")
+      assert_equal(-2, a.ttl)
+      a.met!
+      assert_equal Goalkeeper.expiration, a.ttl
+    end
+  end
+end

data/test/goalkeeper/set_test.rb

@@ -0,0 +1,104 @@
+require 'test_helper'
+
+describe Goalkeeper::Set do
+  before do
+    Goalkeeper.redis.flushdb
+  end
+
+  let(:goals) { Goalkeeper::Set.new }
+
+  describe "#add" do
+    it "creates a Goal from the label" do
+      goals.add("a:1")
+      assert_equal 1, goals.size
+      assert_equal "a:1", goals[0].label
+    end
+
+    it "accepts an option expiration" do
+      goals.add("a:1", expiration: 20)
+      assert_equal 20, goals.first.expiration
+    end
+
+    it "should return itself (so it is chainable)" do
+      assert_equal goals, goals.add("a:1")
+    end
+  end
+
+  it "behaves as a unique set" do
+    goals << Goalkeeper::Goal.new("a")
+    goals << Goalkeeper::Goal.new("b")
+    goals << Goalkeeper::Goal.new("a")
+    goals.push Goalkeeper::Goal.new("a")
+
+    assert_equal 2, goals.size
+  end
+
+  it "ignores insertion of nonGoals" do
+    goals << "a"
+    goals.push 1, 2, :a
+    assert_equal 0, goals.size
+  end
+
+  describe "with goals" do
+    before do
+      goals.add("x").add("y")
+    end
+
+    describe "#met" do
+      it "returns all Goals which have been met" do
+        assert goals.met.empty?
+        goals[0].met!
+        assert_equal ["x"], goals.met.map(&:label)
+        goals[1].met!
+        assert_equal(%w( x y ), goals.met.map(&:label))
+
+        assert goals.met.is_a?(Goalkeeper::Set)
+      end
+    end
+
+    describe "#unmet" do
+      it "returns all Goals which have not been met" do
+        assert_equal(%w( x y ), goals.unmet.map(&:label))
+        goals[0].met!
+        assert_equal ["y"], goals.unmet.map(&:label)
+        goals[1].met!
+        assert goals.unmet.empty?
+
+        assert goals.unmet.is_a?(Goalkeeper::Set)
+      end
+    end
+
+    describe "#met?" do
+      it "is true when all Goals have been met" do
+        assert !goals.met?
+        goals.each(&:met!)
+        assert goals.met?
+      end
+    end
+
+    describe "#met_at" do
+      before do
+        goals << Goalkeeper::Goal.new("a")
+        goals << Goalkeeper::Goal.new("b")
+        goals << Goalkeeper::Goal.new("a")
+      end
+
+      it "is nil unless all Goals are met" do
+        goals[0].met!
+        goals[1].met!
+        assert_equal nil, goals.met_at
+      end
+
+      it "is the most recent met_at from the Goals" do
+        t = Time.now
+        Time.stub(:now, t + 1000) do
+          goals.first.met!
+        end
+        # meet the reset
+        goals.each &:met!
+
+        assert_equal((t + 1000).to_a, goals.met_at.to_a)
+      end
+    end
+  end
+end

data/test/goalkeeper_test.rb

@@ -28,118 +28,4 @@ describe Goalkeeper do
       Goalkeeper.namespace = ns
     end
   end
-
-  describe Goalkeeper::List do
-    before do
-      @goals = Goalkeeper::List.new
-    end
-
-    describe "#add" do
-      it "creates a Goal" do
-        @goals.add("a:1")
-        assert_equal 1, @goals.size
-        assert_equal "a:1", @goals[0].label
-      end
-
-      it "accepts an optional reference object" do
-        o = Object.new
-        @goals.add("a:1", ref: o)
-        assert_equal o, @goals[0].ref
-      end
-
-      it "should return itself (so it is chainable)" do
-        assert_equal @goals, @goals.add("a:1")
-      end
-    end
-
-    describe "with goals" do
-      before do
-        @goals.add("x").add("y")
-      end
-
-      describe "#met" do
-        it "returns all Goals which have been met" do
-          assert @goals.met.empty?
-          @goals[0].met!
-          assert_equal ["x"], @goals.met.map(&:label)
-          @goals[1].met!
-          assert_equal ["x","y"], @goals.met.map(&:label)
-        end
-      end
-
-      describe "#unmet" do
-        it "returns all Goals which have not been met" do
-          assert_equal ["x","y"], @goals.unmet.map(&:label)
-          @goals[0].met!
-          assert_equal ["y"], @goals.unmet.map(&:label)
-          @goals[1].met!
-          assert @goals.unmet.empty?
-        end
-      end
-
-      describe "#met?" do
-        it "is true when all Goals have been met" do
-          assert ! @goals.met?
-          @goals.each(&:met!)
-          assert @goals.met?
-        end
-      end
-    end
-  end
-
-  describe Goalkeeper::Goal do
-    before do
-      @goal = Goalkeeper::Goal.new("b")
-    end
-
-    it "has a label" do
-      assert_equal "b", @goal.label
-    end
-
-    it "has a namespaced key" do
-      assert_equal "Goalkeeper:b", @goal.key
-    end
-
-    it "is met? if the label has a Redis record" do
-      assert ! @goal.met?
-      Goalkeeper.redis.set @goal.key, Time.now
-      assert @goal.met?
-    end
-
-    describe "met_at" do
-      it "is nil if the Goal is not met" do
-        assert_equal nil, @goal.met_at
-      end
-
-      it "is the timestamp that the Goal was met" do
-        @t = Time.parse(Time.now.to_s)
-        @goal.met!
-        assert_equal @t, @goal.met_at
-      end
-    end
-
-    describe "#met!" do
-      it "creates a Redis record" do
-        assert Goalkeeper.redis.get(@goal.key).nil?
-        @goal.met!
-        assert ! Goalkeeper.redis.get(@goal.key).nil?
-      end
-
-      it "has a default ttl expiration" do
-        @goal.met!
-        assert_equal @goal.expiration, Goalkeeper.redis.ttl(@goal.key) 
-      end
-    end
-
-    describe "#expiration" do
-      it "has a default of 24 hours" do
-        assert_equal 24 * 60 * 60, @goal.expiration
-      end
-
-      it "can be set at initialization" do
-        g = Goalkeeper::Goal.new("x", expiration: 60)
-        assert_equal 60, g.expiration
-      end
-    end
-  end
 end

data/test/test_helper.rb

@@ -1,11 +1,8 @@
 require 'minitest/unit'
 require 'minitest/autorun'
 require 'minitest/pride'
-
 require './lib/goalkeeper'
-
 require './test/support/redis_instance'
 
 # Start up Redis on a random port
 Goalkeeper.redis = RedisInstance.run!
-

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: goalkeeper
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: 0.3.0
 platform: ruby
 authors:
 - John Weir
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-04 00:00:00.000000000 Z
+date: 2015-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -63,12 +63,15 @@ files:
 - ".gitignore"
 - Gemfile
 - LICENSE
-- LICENSE.txt
 - README.md
 - Rakefile
 - goalkeeper.gemspec
 - lib/goalkeeper.rb
+- lib/goalkeeper/goal.rb
+- lib/goalkeeper/set.rb
 - lib/goalkeeper/version.rb
+- test/goalkeeper/goal_test.rb
+- test/goalkeeper/set_test.rb
 - test/goalkeeper_test.rb
 - test/support/redis_instance.rb
 - test/test_helper.rb
@@ -97,6 +100,8 @@ signing_key:
 specification_version: 4
 summary: A Todo App for your application.
 test_files:
+- test/goalkeeper/goal_test.rb
+- test/goalkeeper/set_test.rb
 - test/goalkeeper_test.rb
 - test/support/redis_instance.rb
 - test/test_helper.rb

data/LICENSE.txt

@@ -1,22 +0,0 @@
-Copyright (c) 2015 John Weir
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.