nano 0.8.1

data/lib/nano/binding/local_variables.rb

@@ -0,0 +1,11 @@
+require 'nano/binding/eval'
+class Binding
+  # Returns the local variables defined in the binding context
+  #
+  #   a = 2
+  #   binding.local_variables  #=> ["a"]
+  #
+  def local_variables()
+    eval( "local_variables" )
+  end
+end

data/lib/nano/binding/method_name.rb

@@ -0,0 +1,14 @@
+require 'nano/binding/caller'
+class Binding
+  # There is a lot of debate on what to call this.
+  # +method_name+ differs from #called only by the fact
+  # that it returns a string, rather then a symbol.
+  #
+  #   def tester; p method_name; end
+  #   tester  #=> "tester"
+  #
+  def method_name
+    name = /\`([^\']+)\'/.match(caller(1).first)[1]
+    return name
+  end
+end

data/lib/nano/binding/of_caller.rb

@@ -0,0 +1,89 @@
+#--
+# Binding-of-Caller, Copyright (c) 2003 Florian Gross
+#++
+
+#begin
+  require 'nano/continuation/%3A%3Acreate'
+#rescue LoadError
+#  class Continuation; end # :nodoc: # for RDoc
+#  def Continuation.create(*args, &block) # :nodoc:
+#    cc = nil; result = callcc {|c| cc = c; block.call(cc) if block and args.empty?}
+#    result ||= args
+#    return *[cc, *result]
+#  end
+#end
+
+class Binding; end # for RDoc
+
+# This method returns the binding of the method that called your
+# method. It will raise an Exception when you're not inside a method.
+#
+# It's used like this:
+#   def inc_counter(amount = 1)
+#     Binding.of_caller do |binding|
+#       # Create a lambda that will increase the variable 'counter'
+#       # in the caller of this method when called.
+#       inc = eval("lambda { |arg| counter += arg }", binding)
+#       # We can refer to amount from inside this block safely.
+#       inc.call(amount)
+#     end
+#     # No other statements can go here. Put them inside the block.
+#   end
+#   counter = 0
+#   2.times { inc_counter }
+#   counter # => 2
+#
+# Binding.of_caller must be the last statement in the method.
+# This means that you will have to put everything you want to
+# do after the call to Binding.of_caller into the block of it.
+# This should be no problem however, because Ruby has closures.
+# If you don't do this an Exception will be raised. Because of
+# the way that Binding.of_caller is implemented it has to be
+# done this way.
+#
+def Binding.of_caller(&block)
+  old_critical = Thread.critical
+  Thread.critical = true
+  count = 0
+  cc, result, error, extra_data = Continuation.create(nil, nil)
+  error.call if error
+
+  tracer = lambda do |*args|
+    type, context, extra_data = args[0], args[4], args
+    if type == "return"
+      count += 1
+      # First this method and then calling one will return --
+      # the trace event of the second event gets the context
+      # of the method which called the method that called this
+      # method.
+      if count == 2
+        # It would be nice if we could restore the trace_func
+        # that was set before we swapped in our own one, but
+        # this is impossible without overloading set_trace_func
+        # in current Ruby.
+        set_trace_func(nil)
+        cc.call(eval("binding", context), nil, extra_data)
+      end
+    elsif type == "line" then
+      nil
+    elsif type == "c-return" and extra_data[3] == :set_trace_func then
+      nil
+    else
+      set_trace_func(nil)
+      error_msg = "Binding.of_caller used in non-method context or " +
+        "trailing statements of method using it aren't in the block."
+      cc.call(nil, lambda { raise(ArgumentError, error_msg) }, nil)
+    end
+  end
+
+  unless result
+    set_trace_func(tracer)
+    return nil
+  else
+    Thread.critical = old_critical
+    case block.arity
+      when 1 then yield(result)
+      else yield(result, extra_data)
+    end
+  end
+end

data/lib/nano/binding/self.rb

@@ -0,0 +1,12 @@
+
+require 'nano/binding/eval'
+
+class Binding
+
+  # Returns the self in the binding context.
+  def self()
+    @self ||= eval( "self" )
+    @self
+  end
+
+end

data/lib/nano/class.rb

@@ -0,0 +1,5 @@
+require 'nano/class/by_name'
+require 'nano/class/descendents'
+require 'nano/class/remove_descendents'
+require 'nano/class/remove_subclasses'
+require 'nano/class/subclasses'

data/lib/nano/class/by_name.rb

@@ -0,0 +1 @@
+require 'nano/module/by_name'

data/lib/nano/class/descendents.rb

@@ -0,0 +1,15 @@
+#--
+# Original code from RubyOnRails (http://www.rubyonrails.com)
+#++
+
+class Class
+  def descendents
+    subclasses = []
+    ObjectSpace.each_object( Class ) do |c|
+      if c.ancestors.include?( self ) and self != c
+        subclasses << c
+      end
+    end
+    return subclasses
+  end
+end

data/lib/nano/class/remove_descendents.rb

@@ -0,0 +1,14 @@
+#--
+# Original code from RubyOnRails (http://www.rubyonrails.com)
+#++
+
+require 'nano/class/descendents'
+
+class Class
+  def remove_descendents
+    self.descendents.each do |subclass|
+      Object.send(:remove_const, subclass.name) rescue nil
+    end
+    ObjectSpace.garbage_collect
+  end
+end

data/lib/nano/class/remove_subclasses.rb

@@ -0,0 +1,4 @@
+require 'nano/class/remove_descendents'
+class Class
+  alias_method :remove_subclasses, :remove_descendents
+end

data/lib/nano/class/subclasses.rb

@@ -0,0 +1,4 @@
+require 'nano/class/descendents'
+class Class
+  alias_method :subclasses, :descendents
+end

data/lib/nano/comparable.rb

@@ -0,0 +1,5 @@
+require 'nano/comparable/at_least'
+require 'nano/comparable/at_most'
+require 'nano/comparable/cap'
+require 'nano/comparable/clip'
+require 'nano/comparable/cmp'

data/lib/nano/comparable/at_least.rb

@@ -0,0 +1,13 @@
+#--
+# Credit goes to Florian Gross.
+#++
+module Comparable
+  # Returns the lower of self or x.
+  #
+  #   4.at_least(5)  #=> 5
+  #   6.at_least(5)  #=> 6
+  #
+  def at_least(x)
+    (self >= x) ? self : x
+  end
+end

data/lib/nano/comparable/at_most.rb

@@ -0,0 +1,13 @@
+#--
+# Credit goes to Florian Gross.
+#++
+module Comparable
+  # Returns the greater of self or x.
+  #
+  #   4.at_most(5)  #=> 4
+  #   6.at_most(5)  #=> 5
+  #
+  def at_most(x)
+    (self <= x) ? self : x
+  end
+end

data/lib/nano/comparable/cap.rb

@@ -0,0 +1,13 @@
+#--
+# Credit goes to Florian Gross.
+#++
+module Comparable
+  # Returns the greater of self or x.
+  #
+  #   4.cap(5)  #=> 4
+  #   6.cap(5)  #=> 5
+  #
+  def cap(x)
+    (self <= x) ? self : x
+  end
+end

data/lib/nano/comparable/clip.rb

@@ -0,0 +1,22 @@
+#--
+# Credit goes to Florian Gross.
+#++
+module Comparable
+  # Returns self if above the given lower bound, or
+  # within the given lower and upper bounds,
+  # otherwise returns the the bound of which the
+  # value falls outside.
+  #
+  #   4.clip(3)    #=> 4
+  #   4.clip(5)    #=> 5
+  #   4.clip(2,7)  #=> 4
+  #   9.clip(2,7)  #=> 7
+  #   1.clip(2,7)  #=> 2
+  #
+  def clip(lower, upper=nil)
+    return lower if self < lower
+    return self unless upper
+    return upper if self > upper
+    return self
+  end
+end

data/lib/nano/comparable/cmp.rb

@@ -0,0 +1,14 @@
+module Comparable
+
+  # Alternate name for comparison operator #<=>.
+  #
+  #   3.cmp(1)   #=>  1
+  #   3.cmp(3)   #=>  0
+  #   3.cmp(10)  #=> -1
+  #
+  def cmp(o)
+    self<=>o
+  end
+
+end
+

data/lib/nano/continuation.rb

@@ -0,0 +1 @@
+require 'nano/continuation/%3A%3Acreate'

data/lib/nano/continuation/%3A%3Acreate.rb

@@ -0,0 +1,50 @@
+
+# Creates a continuation in a way that is easier to use than callcc.
+# On the initial call this will return the created Continuation and
+# the arguments you gave to Continuation.create in an Array. If you
+# then issue .call() on the Continuation execution will jump back to
+# the point of time where you initially invoked Continuation.create,
+# but this time it will return the Continuation and the arguments
+# you supplied in an Array.
+#
+# You can supply a block instead of default arguments which will
+# cause that block to be executed once and its result to be returned
+# along side the created Continuation, but this form is confusing
+# and does only rarely make sense.
+#
+#   # Count from 0 to 10
+#   cc, counter = Continuation.create(0)
+#   puts counter
+#   cc.call(counter + 1) if counter < 10
+#
+#   # Implement something similar to Array#inject using Continuations.
+#   # For simplicity's sake, this is not fully compatible with the real
+#   # inject. Make sure that you understand Array#inject before you try
+#   # to understand this.
+#   class Array
+#     def cc_inject(value = nil)
+#       copy = self.clone
+#       cc, result, item = Continuation.create(value, nil)
+#       next_item = copy.shift
+#       if result and item
+#         # Aggregate the result using the block.
+#         cc.call(yield(result, item), next_item)
+#       elsif next_item
+#         # item not yet set and Array is not empty:
+#         # This means we did not get a value and thus need to use the
+#         # first item from the Array before we can start using the
+#         # block to aggregate the result.
+#         cc.call(next_item, result)
+#       end
+#
+#       return result
+#    end
+#  end
+#  [1,2,3,4,5].cc_inject { |acc, n| acc + n } # => 15
+#
+def Continuation.create(*args, &block)
+  args = [args] if not args.nil? and not args.is_a? Array # 1.6.8 compatibility
+  cc = nil; result = callcc {|c| cc = c; block.call(cc) if block and args.empty?}
+  result ||= args
+  return *[cc, *result]
+end

data/lib/nano/date.rb

@@ -0,0 +1,6 @@
+require 'nano/date/days_in_month'
+require 'nano/date/days_of_month'
+require 'nano/date/stamp'
+require 'nano/date/to_date'
+require 'nano/date/to_s'
+require 'nano/date/to_time'

data/lib/nano/date/days_in_month.rb

@@ -0,0 +1,13 @@
+require 'date'
+class Date
+  # Returns the number of days in the date's month.
+  #
+  #   Date.new(2004,2).days_in_month #=> 28
+  #
+  #--
+  # Credit goes to Ken Kunz.
+  #++
+  def days_in_month
+     Date.civil(year, month, -1).day
+  end
+end

data/lib/nano/date/days_of_month.rb

@@ -0,0 +1,6 @@
+require 'date'
+class Date
+  def days_of_month
+    (1..days_in_month).to_a
+  end
+end

data/lib/nano/date/stamp.rb

@@ -0,0 +1,11 @@
+
+require 'date'
+
+class Date
+
+  # Alias for the original #to_s. Primarily this is used
+  # to create an improved to_s (see date/to_s).
+  #
+  alias_method( :stamp, :to_s )
+
+end

data/lib/nano/date/to_date.rb

@@ -0,0 +1,9 @@
+require 'date'
+
+class Date
+  # To be able to keep Dates and Times
+  # interchangeable on conversions.
+  def to_date
+    self
+  end
+end

data/lib/nano/date/to_s.rb

@@ -0,0 +1,16 @@
+require 'nano/date/stamp'
+
+class Date
+  # An improved #to_s method that cane take an optional
+  # format flag of :short or :long.
+  def to_s(format = nil)
+    case format
+    when :short
+      strftime("%e %b").strip
+    when :long
+      strftime("%B %e, %Y").strip
+    else
+      stamp
+    end
+  end
+end # Date

data/lib/nano/date/to_time.rb

@@ -0,0 +1,10 @@
+require 'date'
+
+class Date
+  # Convert Date to Time.
+  #
+  #
+  def to_time(form = :local)
+    ::Time.send(form, year, month, day)
+  end
+end

data/lib/nano/dir.rb

@@ -0,0 +1,2 @@
+require 'nano/dir/%3A%3Als_r'
+require 'nano/dir/%3A%3Arecurse'

data/lib/nano/dir/%3A%3Als_r.rb

@@ -0,0 +1,21 @@
+#--
+# Credit due to George Moschovitis <gm@navel.gr>
+#++
+class Dir
+  # Recursively scan a directory and pass each file
+  # to the given block.
+  def self.ls_r(path='.', &block)
+    list = []
+    stoplist = ['.', '..']
+    Dir.foreach(path) do |f|
+      next if stoplist.include?(f)
+      filename = path + '/' + f
+      list << filename
+      block.call(filename) if block
+      if FileTest.directory?(filename) and not FileTest.symlink?(filename)
+        list.concat( Dir.recurse(filename, &block) )
+      end
+    end
+    list
+  end
+end

data/lib/nano/dir/%3A%3Arecurse.rb

@@ -0,0 +1,7 @@
+require 'nano/dir/%3A%3Als_r'
+class Dir
+  class << self
+    # Alias for Dir#ls_r (deprecate?)
+    alias_method( :recurse, :ls_r )
+  end
+end