red 4.1.0 → 4.1.1

data/lib/source/redshift/browser.rb

@@ -0,0 +1,150 @@
+# The +Browser+ module contains methods for checking the current platform and
+# rendering engine.
+# 
+module Browser
+  Plugins = {}
+  
+  # call-seq:
+  #   Browser.engine -> hash
+  # 
+  # Returns a hash containing the name and version of the current rendering
+  # engine.
+  # 
+  #   Browser.engine    #=> {:name => "gecko", :version => 19}
+  # 
+  def self.engine
+    {:name => Engine.instance_variable_get('@name'), :version => Engine.instance_variable_get('@version')}
+  end
+  
+  # call-seq:
+  #   Browser.platform -> string
+  # 
+  # Returns the name of the current platform as a string.
+  # 
+  #   Browser.platform    #=> "mac"
+  # 
+  def self.platform
+    @platform ||= `$q(window.orientation==undefined?(navigator.platform.match(/mac|win|linux/i)||['other'])[0].toLowerCase():'ipod')`
+  end
+  
+  # The +Features+ module mixes in methods to check for browser features such
+  # as XPath and Adobe AIR.
+  # 
+  module Features
+    `c$Browser.c$Features.__xpath__=!!(document.evaluate)`
+    `c$Browser.c$Features.__air__=!!(window.runtime)`
+    `c$Browser.c$Features.__query__=!!(document.querySelector)`
+    
+    # call-seq:
+    #   xpath? -> true or false
+    # 
+    # Returns +true+ if XPath is available, +false+ otherwise.
+    # 
+    def xpath?
+      `c$Browser.c$Features.__xpath__`
+    end
+    
+    # call-seq:
+    #   air? -> true or false
+    # 
+    # Returns +true+ if Adobe AIR is available, +false+ otherwise.
+    # 
+    def air?
+      `c$Browser.c$Features.__air__`
+    end
+    
+    # call-seq:
+    #   query? -> true or false
+    # 
+    # Returns +true+ if the W3C Selectors API is available, +false+ otherwise.
+    #
+    def query?
+      `c$Browser.c$Features.__query__`
+    end
+  end
+  
+  # The +Engine+ module mixes in methods to check the current browser's
+  # rendering engine and its version.
+  # 
+  module Engine
+    if `window.opera`
+      @name    = 'presto'
+      @version = `document.getElementsByClassName` ? 950 : 925
+    elsif `window.ActiveXObject`
+      @name    = 'trident'
+      @version = `window.XMLHttpRequest` ? 5 : 4
+    elsif `!navigator.taintEnabled`
+      @name    = 'webkit'
+      @version = `#{Browser::Features}.__xpath__` ? (`#{Browser::Features}.__query__` ? 525 : 420) : 419
+    elsif `document.getBoxObjectFor != null`
+      @name    = 'gecko'
+      @version = `document.getElementsByClassName` ? 19 : 18
+    else
+      @name    = 'unknown'
+      @version = 0
+    end
+    
+    # call-seq:
+    #   gecko?      -> true or false
+    #   gecko?(num) -> true or false
+    # 
+    # Returns +true+ if the current browser is Firefox. Optionally checks for
+    # version _num_.
+    # 
+    #   gecko?        #=> true
+    #   gecko?(18)    #=> false
+    # 
+    def gecko?(version)
+      self.browser?('gecko', version)
+    end
+    
+    # call-seq:
+    #   presto?      -> true or false
+    #   presto?(num) -> true or false
+    # 
+    # Returns +true+ if the current browser is Opera. Optionally checks for
+    # version _num_.
+    # 
+    #   presto?         #=> true
+    #   presto?(925)    #=> false
+    # 
+    def presto?(version)
+      self.browser?('presto', version)
+    end
+    
+    # call-seq:
+    #   trident?      -> true or false
+    #   trident?(num) -> true or false
+    # 
+    # Returns +true+ if the current browser is Internet Explorer. Optionally
+    # checks for version _num_.
+    # 
+    #   trident?      #=> true
+    #   trident?(4)   #=> false
+    # 
+    def trident?(version)
+      self.browser?('trident', version)
+    end
+    
+    # call-seq:
+    #   webkit?      -> true or false
+    #   webkit?(num) -> true or false
+    # 
+    # Returns +true+ if the current browser is Safari, Mobile Safari, or
+    # Google Chrome. Optionally checks for version _num_.
+    # 
+    #   webkit?         #=> true
+    #   webkit?(419)    #=> false
+    # 
+    def webkit?(version)
+      self.browser?('webkit', version)
+    end
+    
+    def browser?(name, version) # :nodoc:
+      Engine.instance_variable_get('@name') == name && (version ? Engine.instance_variable_get('@version') == version : true)
+    end
+  end
+end
+
+include Browser::Engine
+include Browser::Features

data/lib/source/redshift/chainable.rb

@@ -0,0 +1,75 @@
+# Classes including module +Chainable+ gain the ability to cache a stack of
+# +Proc+ objects. These blocks of code can later be executed one at a time, in
+# the order of their insertion.
+# 
+#   class Foo
+#     include Chainable
+#   end
+#   
+#   foo = Foo.new
+#   foo.chain {|x| puts "x: " + x }.chain {|y,z| puts ["y: %s","z: %s"].join("\n") % [y,z] }
+#   
+#   foo.call_chain('called 1st')
+#   foo.call_chain('called 2nd', 'called 2nd also')
+# 
+# produces:
+# 
+#   x: called 1st
+#   y: called 2nd
+#   z: called 2nd also
+# 
+module Chainable
+  # call-seq:
+  #   chainable.call_chain(arg, ...) -> object or false
+  # 
+  # Removes the foremost +Proc+ from _chainable_'s chain and calls it,
+  # returning the result. Returns +false+ if the chain was empty.
+  # 
+  #   chainable.chain {|x,y,z| x * (y + z) }
+  #   
+  #   chainable.call_chain(4,5,6)   #=> 44
+  #   chainable.call_chain          #=> false
+  # 
+  def call_chain(*args)
+    @chain ||= []
+    return `#{@chain.shift}.__block__.apply(this,args)` unless @chain.empty?
+    return false
+  end
+  
+  # call-seq:
+  #   chainable.chain { |arg,...| block } -> chainable
+  # 
+  # Adds _block_ to the end of _chainable_'s chain, then returns _chainable_.
+  # 
+  #   chainable.chain { puts 1; return 'called 1' }.chain { puts 2; return 'called 2' }
+  #   
+  #   chainable.call_chain    #=> "called 1"
+  #   chainable.call_chain    #=> "called 2"
+  #   chainable.call_chain    #=> false
+  # 
+  # produces:
+  # 
+  #   1
+  #   2
+  # 
+  def chain(&block)
+    @chain ||= []
+    @chain << block
+    return self
+  end
+  
+  # call-seq:
+  #   chainable.clear_chain -> chainable
+  # 
+  # Returns _chainable_ with its chain emptied.
+  # 
+  #   chainable.chain { 1 + 1 }
+  #   
+  #   chainable.clear_chain.call_chain    #=> false
+  # 
+  def clear_chain
+    @chain ||= []
+    @chain.clear
+    return self
+  end
+end

data/lib/source/redshift/code_events.rb

@@ -0,0 +1,204 @@
+# Module +CodeEvents+ enables event-driven programming by giving objects of
+# the including class the ability to define custom observers and callbacks.
+# 
+#   class Looper
+#     include CodeEvents
+#     
+#     def initialize(range)
+#       @range = range
+#     end
+#     
+#     def run(min, max)
+#       self.fire(:start)
+#       @range.each do |i|
+#         self.fire(:minimum, 0, i) && next if i == min
+#         self.fire(:maximum, 0, i) && next if i == max
+#         puts i
+#       end
+#       return self
+#     end
+#   end
+#   
+#   looper = Looper.new(1..10)                                          #=> #<Looper:0x34fe78>
+#   
+#   looper.upon :start do
+#     puts "The loop has begun"
+#   end
+#   
+#   min_proc = Proc.new {|i| puts "Minimum amount reached: %s" % i }    #=> #<Proc:0x3e72a9>
+#   max_proc = Proc.new {|i| puts "Maximum amount reached: %s" % i }    #=> #<Proc:0x3ea147>
+#   looper.upon(:minimum => min_proc, :maximum => max_proc)             #=> #<Looper:0x34fe78>
+#   
+#   looper.run(3,8)                                                     #=> #<Looper:0x34fe78>
+# 
+# produces:
+# 
+#   The loop has begun
+#   1
+#   2
+#   Minimum amount reached: 3
+#   4
+#   5
+#   6
+#   7
+#   Maximum amount reached: 8
+#   9
+#   10
+# 
+module CodeEvents
+  # call-seq:
+  #   obj.fire(sym)                  -> obj
+  #   obj.fire(sym, delay, arg, ...) -> obj
+  # 
+  # Instructs _obj_ to call the +Proc+ objects associated with the event
+  # _sym_, then returns _obj_. Optionally delays the firing of the event by
+  # _delay_ milliseconds. The second form allows passing of arguments to the
+  # event's +Proc+ objects, but if any arguments are passed, the first must be
+  # the _delay_ argument.
+  # 
+  #   obj.upon(:A) {|x| puts x }        #=> obj
+  #   obj.upon(:B) {|y| puts y }        #=> obj
+  #   obj.upon(:C) { puts 'fire 3' }    #=> obj
+  #   
+  #   obj.fire(:A, 500, 'fire 1').fire(:B, 0, 'fire 2').fire(:C)
+  # 
+  # produces:
+  # 
+  #   fire 2
+  #   fire 3
+  #   fire 1
+  # 
+  def fire(sym, delay, *args)
+    name = sym.to_sym
+    return self unless @code_events && events_group = @code_events[name]
+    events_group.each {|proc| proc.process_event(self, delay, args) }
+    return self
+  end
+  
+  # call-seq:
+  #   obj.ignore             -> obj
+  #   obj.ignore(sym)        -> obj
+  #   obj.ignore(sym, &proc) -> obj
+  # 
+  # Instructs _obj_ to ignore the specified event, then returns _obj_.
+  # 
+  # In the first form, all event-related +Proc+ objects not marked
+  # as "unignorable" are removed from _obj_.
+  # 
+  #   obj.upon(:A, true) { puts '1st executed' }    #=> obj
+  #   obj.upon(:A)       { puts '2nd executed' }    #=> obj
+  #   obj.upon(:B)       { puts '3rd executed' }    #=> obj
+  #   
+  #   obj.ignore                                    #=> obj
+  #   obj.fire(:A).fire(:B)                         #=> obj
+  # 
+  # produces:
+  # 
+  #   1st executed
+  # 
+  # In the second form, only the ignorable +Proc+ objects associated with the
+  # event _sym_ are removed.
+  # 
+  #   obj.upon(:A, true) { puts '1st executed' }    #=> obj
+  #   obj.upon(:A)       { puts '2nd executed' }    #=> obj
+  #   obj.upon(:B)       { puts '3rd executed' }    #=> obj
+  #   
+  #   obj.ignore(:A)                                #=> obj
+  #   obj.fire(:A).fire(:B)                         #=> obj
+  # 
+  # produces:
+  # 
+  #   1st executed
+  #   3rd executed
+  # 
+  # In the third form, only the +Proc+ object passed in as <i>&proc</i> is
+  # removed.
+  # 
+  #   proc_1 = Proc.new { puts 'Proc 1 executed' }    #=> #<Proc:0x3e78ee>
+  #   proc_2 = Proc.new { puts 'Proc 2 executed' }    #=> #<Proc:0x3e888a>
+  #   
+  #   obj.upon(:A, &proc_1)                           #=> obj
+  #   obj.upon(:A, &proc_2)                           #=> obj
+  #   
+  #   obj.ignore(:A, &proc_1)                         #=> obj
+  #   obj.fire(:A)                                    #=> obj
+  # 
+  # produces:
+  # 
+  #   Proc 2 executed
+  # 
+  def ignore(sym, &block)
+    if sym
+      name = sym.to_sym
+      return self unless @code_events && events_group = @code_events[name]
+      if block
+        events_group.delete(block) unless `block.__block__.__unignorable__`
+      else
+        events_group.each {|proc| self.disregard(name, &proc) }
+      end
+    else
+      @code_events.each_key {|name| self.disregard(name) }
+    end
+    return self
+  end
+  
+  # call-seq:
+  #   obj.upon(sym, unignorable = false) { |arg,...| block } -> obj
+  #   obj.upon(hash)                                         -> obj
+  # 
+  # Stores a number of +Proc+ objects to be called when the event _sym_ is
+  # fired.
+  # 
+  # The first form adds _block_ to the array of +Proc+ objects executed when
+  # the event _sym_ is fired, then returns _obj_. If _unignorable_ is set to
+  # +true+, the _block_ will be executed when _sym_ fires, regardless of
+  # whether it has been ignored.
+  # 
+  #   obj.upon(:A, true) { puts '1st executed' }    #=> obj
+  #   obj.upon(:A, true) { puts '2nd executed' }    #=> obj
+  #   obj.upon(:A)       { puts '3rd executed' }    #=> obj
+  #   
+  #   obj.ignore(:A)                                #=> obj
+  #   obj.fire(:A)                                  #=> obj
+  # 
+  # produces:
+  # 
+  #   1st executed
+  #   2nd executed
+  # 
+  # The second form takes a hash of +Proc+ objects keyed by event name,
+  # running <tt>obj.upon(name, &proc)</tt> on each key-value pair, then
+  # returns _obj_.
+  # 
+  #   proc_1 = Proc.new { puts '1st executed' }   #=> #<Proc:0x3e78ee>
+  #   proc_2 = Proc.new { puts '2nd executed' }   #=> #<Proc:0x3e888a>
+  #   
+  #   obj.upon(:A => proc_1, :B => proc_2)        #=> obj
+  #   obj.fire(:B)                                #=> obj
+  # 
+  # produces
+  # 
+  #   2nd executed
+  # 
+  def upon(sym_or_hash, unignorable, &block)
+    if sym_or_hash.instance_of?(Hash)
+      sym_or_hash.each {|name,proc| self.upon(name, &proc) }
+      return self
+    else
+      name = sym_or_hash.to_sym
+      @code_events       ||= {}
+      @code_events[name] ||= []
+      @code_events[name] << block
+      `block.__block__.__unignorable__=typeof(unignorable)=='function'?false:unignorable`
+      return self
+    end
+  end
+  
+  class ::Proc # :nodoc:
+    def process_event(context, delay, args_array) # :nodoc:
+      `var f=this.__block__.__unbound__,event_function=function(){return f.apply(context,args_array);}`
+      `if(delay){return setTimeout(event_function,delay);}`
+      `event_function()`
+    end
+  end
+end

data/lib/source/redshift/cookie.rb

@@ -0,0 +1,142 @@
+# Class +Cookie+ governs the writing and accessing of cookies in the browser.
+# 
+# A cookie is a key-value pair stored by your browser as text data. If you
+# know a cookie's key, you can read or overwrite its value, or reassign any of
+# a number of parameters.
+# 
+# Instances of class +Cookie+ are temporary holders for browser-based cookie
+# data. When you create a new +Cookie+ object using <tt>Cookie.new</tt> or
+# update an existing +Cookie+ object using <tt>Cookie#update</tt>, class
+# +Cookie+ writes the key-value pair and the cookie's parameters to the
+# browser's cookie file. You can then read the value of the cookie immediately
+# or during subsequent visits using <tt>Cookie.read</tt>.
+# 
+# The following parameters can be set for a +Cookie+ object:
+# 
+# *Required*
+# _key_::   The unique (per domain) identifier by which you identify a cookie.
+# _value_:: The string of data associated with a given key.
+# 
+# *Optional*
+# _duration_:: The amount of time (in days) before the cookie should expire.
+# _domain_::   The domain to which the cookie should be sent.
+# _path_::     The path, relative to the domain, where the cookie is active.
+# _secure_::   If +true+, the browser will use SSL when sending the cookie.
+# 
+# The browser can hold up to 20 cookies from a single domain.
+# 
+class Cookie
+  OPTIONS = {
+    :duration => nil,
+    :domain   => nil,
+    :path     => nil,
+    :secure   => false,
+    :document => Document
+  }
+  
+  attr_accessor :key, :value, :duration, :domain, :path, :secure, :document
+  
+  # call-seq:
+  #   Cookie.new(key, value, options = {}) -> cookie
+  # 
+  # Returns a new +Cookie+ object with the given parameters and stores the
+  # data in the browser as cookie data. If the browser already has a cookie
+  # that matches _key_, that cookie's parameters will be overwritten.
+  # 
+  #   Cookie.new(:user_jds, '2237115568')   #=> #<Cookie: @key="user_jds" @value="2237115568">
+  #   Cookie.read(:user_jds)                #=> '2237115568'
+  #   
+  #   Cookie.new(:user_jds, '8557acb0')     #=> #<Cookie: @key="user_jds" @value="8557acb0">
+  #   Cookie.read(:user_jds)                #=> '8557acb0'
+  # 
+  def initialize(key, value, options = {})
+    self.key = key
+    self.update(value, OPTIONS.merge(options))
+  end
+  
+  # call-seq:
+  #   Cookie.read(key) -> string
+  # 
+  # Returns the string value of the cookie named _key_, or +nil+ if no such
+  # cookie exists.
+  # 
+  #   c = Cookie.new(:user_jds, '2237115568', :domain => '.example.com')
+  #   
+  #   Cookie.read(:user_jds)   #=> '2237115568'
+  # 
+  # This method can be used to test whether a cookie with the name _key_
+  # exists in the browser.
+  # 
+  #   Cookie.new(:user_jds, '8557acb0') unless Cookie.read(:user_jds)
+  # 
+  def self.read(key)
+    value = `#{OPTIONS[:document].native}.cookie.match('(?:^|;)\\s*' + #{Regexp.escape(key)}.__value__ + '=([^;]*)')`
+    return value ? `$q(decodeURIComponent(value[1]))` : nil
+  end
+  
+  # call-seq:
+  #   Cookie.store(cookie) -> cookie
+  # 
+  # Writes the given cookie to the browser, then returns _cookie_. This method
+  # is called internally by <tt>Cookie.new</tt> and <tt>Cookie#update</tt>.
+  # 
+  def self.store(cookie)
+    `var str = cookie.m$key().__value__ + '=' + encodeURIComponent(cookie.m$value().__value__)`
+    `str += '; domain=' + cookie.m$domain().__value__` if cookie.domain
+    `str += '; path='   + cookie.m$path().__value__`   if cookie.path
+    if cookie.duration
+      `date = new Date()`
+      `date.setTime(date.getTime() + cookie.m$duration() * 86400000)`
+      `str += '; expires=' + date.toGMTString()`
+    end
+    `str += '; secure'` if cookie.secure
+    
+    `#{cookie.document.native}.cookie = str`
+    return cookie
+  end
+  
+  # call-seq:
+  #   cookie.destroy -> true
+  # 
+  # Expires _cookie_, then returns +true+.
+  # 
+  #   c = Cookie.new(:user_jds, '2237115568', :duration => 14)
+  #   
+  #   c.destroy                 #=> true
+  #   Cookie.read(:user_jds)    #=> nil
+  # 
+  def destroy
+    self.update('',:duration => -1)
+  end
+  
+  # call-seq:
+  #   cookie.inspect -> string
+  # 
+  # Returns a string representing _cookie_ and its key-value data.
+  # 
+  #   c = Cookie.new(:user_jds, '2237115568', :duration => 14)
+  #   
+  #   c.inspect   #=> #<Cookie: @key="user_jds" @value="2237115568">
+  # 
+  def inspect
+    "#<Cookie: @key=#{self.key.inspect} @value=#{self.value.inspect}>"
+  end
+  
+  # call-seq:
+  #   cookie.update(value, options = {}) -> cookie
+  # 
+  # Updates _cookie_ with the given parameters, then writes the cookie data to
+  # the browser.
+  # 
+  #   c = Cookie.new(:user_jds, '2237115568', :duration => 14)
+  #   
+  #   Cookie.read(:user_jds)    #=> '2237115568'
+  #   c.update('8557acb0')      #=> #<Cookie: @key="user_jds" @value="8557acb0">
+  #   Cookie.read(:user_jds)    #=> '8557acb0'
+  # 
+  def update(value, options = {})
+    self.value = value
+    options.each {|k,v| self.send("#{k}=",v) }
+    Cookie.store(self)
+  end
+end