ss-se_gem 0.0.6 → 1.0.0

data/lib/core_ext.rb

@@ -1,2 +1,3 @@
-require 'lib/se/core_ext/meta_class'
+require 'lib/se/core_ext/benchmark'
+require 'lib/se/core_ext/date'
 require 'lib/se/core_ext/object'

data/lib/se/aspect.rb

@@ -0,0 +1,118 @@
+#
+# I had a look at AspectR [1], and it looked awfully confusing.
+# I then had a look at AOP on wikipedia [2], I think the people
+# who contributed to that have possibly gone whacko. An excerpt:
+#
+# "Since the risk is to code written by others, code weaving can
+#  be emotional for the authors of the original code. There is
+#  little moral grounding to guide programmers in these matters
+#  because morality isn't something often applied to coding practices"
+#
+# What??!
+#
+# Here is my non-academic completely morality-free implementation.
+#
+# See line 99 for the API. Feedback is appreciated.
+#
+# Ryan Allen (aspect@yeahnah.org)
+#
+# [1] http://aspectr.sourceforge.net/
+# [2] http://en.wikipedia.org/wiki/Aspect-oriented_programming
+#
+
+#
+# Example:
+#
+#   class Foo
+#     def self.class_method
+#       puts 'class_method'
+#     end
+#     def instance_method
+#       puts 'instance_method'
+#     end
+#   end
+#
+#   SE::Aspect.define do
+#     with_class(Foo).before(:class_method) do |klass|
+#       puts 'before class_method'
+#     end
+#
+#     with_instance_of(Foo).before(:instance_method) do |instance|
+#       puts 'before instance_method'
+#     end
+#
+#     with_class(Foo).after(:class_method) do | klass|
+#       puts 'after class_method'
+#     end
+#
+#     with_instance_of(Foo).after(:instance_method) do |instance|
+#       puts 'after instance_method'
+#     end
+#   end
+#
+#   Foo.class_method
+#     #=> before class_method
+#     #=> class_method
+#     #=> after class_method
+#
+#   Foo.new.instance_method
+#     #=> before instance_method
+#     #=> instance_method
+#     #=> after instance_method
+#
+module SE
+  module Aspect
+
+    class << self
+
+      def define(&aspects)
+        instance_eval(&aspects)
+      end
+
+      def with_instance_of(klass)
+        @class = klass
+        @subject = :instance
+        self
+      end
+
+      def with_class(klass)
+        @class = klass
+        @subject = :class
+        self
+      end
+
+      def before(method_name, &perform_before)
+        with_scope do
+          method_prior = instance_method(method_name)
+          define_method method_name do |*args|
+            perform_before.call(self, *args)
+            method_prior.bind(self).call(*args)
+          end
+        end
+      end
+
+      def after(method_name, &perform_after)
+        with_scope do
+          method_prior = instance_method(method_name)
+          define_method method_name do |*args|
+            return_value = method_prior.bind(self).call(*args)
+            perform_after.call(self, *args)
+            return_value
+          end
+        end
+      end
+
+    private
+
+      def with_scope(&code)
+        if @subject == :class
+          @class.class_eval { class << self; self; end }.instance_eval(&code)
+        else
+          @class.class_eval(&code)
+        end
+      end
+
+    end # class << self
+
+  end # module Aspect
+end # module SE

data/lib/se/core_ext/benchmark.rb

@@ -0,0 +1,11 @@
+module Benchmark
+  # from: http://blog.pluron.com/2008/01/guerrillas-way.html
+  # optimization to prevent unnecessary object creation
+  def realtime
+    r0 = Time.now
+    yield
+    r1 = Time.now
+    r1.to_f - r0.to_f
+  end
+  module_function :realtime
+end

data/lib/se/core_ext/date.rb

@@ -0,0 +1,10 @@
+require 'date'
+
+class Date
+
+  # returns the number of days in the year
+  def days_in_year
+    leap? ? 366 : 365
+  end
+
+end

data/lib/se/core_ext/regexp.rb

@@ -0,0 +1,20 @@
+class Regexp
+
+  def blank?
+    false
+  end
+
+  #
+  # Allow a Regexp to be used instead of an Array for matching a value.
+  #
+  # Instead of:
+  #   ['a-1','a-2'].include?(value)
+  #
+  # We can:
+  #   /a-[12]/.include?(value)
+  #
+  def include?(value)
+    not match(value.to_s).nil?
+  end
+
+end

data/lib/se/core_ext/retryable.rb

@@ -0,0 +1,32 @@
+# From: http://blog.codefront.net/2008/01/14/retrying-code-blocks-in-ruby-on-exceptions-whatever/
+#
+# Adds +retryable+ method to Kernel.
+#
+module Kernel
+
+  # Options:
+  # * :tries - Number of retries to perform. Defaults to 1.
+  # * :on    - The Exception on which a retry will be performed. (default Exception)
+  #
+  # Example
+  # =======
+  #   retryable(:tries => 1, :on => OpenURI::HTTPError) do
+  #     # your code here
+  #   end
+  def retryable(options = {}, &block)
+    opts = {:tries => 1}.merge!(options)
+
+    retry_exception = opts[:on] || Exception
+
+    begin
+      return yield
+    rescue retry_exception
+      (opts[:tries] - 1).times do
+        return yield rescue retry_exception
+      end
+    end
+
+    yield
+  end
+
+end

data/lib/se/core_ext/socket.rb

@@ -0,0 +1,24 @@
+
+
+# from http://coderrr.wordpress.com/2008/05/28/get-your-local-ip-address/
+#
+# This method does NOT make a connection or send any packets to 64.233.187.99
+# (Google).  Since UDP is a stateless protocol connect() merely makes a
+# system call which figures out how to route the packets based on the address
+# and what interface (and therefore IP address) it should bind to. addr()
+# returns an array containing the family (AF_INET), local port, and local
+# address (which is what we want) of the socket.
+#
+def Socket.local_ip
+  @local_ip ||= begin
+    # turn off reverse DNS resolution temporarily
+    orig, Socket.do_not_reverse_lookup = Socket.do_not_reverse_lookup, true
+    UDPSocket.open do |s|
+      s.connect '64.233.187.99', 1
+      s.addr.last
+    end
+  end
+ensure
+  Socket.do_not_reverse_lookup = orig
+end
+

data/lib/se/core_ext/yaml.rb

@@ -0,0 +1,13 @@
+
+
+#
+# Read a file, run it through ERB, then YAML::load.
+#
+# The caller is expected to have loaded ERB.
+#
+#  +filename+ - name of file
+#  +args+     - arguments for ERB.new call
+#
+def YAML.load_erb_file(filename, *args)
+  YAML::load(ERB.new(IO.read(filename), *args).result)
+end

data/lib/se/memory_profiler.rb

@@ -0,0 +1,93 @@
+# From http://scottstuff.net/blog/articles/2006/08/17/memory-leak-profiling-with-rails
+
+# Simple memory profiler.
+#
+# Calling SE::MemoryProfiler.start will spin up a thread that writes
+# instance counts to +log_file_name+ and optionally writes String
+# values to +string_log_file_name+.
+#
+#  Example:
+#
+#   # write to log every 3 seconds
+#   SE::MemoryProfiler.start(:every=>3)
+#
+module SE
+  class MemoryProfiler
+    DEFAULTS = {:every => 10, :string_debug => false}
+
+    # Start the profiler.
+    #
+    # opts can be one of:
+    #   +every+         => delay in seconds between output to +log_file_name+ (default 10)
+    #   +string_debug+  => whether to write string values to +string_log_file_name+ (default false)
+    #
+    def self.start(opt={})
+      opt = DEFAULTS.dup.merge(opt)
+
+      Thread.new do
+        prev = Hash.new(0)
+        curr = Hash.new(0)
+        curr_strings = []
+        delta = Hash.new(0)
+
+        file = File.open(log_file_name,'w')
+
+        loop do
+          begin
+            GC.start
+            curr.clear
+
+            curr_strings = [] if opt[:string_debug]
+
+            ObjectSpace.each_object do |o|
+              curr[o.class] += 1 #Marshal.dump(o).size rescue 1
+              if opt[:string_debug] and o.class == String
+                curr_strings.push o
+              end
+            end
+
+            if opt[:string_debug]
+              File.open(string_log_file_name, 'w') do |f|
+                curr_strings.sort.each do |s|
+                  f.puts s
+                end
+              end
+              curr_strings.clear
+            end
+
+            delta.clear
+            (curr.keys + delta.keys).uniq.each do |k,v|
+              delta[k] = curr[k]-prev[k]
+            end
+
+            file.puts "Top 20"
+            delta.sort_by { |k,v| -v.abs }[0..19].sort_by { |k,v| -v}.each do |k,v|
+              file.printf "%+5d: %s (%d)\n", v, k.name, curr[k] unless v == 0
+            end
+            file.flush
+
+            delta.clear
+            prev.clear
+            prev.update curr
+            GC.start
+          rescue Exception => err
+            STDERR.puts "** memory_profiler error: #{err}"
+          end
+          sleep opt[:every].to_i
+        end
+      end
+    end
+
+
+    # log file where object counts are written
+    def self.log_file_name
+      'memory_profiler.log'
+    end
+
+    # log file where string values are written
+    def self.string_log_file_name(time=Time.now)
+      "memory_profiler_strings.log.#{time.to_i}"
+    end
+
+  end # class MemoryProfile
+end # module SE

data/lib/se/negator.rb

@@ -0,0 +1,23 @@
+# http://probablycorey.wordpress.com/2008/03/28/abusing-rubys-question-mark-methods/
+#
+# Takes an object as a parameter and will invert the return values of all its
+# methods.
+#
+
+module SE
+  class Negator
+    def initialize(object)
+      @object = object
+    end
+
+    def method_missing(symbol, *args)
+      !@object.send(symbol, *args)
+    end
+  end
+end
+
+class Object
+  def not
+    SE::Negator.new(self)
+  end
+end

data/lib/se/pager.rb

@@ -0,0 +1,39 @@
+# From: http://nex-3.com/posts/73-git-style-automatic-paging-in-ruby
+#
+# Route STDOUT and STDERR through +less+ if output is more than one screen
+#
+# Call +SE::Pager.run_pager+ before you emit output in your program.
+#
+module SE
+  module Pager
+    def self.run_pager(less_opts='FRSX')
+      return if PLATFORM =~ /win32/
+      return unless STDOUT.tty?
+
+      read, write = IO.pipe
+
+      if Kernel.fork.nil?
+        # Child process
+        STDOUT.reopen(write)
+        STDERR.reopen(write) if STDERR.tty?
+        read.close
+        write.close
+        return
+      end
+
+      # Parent process, become pager
+      STDIN.reopen(read)
+      read.close
+      write.close
+
+      # set less options via envar
+      ENV['LESS'] = less_opts
+
+      # Wait until we have input before we start the pager
+      Kernel.select [STDIN]
+
+      pager = ENV['PAGER'] || 'less'
+      exec pager rescue exec "/bin/sh", "-c", pager
+    end
+  end # module Pager
+end # module SE

data/lib/se/sleeper.rb

@@ -0,0 +1,105 @@
+# Sleep, execute block, repeat.
+# Allow resetting of the timer.
+#
+# An array of sleepers is stored in +Thread.main[:sleepers]+ to make
+# sure we terminate all sleeper threads when a signal is trapped.
+#
+class Sleeper
+
+  # a hash of signals and their old handlers
+  OLD_HANDLERS = {
+    'INT'   => nil,
+    'TERM'  => nil,
+  }
+
+  class Reset < Exception ; end
+
+  attr_reader :thread
+
+  # Return an array of Sleepers in this process.
+  def self.sleepers
+    Thread.main[:sleepers] ||= begin
+      set_traps
+      []
+    end
+  end
+
+
+  # Initialize the sleeper by passing a +timetout+ in seconds and an
+  # optional block.
+  #
+  def initialize(timeout, &block)
+    after_wake &block if block_given?
+
+    Sleeper.sleepers << self
+
+    @thread = Thread.new do
+      while true do
+        begin
+          sleep(timeout.to_i)
+          # TODO: investigate using Thread.critical
+          Thread.current[:awake] = true
+          @after_wake.each {|block| block.call} if @after_wake
+        rescue Reset
+          @after_reset.each {|block| block.call} if @after_reset
+          # re-start sleep cycle
+        ensure
+          Thread.current[:awake] = false
+        end
+      end
+    end
+
+  end
+
+  # Reset the sleeper.
+  #
+  # This will cause all +after_reset+ handlers to be executed.
+  #
+  def reset
+    thread.raise(Reset.new) unless thread[:awake]
+  end
+
+  # Terminate the Sleeper.
+  #
+  # This will cause all +after_terminate+ handlers to be executed.
+  #
+  def terminate
+    Sleeper.sleepers.delete(self)
+    thread.terminate
+    @after_terminate.each {|block| block.call} if @after_terminate
+    @thread = nil
+  end
+
+  # Add a block to be executed after the Sleeper wakes up.
+  def after_wake(&block)
+    (@after_wake ||= []) << block
+  end
+
+  # Add a block to be executed after the Sleeper is reset.
+  def after_reset(&block)
+    (@after_reset ||= []) << block
+  end
+
+  # Add a block to be executed after the Sleeper is terminated.
+  def after_terminate(&block)
+    (@after_terminate ||= []) << block
+  end
+
+private
+
+  def self.set_traps
+    OLD_HANDLERS.keys.each do |sig|
+      OLD_HANDLERS[sig] = Signal.trap(sig) do
+        kill_all_sleepers
+        OLD_HANDLERS[sig].call unless 'DEFAULT' == OLD_HANDLERS[sig]
+      end
+    end
+  end
+
+  def self.kill_all_sleepers
+    while to_kill = Thread.main[:sleepers].pop do
+      to_kill.terminate
+    end
+  end
+
+end

data/lib/se/timer.rb

@@ -0,0 +1,67 @@
+require 'lib/se/aspect'
+
+module SE
+  class Timer
+
+    class << self
+      attr_accessor :stats, :timers, :enabled
+
+      def start(item)
+        return unless enabled
+        timers[item] = Time.now
+      end
+
+      def end(item)
+        return unless enabled
+        return unless timers[item]
+        self.stats[item][:calls] += 1
+        self.stats[item][:time]  += Time.now - timers[item]
+      end
+
+      def time_block(item)
+        self.start(item)
+        retval = yield
+        self.end(item)
+        return retval
+      end
+
+      # Note: Does not work on methods that take blocks.
+      def time_method(klass, method, item, type="instance")
+        item ||= "#{klass}::#{method}"
+        SE::Aspect.define do
+          if type == "instance"
+            with_instance_of(klass).before(method.to_sym) {SE::Timer.start(item)}
+            with_instance_of(klass).after(method.to_sym) {SE::Timer.end(item)}
+          else
+            with_class(klass).before(method.to_sym) {SE::Timer.start(item)}
+            with_class(klass).after(method.to_sym) {SE::Timer.end(item)}
+          end
+        end
+      end
+
+      def reset
+        stats.clear
+        timers.clear
+        enabled = true
+      end
+
+      def stats
+        Thread.current['SE::Timer.stats'] ||= Hash.new {|hash, key| hash[key] = Hash.new(0.0)}
+      end
+
+      def timers
+        Thread.current['Worfkeed::Timer.timers'] ||= {}
+      end
+
+      def enabled
+        Thread.current['SE::timer.enabled'] ||= false
+      end
+
+      def enabled=(value)
+        Thread.current['SE::timer.enabled'] = value
+      end
+
+    end
+
+  end # class Timer
+end # module SE

data/lib/se/unicode.rb

@@ -0,0 +1,28 @@
+# Source: http://snippets.dzone.com/posts/show/4546
+#
+# This module lazily defines constants of the form Uxxxx for all Unicode
+# codepoints from +U0000+ to +U10FFFF+. The value of each constant is the
+# UTF-8 string for the codepoint.
+#
+# Examples:
+#   copyright = SE::Unicode::U00A9
+#   euro = SE::Unicode::U20AC
+#   infinity = SE::Unicode::U221E
+#
+module SE
+  module Unicode
+
+    def self.const_missing(name)
+      # Check that the constant name is of the right form: U0000 to U10FFFF
+      if name.to_s =~ /^U([0-9a-fA-F]{4,5}|10[0-9a-fA-F]{4})$/
+        # Convert the codepoint to an immutable UTF-8 string,
+        # define a real constant for that value and return the value
+        #p name, name.class
+        const_set(name, [$1.to_i(16)].pack("U").freeze)
+      else  # Raise an error for constants that are not Unicode.
+        raise NameError, "Uninitialized constant: Unicode::#{name}"
+      end
+    end
+
+  end # module Unicode
+end # module SE

data/test/se/aspect_test.rb

@@ -0,0 +1,43 @@
+require 'test/unit'
+require "#{File.dirname(__FILE__)}/../../lib/se/aspect"
+
+class AspectTest < Test::Unit::TestCase
+
+  class Foo < Array
+  end
+
+
+  # need to do all tests at once or we'll have side effects between tests
+  def test_aspect
+    before_class    = false
+    before_instance = false
+    after_instance  = false
+    after_class     = false
+
+    SE::Aspect.define do
+      with_class(Foo).before(:new) do |klass|
+        before_class = true
+      end
+
+      with_instance_of(Foo).before(:empty?) do |instance|
+        before_instance = true
+      end
+
+      with_class(Foo).after(:new) do |klass|
+        after_instance = true
+      end
+
+      with_instance_of(Foo).after(:empty?) do |instance|
+        after_class = true
+      end
+    end
+
+    Foo.new.empty?
+    assert_equal true, before_class, 'before class method failed'
+    assert_equal true, after_class, 'after class method failed'
+    assert_equal true, before_instance, 'before instance method failed'
+    assert_equal true, after_instance, 'after instance method failed'
+  end
+
+end
+

data/test/se/core_ext/date_test.rb

@@ -0,0 +1,15 @@
+require 'test/unit'
+require "#{File.dirname(__FILE__)}/../../../lib/se/core_ext/date"
+
+class DateTest < Test::Unit::TestCase
+
+  def test_days_in_year_for_normal_year
+    assert_equal 365, Date.parse('2009-01-01').days_in_year
+  end
+
+  def test_days_in_year_for_leap_year
+    assert_equal 366, Date.parse('2000-01-01').days_in_year
+  end
+
+
+end

data/test/se/core_ext/regexp_test.rb

@@ -0,0 +1,15 @@
+require 'test/unit'
+require "#{File.dirname(__FILE__)}/../../../lib/se/core_ext/regexp"
+
+class RegexpTest < Test::Unit::TestCase
+
+  def test_blank
+    assert_equal false, /abc/.blank?, 'blank? should always return false'
+  end
+
+  def test_include
+    assert_equal true, /a|b|c/.include?('a'), '/a|b|c/ should match a'
+    assert_equal false, /a|b|c/.include?('x'), '/a|b|c/ should not match a'
+  end
+
+end

data/test/se/core_ext/retryable_test.rb

@@ -0,0 +1,16 @@
+require 'test/unit'
+require "#{File.dirname(__FILE__)}/../../../lib/se/core_ext/retryable"
+
+class RetryableTest < Test::Unit::TestCase
+
+  def test_retryable_smoke_test
+    flag = true
+    Kernel.retryable(:tries => 2) do
+      if flag
+        flag = false
+        raise 'oops!'
+      end
+    end
+  end
+
+end

data/test/se/{debug/debug_test.rb → debug_test.rb}

@@ -1,5 +1,5 @@
 require 'test/unit'
-require "#{File.dirname(__FILE__)}/../../../lib/se/debug/debug"
+require "#{File.dirname(__FILE__)}/../../lib/se/debug"
 
 class DebugTest < Test::Unit::TestCase
 

data/test/se/memory_profiler_test.rb

@@ -0,0 +1,19 @@
+require 'test/unit'
+require "#{File.dirname(__FILE__)}/../../lib/se/memory_profiler"
+require 'fileutils'
+
+class MemoryProfilerTest < Test::Unit::TestCase
+
+  def teardown
+    FileUtils.rm(SE::MemoryProfiler.log_file_name)
+  end
+
+  def test_memory_profiler
+    SE::MemoryProfiler.start(:every=>1)
+    sleep 3
+    assert_equal true, File.exists?(SE::MemoryProfiler.log_file_name)
+    lines = File.open(SE::MemoryProfiler.log_file_name, 'r') {|f| f.readlines}
+    assert_equal 3, lines.grep(/Top 20/).size
+  end
+
+end

data/test/se/negator_test.rb

@@ -0,0 +1,13 @@
+require 'test/unit'
+require "#{File.dirname(__FILE__)}/../../lib/se/negator"
+
+class NegatorTest < Test::Unit::TestCase
+
+  def test_negation
+    assert_equal false, [].not.empty?
+    assert_equal true, ['1'].not.empty?
+  end
+
+end
+
+

data/test/se/sleeper_test.rb

@@ -0,0 +1,54 @@
+require 'test/unit'
+require "#{File.dirname(__FILE__)}/../../lib/se/sleeper"
+
+class SleeperTest < Test::Unit::TestCase
+
+  def teardown
+    Sleeper.send(:kill_all_sleepers)
+  end
+
+  def test_initialize_accepts_no_block
+    @sleeper = Sleeper.new(1)
+  end
+
+  def test_block_executed_multiple_times
+    wakes = 0
+    @sleeper = Sleeper.new(1) {wakes += 1}
+    sleep(3)
+    assert_equal 2, wakes
+  end
+
+  def test_reset_invokes_after_reset_blocks
+    resets = 0
+    @sleeper = Sleeper.new(1)
+    @sleeper.after_reset {resets += 1}
+    @sleeper.reset
+    assert_equal 1, resets, 'Invalid number of resets'
+  end
+
+  def test_reset_prevents_after_wake_execution
+    @sleeper = Sleeper.new(2) {raise %q{after_wake shouldn't be called}}
+    3.times do
+      sleep(1)
+      @sleeper.reset
+    end
+  end
+
+  def test_terminate_invokes_after_terminate_blocks
+    terminates = 0
+    sleeper = Sleeper.new(5)
+    sleeper.after_terminate {terminates += 1}
+    sleeper.terminate
+    assert_equal 1, terminates, 'Invalid number of terminates'
+  end
+
+  def test_signals_kills_sleeper_threads
+    count = Thread.list.size
+    Sleeper::OLD_HANDLERS.keys.each do |sig|
+      5.times {Sleeper.new(30)}
+      Process.kill(sig, $$)
+      assert_equal count, Thread.list.size, 'too many threads left'
+    end
+  end
+
+end

data/test/se/timer_test.rb

@@ -0,0 +1,37 @@
+require 'test/unit'
+require "#{File.dirname(__FILE__)}/../../lib/se/timer"
+
+class TimerTest < Test::Unit::TestCase
+
+  def test_thread_safety
+    threads = []
+    3.times do
+      threads << Thread.new do
+        SE::Timer.enabled = true
+        SE::Timer.start(:thread)
+        sleep(1)
+        SE::Timer.end(:thread)
+        assert_equal 1, SE::Timer.stats[:thread][:calls], 'Incorrect call count'
+      end
+    end
+    threads.each {|ii| ii.join}
+  end
+
+  class Base
+    def foo
+      :foo
+    end
+  end
+
+  class Foo < Base
+  end
+
+  def test_inherited_class_timing
+    SE::Timer.time_method(Base, :foo, 'base.foo')
+    SE::Timer.time_method(Foo,  :foo, 'foo.foo' )
+    SE::Timer.enabled = true
+    Foo.new.foo
+    assert_equal ['base.foo','foo.foo'], SE::Timer.stats.keys.sort
+  end
+
+end # class TimerTest

data/test/se/unicode_test.rb

@@ -0,0 +1,16 @@
+require 'test/unit'
+require "#{File.dirname(__FILE__)}/../../lib/se/unicode"
+
+class UnicodeTest < Test::Unit::TestCase
+
+  def test_unicode
+    assert_equal "a", "#{SE::Unicode::U0061}"
+  end
+
+  def test_excepton_raised_on_invalid_unicode_value
+    assert_raise NameError do
+      "#{SE::Unicode::U65}"
+    end
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ss-se_gem
 version: !ruby/object:Gem::Version 
-  version: 0.0.6
+  version: 1.0.0
 platform: ruby
 authors: 
 - Scott Steadman
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-05 00:00:00 -07:00
+date: 2009-07-12 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -25,12 +25,25 @@ extra_rdoc_files:
 files: 
 - lib/core_ext.rb
 - lib/debug.rb
+- lib/se/aspect.rb
 - lib/se/core_ext/array.rb
+- lib/se/core_ext/benchmark.rb
+- lib/se/core_ext/date.rb
 - lib/se/core_ext/dir.rb
-- lib/se/core_ext/meta_class.rb
 - lib/se/core_ext/object.rb
-- lib/se/debug/debug.rb
+- lib/se/core_ext/regexp.rb
+- lib/se/core_ext/retryable.rb
+- lib/se/core_ext/socket.rb
+- lib/se/core_ext/yaml.rb
+- lib/se/debug.rb
+- lib/se/memory_profiler.rb
+- lib/se/metaclass.rb
+- lib/se/negator.rb
+- lib/se/pager.rb
+- lib/se/sleeper.rb
 - lib/se/test/difference.rb
+- lib/se/timer.rb
+- lib/se/unicode.rb
 - lib/se_gem.rb
 - lib/test.rb
 - LICENSE
@@ -62,7 +75,16 @@ signing_key:
 specification_version: 3
 summary: A collection of handy scripts.
 test_files: 
-- test/se/debug/debug_test.rb
+- test/se/sleeper_test.rb
+- test/se/aspect_test.rb
+- test/se/negator_test.rb
+- test/se/unicode_test.rb
 - test/se/core_ext/dir_test.rb
+- test/se/core_ext/retryable_test.rb
 - test/se/core_ext/object_test.rb
+- test/se/core_ext/date_test.rb
 - test/se/core_ext/array_test.rb
+- test/se/core_ext/regexp_test.rb
+- test/se/timer_test.rb
+- test/se/memory_profiler_test.rb
+- test/se/debug_test.rb