ptomato-ramaze 2009.02

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/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,21 @@
+module Ramaze
+  DEPRECATED_CONSTANTS = {
+    :ThreadAccessor => :StateAccessor
+  }
+
+  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

data/lib/ramaze/snippets/ramaze/fiber.rb

@@ -0,0 +1,24 @@
+module Ramaze
+  class Fiber < ::Fiber
+    attr_accessor :state
+
+    def initialize(*args)
+      super
+      @state = {}
+    end
+
+    attr_accessor :state
+
+    def [](key)
+      @state[key]
+    end
+
+    def []=(key, value)
+      @state[key] = value
+    end
+
+    def key?(key)
+      @state.key?(key)
+    end
+  end if defined?(::Fiber)
+end

data/lib/ramaze/snippets/ramaze/state.rb

@@ -0,0 +1,86 @@
+module Ramaze
+  class State
+    def initialize
+      @core = detect
+    end
+
+    def detect
+      require 'fiber'
+      @extract = :resume
+      Ramaze::Fiber
+    rescue LoadError
+      @extract = :value
+      ::Thread
+    end
+
+    def [](key)
+      @core.current[key]
+    end
+
+    def []=(key, value)
+      @core.current[key] = value
+    end
+
+    def key?(key)
+      @core.current.key?(key)
+    end
+
+    def wrap(&block)
+      @core.new(&block).send(@extract)
+    end
+  end
+
+  module StateAccessor
+
+    # 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
+
+    # state_writer and state_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 state_accessor(*names, &initializer)
+      state_writer(*names)
+      state_reader(*names, &initializer)
+    end
+
+    # Simple writer accessor to STATE[key]=
+    def state_writer(*names)
+      StateAccessor.each(*names) do |key, meth|
+        define_method("#{meth}="){|obj| STATE[key] = obj }
+      end
+    end
+
+    # Reader accessor for STATE[key]
+    def state_reader(*names, &initializer)
+      StateAccessor.each(*names) do |key, meth|
+        if initializer
+          define_method(meth) do
+            unless STATE.key?(key)
+              STATE[key] = instance_eval(&initializer)
+            else
+              STATE[key]
+            end
+          end
+        else
+          define_method(meth){ STATE[key] }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+
+#          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
+  class Struct < ::Struct
+
+    # Makes it possible to access the keys directly by their name, not only
+    # their index. The original Struct#values_at tries to call #to_int on the
+    # arguments.
+    # in Ruby < 1.9 this would lead to a quite unintuitive IndexError, while
+    # in 1.9 it will say outright that it cannot convert Symbol into Integer.
+    # I think this is neither useful nor expected, so we extend
+    # Struct#values_at to recognize valid members of the Struct passed into
+    # the method and return their values in the same order, just like
+    # Hash#values_at.
+    #
+    # Example:
+    #  Point = Struct.new(:x, :y)
+    #  point = Point.new(15, 10)
+    #
+    #  # Old behaviour:
+    #  point.values_at(0, 1)
+    #  # => [15, 10]
+    #  point.values_at(0..1)
+    #  # => [15, 10]
+    #  point.values_at(:y, :x)
+    #  # => IndexError: offset 20697 too large for struct(size:2)
+    #
+    #  # Added new behaviour:
+    #  point.values_at(:y, :x)
+    #  # => [10, 15]
+
+    def values_at(*keys)
+      keys.map do |key|
+        case key
+        when String, Symbol
+          self[key]
+        else
+          return super
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/snippets/string/camel_case.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.
+
+module Ramaze
+  module CoreExtensions
+
+    # Extensions for String
+
+    module String
+
+      # simple transformation to CamelCase from snake_case
+      #
+      #   'foo_bar'.camel_case # => 'FooBar'
+
+      def camel_case
+        split('_').map{|e| e.capitalize}.join
+      end
+    end
+
+  end
+end

data/lib/ramaze/snippets/string/color.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
+  module CoreExtensions
+    # Extensions for String
+
+    module String
+      { :reset          =>  0,
+        :bold           =>  1,
+        :dark           =>  2,
+        :underline      =>  4,
+        :blink          =>  5,
+        :negative       =>  7,
+        :black          => 30,
+        :red            => 31,
+        :green          => 32,
+        :yellow         => 33,
+        :blue           => 34,
+        :magenta        => 35,
+        :cyan           => 36,
+        :white          => 37,
+      }.each do |key, value|
+        define_method key do
+          "\e[#{value}m" + self + "\e[0m"
+        end
+      end
+    end
+
+  end
+end

data/lib/ramaze/snippets/string/each.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 String
+
+    module String
+      # 1.9 Compatibility with 1.8
+
+      unless ''.respond_to?(:each)
+        def each(*args, &block)
+          each_line(*args, &block)
+        end
+      end
+    end
+  end
+end