ramaze 0.3.9.1 → 2008.06

data/lib/ramaze/snippets/kernel/__dir__.rb

@@ -16,7 +16,7 @@ module Kernel
     #
 
     def __DIR__()
-      filename = caller[0][/(.*?):/, 1]
+      filename = caller[0][/^(.*):/, 1]
       File.expand_path(File.dirname(filename))
     end
   end

data/lib/ramaze/snippets/kernel/acquire.rb

@@ -31,9 +31,4 @@ module Kernel
       end
     end
   end
-
-  def aquire *globs
-    warn "Kernel#aquire is being deprecated, use Kernel#acquire instead"
-    acquire *globs
-  end
 end

data/lib/ramaze/snippets/metaid.rb

@@ -3,7 +3,7 @@
 class Object
   # The hidden singleton lurks behind everyone
   def metaclass; class << self; self; end; end
-  def meta_eval &blk; metaclass.instance_eval &blk; end
+  def meta_eval &blk; metaclass.instance_eval(&blk); end
 
   # Adds methods to a metaclass
   def meta_def name, &blk

data/lib/ramaze/snippets/numeric/filesize_format.rb

@@ -3,12 +3,18 @@
 
 class Numeric
   FILESIZE_FORMAT = [
-      ['%.1fT', 1 << 40],
-      ['%.1fG', 1 << 30],
-      ['%.1fM', 1 << 20],
-      ['%.1fK', 1 << 10],
-    ]
+    ['%.1fT', 1 << 40],
+    ['%.1fG', 1 << 30],
+    ['%.1fM', 1 << 20],
+    ['%.1fK', 1 << 10],
+  ]
 
+  # Output this number as easily readable filesize.
+  # Usage:
+  #   100_000.filesize_format             # => "97.7K"
+  #   100_000_000.filesize_format         # => "95.4M"
+  #   100_000_000_000.filesize_format     # => "93.1G"
+  #   100_000_000_000_000.filesize_format # => "90.9T"
   def filesize_format
     FILESIZE_FORMAT.each do |format, size|
       return format % (self.to_f / size) if self >= size

data/lib/ramaze/snippets/object/instance_variable_defined.rb

@@ -0,0 +1,8 @@
+class Object
+  # Available in 1.8.6 and later.
+  unless method_defined?(:instance_variable_defined?)
+    def instance_variable_defined?(variable)
+      instance_variables.include?(variable.to_s)
+    end
+  end
+end

data/lib/ramaze/snippets/object/scope.rb

@@ -1,7 +1,7 @@
 class Object
 
   # returns a new clean binding for this object
-  #   usage: eval 'self', object.scope  #=> returns object 
+  #   usage: eval 'self', object.scope  #=> returns object
   #
 
   def scope

data/lib/ramaze/snippets/object/thread_accessor.rb

@@ -1,4 +1,4 @@
-require(File.join(File.dirname(__FILE__), '../ramaze/thread_accessor'))
+require(File.expand_path(File.join(File.dirname(__FILE__), '../ramaze/thread_accessor')))
 
 class Object
   include Ramaze::ThreadAccessor

data/lib/ramaze/snippets/ordered_set.rb

@@ -3,7 +3,9 @@
 
 require(File.join(File.dirname(__FILE__), 'blankslate'))
 
+# Basically an Set, but with Order, ain't that obivous?
 class OrderedSet < BlankSlate
+  # Create new instances, optionally pass the first set
   def initialize(*args)
     if args.size == 1
       @set = args.shift
@@ -16,10 +18,12 @@ class OrderedSet < BlankSlate
     @set.uniq!
   end
 
+  # Delegate everything, but controlled, keep elements unique.
+  # Warning, this is not really atomic.
   def method_missing(meth, *args, &block)
     case meth.to_s
     when /push|unshift|\<\</
-      @set.delete *args
+      @set.delete(*args)
     when '[]='
       @set.map! do |e|
         if ::Array === args.last

data/lib/ramaze/snippets/ramaze/deprecated.rb

@@ -0,0 +1,7 @@
+module Ramaze
+  def self.deprecated(from, to = nil)
+    message = "%s is deprecated"
+    message << ", use %s instead" unless to.nil?
+    Log.warn(message % [from, to])
+  end
+end

data/lib/ramaze/snippets/ramaze/thread_accessor.rb

@@ -1,6 +1,15 @@
 module Ramaze
+
+  # A alike of attr_accessor and friends, but for thread variables in
+  # Thread::current
   module ThreadAccessor
-    def ThreadAccessor.each(*names)
+
+    # Iterate over the names and yield accordingly.
+    # names are either objects responding to #to_sym or hashes.
+    #
+    # It's only used within this module for abstractin-purposes.
+    # Usage below.
+    def self.each(*names)
       names.each do |name|
         if name.respond_to?(:to_hash)
           name.to_hash.each do |key, meth|
@@ -14,17 +23,22 @@ module Ramaze
       end
     end
 
+    # thread_writer and thread_reader, initializer is a block that may be given
+    # and its result will be the new value in case the reader was never called
+    # before or the value wasn't set before.
     def thread_accessor(*names, &initializer)
       thread_writer(*names)
       thread_reader(*names, &initializer)
     end
 
+    # Simple writer accessor to Thread::current[key]=
     def thread_writer(*names)
       ThreadAccessor.each(*names) do |key, meth|
         define_method("#{meth}="){|obj| Thread.current[key] = obj }
       end
     end
 
+    # Reader accessor for Thread::current[key]
     def thread_reader(*names, &initializer)
       ThreadAccessor.each(*names) do |key, meth|
         if initializer

data/lib/ramaze/snippets/string/esc.rb

@@ -8,7 +8,6 @@ class String
   #   '<div>foo bar</div>'.esc(:html)
   #   'foo bar'.esc(:uri)
   #   'foo bar'.esc(:cgi)
-  #   "foo 'bar'".esc(:sql)
 
   def escape which = :html
     case which
@@ -18,7 +17,8 @@ class String
       ::CGI.escape(self)
     when :uri
       ::URI.escape(self)
-    when :sql  # TODO - leverage DBI or something
+    when :sql
+      Ramaze::deprecated("String#escape(:sql)")
       gsub(%r/'/, "''")
     else
       raise ArgumentError, "do not know how to escape '#{ which }'"

data/lib/ramaze/snippets/string/start_with.rb

@@ -1,5 +1,6 @@
 class String
   unless method_defined?(:start_with?)
+    # Compatibility with 1.9
     def start_with?(other)
       self[0, other.size] == other
     end

data/lib/ramaze/snippets/string/unindent.rb

@@ -1,10 +1,18 @@
 class String
+  # Useful for writing indented String and unindent on demand, based on the
+  # first line with indentation.
   def unindent
-    space = self.split("\n").find{|l| !l.strip.empty?}.to_s[/^(\s+)/, 1]
+    find_indent = proc{ |l| l.find{|l| !l.strip.empty?}.to_s[/^(\s+)/, 1] }
+
+    lines = self.split("\n")
+    space = find_indent[lines]
+    space = find_indent[lines.reverse] unless space
+
     strip.gsub(/^#{space}/, '')
   end
   alias ui unindent
 
+  # Destructive variant of undindent, replacing the String
   def unindent!
     self.replace unindent
   end

data/lib/ramaze/snippets/struct/values_at.rb

@@ -4,6 +4,7 @@
 # Extensions for Struct
 
 class Struct
+  undef values_at
 
   # Example:
   #  Point = Struct.new(:x, :y)
@@ -12,12 +13,27 @@ class Struct
   #  # => [10, 15]
   #  point.values_at(0, 1)
   #  # => [15, 10]
+  #  point.values_at(0..1)
+  #  # => [15, 10]
 
   def values_at(*keys)
     if keys.all?{|key| key.respond_to?(:to_int) and not key.is_a?(Symbol) }
       keys.map{|key| values[key.to_int] }
     else
-      keys.map{|k| self[k] }
+      out = []
+
+      keys.each do |key|
+        case key
+        when Range
+          key.each do |r|
+            out << self[r]
+          end
+        else
+          out << self[key]
+        end
+      end
+
+      out
     end
   end
 end

data/lib/ramaze/snippets/thread/into.rb

@@ -12,7 +12,7 @@ class Thread
         Thread.current[k] = thread[k] unless k.to_s =~ /^__/
       end
 
-      yield *args
+      yield(*args)
     end
   end
 end

data/lib/ramaze/sourcereload.rb

@@ -9,139 +9,142 @@ module Ramaze
   # manner.
 
   class SourceReload
-    attr_accessor :thread, :interval, :map
 
-    # Reload everything which falls under this regex
-    trait :reload_glob => Regexp.union(/^\.\//, Dir.pwd, 'ramaze')
+    # Called from Ramaze::startup, just assigns a new instance to
+    # Global.sourcreloader
+    def self.startup(options = {})
+      Thread.main[:sourcereload] = new
+    end
 
-    # Take interval for files that are going to be reloaded.
+    def self.restart
+      Log.dev("Restart SourceReload")
+      shutdown
+      startup
+    end
 
-    def initialize(interval = 1)
-      @interval = interval
-      @map, @files, @paths = [], [], []
-      @mtimes = {}
+    # Maybe make this better?
+    def self.shutdown
+      new(false)
     end
 
-    # start reloader-thread and assign it to this instance.
+    attr_reader :thread
+    attr_accessor :interval
 
-    def start
-      Log.dev("initialize automatic source reload every #{interval} seconds")
-      @thread = reloader
+    # Setup the @mtimes hash. any new file will be assigned it's last modified
+    # time (mtime) so we don't reload a file when we see it the first time.
+    #
+    # The thread only runs if Global.sourcereload is set.
+    def initialize(interval = Global.sourcereload)
+      if sr = Thread.main[:sourcereload]
+        sr.interval = interval
+      else
+        @interval = interval
+        startup
+      end
     end
 
-    # Takes value of Global.sourcereload and unless it's false calls #start
+    def startup
+      return unless @interval
+      Log.dev("Startup SourceReload")
 
-    def self.startup(options = {})
-      interval = Global.sourcereload
-      instance = new(interval)
-      Thread.main[:sourcereload] = instance
-      instance.reload # initial scan of all files
-      instance.start if interval
-    end
+      @mtimes = Hash.new{|h,k| h[k] = mtime(k) }
 
-    # Start reload loop in separate Thread
+      @thread = Thread.new{
+        current = Thread.current
+        current.priority = -1
 
-    def reloader
-      Thread.new do
-        loop do
-          reload
-          sleep(@interval)
+        while iv = @interval
+          rotate
+          sleep iv
         end
-      end
+      }
     end
 
-    # One iteration of reload will look for files that changed since the last
+    # One iteration of rotate will look for files that changed since the last
     # iteration and will try to #safe_load it.
     # This method is quite handy if you want direct control over when your
-    # code is reloaded
+    # code is reloaded.
     #
     # Usage example:
     #
     #   trap :HUP do
     #     Ramaze::Log.info "reloading source"
-    #     Thread.main[:sourcereload].reload
+    #     Thread.main[:sourcereload].rotate
     #   end
     #
 
-    def reload
-      SourceReloadHooks.before_reload
-      all_reload_files.each do |file|
-        mtime = mtime(file)
+    def rotate
+      before_rotation
 
-        next if (@mtimes[file] ||= mtime) == mtime
+      rotation do |file|
+        mtime = mtime(file)
 
-        Log.debug("reload #{file}")
-        @mtimes[file] = mtime if safe_load(file)
+        if mtime > @mtimes[file]
+          safe_load(file)
+        end
       end
-      SourceReloadHooks.after_reload
+
+      after_rotation
     end
 
-    # Scans loaded features and paths for file-paths, filters them in the end
-    # according to the trait[:reload_glob]
-
-    def all_reload_files
-      files = Array[$0, *$LOADED_FEATURES]
-      paths = Array['./', *$LOAD_PATH]
-
-      unless [@files, @paths] == [files, paths]
-        @files, @paths = files.dup, paths.dup
-
-        @map = files.map{|file|
-          if Pathname.new(file).absolute?
-            file
-          else
-            path = paths.find{|pa|
-              ex = File.expand_path(pa/file)
-              File.exists?(ex)
-            }
-            File.expand_path(path/file) if path
+    # Iterates over the $LOADED_FEATURES ($") and $LOAD_PATH ($:) and tries to
+    # find either absolute paths or tries to find one by combining paths and files.
+    # Every found file is yielded to the rotate method.
+
+    def rotation
+      files = Array[$0, *$LOADED_FEATURES].uniq
+      paths = Array['./', *$LOAD_PATH].uniq
+
+      files.each do |file|
+        if Pathname.new(file).absolute?
+          yield(file) if File.file?(file)
+        else
+          paths.each do |path|
+            full = File.join(path, file)
+            if File.file?(full)
+              break yield(full)
+            end
           end
-        }.compact
+        end
       end
-
-      @map.grep(class_trait[:reload_glob])
     end
 
     # Safe mtime
-
     def mtime(file)
       File.mtime(file)
     rescue Errno::ENOENT
       false
     end
 
-    # A safe Kernel::load, issuing the SourceReloadHooks depending on the
-    # result.
-
+    # A safe Kernel::load, issuing the hooks depending on the results
     def safe_load(file)
-      SourceReloadHooks.before_safe_load(file)
+      before_safe_load(file)
       load(file)
-      SourceReloadHooks.after_safe_load_succeed(file)
-      true
+      after_safe_load_succeed(file)
     rescue Object => ex
-      SourceReloadHooks.after_safe_load_failed(file, ex)
-      false
+      after_safe_load_failed(file, ex)
+    ensure
+      @mtimes[file] = mtime(file)
     end
   end
 
   # Holds hooks that are called before and after #reload and #safe_load
 
   module SourceReloadHooks
-    module_function
-
-    # Overwrite to add actions before the reload cycle is started.
+    # Overwrite to add actions before the reload rotation is started.
 
-    def before_reload
+    def before_rotation
     end
 
-    # Overwrite to add actions after the reload cycle has ended.
+    # Overwrite to add actions after the reload rotation has ended.
 
-    def after_reload
+    def after_rotation
     end
 
     # Overwrite to add actions before a file is Kernel::load-ed
 
     def before_safe_load(file)
+      Log.debug("reload #{file}")
     end
 
     # Overwrite to add actions after a file is Kernel::load-ed successfully,
@@ -151,7 +154,7 @@ module Ramaze
       Cache.compiled.clear
       Cache.resolved.clear
       Cache.action_methods.clear
-      SourceReloadHooks.after_safe_load(file)
+      after_safe_load(file)
     end
 
     # Overwrite to add custom hook in addition to default Cache cleaning
@@ -166,4 +169,8 @@ module Ramaze
       Log.error(error)
     end
   end
+
+  class SourceReload
+    include SourceReloadHooks
+  end
 end