ramaze 0.0.6

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

@@ -0,0 +1,22 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Kernel
+
+  # Example:
+  #   aquire 'foo/bar/*'
+  # requires all files inside foo/bar - recursive
+  # can take multiple parameters, it's mainly used to require all the
+  # snippets.
+
+  def aquire *files
+    files.each do |file|
+      require file if %w(rb so).any?{|f| File.file?("#{file}.#{f}")}
+      $:.each do |path|
+        Dir[File.join(path, file, '*.rb')].each do |file|
+          require file
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'set'
+
+module Ramaze
+
+  # this method loops through all loaded/required files
+  # and re-loads them when they are updated.
+  # It takes one parameter, which is the interval in seconds
+  # with a default of 10.
+  # You can also safely kill all threads (except for the main)
+  # and it will just restart the autoreloader.
+
+  def self.autoreload interval = 10
+    debug "initialize autoreload with an interval of #{interval} seconds"
+
+    gatherer = Thread.new do
+      this = Thread.current
+      this[:task] = :autoreload
+
+      cache = {}
+      file_set = Set.new
+
+      loop do
+        files = file_set.dup
+        $LOADED_FEATURES.map do |file|
+          file = file.to_s
+          paths = $LOAD_PATH + ['']
+          correct_path = paths.find{|lp| File.exist?(File.join(lp.to_s, file))}
+          correct_file = File.expand_path(File.join(correct_path, file)) if correct_path
+
+          files << correct_file if correct_file
+        end
+
+        this[:files] = files
+
+        sleep_interval = this[:interval] ||= interval || 10
+        sleep sleep_interval
+      end
+    end
+
+    reloader = Thread.new do
+      this = Thread.current
+      this[:task] = :autoreload
+
+      cache = {}
+      this[:interval] = interval
+      sleep 0.1 until gatherer[:files] # wait for the gatherer
+
+      loop do
+        gatherer[:files].each do |file|
+          begin
+            current_time = File.mtime(file)
+            if last_time = cache[file]
+              unless last_time == current_time
+                Ramaze::Informer.info "autoreload #{file}"
+                load(file)
+                cache[file] = current_time
+              end
+            else
+              cache[file] = current_time
+            end
+          rescue Object => ex # catches errors when the load fails
+            # in case mtime fails
+            unless ex.message =~ /No such file or directory/
+              puts ex
+              puts ex.backtrace
+            end
+            # sleep a total of reloader[:interval],
+            # but spread it evenly on all files
+          end # begin
+          sleep_interval = this[:interval].to_f / gatherer[:files].size
+          sleep sleep_interval
+        end # each
+      end # loop
+    end # Thread.new
+  end # autoreload
+end # Ramaze

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

@@ -0,0 +1,58 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Kernel
+  # Gives you back the file, line and method of the caller number i
+  # Example:
+  #   __caller_info__(1) # -> ['/usr/lib/ruby/1.8/irb/workspace.rb', '52', 'irb_binding']
+
+  def __caller_info__(i = 1)
+    file, line, meth = caller[i].scan(/(.*?):(\d+):in `(.*?)'/).first
+  end
+
+  # 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 __caller_lines__ file, line, size = 4
+    return [[0, file, true]] if file == '(eval)'
+    lines = File.readlines(file)
+    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/kernel/constant.rb

@@ -0,0 +1,24 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+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/rescue_require.rb

@@ -0,0 +1,12 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+module Kernel
+
+  # try to require a file, output message if it failes.
+
+  def rescue_require(sym, message = nil)
+    require sym
+  rescue LoadError, RuntimeError
+    puts message if message
+  end
+end

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

@@ -0,0 +1,41 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Kernel
+  alias_method :method_get, :method unless defined? method_get
+
+  # get the object of the method you are currently in or any
+  # other out of the backtrace, as long as it is in the same
+  # instance and retrievable via method_get (which is the old #method).
+  #
+  #   class Foo
+  #     def bar
+  #       method
+  #     end
+  #   end
+  #
+  #   Foo.new.bar #=> #<Method: Foo#bar>
+
+  def method(n = 0)
+    return method_get(n) unless n.is_a? Integer
+    method_get caller.to_s.scan(/`(.*?)'/)[n].first rescue nil
+  end
+end
+
+class Method
+
+  # name of the Method (example shows combination with the new Kernel#method)
+  #
+  #   class Foo
+  #     def bar
+  #       method.name
+  #     end
+  #   end
+  #
+  #   Foo.new.bar #=> 'bar'
+
+  def name
+    #<Method: A.d>
+    inspect.gsub(/#<Method: .*?[\.#](.*?)>/, '\1')
+  end
+end

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

@@ -0,0 +1,13 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+module Kernel
+
+  # sets $VERBOSE temporarily to nil so you can redefine constants in peace
+
+  def silently
+    old_verbose, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+end

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

@@ -0,0 +1,60 @@
+#          Copyright (c) 2006 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] = {}}
+
+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
+    ancs = (ancestors rescue self.class.ancestors)
+    ancs.reverse.inject({}){|s,v| s.merge(v.trait)}.merge(trait)
+  end
+end

data/lib/ramaze/snippets/openstruct/temp.rb

@@ -0,0 +1,10 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+class OpenStruct
+
+  # create a new OpenStruct and fill it with a merge of the old @table and the passed hash
+
+  def temp hash
+    self.class.new(@table.merge(hash))
+  end
+end

data/lib/ramaze/snippets/string/DIVIDE.rb

@@ -0,0 +1,16 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+class String
+
+  # A convinient way to do File.join
+  #
+  # Example:
+  #   'a' / 'b'                      # -> 'a/b'
+  #   File.dirname(__FILE__) / 'bar' # -> "ramaze/snippets/string/bar"
+
+  def / obj
+    File.join(self, obj.to_s)
+  end
+end
+

data/lib/ramaze/snippets/string/camel_case.rb

@@ -0,0 +1,14 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+class String
+
+  # simple transformation to CamelCase from snake_case
+  #
+  #   'foo_bar'.camel_case # => 'FooBar'
+
+  def camel_case
+    split('_').map{|e| e.capitalize}.join
+  end
+end
+

data/lib/ramaze/snippets/string/snake_case.rb

@@ -0,0 +1,12 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+class String
+
+  # convert to snake_case from CamelCase
+  #
+  #   'FooBar'.snake_case # => 'foo_bar'
+
+  def snake_case
+    gsub(/\B[A-Z]/, '_\&').downcase.gsub(' ', '_')
+  end
+end

data/lib/ramaze/snippets/symbol/to_proc.rb

@@ -0,0 +1,14 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+class Symbol
+
+  # the well-known #to_proc
+  # creates a lambda that sends the symbol and any further arguments
+  # to the object yielded.
+  #   [1, 2, 3].map(&:to_s)    # => ['1', '2', '3']
+  #   %w[a b c].map(&:to_sym)  # => [:a, :b, :c]
+
+  def to_proc
+    lambda{|o, *args| o.send(self, *args) }
+  end
+end

data/lib/ramaze/snippets/thread/deadQUESTIONMARK.rb

@@ -0,0 +1,11 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+class Thread
+
+  # check if the thread is not alive (not alive?)
+
+  def dead?
+    not alive?
+  end
+end

data/lib/ramaze/store/default.rb

@@ -0,0 +1,48 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'yaml/store'
+
+module Ramaze
+  module Store
+
+    # A simple wrapper around YAML::Store
+
+    class Default
+      attr_accessor :db
+
+      # create a new store with a filename
+
+      def initialize filename = 'db.yaml'
+        FileUtils.touch(filename)
+        @db = YAML::Store.new(filename)
+      end
+
+      # pass on all methods inside a transaction
+
+      def method_missing(meth, *args, &block)
+        @db.transaction do
+          @db.send(meth, *args, &block)
+        end
+      end
+
+      # the actual content of the store in YAML format
+
+      def to_yaml
+        Db.dump(:x)
+      end
+
+      # loads the #to_yaml
+
+      def original
+        YAML.load(to_yaml)
+      end
+
+      # available keys of the store
+
+      def keys
+        original.keys
+      end
+    end
+  end
+end