ramaze 2012.04.14 → 2012.12.08b

data/lib/ramaze/snippets/array/put_within.rb

@@ -1,38 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the MIT license.
-
-module Ramaze
-  module CoreExtensions
-    # Extensions for Array
-    module Array
-      #   a = [1, 2, 3]
-      #   a.put_within(4, :after => 2, :before => 3)
-      #   a # => [1, 2, 4, 3]
-      def put_within(object, constrain)
-        pre, post = constrain.values_at(:after, :before)
-
-        return put_after(pre, object) if rindex(post) - index(pre) == 1
-
-        raise ArgumentError, "Too many elements within constrain"
-      end
-
-      #   a = [1, 2, 3]
-      #   a.put_after(2, 4)
-      #   a # => [1, 2, 4, 3]
-      def put_after(element, object)
-        return self[index(element) + 1, 0] = object if include?(element)
-
-        raise ArgumentError, "The given element doesn't exist"
-      end
-
-      #   a = [1, 2, 3]
-      #   a.put_before(2, 4)
-      #   a # => [1, 4, 2, 3]
-      def put_before(element, object)
-        return self[rindex(element), 0] = object if include?(element)
-
-        raise ArgumentError, "The given element doesn't exist"
-      end
-    end # Array
-  end # CoreExtensions
-end # Ramaze

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

@@ -1,20 +0,0 @@
-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
-      #
-      # @example
-      #  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 # Binding
-  end # CoreExtensions
-end # Ramaze

data/lib/ramaze/snippets/fiber.rb

@@ -1,41 +0,0 @@
-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

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

@@ -1,18 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the MIT 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 # Kernel
-  end # CoreExtensions
-end # Ramaze

data/lib/ramaze/snippets/metaid.rb

@@ -1,17 +0,0 @@
-# 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

@@ -1,30 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the MIT 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 # Numeric
-  end # CoreExtensions
-end # Ramaze

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

@@ -1,59 +0,0 @@
-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 # Numeric
-  end # CoreExtensions
-end # Ramaze

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

@@ -1,16 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the MIT 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 # Object
-  end # CoreExtensions
-end # Ramaze

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

@@ -1,12 +0,0 @@
-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 # Object
-  end # CoreExtensions
-end # Ramaze

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

@@ -1,16 +0,0 @@
-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 # Object
-  end # CoreExtensions
-end # Ramaze

data/lib/ramaze/snippets/ordered_set.rb

@@ -1,51 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the MIT 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

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

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

@@ -1,32 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the MIT 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 # Ramaze

data/lib/ramaze/snippets/ramaze/dictionary.rb

@@ -1,400 +0,0 @@
-# = dictionary.rb
-#
-# == Copyright (c) 2005 Jan Molic, Thomas Sawyer
-#
-#   Ruby License
-#
-#   This module is free software. You may use, modify, and/or redistribute this
-#   software under the same terms as Ruby.
-#
-#   This program is distributed in the hope that it will be useful, but WITHOUT
-#   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-#   FOR A PARTICULAR PURPOSE.
-#
-# == Special Thanks
-#
-# Ported from OrderHash 2.0, Copyright (c) 2005 jan molic
-#
-# Thanks to Andrew Johnson for his suggestions and fixes of Hash[],
-# merge, to_a, inspect and shift.
-#
-# == Authors & Contributors
-#
-# * Jan Molic
-# * Thomas Sawyer
-
-# Author::    Jan Molic
-# Copyright:: Copyright (c) 2006 Jan Molic
-# License::   Ruby License
-
-# = Dictionary
-#
-# The Dictionary class is a Hash that preserves order.
-# So it has some array-like extensions also. By defualt
-# a Dictionary object preserves insertion order, but any
-# order can be specified including alphabetical key order.
-#
-# == Usage
-#
-# Just require this file and use Dictionary instead of Hash.
-#
-#   # You can do simply
-#   hsh = Dictionary.new
-#   hsh['z'] = 1
-#   hsh['a'] = 2
-#   hsh['c'] = 3
-#   p hsh.keys     #=> ['z','a','c']
-#
-#   # or using Dictionary[] method
-#   hsh = Dictionary['z', 1, 'a', 2, 'c', 3]
-#   p hsh.keys     #=> ['z','a','c']
-#
-#   # but this don't preserve order
-#   hsh = Dictionary['z'=>1, 'a'=>2, 'c'=>3]
-#   p hsh.keys     #=> ['a','c','z']
-#
-#   # Dictionary has useful extensions: push, pop and unshift
-#   p hsh.push('to_end', 15)       #=> true, key added
-#   p hsh.push('to_end', 30)       #=> false, already - nothing happen
-#   p hsh.unshift('to_begin', 50)  #=> true, key added
-#   p hsh.unshift('to_begin', 60)  #=> false, already - nothing happen
-#   p hsh.keys                     #=> ["to_begin", "a", "c", "z", "to_end"]
-#   p hsh.pop                      #=> ["to_end", 15], if nothing remains, return nil
-#   p hsh.keys                     #=> ["to_begin", "a", "c", "z"]
-#   p hsh.shift                    #=> ["to_begin", 30], if nothing remains, return nil
-#
-# == Usage Notes
-#
-# * You can use #order_by to set internal sort order.
-# * #<< takes a two element [k,v] array and inserts.
-# * Use ::auto which creates Dictionay sub-entries as needed.
-# * And ::alpha which creates a new Dictionary sorted by key.
-
-module Ramaze
-  class Dictionary
-
-    class << self
-
-      #--
-      # TODO is this needed? Doesn't the super class do this?
-      #++
-
-      def []( *args )
-        hsh = new
-        if Hash === args[0]
-          hsh.replace(args[0])
-        elsif (args.size % 2) != 0
-          raise ArgumentError, "odd number of elements for Hash"
-        else
-          while !args.empty?
-            hsh[args.shift] = args.shift
-          end
-        end
-        hsh
-      end
-
-      # Like #new but the block sets the order.
-      #
-      def new_by( *args, &blk )
-        new(*args).order_by(&blk)
-      end
-
-      # Alternate to #new which creates a dictionary sorted by key.
-      #
-      #   d = Dictionary.alpha
-      #   d["z"] = 1
-      #   d["y"] = 2
-      #   d["x"] = 3
-      #   d  #=> {"x"=>3,"y"=>2,"z"=>2}
-      #
-      # This is equivalent to:
-      #
-      #   Dictionary.new.order_by { |key,value| key }
-
-      def alpha( *args, &block )
-        new( *args, &block ).order_by_key
-      end
-
-      # Alternate to #new which auto-creates sub-dictionaries as needed.
-      #
-      #   d = Dictionary.auto
-      #   d["a"]["b"]["c"] = "abc"  #=> { "a"=>{"b"=>{"c"=>"abc"}}}
-      #
-      def auto( *args )
-        #AutoDictionary.new(*args)
-        leet = lambda { |hsh, key| hsh[key] = new( &leet ) }
-        new(*args, &leet)
-      end
-    end
-
-    def initialize( *args, &blk )
-      @order = []
-      @order_by = nil
-      @hash = Hash.new( *args, &blk )
-    end
-
-    def order
-      reorder if @order_by
-      @order
-    end
-
-    # Keep dictionary sorted by a specific sort order.
-
-    def order_by( &block )
-      @order_by = block
-      order
-      self
-    end
-
-    # Keep dictionary sorted by key.
-    #
-    #   d = Dictionary.new.order_by_key
-    #   d["z"] = 1
-    #   d["y"] = 2
-    #   d["x"] = 3
-    #   d  #=> {"x"=>3,"y"=>2,"z"=>2}
-    #
-    # This is equivalent to:
-    #
-    #   Dictionary.new.order_by { |key,value| key }
-    #
-    # The initializer Dictionary#alpha also provides this.
-
-    def order_by_key
-      @order_by = lambda { |k,v| k }
-      order
-      self
-    end
-
-    # Keep dictionary sorted by value.
-    #
-    #   d = Dictionary.new.order_by_value
-    #   d["z"] = 1
-    #   d["y"] = 2
-    #   d["x"] = 3
-    #   d  #=> {"x"=>3,"y"=>2,"z"=>2}
-    #
-    # This is equivalent to:
-    #
-    #   Dictionary.new.order_by { |key,value| value }
-
-    def order_by_value
-      @order_by = lambda { |k,v| v }
-      order
-      self
-    end
-
-    #
-
-    def reorder
-      if @order_by
-        assoc = @order.collect{ |k| [k,@hash[k]] }.sort_by( &@order_by )
-        @order = assoc.collect{ |k,v| k }
-      end
-      @order
-    end
-
-    #def ==( hsh2 )
-    #  return false if @order != hsh2.order
-    #  super hsh2
-    #end
-
-    def ==( hsh2 )
-      if hsh2.is_a?( Dictionary )
-        @order == hsh2.order &&
-          @hash  == hsh2.instance_variable_get("@hash")
-      else
-        false
-      end
-    end
-
-    def [] k
-      @hash[ k ]
-    end
-
-    def fetch( k )
-      @hash.fetch( k )
-    end
-
-    # Store operator.
-    #
-    #   h[key] = value
-    #
-    # Or with additional index.
-    #
-    #  h[key,index] = value
-
-    def []=(k, i=nil, v=nil)
-      if v
-        insert(i,k,v)
-      else
-        store(k,i)
-      end
-    end
-
-    def insert( i,k,v )
-      @order.insert( i,k )
-      @hash.store( k,v )
-    end
-
-    def store( a,b )
-      @order.push( a ) unless @hash.has_key?( a )
-      @hash.store( a,b )
-    end
-
-    def clear
-      @order = []
-      @hash.clear
-    end
-
-    def delete( key )
-      @order.delete( key )
-      @hash.delete( key )
-    end
-
-    def each_key
-      order.each { |k| yield( k ) }
-      self
-    end
-
-    def each_value
-      order.each { |k| yield( @hash[k] ) }
-      self
-    end
-
-    def each
-      order.each { |k| yield( k,@hash[k] ) }
-      self
-    end
-    alias each_pair each
-
-    def delete_if
-      order.clone.each { |k| delete k if yield }
-      self
-    end
-
-    def values
-      ary = []
-      order.each { |k| ary.push @hash[k] }
-      ary
-    end
-
-    def keys
-      order
-    end
-
-    def invert
-      hsh2 = self.class.new
-      order.each { |k| hsh2[@hash[k]] = k }
-      hsh2
-    end
-
-    def reject( &block )
-      self.dup.delete_if(&block)
-    end
-
-    def reject!( &block )
-      hsh2 = reject(&block)
-      self == hsh2 ? nil : hsh2
-    end
-
-    def replace( hsh2 )
-      @order = hsh2.order
-      @hash = hsh2.hash
-    end
-
-    def shift
-      key = order.first
-      key ? [key,delete(key)] : super
-    end
-
-    def unshift( k,v )
-      unless @hash.include?( k )
-        @order.unshift( k )
-        @hash.store( k,v )
-        true
-      else
-        false
-      end
-    end
-
-    def <<(kv)
-      push(*kv)
-    end
-
-    def push( k,v )
-      unless @hash.include?( k )
-        @order.push( k )
-        @hash.store( k,v )
-        true
-      else
-        false
-      end
-    end
-
-    def pop
-      key = order.last
-      key ? [key,delete(key)] : nil
-    end
-
-    def to_a
-      ary = []
-      each { |k,v| ary << [k,v] }
-      ary
-    end
-
-    def to_s
-      self.to_a.to_s
-    end
-
-    def inspect
-      ary = []
-      each {|k,v| ary << k.inspect + "=>" + v.inspect}
-      '{' + ary.join(", ") + '}'
-    end
-
-    def dup
-      self.class[*to_a.flatten]
-    end
-
-    def update( hsh2 )
-      hsh2.each { |k,v| self[k] = v }
-      reorder
-      self
-    end
-    alias merge! update
-
-    def merge( hsh2 )
-      self.dup.update(hsh2)
-    end
-
-    def select
-      ary = []
-      each { |k,v| ary << [k,v] if yield k,v }
-      ary
-    end
-
-    def find
-      each{|k,v| return k, v if yield(k,v) }
-      return nil
-    end
-
-    def first
-      @hash[order.first]
-    end
-
-    def last
-      @hash[order.last]
-    end
-
-    def length
-      @order.length
-    end
-    alias size length
-
-    def empty?
-      @hash.empty?
-    end
-
-  end
-end