slot_machine 0.1.0 → 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b1284fee79db641ca71f72ab2e27cb60ddcaa746
+  data.tar.gz: 31bde868b4da37d7212774fcf38fffb8c8a8c2a1
+SHA512:
+  metadata.gz: 59638a38e444e119286deff086c8b946e8c8f33af5858995bba77c0837faa3aebaab4b74a58f30a74072d1a774f182e8077c7737ebf6de475d7d469f7052c69c
+  data.tar.gz: d149fba61a6c0edde6952ddb408bdd275a59738deb31925fe8eaad74cce2a9bf3bc897d4670a55d2b53076f11288cbeed03d95904f5a14ac3e67fa8e92a5b347

data/CHANGELOG.rdoc

@@ -1,5 +1,13 @@
 = SlotMachine CHANGELOG
 
+== Version 0.1.1 (July 10, 2013)
+
+* Introduced SlotMachine::Slots (also Slots and TimeSlots) for addition and subtraction of slots
+* Being able to match available slots within slots
+* Merging ranges on initialization of a slots instance
+* Accepting Time objects within TimeSlot
+* Improved Bundler setup
+
 == Version 0.1.0 (September 16, 2012)
 
 * Initial release

data/Gemfile

@@ -1,18 +1,7 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 
 gemspec
 
-group :gem_default do
-  gem "slot_machine", :path => "."
-end
-
-group :gem_development do
-  gem "pry"
-end
-
-group :gem_test do
-  gem "minitest"
-  gem "mocha"
+group :console do
   gem "pry"
-  gem "rake"
 end

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Paul Engel
+Copyright (c) 2013 Paul Engel
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -127,7 +127,7 @@ Well that's about it! Pretty straightforward, right? Have fun playing with the `
 
 ## TODO
 
-* Accept Time objects within TimeSlot
+* Update documentation regarding Slots, TimeSlots and Time objects
 
 ## Contact me
 
@@ -135,7 +135,7 @@ For support, remarks and requests, please mail me at [paul.engel@holder.nl](mail
 
 ## License
 
-Copyright (c) 2012 Paul Engel, released under the MIT license
+Copyright (c) 2013 Paul Engel, released under the MIT license
 
 [http://holder.nl](http://holder.nl) - [http://codehero.es](http://codehero.es) - [http://gettopup.com](http://gettopup.com) - [http://github.com/archan937](http://github.com/archan937) - [http://twitter.com/archan937](http://twitter.com/archan937) - [paul.engel@holder.nl](mailto:paul.engel@holder.nl)
 

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.1.1

data/lib/slot_machine.rb

@@ -1,4 +1,9 @@
-require "slot_machine/slot"
 require "slot_machine/version"
+require "slot_machine/slot"
+require "slot_machine/slots"
+
 require "slot"
-require "time_slot"
+require "slots"
+
+require "time_slot"
+require "time_slots"

data/lib/slot_machine/slot.rb

@@ -12,6 +12,12 @@ module SlotMachine
         def self.default_interval
           @interval || 10
         end
+
+        def self.slots_class
+          @slots_class ||= "#{name}s".split("::").inject(Object) do |mod, name|
+            mod.const_get name
+          end
+        end
       end
     end
 
@@ -55,6 +61,14 @@ module SlotMachine
       match_compared to_compared, other.to_compared, interval
     end
 
+    def +(other)
+      self.class.slots_class.new(self) + other
+    end
+
+    def -(other)
+      self.class.slots_class.new(self) - other
+    end
+
     def ==(other)
       self.class == other.class && self.start == other.start && self.end == other.end && self.length == other.length
     end
@@ -72,6 +86,10 @@ module SlotMachine
 
   protected
 
+    def typecast(value)
+      value.to_s
+    end
+
     def valid?(value)
       true
     end
@@ -125,7 +143,7 @@ module SlotMachine
     end
 
     def typecast!(value, operator, compared)
-      Integer(value.to_s).tap do |value|
+      Integer(typecast(value)).tap do |value|
         raise ArgumentError, "Passed value should be #{operator} #{compared} (#{value} given)" if compared && !value.send(operator, compared)
       end
     end

data/lib/slot_machine/slots.rb

@@ -0,0 +1,130 @@
+module SlotMachine
+  module Slots
+
+    def self.included(base)
+      base.class_eval do
+        def self.slot_class
+          @slot_class ||= name.gsub(/s$/, "").split("::").inject(Object) do |mod, name|
+            mod.const_get name
+          end
+        end
+      end
+    end
+
+    def initialize(*ranges_or_range_slots)
+      @range_slots = to_range_slots(add(ranges_or_range_slots.flatten))
+    end
+
+    def range_slots
+      @range_slots || []
+    end
+
+    def match(other, interval = nil)
+      range_slots.collect{|range_slot| range_slot.match other, interval}.flatten.uniq
+    end
+
+    def +(other)
+      unless other.is_a?(Range) || other.is_a?(Array) || other.class == self.class.slot_class || other.class == self.class
+        raise ArgumentError, "Either subtract a Range, an Array, #{self.class.slot_class.name} or #{self.class.name} instance (#{other.class.name} given)"
+      end
+      self.class.new add(other)
+    end
+
+    def -(other)
+      unless other.is_a?(Range) || other.is_a?(Array) || other.class == self.class.slot_class || other.class == self.class
+        raise ArgumentError, "Either subtract a Range, an Array, #{self.class.slot_class.name} or #{self.class.name} instance (#{other.class.name} given)"
+      end
+      self.class.new subtract(other)
+    end
+
+    def ==(other)
+      ((self.class == other.class) || (other_is_an_array = other.is_a?(Array))) && begin
+        range_slots.size == (other_range_slots = other_is_an_array ? other : other.range_slots).size && begin
+          range_slots.each_with_index do |range_slot, index|
+            return false unless range_slot == other_range_slots[index]
+          end
+          true
+        end
+      end
+    end
+
+  private
+
+    def to_range_slots(ranges_or_range_slots)
+      ranges_or_range_slots.flatten.collect do |range_or_range_slot|
+        if range_or_range_slot.class == self.class.slot_class
+          range_or_range_slot
+        elsif range_or_range_slot.is_a?(Range)
+          self.class.slot_class.new range_or_range_slot
+        else
+          raise ArgumentError
+        end
+      end.sort do |a, b|
+        [a.start, a.end] <=> [b.start, b.end]
+      end
+    end
+
+    def to_ranges(object)
+      begin
+        if object.is_a?(Range) || object.class == self.class.slot_class
+          [object]
+        elsif object.class == self.class
+          object.range_slots
+        else
+          object
+        end
+      end.collect do |entry|
+        if entry.class == self.class.slot_class
+          entry.start..entry.end
+        elsif entry.is_a?(Range)
+          entry
+        else
+          raise ArgumentError
+        end
+      end
+    end
+
+    def add(other)
+      *merged_ranges = (ranges = to_ranges(self).concat(to_ranges(other)).sort{|a, b| [a.first, a.last] <=> [b.first, b.last]}).shift
+      ranges.each do |range|
+        last_range = merged_ranges[-1]
+        if last_range.last >= range.first - 1
+          merged_ranges[-1] = last_range.first..[range.last, last_range.last].max
+        else
+          merged_ranges.push range
+        end
+      end
+      merged_ranges
+    end
+
+    def subtract(other)
+      divided_ranges = to_ranges(self)
+      to_ranges(other).each do |range|
+        divided_ranges = divided_ranges.collect do |divided_range|
+          if range.first <= divided_range.first && range.last > divided_range.first && range.last < divided_range.last
+            # | range |
+            #     | divided_range |
+            range.last..divided_range.last
+          elsif range.first > divided_range.first && range.first < divided_range.last && range.last >= divided_range.last
+            #             | range |
+            # | divided_range |
+            divided_range.first..range.first
+          elsif range.first > divided_range.first && range.last < divided_range.last
+            #     | range |
+            # | divided_range |
+            [divided_range.first..range.first, range.last..divided_range.last]
+          elsif range.last <= divided_range.first || range.first >= divided_range.last
+            # | range |
+            #           | divided_range |
+            # or
+            #                   | range |
+            # | divided_range |
+            divided_range
+          end
+        end.flatten.compact
+      end
+      divided_ranges
+    end
+
+  end
+end

data/lib/slot_machine/version.rb

@@ -1,7 +1,7 @@
 module SlotMachine #:nodoc:
   MAJOR = 0
   MINOR = 1
-  TINY  = 0
+  TINY  = 1
 
   VERSION = [MAJOR, MINOR, TINY].join(".")
 end

data/lib/slots.rb

@@ -0,0 +1,3 @@
+class Slots
+  include SlotMachine::Slots
+end

data/lib/time_slot.rb

@@ -7,6 +7,10 @@ class TimeSlot
 
 protected
 
+  def typecast(value)
+    value.is_a?(Time) ? value.strftime("%Y%m%d%H%M") : value.to_s
+  end
+
   def valid?(value)
     (value - (100 * (value / 100))) < 60
   end

data/lib/time_slots.rb

@@ -0,0 +1,3 @@
+class TimeSlots
+  include SlotMachine::Slots
+end

data/script/console

@@ -1,10 +1,7 @@
 #!/usr/bin/env ruby
 
-require "rubygems"
 require "bundler"
-
-Bundler.require :gem_default, :gem_development
+Bundler.require :default, :console
 
 puts "Loading development environment (SlotMachine #{SlotMachine::VERSION})"
-
 Pry.start

data/slot_machine.gemspec

@@ -1,4 +1,5 @@
 # -*- encoding: utf-8 -*-
+require File.expand_path("../lib/slot_machine/version", __FILE__)
 
 Gem::Specification.new do |gem|
   gem.authors       = ["Paul Engel"]
@@ -12,5 +13,8 @@ Gem::Specification.new do |gem|
   gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   gem.name          = "slot_machine"
   gem.require_paths = ["lib"]
-  gem.version       = "0.1.0"
+  gem.version       = SlotMachine::VERSION
+
+  gem.add_development_dependency "minitest", "4.6.2"
+  gem.add_development_dependency "mocha", "0.13.2"
 end

data/test/test_helper.rb

@@ -1,7 +1,6 @@
-require "rubygems"
-require "bundler"
+$:.unshift File.expand_path("../../lib", __FILE__)
 
 require "minitest/unit"
 require "minitest/autorun"
-
-Bundler.require :gem_default, :gem_test
+require "mocha/setup"
+require "slot_machine"

data/test/unit/test_slot.rb

@@ -14,6 +14,11 @@ module Unit
             interval 20
           end
           assert_equal 20, Slot.default_interval
+
+          Slot.class_eval do
+            interval 10
+          end
+          assert_equal 10, Slot.default_interval
         end
       end
 
@@ -28,8 +33,10 @@ module Unit
           assert slot.respond_to?(:end=)
           assert slot.respond_to?(:length)
           assert slot.respond_to?(:length=)
-          assert slot.respond_to?(:to_compared)
+          assert slot.respond_to?(:to_compared, true)
           assert slot.respond_to?(:match)
+          assert slot.respond_to?(:+)
+          assert slot.respond_to?(:-)
         end
       end
 
@@ -75,7 +82,7 @@ module Unit
       end
 
       describe "equality" do
-        it "should return whether it equals another objects" do
+        it "should return whether it equals another object" do
           slot = Slot.new 1
 
           assert !(slot == 1)
@@ -190,6 +197,20 @@ module Unit
             Slot.new(5).match(5)
           end
         end
+
+        it "should be able to add other slots" do
+          assert_equal Slots, (Slot.new(1..10) + (5..8)).class
+          assert_equal Slots, (Slot.new(1..10) + Slot.new(5..8)).class
+          assert_equal Slots, (Slot.new(1..10) + [5..8]).class
+          assert_equal Slots, (Slot.new(1..10) + Slots.new([5..8])).class
+        end
+
+        it "should be able to subtract other slots" do
+          assert_equal Slots, (Slot.new(1..10) - (5..8)).class
+          assert_equal Slots, (Slot.new(1..10) - Slot.new(5..8)).class
+          assert_equal Slots, (Slot.new(1..10) - [5..8]).class
+          assert_equal Slots, (Slot.new(1..10) - Slots.new([5..8])).class
+        end
       end
 
       describe "length slots" do
@@ -233,5 +254,6 @@ module Unit
         end
       end
     end
+
   end
 end

data/test/unit/test_slots.rb

@@ -0,0 +1,117 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+module Unit
+  class TestSlots < MiniTest::Unit::TestCase
+
+    describe Slots do
+      describe "instance methods" do
+        it "should have the expected instance methods" do
+          slots = Slots.new 1..10
+          assert slots.respond_to?(:range_slots)
+        end
+      end
+
+      describe "initialization" do
+        it "should accept a range" do
+          slots = Slots.new 10..20
+          assert_equal [Slot.new(10..20)], slots.range_slots
+        end
+
+        it "should accept ranges" do
+          slots = Slots.new 10..20, Slot.new(30..40)
+          assert_equal [Slot.new(10..20), Slot.new(30..40)], slots.range_slots
+
+          slots = Slots.new 10..20, Slot.new(22..30)
+          assert_equal [Slot.new(10..20), Slot.new(22..30)], slots.range_slots
+        end
+
+        it "should merge slots on initialization" do
+          slots = Slots.new 10..20, 20..30
+          assert_equal [Slot.new(10..30)], slots.range_slots
+        end
+
+        it "should raise an exception when invalid" do
+          assert_raises ArgumentError do
+            Slots.new "bar"
+          end
+          assert_raises ArgumentError do
+            Slots.new 1.."bar"
+          end
+          assert_raises ArgumentError do
+            Slots.new "bar"..1
+          end
+          assert_raises ArgumentError do
+            Slots.new "slot".."bar"
+          end
+        end
+      end
+
+      describe "equality" do
+        it "should return whether it equals another object" do
+          slots = Slots.new 1..2, 3..4
+
+          assert !(slots == Slot.new(1..2))
+          assert !(slots == Slots.new(1..2, 3..5))
+
+          assert_equal slots, Slots.new(3..4, 1..2)
+          assert_equal slots, Slots.new(1..2, 3..4)
+          assert_equal slots, Slots.new([1..2, 3..4])
+          assert_equal slots, Slots.new(Slot.new(1..2), Slot.new(3..4))
+          assert_equal slots, [Slot.new(1..4)]
+        end
+      end
+
+      describe "calculations" do
+        it "should be able to add slots" do
+          slots = Slots.new 0..10
+
+          assert_equal Slots, (slots + (10..20)).class
+          assert_equal Slots, (slots + Slot.new(10..20)).class
+          assert_equal Slots, (slots + Slots.new(10..20)).class
+
+          assert_equal Slots.new(0..20), (slots + (10..20))
+          assert_equal Slots.new(0..10, 20..30), (slots + Slot.new(20..30))
+          assert_equal Slots.new(0..10, 20..30, 40..60), (slots + Slots.new(20..30, 40..50) + (45..60))
+
+          assert_equal Slots.new(0..15, 20..30), (((slots + (5..15)) + (20..25)) + (24..30))
+        end
+
+        it "should be able to subtract slots" do
+          slots = Slots.new 0..30
+
+          assert_equal Slots, (slots - (10..20)).class
+          assert_equal Slots, (slots - Slot.new(10..20)).class
+          assert_equal Slots, (slots - Slots.new(10..20)).class
+
+          assert_equal Slots.new(0..10, 20..30), (slots - (10..20))
+          assert_equal Slots.new(0..10, 20..30), (slots - Slot.new(10..20))
+          assert_equal Slots.new(0..10, 20..30), (slots - Slots.new(10..20, 30..40))
+
+          assert_equal Slots.new(0..5, 10..20, 25..30), (((slots - (20..25)) - (5..10)) - (20..22))
+        end
+
+        it "should be able to match available slots" do
+          slots = Slots.new(0..10, 15..40, 50..65)
+
+          assert_equal [
+            Slot.new(0..10),
+            Slot.new(15..25),
+            Slot.new(25..35),
+            Slot.new(50..60)
+          ], slots.match(10)
+
+          assert_equal [
+            Slot.new(0..10),
+            Slot.new(15..25),
+            Slot.new(20..30),
+            Slot.new(25..35),
+            Slot.new(30..40),
+            Slot.new(50..60),
+            Slot.new(55..65)
+          ], slots.match(10, 5)
+        end
+      end
+    end
+
+  end
+end

data/test/unit/test_time_slot.rb

@@ -1,5 +1,7 @@
 require File.expand_path("../../test_helper", __FILE__)
 
+require "time"
+
 module Unit
   class TestTimeSlot < MiniTest::Unit::TestCase
 
@@ -15,6 +17,17 @@ module Unit
         end
       end
 
+      it "should accept time objects" do
+        assert_equal [
+          198208010859,
+          198208010900,
+          198208010901,
+          198208010902,
+          198208010903,
+          198208010904
+        ], TimeSlot.new(Time.parse("1982-08-01 08:59")..Time.parse("1982-08-01 09:05")).send(:to_compared)
+      end
+
       it "should represent itself as an array when invoking to_compared" do
         assert_equal 10 , TimeSlot.new(855..905).send(:to_compared).size
         assert_equal 222, TimeSlot.new(955..1337).send(:to_compared).size
@@ -42,6 +55,13 @@ module Unit
           TimeSlot.new(1109..1149)
         ], time_slot.match(40, 18)
 
+        assert_equal [
+          TimeSlot.new(198208011015..198208011055),
+          TimeSlot.new(198208011033..198208011113),
+          TimeSlot.new(198208011051..198208011131),
+          TimeSlot.new(198208011109..198208011149)
+        ], TimeSlot.new(Time.parse("1982-08-01 10:15")..Time.parse("1982-08-01 12:00")).match(40, 18)
+
         assert_equal [], time_slot.match(945..1005)
         assert_equal [], time_slot.match(1205..1225)
         assert_equal [TimeSlot.new(1015..1200)], time_slot.match(1015..1200)

data/test/unit/test_time_slots.rb

@@ -0,0 +1,54 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+module Unit
+  class TestTimeSlots < MiniTest::Unit::TestCase
+
+    describe TimeSlots do
+      it "should merge slots on initialization" do
+        time_slots = TimeSlots.new 1015..1100, 1100..1115
+        assert_equal [TimeSlot.new(1015..1115)], time_slots.range_slots
+      end
+
+      it "should be able to add slots" do
+        time_slot = TimeSlot.new 1015..1100
+
+        assert_equal TimeSlots.new(1015..1130), (time_slot + (1055..1130))
+        assert_equal TimeSlots.new(1015..1130), (time_slot + TimeSlot.new(1055..1130))
+        assert_equal TimeSlots.new(1015..1130, 1145..1200), (time_slot + TimeSlots.new(1055..1130, 1145..1200))
+      end
+
+      it "should be able to subtract slots" do
+        time_slot = TimeSlot.new 1015..1100
+
+        assert_equal TimeSlots.new(1015..1030, 1045..1100), (time_slot - (1030..1045))
+        assert_equal TimeSlots.new(1015..1055), (time_slot - TimeSlot.new(1055..1130))
+        assert_equal TimeSlots.new(1015..1045, 1055..1100), (time_slot - TimeSlots.new(1045..1055, 1145..1200))
+      end
+
+      it "should be able to match available slots" do
+        time_slots = TimeSlots.new(1015..1100, 1230..1337)
+
+        assert_equal [
+          TimeSlot.new(1015..1035),
+          TimeSlot.new(1030..1050),
+          TimeSlot.new(1230..1250),
+          TimeSlot.new(1245..1305),
+          TimeSlot.new(1300..1320),
+          TimeSlot.new(1315..1335)
+        ], time_slots.match(20)
+
+        assert_equal [
+          TimeSlot.new(1015..1035),
+          TimeSlot.new(1025..1045),
+          TimeSlot.new(1035..1055),
+          TimeSlot.new(1230..1250),
+          TimeSlot.new(1240..1300),
+          TimeSlot.new(1250..1310),
+          TimeSlot.new(1300..1320),
+          TimeSlot.new(1310..1330)
+        ], time_slots.match(20, 10)
+      end
+    end
+
+  end
+end

metadata

@@ -1,33 +1,53 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: slot_machine
-version: !ruby/object:Gem::Version 
-  hash: 27
-  prerelease: 
-  segments: 
-  - 0
-  - 1
-  - 0
-  version: 0.1.0
+version: !ruby/object:Gem::Version
+  version: 0.1.1
 platform: ruby
-authors: 
+authors:
 - Paul Engel
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-09-15 00:00:00 Z
-dependencies: []
-
-description: One of the classic programming problems is the determination of time slot availability. Very often this is used within scheduling / calendar programs. SlotMachine is a very small Ruby gem which can do the job for you. It does not only focuses on time slots, but also slots in general.
-email: 
+date: 2013-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.6.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 4.6.2
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.13.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.13.2
+description: One of the classic programming problems is the determination of time
+  slot availability. Very often this is used within scheduling / calendar programs.
+  SlotMachine is a very small Ruby gem which can do the job for you. It does not only
+  focuses on time slots, but also slots in general.
+email:
 - paul.engel@holder.nl
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - .travis.yml
 - CHANGELOG.rdoc
@@ -39,47 +59,44 @@ files:
 - lib/slot.rb
 - lib/slot_machine.rb
 - lib/slot_machine/slot.rb
+- lib/slot_machine/slots.rb
 - lib/slot_machine/version.rb
+- lib/slots.rb
 - lib/time_slot.rb
+- lib/time_slots.rb
 - script/console
 - slot_machine.gemspec
 - test/test_helper.rb
 - test/unit/test_slot.rb
+- test/unit/test_slots.rb
 - test/unit/test_time_slot.rb
+- test/unit/test_time_slots.rb
 homepage: https://github.com/archan937/slot_machine
 licenses: []
-
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Ruby gem for matching available slots (time slots are also supported)
-test_files: 
+test_files:
 - test/test_helper.rb
 - test/unit/test_slot.rb
+- test/unit/test_slots.rb
 - test/unit/test_time_slot.rb
+- test/unit/test_time_slots.rb