splib 1.0

data/CHANGELOG

@@ -0,0 +1,2 @@
+1.0
+    * Initial release

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009 spox <spox@modspox.com>
+
+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.rdoc

@@ -0,0 +1,38 @@
+== Spox Library (splib)
+
+The Spox Library is collection of helper methods and classes.
+
+=== install (easy):
+
+    gem install splib
+
+=== install (less easy):
+
+    git clone http://github.com/spox/splib.git
+    cd splib
+    gem build *.gemspec
+    gem install ./
+
+=== install (less easy that's a little easier)
+
+{rip}[http://hellorip.com/about.html] makes it easy to install directly from a github repository.
+
+=== Usage
+
+The Spox Library has various things located within it. The Splib#load method will allow you to load individual parts of the library, or the entire thing into your program.
+
+    require 'splib'
+
+    Splib.load :UrlShorteners
+    puts Splib.tinyurl 'www.google.com'
+
+    => "http://tinyurl.com/2ty"
+
+== Last remarks
+
+If you find any bugs, please report them through {github}[http://github.com/spox/splib/issues]. If you are in need of any help, you can generally find me on DALnet and Freenode.
+
+== License
+
+    Spox Library is licensed under the MIT License
+    Copyright (c) 2009 spox <spox@modspox.com>

data/lib/splib.rb

@@ -0,0 +1,32 @@
+module Splib
+    LIBS = [:CodeReloader,
+            :Constants,
+            :Conversions,
+            :Exec,
+            :HumanIdealRandomIterator,
+            :PriorityQueue,
+            :UrlShorteners
+           ]
+    # args:: name of library to load
+    # Loads the given library. Currently available:
+    # :CodeReloader
+    # :Constants
+    # :Conversions
+    # :Exec
+    # :HumanIdealRandomIterator
+    # :PriorityQueue
+    # :UrlShorteners
+    # :all
+    def self.load(*args)
+        if(args.include?(:all))
+            LIBS.each do |lib|
+                require "splib/#{lib}"
+            end
+        else
+            args.each do |lib|
+                raise NameError.new("Unknown library name: #{lib}") unless LIBS.include?(lib)
+                require "splib/#{lib}"
+            end
+        end
+    end
+end

data/lib/splib/CodeReloader.rb

@@ -0,0 +1,54 @@
+module Splib
+    # path:: path to ruby file
+    # type:: return constants only of given type
+    # Find all constants in a given ruby file. Array of 
+    # symbols is returned
+    def self.discover_constants(path, type=nil)
+        raise ArgumentError.new('Failed to locate plugin file') unless File.exists?(path)
+        consts = []
+        sandbox = Module.new
+        sandbox.module_eval(IO.binread(path))
+        sandbox.constants.each do |const|
+            klass = sandbox.const_get(const)
+            if(type.nil? || (type && klass < type))
+                sklass = klass.to_s.slice(klass.to_s.rindex(':')+1, klass.to_s.length)
+                consts << sklass.to_sym
+            end
+        end
+        return consts
+    end
+
+    # path:: path to ruby file
+    # holder:: module holding loaded ruby code
+    # Load code from a ruby file into a module
+    def self.load_code(path, holder=nil)
+        if(holder)
+            raise ArgumentError.new('Expecting a module containing loaded code') unless holder.respond_to?(:path)
+        else
+            holder = self.create_holder(path)
+        end
+        holder.module_eval(IO.binread(path))
+        holder
+    end
+
+    # holder:: module holding loaded ruby code
+    # Reload the code within the module
+    def self.reload_code(holder)
+        raise ArgumentError.new('Expecting a module containing loaded code') unless holder.respond_to?(:path)
+        holder.constants.each do |const|
+            holder.send(:remove_const, const)
+        end
+        self.load_code(holder.path, holder)
+    end
+
+    # path:: path to ruby code
+    # Creates a module to hold loaded code
+    def self.create_holder(path)
+        return Module.new do
+            @path = path
+            def self.path
+                @path
+            end
+        end
+    end
+end

data/lib/splib/Constants.rb

@@ -0,0 +1,21 @@
+module Splib
+    # c:: constant name (String)
+    # things:: Array of Object/Module constants to look in
+    # Finds a constant if it exists
+    # Example:: Foo::Bar 
+    def self.find_const(c, things=[])
+        raise ArgumentError.new('Exepcting an array') unless things.is_a?(Array)
+        const = nil
+        (things + [Object]).each do |base|
+            begin
+                c.split('::').each do |part|
+                    const = const.nil? ? base.const_get(part) : const.const_get(part)
+                end
+            rescue NameError
+                const = nil
+            end
+            break unless const.nil?
+        end
+        const.nil? ? c : const
+    end
+end

data/lib/splib/Conversions.rb

@@ -0,0 +1,45 @@
+module Splib
+    # secs:: number of seconds
+    # Converts seconds into a human readable string (This is an estimate
+    # and does not account for leaps)
+    def self.format_seconds(secs)
+        arg = {:year => 31536000,
+                :month => 2678400,
+                :week => 604800,
+                :day => 86400,
+                :hour => 3600,
+                :minute => 60,
+                :second => 1}
+        res = ''
+        arg.each_pair do |k,v|
+            z = (secs / v).to_i
+            next unless z > 0
+            res += " #{z} #{k}#{z == 1 ? '':'s'}"
+            secs = secs % v
+        end
+        res = '0 seconds' if res.empty?
+        return res.strip
+    end
+
+    # bytes:: number of bytes
+    # Converts bytes into easy human readable form
+    # O(1) version by Ryan "pizza_milkshake" Flynn
+    Suff = [
+    "",       # 1024^0
+    "Kilo",   # 1024^1
+    "Mega",   # 1024^2
+    "Giga",   # 1024^3
+    "Tera",   # 1024^4
+    "Peta",   # 1024^5
+    "Exa",    # 1024^6
+    "Zetta",  # 1024^7
+    "Yotta"   # 1024^8
+    ]
+    def self.format_size(bytes)
+        return "0 bytes" if bytes == 0
+        mag = (Math.log(bytes) / Math.log(1024)).floor
+        mag = [ Suff.length - 1, mag ].min
+        val = bytes.to_f / (1024 ** mag)
+        ("%.2f %sbyte%s" % [ val, Suff[mag], val == 1 ? "" : "s" ]).strip
+    end
+end

data/lib/splib/Exec.rb

@@ -0,0 +1,35 @@
+require 'timeout'
+
+module Splib
+    # command:: command to execute
+    # timeout:: maximum number of seconds to run
+    # maxbytes:: maximum number of result bytes to accept
+    # Execute a system command (use with care)
+    def self.exec(command, timeout=10, maxbytes=500)
+        output = []
+        pro = nil
+        begin
+            Timeout::timeout(timeout) do
+                pro = IO.popen(command)
+                until(pro.closed? || pro.eof?)
+                    if(RUBY_VERSION >= '1.9.0')
+                        output << pro.getc
+                    else
+                        output << pro.getc.chr
+                    end
+                    raise IOError.new("Maximum allowed output bytes exceeded. (#{maxbytes} bytes)") unless output.size <= maxbytes
+                end
+            end
+            output = output.join('')
+        rescue Exception => boom
+            raise boom
+        ensure
+            if(RUBY_PLATFORM == 'java')
+                Process.kill('KILL', pro.pid) unless pro.nil?
+            else
+                Process.kill('KILL', pro.pid) if Process.waitpid2(pro.pid, Process::WNOHANG).nil? # make sure the process is dead
+            end
+        end
+        return output
+    end
+end

data/lib/splib/HumanIdealRandomIterator.rb

@@ -0,0 +1,40 @@
+module Splib
+    # IdealHumanRandomIterator - select "random" members of a population, favoring
+    # those least-recently selected, to appease silly humans who hate repeats
+    #
+    # Abstract:
+    # given a decently-sized set of items (say, 100 famous quotes), an
+    # average persons's idea of N "random" entries is not actually random.
+    # people don't want items to appear twice in a row, or too frequently
+    # (even though true randomness means this is just as likely as any other order).
+    #
+    # instead, design a scheme whereby LRU items are weighted more heavily,
+    # to "encourage" subsequent selections to not repeat.
+    #
+    # Author: Ryan "pizza_" Flynn
+    # - pulled from the algodict project
+    # - - http://github.com/pizza/algodict
+    class IdealHumanRandomIterator
+        
+        def initialize(list)
+            raise ArgumentError.new("Array type required") unless list.is_a?(Array)
+            @items = list
+        end
+        
+        # Given length L, generate a random number in the range [0,len-1), heavily
+        # weighted towards the low end.
+        def self.nexti(len)
+            len += 1 if len % 2 == 1
+            index = len > 2 ? rand(len/2) : 0
+            return index
+        end
+        
+        # return a psuedo-random member of items. subsequent calls should never
+        # return the same item.
+        def next()
+            index = IdealHumanRandomIterator.nexti(@items.length)
+            @items.push @items.delete_at(index)
+            return @items.last
+        end
+    end
+end

data/lib/splib/PriorityQueue.rb

@@ -0,0 +1,98 @@
+module Splib
+    # Exception raised when queue is empty
+    class EmptyQueue < Exception
+    end
+    # This class provides some simple logic for item output. It is
+    # basically a priority based queue with some round robin thrown
+    # in to keep things interesting. This queue provides an easy way
+    # for many threads to populate it without drowning out each other.
+    # NOTE: Design help from the great Ryan "pizza_" Flynn
+    class PriorityQueue
+
+        # args:: config arguments
+        #   :raise_on_empty
+        # whocares:: lambda{|target| true||false}
+        # Create a priority queue
+        def initialize(*args, &whocares)
+            @raise = args.include?(:raise_on_empty)
+            @whocares = whocares
+            @target_queues = {}
+            @queues = {:PRIORITY => [], :NEW => [], :NORMAL => [], :WHOCARES => []}
+            @lock = Mutex.new
+        end
+        
+        # target:: target queue
+        # item:: item to queue
+        # This prioritizes output to help reduce lag when lots of output
+        # is being sent to another target. This will automatically decide
+        # how to queue the item based on the target
+        def prioritized_queue(target, item)
+            raise NameError.new('The target :internal_prio is a restricted target') if target == :internal_prio
+            @lock.synchronize do
+                @target_queues[target] = [] unless @target_queues[target]
+                if(@whocares && @whocares.call(target))
+                    @target_queues[target] << item
+                    add_queue(:WHOCARES, @target_queues[target])
+                else
+                    @target_queues[target] << item
+                    if(@target_queues[target].size < 2)
+                        add_queue(:NEW, @target_queues[target])
+                    else
+                        add_queue(:NORMAL, @target_queues[target])
+                    end
+                end
+            end
+            item
+        end
+        
+        # item:: item to queue
+        # This will add item to the PRIORITY queue which gets
+        # sent before all other items.
+        def direct_queue(message)
+            @lock.synchronize do
+                @target_queues[:internal_prio] = [] unless @target_queues[:internal_prio]
+                @target_queues[:internal_prio] << message
+                add_queue(:PRIORITY, @target_queues[:internal_prio])
+            end
+            message
+        end
+
+        # raise_e:: raise an exception on empty
+        # Returns the next message to send. This method decides what
+        # message to send based on the priority of the message. It
+        # will throw an Exceptions::EmptyQueue when there are no messages
+        # left.
+        def pop
+            m = nil
+            @lock.synchronize do
+                [:PRIORITY, :NEW, :NORMAL, :WHOCARES].each do |k|
+                    unless(@queues[k].empty?)
+                        q = @queues[k].shift
+                        unless(q.empty?)
+                            m = q.shift
+                            add_queue(k, q) unless(q.empty?)
+                            break
+                        end
+                    end
+                end
+            end
+            raise EmptyQueue.new('Queue is currently empty') if m.nil? && @raise
+            return m
+        end
+
+        # Returns true if queue is empty
+        def empty?
+            @lock.synchronize{@target_queues.values.find{|n|!n.empty?}.nil?}
+        end
+
+        alias :push :prioritized_queue
+
+        private
+        
+        def add_queue(name, queue)
+            unless(@queues[name].include?(queue))
+                @queues[name] << queue
+            end
+        end
+    end
+end

data/lib/splib/UrlShorteners.rb

@@ -0,0 +1,48 @@
+require 'net/http'
+
+module Splib
+    # url:: URL to shorten
+    # Gets a tinyurl for given URL
+    def self.tiny_url(url)
+        connection = Net::HTTP.new('tinyurl.com', 80)
+        resp, data = connection.get("/api-create.php?url=#{url}")
+        if(resp.code !~ /^200$/)
+            raise "Failed to make the URL small."
+        end
+        return data.strip
+    end
+    # url:: URL to shorten
+    # Gets a tr.im for given URL
+    def self.trim_url(url)
+        connection = Net::HTTP.new('api.tr.im', 80)
+        resp, data = connection.get("/v1/trim_simple?url=#{url}")
+        if(resp.code !~ /^200$/)
+            raise "Failed to make the URL small."
+        end
+        return data.strip
+    end
+    # url:: URL to shorten
+    # Gets a is.gd for given URL
+    def self.isgd_url(url)
+        connection = Net::HTTP.new('is.gd', 80)
+        resp, data = connection.get("/api.php?longurl=#{url}")
+        if(resp.code !~ /^200$/)
+            raise "Failed to make the URL small."
+        end
+        return data.strip
+    end
+    # url:: URL to shorten
+    # Get shortest for given url
+    def self.shortest_url(url)
+        results = []
+        [:tiny_url, :isgd_url, :trim_url].each do |service|
+            begin
+                results << self.send(service, url)
+            rescue
+                #ignore#
+            end
+        end
+        raise 'Failed to make URL small' if results.empty?
+        results.sort{|a,b| a.length <=> b.length}[0]
+    end
+end

data/splib.gemspec

@@ -0,0 +1,15 @@
+spec = Gem::Specification.new do |s|
+    s.name              = 'splib'
+    s.author            = 'spox'
+    s.email             = 'spox@modspox.com'
+    s.version           = '1.0'
+    s.summary           = 'Spox Library'
+    s.platform          = Gem::Platform::RUBY
+    s.files             = Dir['**/*']
+    s.rdoc_options      = %w(--title splib --main README.rdoc --line-numbers)
+    s.extra_rdoc_files  = %w(README.rdoc CHANGELOG)
+    s.require_paths     = %w(lib)
+    s.required_ruby_version = '>= 1.8.6'
+    s.homepage          = %q(http://github.com/spox/splib)
+    s.description         = "The spox library contains various useful tools to help you in your day to day life. Like a trusty pocket knife, only more computery."
+end

data/tests/cases/CodeReloader.rb

@@ -0,0 +1,38 @@
+require 'splib'
+require 'test/unit'
+require 'fileutils'
+
+class CodeReloaderTest < Test::Unit::TestCase
+    def setup
+        @s = File.expand_path("#{__FILE__}/../../samplecode.rb")
+        @s1 = File.expand_path("#{__FILE__}/../../samplecode1.rb")
+        @s2 = File.expand_path("#{__FILE__}/../../samplecode2.rb")
+        Splib.load :CodeReloader
+        Splib.load :Constants
+        FileUtils.cp @s1, @s
+    end
+    def teardown
+        FileUtils.rm @s, :force => true
+    end
+    def test_load
+        holder = Splib.load_code(@s)
+        klass = Splib.find_const('Fu::Bar', [holder])
+        obj = klass.new
+        assert_equal('hello world', obj.foobar)
+    end
+    def test_reload
+        holder = Splib.load_code(@s)
+        klass = Splib.find_const('Fu::Bar', [holder])
+        obj = klass.new
+        assert(obj.respond_to?(:foobar))
+        assert(!obj.respond_to?(:feebar))
+        assert_equal('hello world', obj.foobar)
+        FileUtils.cp @s2, @s
+        Splib.reload_code(holder)
+        klass = Splib.find_const('Fu::Bar', [holder])
+        obj = klass.new
+        assert(obj.respond_to?(:feebar))
+        assert(!obj.respond_to?(:foobar))
+        assert_equal('goodbye world', obj.feebar)
+    end
+end

data/tests/cases/Constants.rb

@@ -0,0 +1,27 @@
+require 'splib'
+require 'test/unit'
+
+module Foo
+    module Bar
+        class Fubar
+        end
+    end
+end
+
+class ConstantsTest < Test::Unit::TestCase
+    def setup
+        Splib.load :Constants
+    end
+    def test_find_const
+        mod = Module.new
+        mod.class_eval("
+            module Fu
+                class Bar
+                end
+            end"
+        )
+        assert_equal(String, Splib.find_const('String'))
+        assert_equal(Foo::Bar::Fubar, Splib.find_const('Foo::Bar::Fubar'))
+        assert_match(/<.+?>::Fu::Bar/, Splib.find_const('Fu::Bar', [mod]).to_s)
+    end
+end

data/tests/cases/Conversions.rb

@@ -0,0 +1,57 @@
+require 'splib'
+require 'test/unit'
+
+class ConversionsTest < Test::Unit::TestCase
+    def setup
+        Splib.load :Conversions
+    end
+
+    def test_format_seconds
+        inc = {:year => 60 * 60 * 24 * 365,
+               :month => 60 * 60 * 24 * 31,
+               :week => 60 * 60 * 24 * 7,
+               :day => 60 * 60 * 24,
+               :hour => 60 * 60,
+               :minute => 60,
+               :second => 1}
+        100.times do |i|
+            time = rand(i)
+            otime = time
+            formatted = []
+            inc.each_pair do |name, value|
+                val = (time / value).to_i
+                if(val > 0)
+                    time = time - (val * value)
+                    formatted << "#{val} #{val == 1 ? name : "#{name}s"}"
+                end
+            end
+            formatted = formatted.empty? ? '0 seconds' : formatted.join(' ')
+            assert_equal(Splib.format_seconds(otime), formatted)
+        end   
+    end
+
+    def test_format_size
+        inc = {"byte" => 1024**0,       # 1024^0
+               "Kilobyte" => 1024**1,   # 1024^1
+               "Megabyte" => 1024**2,   # 1024^2
+               "Gigabyte" => 1024**3,   # 1024^3
+               "Terabyte" => 1024**4,   # 1024^4
+               "Petabyte" => 1024**5,   # 1024^5
+               "Exabyte" => 1024**6,    # 1024^6
+               "Zettabyte" => 1024**7,  # 1024^7
+               "Yottabyte" => 1024**8   # 1024^8
+               }
+        100.times do |i|
+            val = i**rand(i)
+            formatted = nil
+            inc.each_pair do |name, value|
+                v = val / value.to_f
+                if(v.to_i > 0)
+                    formatted = ("%.2f " % v) + " #{name}#{v == 1 ? '' : 's'}".strip
+                end
+            end
+            formatted = '0 bytes' if formatted.nil?
+            assert_equal(formatted, Splib.format_size(val))
+        end 
+    end
+end

data/tests/cases/Exec.rb

@@ -0,0 +1,18 @@
+require 'splib'
+require 'test/unit'
+
+class ExecTest < Test::Unit::TestCase
+    def setup
+        Splib.load :Exec
+    end
+    
+    def test_exec
+        assert_raise(IOError) do
+            Splib.exec('echo test', 10, 1)
+        end
+        assert_raise(Timeout::Error) do
+            Splib.exec('while [ true ]; do true; done;', 1)
+        end
+        assert_equal("test\n", Splib.exec('echo test'))
+    end
+end

data/tests/cases/HumanIdealRandomIterator.rb

@@ -0,0 +1,30 @@
+require 'splib'
+require 'test/unit'
+
+class HumanIdealRandomIteratorTest < Test::Unit::TestCase
+    def setup
+        Splib.load :HumanIdealRandomIterator
+    end
+
+    def test_iterator
+        assert_raise(EOFError) do
+            100.times do
+                results = []
+                pool = (0..rand(1000)).to_a
+                ideal = Splib::IdealHumanRandomIterator.new(pool)
+                (pool.size / 2).times do
+                    n = ideal.next()
+                    if(results.include?(n))
+                        raise ArgumentError.new("Duplicated result")
+                    else
+                        results << n
+                    end
+                end
+            end
+            raise EOFError.new("OK")
+        end
+        assert_raise(ArgumentError){ Splib::IdealHumanRandomIterator.new(1) }
+        assert_nil(Splib::IdealHumanRandomIterator.new([]).next)
+        assert_equal(0, Splib::IdealHumanRandomIterator.new([0]).next)
+    end
+end

data/tests/cases/PriorityQueue.rb

@@ -0,0 +1,45 @@
+require 'splib'
+require 'test/unit'
+
+class PriorityQueueTest < Test::Unit::TestCase
+    def setup
+        Splib.load :PriorityQueue
+    end
+
+    def test_direct
+        queue = Splib::PriorityQueue.new
+        queue.direct_queue(1)
+        assert_equal(1, queue.pop)
+        queue.direct_queue(2)
+        queue.direct_queue(3)
+        assert_equal(2, queue.pop)
+        assert_equal(3, queue.pop)
+        assert(queue.empty?)
+    end
+
+    def test_prioritizer
+        queue = Splib::PriorityQueue.new
+        5.times{queue.push('slot1', 'test')}
+        5.times{queue.push('slot2', 'fubar')}
+        queue.direct_queue('first')
+        assert_equal('first', queue.pop)
+        5.times do
+            assert_equal('test', queue.pop)
+            assert_equal('fubar', queue.pop)
+        end
+        assert(queue.empty?)
+    end
+
+    def test_whocares
+        queue = Splib::PriorityQueue.new{|s| s == :last }
+        queue.push(:last, 'last')
+        2.times{ queue.push(:slot1, 'test') }
+        2.times{ queue.push(:slot2, 'fubar') }
+        2.times do
+            assert_equal('test', queue.pop)
+            assert_equal('fubar', queue.pop)
+        end
+        assert_equal('last', queue.pop)
+        assert(queue.empty?)
+    end
+end

data/tests/cases/UrlShorteners.rb

@@ -0,0 +1,24 @@
+require 'splib'
+require 'test/unit'
+
+class UrlShortenersTest < Test::Unit::TestCase
+    def setup
+        Splib.load :UrlShorteners
+    end
+
+    def test_tiny_url
+        assert_match(/^http:\/\/[\w|\.|\/]+$/, Splib.tiny_url('www.google.com'))
+    end
+
+    def test_trim_url
+        assert_match(/^http:\/\/[\w|\.|\/]+$/, Splib.trim_url('www.google.com'))
+    end
+
+    def test_isgd_url
+        assert_match(/^http:\/\/[\w|\.|\/]+$/, Splib.isgd_url('www.google.com'))
+    end
+
+    def test_shortest_url
+        assert_match(/^http:\/\/[\w|\.|\/]+$/, Splib.shortest_url('www.google.com'))
+    end
+end

data/tests/run_tests.rb

@@ -0,0 +1,6 @@
+require 'test/unit'
+require 'splib'
+
+Dir.new("#{File.dirname(__FILE__)}/cases").each{|f|
+    require "#{File.dirname(__FILE__)}/cases/#{f}" if f[-2..f.size] == 'rb'
+}

data/tests/samplecode1.rb

@@ -0,0 +1,7 @@
+module Fu
+    class Bar
+        def foobar
+            'hello world'
+        end
+    end
+end

data/tests/samplecode2.rb

@@ -0,0 +1,7 @@
+module Fu
+    class Bar
+        def feebar
+            'goodbye world'
+        end
+    end
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: splib
+version: !ruby/object:Gem::Version 
+  version: "1.0"
+platform: ruby
+authors: 
+- spox
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-17 00:00:00 -08:00
+default_executable: 
+dependencies: []
+
+description: The spox library contains various useful tools to help you in your day to day life. Like a trusty pocket knife, only more computery.
+email: spox@modspox.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- CHANGELOG
+files: 
+- tests/cases/PriorityQueue.rb
+- tests/cases/UrlShorteners.rb
+- tests/cases/Exec.rb
+- tests/cases/Constants.rb
+- tests/cases/CodeReloader.rb
+- tests/cases/HumanIdealRandomIterator.rb
+- tests/cases/Conversions.rb
+- tests/run_tests.rb
+- tests/samplecode2.rb
+- tests/samplecode1.rb
+- lib/splib.rb
+- lib/splib/PriorityQueue.rb
+- lib/splib/UrlShorteners.rb
+- lib/splib/Exec.rb
+- lib/splib/Constants.rb
+- lib/splib/CodeReloader.rb
+- lib/splib/HumanIdealRandomIterator.rb
+- lib/splib/Conversions.rb
+- CHANGELOG
+- LICENSE
+- splib.gemspec
+- README.rdoc
+has_rdoc: true
+homepage: http://github.com/spox/splib
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- splib
+- --main
+- README.rdoc
+- --line-numbers
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.6
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Spox Library
+test_files: []
+