ramaze 2008.06 → 2008.11

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

@@ -1,16 +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.
 
-# Extensions for String
+module Ramaze
+  module CoreExtensions
 
-class String
+    # Extensions for String
 
-  # simple transformation to CamelCase from snake_case
-  #
-  #   'foo_bar'.camel_case # => 'FooBar'
+    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
 
-  def camel_case
-    split('_').map{|e| e.capitalize}.join
   end
 end
-

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

@@ -1,27 +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.
 
-# Extensions for String
+module Ramaze
+  module CoreExtensions
+    # Extensions for String
 
-class 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"
+    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

@@ -1,8 +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.
 
-# Extensions for String
+module Ramaze
+  module CoreExtensions
 
-class String
-  alias each each_line unless ''.respond_to?(:each)
+    # 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

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

@@ -1,29 +1,34 @@
 require 'cgi'
 require 'uri'
 
-class String
+module Ramaze
+  module CoreExtensions
 
-  # String#escape is an extensible escaping mechanism for string.  currently
-  # it suports
-  #   '<div>foo bar</div>'.esc(:html)
-  #   'foo bar'.esc(:uri)
-  #   'foo bar'.esc(:cgi)
+    # Extensions for String
 
-  def escape which = :html
-    case which
-    when :html
-      ::CGI.escapeHTML(self)
-    when :cgi
-      ::CGI.escape(self)
-    when :uri
-      ::URI.escape(self)
-    when :sql
-      Ramaze::deprecated("String#escape(:sql)")
-      gsub(%r/'/, "''")
-    else
-      raise ArgumentError, "do not know how to escape '#{ which }'"
+    module String
+
+      # String#escape is an extensible escaping mechanism for string.  currently
+      # it suports
+      #   '<div>foo bar</div>'.esc(:html)
+      #   'foo bar'.esc(:uri)
+      #   'foo bar'.esc(:cgi)
+
+      def escape which = :html
+        case which
+        when :html
+          Rack::Utils.escape_html(self)
+        when :cgi
+          Rack::Utils.escape(self)
+        when :uri
+          ::URI.escape(self)
+        else
+          raise ArgumentError, "do not know how to escape '#{ which }'"
+        end
+      end
+
+      alias_method 'esc', 'escape'
     end
-  end
 
-  alias_method 'esc', 'escape'
+  end
 end

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

@@ -1,15 +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.
 
-# Extensions for String
+module Ramaze
+  module CoreExtensions
 
-class String
-  unless method_defined?(:ord)
+    # Extensions for String
 
-    # compatibility with Ruby 1.9
+    module String
+      unless ''.respond_to?(:ord)
 
-    def ord
-      self[0]
+        # compatibility with Ruby 1.9
+
+        def ord
+          self[0]
+        end
+      end
     end
+
   end
 end

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

@@ -1,15 +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.
 
-# Extensions for String
+module Ramaze
+  module CoreExtensions
 
-class String
+    # Extensions for String
 
-  # convert to snake_case from CamelCase
-  #
-  #   'FooBar'.snake_case # => 'foo_bar'
+    module String
+
+      # convert to snake_case from CamelCase
+      #
+      #   'FooBar'.snake_case # => 'foo_bar'
+
+      def snake_case
+        gsub(/\B[A-Z][^A-Z]/, '_\&').downcase.gsub(' ', '_')
+      end
+    end
 
-  def snake_case
-    gsub(/\B[A-Z][^A-Z]/, '_\&').downcase.gsub(' ', '_')
   end
 end

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

@@ -1,8 +1,19 @@
-class String
-  unless method_defined?(:start_with?)
-    # Compatibility with 1.9
-    def start_with?(other)
-      self[0, other.size] == other
+module Ramaze
+  module CoreExtensions
+
+    # Extensions for String
+
+    module String
+
+      unless ''.respond_to?(:start_with?)
+
+        # Compatibility with 1.9
+
+        def start_with?(other)
+          other = other.to_s
+          self[0, other.size] == other
+        end
+      end
     end
   end
 end

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

@@ -1,20 +1,28 @@
-class String
-  # Useful for writing indented String and unindent on demand, based on the
-  # first line with indentation.
-  def unindent
-    find_indent = proc{ |l| l.find{|l| !l.strip.empty?}.to_s[/^(\s+)/, 1] }
+module Ramaze
+  module CoreExtensions
 
-    lines = self.split("\n")
-    space = find_indent[lines]
-    space = find_indent[lines.reverse] unless space
+    # Extensions for String
 
-    strip.gsub(/^#{space}/, '')
-  end
-  alias ui unindent
+    module String
+
+      # Useful for writing indented String and unindent on demand, based on the
+      # first line with indentation.
+      def unindent
+        find_indent = proc{ |l| l.find{|l| !l.strip.empty?}.to_s[/^(\s+)/, 1] }
+
+        lines = self.split("\n")
+        space = find_indent[lines]
+        space = find_indent[lines.reverse] unless space
+
+        strip.gsub(/^#{space}/, '')
+      end
+      alias ui unindent
 
-  # Destructive variant of undindent, replacing the String
-  def unindent!
-    self.replace unindent
+      # Destructive variant of undindent, replacing the String
+      def unindent!
+        self.replace unindent
+      end
+      alias ui! unindent!
+    end
   end
-  alias ui! unindent!
 end