clivecrous-ramaze 0.3.9.5

data/lib/ramaze/snippets/divide.rb

@@ -0,0 +1,20 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+class String
+  # A convenient way to do File.join
+  # Usage:
+  #   'a' / 'b' # => 'a/b'
+  def / obj
+    File.join(self, obj.to_s)
+  end
+end
+
+class Symbol
+  # A convenient way to do File.join
+  # Usage:
+  #   :dir/:file # => 'dir/file'
+  def / obj
+    self.to_s / obj
+  end
+end

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

@@ -0,0 +1,23 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+# Extensions for Kernel
+
+module Kernel
+  unless defined?__DIR__
+
+    # This is similar to +__FILE__+ and +__LINE__+, and returns a String
+    # representing the directory of the current file is.
+    # Unlike +__FILE__+ the path returned is absolute.
+    #
+    # This method is convenience for the
+    #  File.expand_path(File.dirname(__FILE__))
+    # idiom.
+    #
+
+    def __DIR__()
+      filename = caller[0][/^(.*):/, 1]
+      File.expand_path(File.dirname(filename))
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+# Extensions for Kernel
+
+module Kernel
+
+  # Require all .rb and .so files on the given globs, utilizes Dir::[].
+  #
+  # Examples:
+  #   # Given following directory structure:
+  #   # src/foo.rb
+  #   # src/bar.so
+  #   # src/foo.yaml
+  #   # src/foobar/baz.rb
+  #   # src/foobar/README
+  #
+  #   # requires all files in 'src':
+  #   acquire 'src/*'
+  #
+  #   # requires all files in 'src' recursive:
+  #   acquire 'src/**/*'
+  #
+  #   # require 'src/foo.rb' and 'src/bar.so' and 'src/foobar/baz.rb'
+  #   acquire 'src/*', 'src/foobar/*'
+
+  def acquire *globs
+    globs.flatten.each do |glob|
+      Dir[glob].each do |file|
+        require file if file =~ /\.(rb|so)$/
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+# Extensions for Kernel
+
+module Kernel
+  # Original from Trans (Facets 1.4.5)
+  # This is similar to +Module#const_get+ but is accessible at all levels,
+  # and, unlike +const_get+, can handle module hierarchy.
+  #
+  #   constant("Fixnum")                  # -> Fixnum
+  #   constant(:Fixnum)                   # -> Fixnum
+  #
+  #   constant("Process::Sys")            # -> Process::Sys
+  #   constant("Regexp::MULTILINE")       # -> 4
+  #
+  #   require 'test/unit'
+  #   Test.constant("Unit::Assertions")   # -> Test::Unit::Assertions
+  #   Test.constant("::Test::Unit")       # -> Test::Unit
+
+  def constant(const)
+    const = const.to_s.dup
+    base = const.sub!(/^::/, '') ? Object : ( self.kind_of?(Module) ? self : self.class )
+    const.split(/::/).inject(base){ |mod, name| mod.const_get(name) }
+  end
+end

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

@@ -0,0 +1,15 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'pp'
+
+# Extensions for Kernel
+
+module Kernel
+  unless defined?(pretty_inspect)
+    # returns a pretty printed object as a string.
+    def pretty_inspect
+      PP.pp(self, '')
+    end
+  end
+end

data/lib/ramaze/snippets/metaid.rb

@@ -0,0 +1,17 @@
+# from http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+
+class Object
+  # The hidden singleton lurks behind everyone
+  def metaclass; class << self; self; end; end
+  def meta_eval &blk; metaclass.instance_eval(&blk); end
+
+  # Adds methods to a metaclass
+  def meta_def name, &blk
+    meta_eval { define_method name, &blk }
+  end
+
+  # Defines an instance method within a class
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
+  end
+end

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

@@ -0,0 +1,25 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+class Numeric
+  FILESIZE_FORMAT = [
+    ['%.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
+    end
+
+    self.to_s
+  end
+end

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/pretty.rb

@@ -0,0 +1,6 @@
+class Object
+  def pretty s = ''
+    PP.pp(self, s)
+    s
+  end
+end

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

@@ -0,0 +1,11 @@
+class Object
+
+  # returns a new clean binding for this object
+  #   usage: eval 'self', object.scope  #=> returns object
+  #
+
+  def scope
+    lambda{}
+  end
+
+end

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

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

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

@@ -0,0 +1,76 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+Traits = Hash.new{|h,k| h[k] = {}} unless defined?(Traits)
+
+# Extensions for Object
+
+class Object
+
+  # Adds a method to Object to annotate your objects with certain traits.
+  # It's basically a simple Hash that takes the current object as key
+  #
+  # Example:
+  #
+  #   class Foo
+  #     trait :instance => false
+  #
+  #     def initialize
+  #       trait :instance => true
+  #     end
+  #   end
+  #
+  #   Foo.trait[:instance]
+  #   # false
+  #
+  #   foo = Foo.new
+  #   foo.trait[:instance]
+  #   # true
+
+  def trait hash = nil
+    if hash
+      Traits[self].merge! hash
+    else
+      Traits[self]
+    end
+  end
+
+  # builds a trait from all the ancestors, closer ancestors
+  # overwrite distant ancestors
+  #
+  # class Foo
+  #   trait :one => :eins
+  #   trait :first => :erstes
+  # end
+  #
+  # class Bar < Foo
+  #   trait :two => :zwei
+  # end
+  #
+  # class Foobar < Bar
+  #   trait :three => :drei
+  #   trait :first => :overwritten
+  # end
+  #
+  # Foobar.ancestral_trait
+  # {:three=>:drei, :two=>:zwei, :one=>:eins, :first=>:overwritten}
+
+  def ancestral_trait
+    if respond_to?(:ancestors)
+      ancs = ancestors
+    else
+      ancs = self.class.ancestors
+    end
+    ancs.reverse.inject({}){|s,v| s.merge(v.trait)}.merge(trait)
+  end
+
+  # trait for self.class
+
+  def class_trait
+    if respond_to?(:ancestors)
+      trait
+    else
+      self.class.trait
+    end
+  end
+end

data/lib/ramaze/snippets/ordered_set.rb

@@ -0,0 +1,40 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+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
+    else
+      @set = *args
+    end
+
+    @set ||= []
+    @set = [@set] unless ::Array === @set
+    @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)
+    when '[]='
+      @set.map! do |e|
+        if ::Array === args.last
+          args.last.include?(e) ? nil : e
+        else
+          args.last == e ? nil : e
+        end
+      end
+    end
+    @set.__send__(meth, *args, &block)
+  ensure
+    @set.compact! if meth == :[]=
+  end
+end

data/lib/ramaze/snippets/proc/locals.rb

@@ -0,0 +1,11 @@
+class Proc
+
+  # returns a hash of localvar/localvar-values from proc, useful for template
+  # engines that do not accept bindings/proc and force passing locals via
+  # hash
+  #   usage: x = 42; p Proc.new.locals #=> {'x'=> 42}
+  def locals
+    instance_eval('binding').locals
+  end
+
+end

data/lib/ramaze/snippets/ramaze/caller_info.rb

@@ -0,0 +1,30 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  # Gives you back the file, line and method of the caller number i
+  # Example:
+  #   Ramaze.caller_info(1)
+  #   # => ['/usr/lib/ruby/1.8/irb/workspace.rb', '52', 'irb_binding']
+
+  def self.caller_info(i = 1)
+    file, line, meth = *parse_backtrace(caller[i])
+  end
+
+  # Parses one line of backtrace and tries to extract as much information
+  # as possible.
+  #
+  # Example:
+  #   line = "/web/repo/ramaze/lib/ramaze/dispatcher.rb:105:in `respond'"
+  #   Ramaze.parse_backtrace(line)
+  #   #=> ["/web/repo/ramaze/lib/ramaze/dispatcher.rb", "105", "respond"]
+
+  def self.parse_backtrace(line = '')
+    full = line.scan(/(.*?):(\d+):in `(.*?)'/).first
+    return full if full and full.all?
+    partial = line.scan(/(.*?):(\d+)/).first
+    return partial if partial and partial.all?
+    line
+  end
+end

data/lib/ramaze/snippets/ramaze/caller_lines.rb

@@ -0,0 +1,51 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+
+  # Gives you some context around a specific line in a file.
+  # the size argument works in both directions + the actual line,
+  # size = 2 gives you 5 lines of source, the returned array has the
+  # following format.
+  #   [
+  #     line = [
+  #              lineno           = Integer,
+  #              line             = String,
+  #              is_searched_line = (lineno == initial_lineno)
+  #            ],
+  #     ...,
+  #     ...
+  #   ]
+  # Example:
+  #  caller_lines('/usr/lib/ruby/1.8/debug.rb', 122, 2) # ->
+  #   [
+  #     [ 120, "  def check_suspend",                               false ],
+  #     [ 121, "    return if Thread.critical",                     false ],
+  #     [ 122, "    while (Thread.critical = true; @suspend_next)", true  ],
+  #     [ 123, "      DEBUGGER__.waiting.push Thread.current",      false ],
+  #     [ 124, "      @suspend_next = false",                       false ]
+  #   ]
+
+  def self.caller_lines(file, line, size = 4)
+    return [[0, file, true]] if file == '(eval)'
+    lines = File.readlines(File.expand_path(file)) rescue []
+    current = line.to_i - 1
+
+    first = current - size
+    first = first < 0 ? 0 : first
+
+    last = current + size
+    last = last > lines.size ? lines.size : last
+
+    log = lines[first..last] || []
+
+    area = []
+
+    log.each_with_index do |line, index|
+      index = index + first + 1
+      area << [index, line.chomp, index == current + 1]
+    end
+
+    area
+  end
+end

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

@@ -0,0 +1,58 @@
+module Ramaze
+
+  # A alike of attr_accessor and friends, but for thread variables in
+  # Thread::current
+  module ThreadAccessor
+
+    # 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|
+            key, meth = key.to_sym, meth.to_sym
+            yield key, meth
+          end
+        else
+          key = meth = name.to_sym
+          yield key, meth
+        end
+      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
+          define_method(meth) do
+            unless Thread.current.key?(key)
+              Thread.current[key] = instance_eval(&initializer)
+            else
+              Thread.current[key]
+            end
+          end
+        else
+          define_method(meth){ Thread.current[key] }
+        end
+      end
+    end
+  end
+end