Pistos-ramaze 2008.09

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 * 883612800
+      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__()
+          filename = caller[0][/^(.*):/, 1]
+          File.expand_path(File.dirname(filename))
+        end
+      end
+    end
+
+  end
+end

data/lib/ramaze/snippets/object/acquire.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.
+
+module Ramaze
+  module CoreExtensions
+
+    # Extensions for Kernel
+
+    module Object
+
+      # 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
+
+  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/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,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/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,20 @@
+module Ramaze
+  DEPRECATED_CONSTANTS = {
+    :ThreadAccessor => :StateAccessor
+  }
+
+  def self.deprecated(from, to = nil)
+    message = "%s is deprecated"
+    message << ", use %s instead" unless to.nil?
+    Log.warn(message % [from, to])
+  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
+    # initialize isn't being called, so we have to hook into ::new
+    def self.new(*args)
+      instance = super
+      instance.state = {}
+      instance
+    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

data/lib/ramaze/snippets/string/end_with.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.
+
+module Ramaze
+  module CoreExtensions
+
+    # Extensions for String
+
+    module String
+      unless ''.respond_to?(:end_with?)
+        # Compatibility with 1.9
+        def end_with?(other)
+          other = other.to_s
+          self[-other.size, other.size] == other
+        end
+      end
+    end
+
+  end
+end