rjspotter-ramaze 2009.06.29

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

@@ -0,0 +1,25 @@
+module Ramaze
+  module CoreExtensions
+
+    # Extensions for Binding
+
+    module Binding
+
+      # Returns a hash of localvar/localvar-values from binding, useful for
+      # template engines that do not accept bindings and force passing locals
+      # via hash
+      #
+      # Usage:
+      #   x = 42; p binding.locals #=> {'x'=> 42}
+
+      def locals
+        ::Kernel::eval '
+        local_variables.inject({}){|h,v|
+          k = v.to_s
+          h.merge!(k => eval(k))
+        }', self
+      end
+
+    end
+  end
+end

data/lib/ramaze/snippets/blankslate.rb

@@ -0,0 +1,7 @@
+unless defined?(BlankSlate)
+  class BlankSlate < BasicObject; end if defined?(BasicObject)
+
+  class BlankSlate
+    instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+  end
+end

data/lib/ramaze/snippets/fiber.rb

@@ -0,0 +1,63 @@
+unless defined? Fiber
+  require 'thread'
+
+  class FiberError < StandardError; end
+
+  class Fiber
+    def initialize
+      raise ArgumentError, 'new Fiber requires a block' unless block_given?
+
+      @yield = Queue.new
+      @resume = Queue.new
+
+      @thread = Thread.new{ @yield.push [*yield(*wait)] }
+      @thread.abort_on_exception = true
+      @thread[:fiber] = self
+    end
+    attr_reader :yield, :thread
+
+    def resume *args
+      raise FiberError, 'dead fiber called' unless @thread.alive?
+      @resume.push(args)
+      result = @yield.pop
+      result.size > 1 ? result : result.first
+    end
+
+    def wait
+      @resume.pop
+    end
+    
+    def self.yield *args
+      raise FiberError, "can't yield from root fiber" unless fiber = Thread.current[:fiber]
+      fiber.yield.push(args)
+      result = fiber.wait
+      result.size > 1 ? result : result.first
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}>"
+    end
+  end
+end
+
+if __FILE__ == $0
+  f = Fiber.new{ puts 'hi'; p Fiber.yield(1); puts 'bye'; :done }
+  p f.resume
+  p f.resume(2)
+end
+
+__END__
+
+$ ruby fbr.rb 
+hi
+1
+2
+bye
+:done
+
+$ ruby1.9 fbr.rb 
+hi
+1
+2
+bye
+:done

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

@@ -0,0 +1,21 @@
+#          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'
+
+module Ramaze
+  module CoreExtensions
+
+    # 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
+
+  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,32 @@
+#          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
+  module CoreExtensions
+
+    # Extensions for Numeric
+    module 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
+
+  end
+end

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

@@ -0,0 +1,63 @@
+module Ramaze
+  module CoreExtensions
+
+    # Extensions for Numeric
+
+    module Numeric
+      def seconds
+        self
+      end
+      alias second seconds
+
+      # 60 seconds in a minute
+      def minutes
+        self * 60
+      end
+      alias minute minutes
+
+      # 60 minutes in an hour
+      def hours
+        self * 3600
+      end
+      alias hour hours
+
+      # 24 hours in a day
+      def days
+        self * 86400
+      end
+      alias day days
+
+      # 7 days in a week
+      def weeks
+        self * 604800
+      end
+      alias week weeks
+
+      # 30 days in a month
+      def months
+        self * 2592000
+      end
+      alias month months
+
+      # 365.25 days in a year
+      def years
+        self * 31557600
+      end
+      alias year years
+
+      # Time in the past, i.e. 3.days.ago
+      def ago t = Time.now
+        t - self
+      end
+      alias before ago
+
+      # Time in the future, i.e. 3.days.from_now
+      def from_now t = Time.now
+        t + self
+      end
+      alias since from_now
+
+    end
+
+  end
+end

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

@@ -0,0 +1,29 @@
+#          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
+  module CoreExtensions
+
+    # Extensions for Object
+
+    module Object
+      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__(*args)
+          filename = caller[0][/^(.*):/, 1]
+          dir = File.expand_path(File.dirname(filename))
+          ::File.expand_path(::File.join(dir, *args.map{|a| a.to_s}))
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,19 @@
+#          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
+  module CoreExtensions
+
+    # Extensions for Object
+    module Object
+      # Available in 1.8.6 and later.
+
+      unless ::Object.method_defined?(:instance_variable_defined?)
+        def instance_variable_defined?(variable)
+          instance_variables.include?(variable.to_s)
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,16 @@
+module Ramaze
+  module CoreExtensions
+
+    # Extensions for Object
+    module Object
+
+      # Returns the string that #pretty_inspect would yield
+
+      def pretty s = ''
+        PP.pp(self, s)
+        s
+      end
+    end
+
+  end
+end

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

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

data/lib/ramaze/snippets/ordered_set.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.
+
+require(File.join(File.dirname(__FILE__), 'blankslate'))
+
+# Basically an Set, but with Order, ain't that obivous?
+class OrderedSet < BlankSlate
+  def self.[](*args)
+    new(*args)
+  end
+
+  # 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
+
+  %w[ push unshift << ].each do |meth|
+    class_eval %[
+      def #{meth} *args
+        @set.delete(*args)
+        @set.#{meth}(*args)
+      end
+    ]
+  end
+
+  def []= *args
+    @set.map! do |e|
+      if ::Array === args.last
+        args.last.include?(e) ? nil : e
+      else
+        args.last == e ? nil : e
+      end
+    end
+    @set.__send__(:[]=, *args)
+    @set.compact!
+  end
+
+  # Delegate everything, but controlled, keep elements unique.
+  # Warning, this is not really atomic.
+  def method_missing(meth, *args, &block)
+    @set.__send__(meth, *args, &block)
+  end
+end

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

@@ -0,0 +1,19 @@
+module Ramaze
+  module CoreExtensions
+
+    # Extensions for Proc
+
+    module 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
+  end
+end

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

@@ -0,0 +1,31 @@
+#          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
+  # 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':
+  #   Ramaze.acquire 'src/*'
+  #
+  #   # requires all files in 'src' recursive:
+  #   Ramaze.acquire 'src/**/*'
+  #
+  #   # require 'src/foo.rb' and 'src/bar.so' and 'src/foobar/baz.rb'
+  #   Ramaze.acquire 'src/*', 'src/foobar/*'
+
+  def self.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/ramaze/deprecated.rb

@@ -0,0 +1,23 @@
+module Ramaze
+  DEPRECATED_CONSTANTS = {
+    :BASEDIR        => :ROOT,
+    :Template       => :View,
+    :Optional       => :Optioned,
+  }
+
+  def self.deprecated(from, to = nil)
+    message = "%s is deprecated"
+    message << ", use %s instead" unless to.nil?
+    message << " - from: %p"
+    Log.warn(message % [from, to, caller[1]])
+  end
+
+  def self.const_missing(name)
+    if to = DEPRECATED_CONSTANTS[name]
+      Log.warn "Ramaze::#{name} is deprecated, use #{to} instead"
+      constant(to)
+    else
+      super
+    end
+  end
+end