tooled 0.0.2

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.irbrc

@@ -0,0 +1,9 @@
+$:.unshift Dir.pwd
+
+require 'rubygems'
+
+require 'bundler'
+Bundler.require
+
+$:.unshift File.join(Dir.pwd, 'lib')
+require 'tooled'

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tooled.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Darren Coxall
+
+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.

data/README.md

@@ -0,0 +1,31 @@
+# Tooled
+
+Small, tested, independant classes that can be used to help keep ruby code clean and simple by avoiding the over-use of `Hash` and making use of commonly ignored features such as implementing the arithmetic methods (`+`, `-`, `/`, `*`).
+
+I started this gem as I enjoy writting underlying classes and implementing many of the libraries I have enjoyed from other languages and tools.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'tooled'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tooled
+
+## Usage
+
+Usage is as simple as installing the gem and then using the classes in your own code.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/tooled/publisher.rb

@@ -0,0 +1,120 @@
+##
+#   Publisher provides a barebones implementation to a pub-sub system.
+#
+#   By including the Publisher into any class you can then regsiter events
+#   and wrap blocks in `with_event` which will then broadcast the event to
+#   any registered subscribers.
+
+module Tooled
+  module Publisher
+
+    ##
+    #   Used to distinguish exceptions relating to the lack of a particular
+    #   event.
+
+    class EventMissingException < Exception ; end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    ##
+    #   Returns a complete hash of subscribers including those registered at
+    #   class level.
+
+    def subscribers
+      (@subscribers ||= self.class.subscribers).dup
+    end
+
+    ##
+    #   Registers a subscriber to an instance.
+    #
+    #   This will raise an EventMissing exception if any of the provided event
+    #   names aren't registered.
+
+    def register_subscriber(subscriber, *event_names)
+      @subscribers ||= self.class.subscribers
+      events = event_names.collect(&:to_sym).uniq
+      invalid_events = events - self.class.publishable_events_list
+      raise EventMissingException.new("`#{invalid_events.collect(&:to_s).join('`, `')}` are not registered events") unless invalid_events.empty?
+      @subscribers[subscriber] = events
+    end
+
+    ##
+    #   Executes a provided block but calls all the events on relevant subscribers
+    #   as well.
+    #
+    #   `before_event_name` -> `around_event_name` -> `around_event_name` -> `after_event_name`
+
+    def with_event(event_name, &block)
+      raise EventMissingException.new("`#{event_name.to_s}` is not a registered event") unless self.class.publishable_events_list.include?(event_name.to_sym)
+      subs = _subscribers_for(event_name)
+      _broadcast(subs, ["before_#{event_name.to_s}", "around_#{event_name.to_s}"])
+      result = block.call if block_given?
+      _broadcast(subs, ["around_#{event_name.to_s}", "after_#{event_name.to_s}"])
+      result
+    end
+
+    private
+
+    def _subscribers_for(event_name)
+      subscribers.select { |subscriber, events| events.include?(event_name.to_sym) }.keys
+    end
+
+    def _broadcast(subs, method)
+      subs.each do |subscriber|
+        if method.is_a?(Array)
+          method.each { |m| subscriber.send(m) if subscriber.respond_to?(m) }
+        else
+          subscriber.send(method.to_s) if subscriber.respond_to?(method.to_s)
+        end
+      end
+    end
+
+    module ClassMethods
+
+      ##
+      #   Sets the list of publishable events. If an event is not registered
+      #   as a publishable event then it will not fire.
+
+      def publishable_events(*event_names)
+        @publishable_events = event_names.collect(&:to_sym).uniq
+      end
+
+      ##
+      #   Registers an individual event without removing previously added events.
+
+      def register_event(event_name)
+        event_name = event_name.to_sym
+        @publishable_events ||= Array.new
+        @publishable_events << event_name unless @publishable_events.include?(event_name)
+      end
+
+      ##
+      #   Provides an array with all publishable event names.
+
+      def publishable_events_list
+        (@publishable_events ||= Array.new).dup
+      end
+
+      ##
+      #   Provides a hash with all subscribers and their associated events.
+
+      def subscribers
+        (@subscribers ||= Hash.new).dup
+      end
+
+      ##
+      #   Registers an individual subscriber to any number of events from a class
+      #   level.
+
+      def register_subscriber(subscriber, *event_names)
+        @subscribers ||= Hash.new
+        events = event_names.collect(&:to_sym).uniq
+        invalid_events = events - publishable_events_list
+        raise EventMissingException.new("`#{invalid_events.collect(&:to_s).join('`, `')}` are not registered events") unless invalid_events.empty?
+        @subscribers[subscriber] = events
+      end
+    end
+  end
+end

data/lib/tooled/queue.rb

@@ -0,0 +1,46 @@
+##
+#   Queue provides a first on, first off array
+
+module Tooled
+  class Queue
+    include Enumerable
+
+    def initialize
+      @queue_values = []
+    end
+
+    def count
+      @queue_values.count
+    end
+    alias_method :length, :count
+
+    def <<(value)
+      @queue_values << value
+    end
+    alias_method :push, :<<
+
+    def peek
+      @queue_values.first
+    end
+
+    def pop
+      @queue_values.delete_at(0)
+    end
+
+    def [](index)
+      @queue_values[index.to_i]
+    end
+
+    def to_a
+      @queue_values.reverse.dup
+    end
+
+    def empty?
+      @queue_values.empty?
+    end
+
+    def each(&block)
+      yield block.call(pop) until empty?
+    end
+  end
+end

data/lib/tooled/stack.rb

@@ -0,0 +1,46 @@
+##
+#   Stack provides a first on, last off array
+
+module Tooled
+  class Stack
+    include Enumerable
+
+    def initialize
+      @stack_values = []
+    end
+
+    def count
+      @stack_values.count
+    end
+    alias_method :length, :count
+
+    def <<(value)
+      @stack_values << value
+    end
+    alias_method :push, :<<
+
+    def peek
+      @stack_values.last
+    end
+
+    def pop
+      @stack_values.delete_at(@stack_values.count - 1)
+    end
+
+    def [](index)
+      @stack_values[@stack_values.count - (index.to_i + 1)]
+    end
+
+    def to_a
+      @stack_values.dup
+    end
+
+    def empty?
+      @stack_values.empty?
+    end
+
+    def each(&block)
+      yield block.call(pop) until empty?
+    end
+  end
+end

data/lib/tooled/vector2d.rb

@@ -0,0 +1,32 @@
+##
+#   Vector2D is a basic data structure developed to store 2 dimensional
+#   co-ordinates and allow them to be manipulated using addition, subtraction,
+#   mulitplication and division.
+
+module Tooled
+  class Vector2D
+    def initialize(x, y)
+      @axis_values = [nil, nil]
+      self.x, self.y = x.to_f, y.to_f
+    end
+
+    %w( x y ).each_with_index do |axis, i|
+      define_method(axis) { @axis_values[i] }
+      define_method("#{axis}=") { |val| @axis_values[i] = val.to_f }
+    end
+
+    %w( * / + - ).each do |sym|
+      define_method(sym) { |val| _perform_message(val, sym) }
+    end
+
+    private
+
+    def _perform_message(val, msg)
+      if val.is_a?(Vector2D)
+        Vector2D.new(x.send(msg, val.x), y.send(msg, val.y))
+      else
+        Vector2D.new(x.send(msg, val.to_f), y.send(msg, val.to_f))
+      end
+    end
+  end
+end

data/lib/tooled/vector3d.rb

@@ -0,0 +1,32 @@
+##
+#   Vector3D is a basic data structure developed to store 3 dimensional
+#   co-ordinates and allow them to be manipulated using addition, subtraction,
+#   mulitplication and division.
+
+module Tooled
+  class Vector3D
+    def initialize(x, y, z)
+      @axis_values = [nil, nil, nil]
+      self.x, self.y, self.z = x.to_f, y.to_f, z.to_f
+    end
+
+    %w( x y z ).each_with_index do |axis, i|
+      define_method(axis) { @axis_values[i] }
+      define_method("#{axis}=") { |val| @axis_values[i] = val.to_f }
+    end
+
+    %w( * / + - ).each do |sym|
+      define_method(sym) { |val| _perform_message(val, sym) }
+    end
+
+    private
+
+    def _perform_message(val, msg)
+      if val.is_a?(Vector3D)
+        Vector3D.new(x.send(msg, val.x), y.send(msg, val.y), z.send(msg, val.z))
+      else
+        Vector3D.new(x.send(msg, val.to_f), y.send(msg, val.to_f), z.send(msg, val.to_f))
+      end
+    end
+  end
+end

data/lib/tooled/version.rb

@@ -0,0 +1,3 @@
+module Tooled
+  VERSION = "0.0.2"
+end

data/lib/tooled.rb

@@ -0,0 +1,10 @@
+require "tooled/version"
+require "tooled/vector2d"
+require "tooled/vector3d"
+require "tooled/stack"
+require "tooled/queue"
+require "tooled/publisher"
+
+module Tooled
+  # Your code goes here...
+end

data/spec/publisher_spec.rb

@@ -0,0 +1,105 @@
+require "tooled/publisher"
+
+describe Tooled::Publisher do
+  let(:klass) do
+    Class.new do
+      include Tooled::Publisher
+      publishable_events :foo, :bar
+    end
+  end
+  subject { klass }
+
+  describe "allows a class to register events" do
+    its(:publishable_events_list) { should include(:foo, :bar) }
+
+    describe "remains unique" do
+      subject { klass.publishable_events_list }
+      specify { expect { klass.register_event(:blegga) }.to change { klass.publishable_events_list.count }.by(1) }
+      specify { expect { klass.register_event(:foo) }.to_not change { klass.publishable_events_list.count } }
+    end
+  end
+
+  describe "registering subscribers" do
+    let(:subscriber) { double(:subscriber) }
+
+    context "at class level" do
+      specify { expect { subject.register_subscriber(subscriber, :foo, :bar) }.to change { subject.subscribers.count }.by(1) }
+
+      context "when already subscribed" do
+        before { subject.register_subscriber(subscriber, :foo) }
+        specify { expect { subject.register_subscriber(subscriber, :foo) }.to_not change { subject.subscribers.count } }
+
+        it "lists the correct event for the subscriber" do
+          subject.subscribers[subscriber].include?(:foo)
+        end
+      end
+
+      context "with invalid event" do
+        specify { expect { subject.register_subscriber(subscriber, :invalid) }.to raise_error(Tooled::Publisher::EventMissingException) }
+      end
+    end
+
+    context "at object level" do
+      let(:object) { klass.new }
+      subject { object }
+
+      specify { expect { subject.register_subscriber(subscriber, :foo, :bar) }.to change { subject.subscribers.count }.by(1) }
+
+      context "when already subscribed" do
+        before { subject.register_subscriber(subscriber, :foo) }
+        specify { expect { subject.register_subscriber(subscriber, :foo) }.to_not change { subject.subscribers.count } }
+
+        it "lists the correct event for the subscriber" do
+          subject.subscribers[subscriber].include?(:foo)
+        end
+      end
+
+      context "with invalid event" do
+        specify { expect { subject.register_subscriber(subscriber, :invalid) }.to raise_error(Tooled::Publisher::EventMissingException) }
+      end
+    end
+  end
+
+  describe "using events" do
+    let(:subscriber) { double(:subscriber, before_foo: true, after_foo: true, around_foo: true) }
+    let(:klass) do
+      Class.new do
+        include Tooled::Publisher
+        publishable_events :foo, :bar
+
+        def using_foo
+          with_event(:foo) { 1 }
+        end
+
+        def using_bar
+          with_event(:bar) { 2 }
+        end
+
+        def using_blegga
+          with_event(:blegga) { 3 }
+        end
+      end
+    end
+
+    subject { klass.new }
+
+    context "having a subscriber" do
+      before do
+        subscriber.should_receive(:before_foo)
+        subscriber.should_receive(:after_foo)
+        subscriber.should_receive(:around_foo).twice
+        subject.register_subscriber(subscriber, :foo)
+      end
+
+      its(:using_foo) { should eql(1) }
+    end
+
+    context "having no subscriber" do
+      its(:using_bar) { should eql(2) }
+    end
+
+    context "having no event" do
+      specify { expect { subject.using_blegga }.to raise_error(Tooled::Publisher::EventMissingException) }
+    end
+  end
+end

data/spec/queue_spec.rb

@@ -0,0 +1,57 @@
+require "tooled/queue"
+
+describe Tooled::Queue do
+  let(:object) { Tooled::Queue.new }
+  subject { object }
+
+  describe "adding elements" do
+    specify { expect { subject << 1 }.to change { subject.count }.by(1) }
+    specify { expect { subject.push(1) }.to change { subject.count }.by(1) }
+  end
+
+  describe "with no elements" do
+    it { should be_empty }
+  end
+
+  describe "converting to array" do
+    before { object << 1; object << 2; object << 3 }
+    its(:to_a) { should eql([3, 2, 1]) }
+  end
+
+  describe "retrieving elements" do
+    before { object << 'bottom' ; object << 'top' }
+
+    context "using peek" do
+      its(:peek) { should eql('bottom') }
+      specify { expect { subject.peek }.to_not change { subject.count } }
+    end
+
+    context "using pop" do
+      its(:pop) { should eql('bottom') }
+      specify { expect { subject.pop }.to change { subject.count }.by(-1) }
+    end
+
+    context "using an index" do
+      context "of 0" do
+        subject { object[0] }
+        it { should eql('bottom') }
+      end
+
+      context "of 1" do
+        subject { object[1] }
+        it { should eql('top') }
+      end
+    end
+  end
+
+  describe "is iterable" do
+    before { object << 1; object << 2; object << 3 }
+    specify do
+      expect do
+        values = []
+        object.each { |v| values << v }
+        values.should include(3, 2, 1)
+      end.to change { object.count }.by(-3)
+    end
+  end
+end

data/spec/stack_spec.rb

@@ -0,0 +1,57 @@
+require "tooled/stack"
+
+describe Tooled::Stack do
+  let(:object) { Tooled::Stack.new }
+  subject { object }
+
+  describe "adding elements" do
+    specify { expect { subject << 1 }.to change { subject.count }.by(1) }
+    specify { expect { subject.push(1) }.to change { subject.count }.by(1) }
+  end
+
+  describe "with no elements" do
+    it { should be_empty }
+  end
+
+  describe "converting to array" do
+    before { object << 1; object << 2; object << 3 }
+    its(:to_a) { should eql([1, 2, 3]) }
+  end
+
+  describe "retrieving elements" do
+    before { object << 'bottom' ; object << 'top' }
+
+    context "using peek" do
+      its(:peek) { should eql('top') }
+      specify { expect { subject.peek }.to_not change { subject.count } }
+    end
+
+    context "using pop" do
+      its(:pop) { should eql('top') }
+      specify { expect { subject.pop }.to change { subject.count }.by(-1) }
+    end
+
+    context "using an index" do
+      context "of 0" do
+        subject { object[0] }
+        it { should eql('top') }
+      end
+
+      context "of 1" do
+        subject { object[1] }
+        it { should eql('bottom') }
+      end
+    end
+  end
+
+  describe "is iterable" do
+    before { object << 1; object << 2; object << 3 }
+    specify do
+      expect do
+        values = []
+        object.each { |v| values << v }
+        values.should include(1, 2, 3)
+      end.to change { object.count }.by(-3)
+    end
+  end
+end

data/spec/vector2d_spec.rb

@@ -0,0 +1,84 @@
+require "tooled/vector2d"
+
+describe Tooled::Vector2D do
+  let(:object) { Tooled::Vector2D.new(1, 2) }
+  subject { object }
+
+  context "when initialized with values" do
+    its(:x) { should eql(1.to_f) }
+    its(:y) { should eql(2.to_f) }
+  end
+
+  describe "when multiplied" do
+    context "with an integer" do
+      subject { object * 2 }
+      its(:x) { should eql(2.to_f) }
+      its(:y) { should eql(4.to_f) }
+    end
+
+    context "with a float" do
+      subject { object * 1.5 }
+      its(:x) { should eql(1.5.to_f) }
+      its(:y) { should eql(3.to_f) }
+    end
+
+    context "with a vector2d" do
+      context "using integer values" do
+        subject { object * Tooled::Vector2D.new(2, 5) }
+        its(:x) { should eql(2.to_f) }
+        its(:y) { should eql(10.to_f) }
+      end
+
+      context "using float values" do
+        subject { object * Tooled::Vector2D.new(1.5, 2.5) }
+        its(:x) { should eql(1.5.to_f) }
+        its(:y) { should eql(5.to_f) }
+      end
+    end
+  end
+
+  describe "when divided" do
+    let(:object) { Tooled::Vector2D.new(5, 10) }
+    context "with an integer" do
+      subject { object / 5 }
+      its(:x) { should eql(1.to_f) }
+      its(:y) { should eql(2.to_f) }
+    end
+
+    context "with a float" do
+      subject { object / 2.5 }
+      its(:x) { should eql(2.to_f) }
+      its(:y) { should eql(4.to_f) }
+    end
+
+    context "with a vector2d" do
+      context "using integer values" do
+        subject { object / Tooled::Vector2D.new(5, 10) }
+        its(:x) { should eql(1.to_f) }
+        its(:y) { should eql(1.to_f) }
+      end
+
+      context "using float values" do
+        subject { object / Tooled::Vector2D.new(2.5, 1.25) }
+        its(:x) { should eql(2.to_f) }
+        its(:y) { should eql(8.to_f) }
+      end
+    end
+  end
+
+  describe "when added" do
+    context "with a vector2d" do
+      subject { object + Tooled::Vector2D.new(1, 5) }
+      its(:x) { should eql(2.to_f) }
+      its(:y) { should eql(7.to_f) }
+    end
+  end
+
+  describe "when subtracted" do
+    context "with a vector2d" do
+      subject { object - Tooled::Vector2D.new(1, 5) }
+      its(:x) { should eql(0.to_f) }
+      its(:y) { should eql(-3.to_f) }
+    end
+  end
+end

data/spec/vector3d_spec.rb

@@ -0,0 +1,95 @@
+require "tooled/vector3d"
+
+describe Tooled::Vector3D do
+  let(:object) { Tooled::Vector3D.new(1, 2, 3) }
+  subject { object }
+
+  context "when initialized with values" do
+    its(:x) { should eql(1.to_f) }
+    its(:y) { should eql(2.to_f) }
+    its(:z) { should eql(3.to_f) }
+  end
+
+  describe "when multiplied" do
+    context "with an integer" do
+      subject { object * 2 }
+      its(:x) { should eql(2.to_f) }
+      its(:y) { should eql(4.to_f) }
+      its(:z) { should eql(6.to_f) }
+    end
+
+    context "with a float" do
+      subject { object * 1.5 }
+      its(:x) { should eql(1.5.to_f) }
+      its(:y) { should eql(3.to_f) }
+      its(:z) { should eql(4.5.to_f) }
+    end
+
+    context "with a vector3d" do
+      context "using integer values" do
+        subject { object * Tooled::Vector3D.new(2, 5, 10) }
+        its(:x) { should eql(2.to_f) }
+        its(:y) { should eql(10.to_f) }
+        its(:z) { should eql(30.to_f) }
+      end
+
+      context "using float values" do
+        subject { object * Tooled::Vector3D.new(1.5, 2.5, 3.5) }
+        its(:x) { should eql(1.5.to_f) }
+        its(:y) { should eql(5.to_f) }
+        its(:z) { should eql(10.5.to_f) }
+      end
+    end
+  end
+
+  describe "when divided" do
+    let(:object) { Tooled::Vector3D.new(5, 10, 15) }
+    context "with an integer" do
+      subject { object / 5 }
+      its(:x) { should eql(1.to_f) }
+      its(:y) { should eql(2.to_f) }
+      its(:z) { should eql(3.to_f) }
+    end
+
+    context "with a float" do
+      subject { object / 2.5 }
+      its(:x) { should eql(2.to_f) }
+      its(:y) { should eql(4.to_f) }
+      its(:z) { should eql(6.to_f) }
+    end
+
+    context "with a vector3d" do
+      context "using integer values" do
+        subject { object / Tooled::Vector3D.new(5, 10, 15) }
+        its(:x) { should eql(1.to_f) }
+        its(:y) { should eql(1.to_f) }
+        its(:z) { should eql(1.to_f) }
+      end
+
+      context "using float values" do
+        subject { object / Tooled::Vector3D.new(2.5, 1.25, 2.5) }
+        its(:x) { should eql(2.to_f) }
+        its(:y) { should eql(8.to_f) }
+        its(:z) { should eql(6.to_f) }
+      end
+    end
+  end
+
+  describe "when added" do
+    context "with a vector3d" do
+      subject { object + Tooled::Vector3D.new(1, 5, 10) }
+      its(:x) { should eql(2.to_f) }
+      its(:y) { should eql(7.to_f) }
+      its(:z) { should eql(13.to_f) }
+    end
+  end
+
+  describe "when subtracted" do
+    context "with a vector3d" do
+      subject { object - Tooled::Vector3D.new(1, 5, 10) }
+      its(:x) { should eql(0.to_f) }
+      its(:y) { should eql(-3.to_f) }
+      its(:z) { should eql(-7.to_f) }
+    end
+  end
+end

data/tooled.gemspec

@@ -0,0 +1,24 @@
+# encoding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tooled/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "tooled"
+  spec.version       = Tooled::VERSION
+  spec.authors       = ["Darren Coxall"]
+  spec.email         = ["darren@darrencoxall.com"]
+  spec.description   = %q{A simple collection of classes to help avoid over-using Hash}
+  spec.summary       = %q{A simple collection of classes to help avoid over-using Hash}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: tooled
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Darren Coxall
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple collection of classes to help avoid over-using Hash
+email:
+- darren@darrencoxall.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .irbrc
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/tooled.rb
+- lib/tooled/publisher.rb
+- lib/tooled/queue.rb
+- lib/tooled/stack.rb
+- lib/tooled/vector2d.rb
+- lib/tooled/vector3d.rb
+- lib/tooled/version.rb
+- spec/publisher_spec.rb
+- spec/queue_spec.rb
+- spec/stack_spec.rb
+- spec/vector2d_spec.rb
+- spec/vector3d_spec.rb
+- tooled.gemspec
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A simple collection of classes to help avoid over-using Hash
+test_files:
+- spec/publisher_spec.rb
+- spec/queue_spec.rb
+- spec/stack_spec.rb
+- spec/vector2d_spec.rb
+- spec/vector3d_spec.rb