red 4.1.0 → 4.1.1

data/lib/source/redshift/store.rb

@@ -0,0 +1,48 @@
+# Classes mixing in <tt>Store</tt> gain the ability to store
+# properties related to DOM objects without causing memory-sapping circular
+# references.
+# 
+module Store
+  `#{Store}.__table__={}`
+  
+  # call-seq:
+  #   obj.delete(sym) -> obj
+  # 
+  # Deletes the property _sym_, then returns _obj_.
+  # 
+  def delete(property)
+    `var stringId=''+this.__id__`
+    storage = `#{Store}.__table__[stringId]`
+    storage = `#{Store}.__table__[stringId]=#{{}}` unless storage
+    value = storage[property]
+    value = nil if `value==null`
+    `delete storage.__contents__[property.m$hash()]`
+    return value
+  end
+  
+  # call-seq:
+  #   obj.retrieve(sym, default = nil) -> object or default
+  # 
+  # Returns the property _sym_, or _default_ if the property is not defined.
+  # 
+  def fetch(property, deflt = nil)
+    `var stringId=''+this.__id__`
+    storage = `#{Store}.__table__[stringId]`
+    storage = `#{Store}.__table__[stringId]=#{{}}` unless storage
+    value   = storage[property.to_sym]
+    value   = storage[property.to_sym] = deflt unless `$T(value)||value==false`
+    return value
+  end
+  
+  # call-seq:
+  #   obj.store(hash) -> object
+  # 
+  # Stores the key-value pairs as properties of _obj_, then returns _obj_.
+  # 
+  def store(hash)
+    `var stringId=''+this.__id__`
+    storage = `#{Store}.__table__[stringId]`
+    storage = `#{Store}.__table__[stringId]=#{{}}` unless storage
+    hash.each {|property,value| storage[property.to_sym] = value }
+  end
+end

data/lib/source/redshift/transform.rb

@@ -0,0 +1,199 @@
+require 'code_events'
+
+class Transform
+  include CodeEvents
+  OPTIONS = {:fps => 50,
+	           :unit => false,
+	           :duration => 500,
+	           :link => 'ignore'
+	          }
+	
+	Durations = {:short => 250, 
+	             :normal => 500,
+	             :long => 1000
+	            }
+	
+		
+	`$clear = function(timer){clearTimeout(timer);clearInterval(timer);return nil;};`
+	
+	# need periodical fot setInterval on Effect#step. Find out what
+	# setInterval is when there is net again.
+	`Function.prototype.create = function(options){
+		var self = this;
+		options = options || {};
+		return function(event){
+			var args = options.arguments;
+			args = (args != undefined) ? $splat(args) : Array.slice(arguments, (options.event) ? 1 : 0);
+			if (options.event) args = [event || window.event].extend(args);
+			var returns = function(){
+				return self.apply(options.bind || null, args);
+			};
+			if (options.delay) return setTimeout(returns, options.delay);
+			if (options.periodical) return setInterval(returns, options.periodical);
+			return returns();
+		};
+	}`
+	`Function.prototype.periodical = function(periodical, bind, args){
+		return this.create({bind: bind, arguments: args, periodical: periodical})();
+	};`
+	
+	def self.compute(from, to, delta)
+  	`(to - from) * delta + from`
+  end
+	
+	def initialize(options={})
+	  @subject = @subject || self
+		@options = OPTIONS.merge(options)
+		@options[:duration] = Transform::Durations[@options[:duration]] || @options[:duration].to_i
+		wait = @options[:wait]
+		@options[:link] = 'cancel' if wait === false
+	end
+
+	def step
+	  `
+    var time = +new Date
+		if (time < this.__time__ + #{@options[:duration]}){
+			var delta = this.__transition__((time - this.__time__) / #{@options[:duration]});
+			this.m$set(this.m$compute(this.__from__, this.__to__, delta));
+		} else {
+			this.m$set(this.m$compute(this.__from__, this.__to__, 1));
+			this.m$complete();
+		}
+		`
+	  return nil
+	end
+	
+	def set(now)
+	  return now
+	end
+	
+	def compute(from, to, delta)
+    return Transform.compute(from, to, delta) 
+	end
+	
+	def check(caller)
+	  `
+    if (!this.__timer__) return true;
+		switch (#{@options[:link]}){
+			case 'cancel': this.cancel(); return true;
+			case 'chain' : this.chain(caller.bind(this, Array.slice(arguments, 1))); return false;
+		}`
+		return false
+	end
+	
+	def start(from,to)
+    `if (!this.m$check(arguments.callee, from, to)) return this`
+		`this.__from__ = from`
+		`this.__to__   = to`
+		`this.__time__ = 0`
+		`this.__transition__ = function(p){
+			return -(Math.cos(Math.PI * p) - 1) / 2;
+		}`
+    self.start_timer
+		
+		self.fire(:start)
+		
+		return self
+	end
+		
+	def complete
+	 self.fire(:completion)
+	 self.stop_timer
+	 self
+	end
+	
+	def cancel
+	 self.fire(:cancellation)
+	 self.stop_timer
+ 	 self
+	end
+	
+	def pause
+	  self.stop_timer
+	  self
+	end
+	
+	def resume
+	 self.start_timer
+	 self
+	end
+	
+	def stop_timer
+		`if (!this.__timer__) return false`
+		`this.__time__ = (+new Date) - this.__time__`
+		`this.__timer__ = $clear(this.__timer__)`
+		return true
+	end
+	
+	def start_timer
+    `if (this.__timer__) return false`
+		`this.__time__ = (+new Date) - this.__time__`
+    `this.__timer__ = this.m$step.periodical(Math.round(1000 / #{@options[:fps]}), this)`
+		return true
+	end
+  
+  module Parser
+    class Color
+      def self.hex_to_array(color)
+        `var hex = color.match(/^#?(\\w{1,2})(\\w{1,2})(\\w{1,2})$/).slice(1)`
+        `var rgb = []
+    		for(i = 0, l = hex.length; i < hex.length; i++){
+    		  value = hex[i]
+    		  if (value.length == 1) value += value;
+    		  rgb[i] = parseInt(value,16);
+    		}`
+    		`rgb`
+      end
+      
+      def self.compute(from, to, delta)
+  			rgb = []
+  			from.each do |i|
+  			  rgb << `Math.round(#{::Transform.compute(from[i], to[i], delta)})`
+			  end
+        `'rgb(' + rgb + ')'`
+      end
+      
+      def self.parse(value)
+        `value = value.__value__ || String(value)`
+        `if (value.match(/^#[0-9a-f]{3,6}$/i)) return #{Transform::Parser::Color.hex_to_array(value)}`
+  			`((value = value.match(/(\\d+),\\s*(\\d+),\\s*(\\d+)/))) ? #{[value[1], value[2], value[3]]} : false`
+      end
+      
+      def self.serve(value, unit)
+        value
+      end
+    end
+    
+    class Number
+      def self.compute(from,to,delta)
+        Transform.compute(from,to,delta)
+      end
+      
+      def self.parse(value)
+        `value = value.__value__ || String(value)`
+        `parsed = parseFloat(value)`
+        `(parsed || parsed == 0) ? parsed : false`
+      end
+      
+      def self.serve(value, unit)
+        return (unit) ? value + unit : value
+      end
+    end
+    
+    # can't tween a string
+    class String
+      def self.parse(value)
+        false
+      end
+      def self.compute(from, to, delta)
+        return to        
+      end
+      
+      def self.serve(value, unit)
+        return value
+      end
+    end
+  end
+  
+  Parsers = [Parser::Color, Parser::Number, Parser::String]
+end

data/lib/source/redshift/tween.rb

@@ -0,0 +1,66 @@
+require 'transform'
+
+class Tween < Transform
+  def initialize(element, options)
+    @element = @subject = element
+    super(options)
+  end
+  
+  def start(property, from, to)
+    @property = property
+    parsed = self.prepare(@element, property, [from, to])
+    super(parsed[:from], parsed[:to])
+  end
+  
+  def prepare(element, property, from_to)
+    to = from_to[1]
+    # set a default to, if one isn't set
+    if (!to)
+      from_to[1] = from_to[0]
+      from_to[0] = element.styles[property]
+    end
+    # convert from and to to numeric values from hex/string if possible
+    parsed_from_to = []
+      from_to.each do |val|
+        parsed_from_to << self.parse(val)
+      end
+    return {:from => parsed_from_to[0], :to => parsed_from_to[1]}
+  end
+  
+  # parses a value by its Parser, returning a hash of the parsed value and parser
+  def parse(value)
+    value = value.to_s.split(' ')
+    returns = []
+    value.each do |val|
+      ::Transform::Parsers.each do |parser|
+       parsed = parser.parse(val)
+       `console.log(parsed)`
+       found = {:value => parsed, :parser => parser}  if (parsed)
+      end
+      found = found || {:value => val, :parser => ::Transform::Parser::String}
+      returns << found
+    end
+    return returns
+  end
+  
+  def set(current_value)
+    self.render(@element, @property, current_value[0], @options[:unit])
+		return self
+  end
+  
+  def render(element, property, current_value, unit)
+    element.set_style(property, self.serve(current_value, unit))
+  end
+  
+  def serve(value, unit)
+    value[:parser].serve(value[:value], unit)
+  end
+  
+  def compute(from,to,delta)
+    computed = []
+    (`Math.min(from.length, to.length)`).times do |i|
+     computed << {:value => from[i][:parser].compute(from[i][:value], to[i][:value], delta), :parser => from[i][:parser]}
+    end
+    return computed 
+  end
+end

data/lib/source/redshift/user_events.rb

@@ -0,0 +1,215 @@
+require 'event'
+
+# The +UserEvents+ module mixes in methods for handling user-generated events
+# such as mouse gestures and keystrokes. +UserEvents+ is also responsible for
+# defining new event types based on native events.
+# 
+# Only +Document+, +Window+, and objects of class +Element+ respond to
+# +UserEvents+ methods. See module +CodeEvents+ for information on defining
+# and handling custom callback events.
+# 
+module UserEvents
+  `c$UserEvents.mousecheck=function(element,event){
+    var related=event.__related_target__,el=element.__native__;
+    if(related===nil||related==undefined){return true;};
+    if(related===false){return false;};
+    return((el!==document)&&(related!=el)&&(related.prefix!='xul')&&!(el.contains?el.contains(related):!!(el.compareDocumentPosition(el)&16)))
+  }`
+  
+  NATIVE_EVENTS = {
+  # mouse buttons
+    :click            => 2,
+    :dblclick         => 2,
+    :mouseup          => 2,
+    :mousedown        => 2,
+    :contextmenu      => 2,
+  # mouse wheel
+    :mousewheel       => 2,
+    :DOMMouseScroll   => 2,
+  # mouse movement
+    :mouseover        => 2,
+    :mouseout         => 2,
+    :mousemove        => 2,
+    :selectstart      => 2,
+    :selectend        => 2,
+  # keyboard
+    :keydown          => 2,
+    :keypress         => 2,
+    :keyup            => 2,
+  # form elements
+    :focus            => 2,
+    :blur             => 2,
+    :change           => 2,
+    :reset            => 2,
+    :select           => 2,
+    :submit           => 2,
+  # window
+    :load             => 1,
+    :unload           => 1,
+    :beforeunload     => 1,
+    :resize           => 1,
+    :move             => 1,
+    :DOMContentLoaded => 1,
+    :readystatechange => 1,
+  # misc
+    :error            => 1,
+    :abort            => 1,
+    :scroll           => 1
+  }
+  
+  DEFINED_EVENTS = {
+    :mouse_enter => {:base => 'mouseover', :condition => proc(`c$UserEvents.mousecheck`) },
+    :mouse_leave => {:base => 'mouseout',  :condition => proc(`c$UserEvents.mousecheck`) },
+    :mouse_wheel => {:base => gecko? ? 'DOMMouseScroll' : 'mousewheel' }
+  }
+  
+  # call-seq:
+  #   UserEvents.define(sym, { :base => symbol [, ...] }) -> true
+  # 
+  # Adds a new event type _sym_ to the UserEvents::DEFINED_EVENTS hash with
+  # the given options. The following options can be set:
+  # 
+  # *Required*
+  # <i>base</i>::        A symbol representing the native event type upon
+  #                      which _sym_ will be based.
+  # 
+  # *Optional*
+  # <i>condition</i>::   A +Proc+ object with parameters
+  #                      <tt>|element, event|</tt> which, if returning +false+
+  #                      when evaluated for a given event, kills the event.
+  # <i>on_listen</i>::   A +Proc+ object with parameters
+  #                      <tt>|element, listener_proc|</tt> that is evaluated
+  #                      when _sym_ is passed to <tt>UserEvents#listen</tt>.
+  # <i>on_unlisten</i>:: A +Proc+ object with parameters
+  #                      <tt>|element, listener_proc|</tt> that is evaluated
+  #                      when _sym_ is passed to <tt>UserEvents#unlisten</tt>.
+  # 
+  # --------------------------------------------------------------------------
+  # 
+  #   condition = proc {|element,event| event.shift? }                                                                            #=> #<Proc:0x393825>
+  #   on_listen = proc {|element,listener_proc| puts "%s responds to shift-click with %s" % [element.inspect, listener_proc] }    #=> #<Proc:0x3935da>
+  #   
+  #   UserEvents.define(:shift_click, :base => 'click', :condition => condition, :on_listen => on_listen)                         #=> true
+  #   
+  #   Document['#example'].listen :shift_click do |element,event|
+  #     puts "%s was shift-clicked" % element.inspect
+  #   end
+  # 
+  # produces:
+  # 
+  #   #<Element: DIV id="example"> responds to shift-click with #<Proc:0x3962ae>
+  # 
+  # shift-clicking element '#example' produces:
+  # 
+  #   #<Element: DIV id="example"> was shift-clicked
+  # 
+  def self.define(sym, hash = {})
+    DEFINED_EVENTS[sym.to_sym] = hash
+    return true
+  end
+  
+  def self.included(base) # :nodoc:
+    raise(TypeError, 'only class Element and the singleton objects Window and Document may include UserEvents; use CodeEvents instead') unless base == `c$Element`
+  end
+  
+  def self.extended(base) # :nodoc:
+    raise(TypeError, 'only Document and Window may be extended with UserEvents; use CodeEvents instead') unless [`c$Document`, `c$Window`].include?(base)
+  end
+  
+  # call-seq:
+  #   obj.listen(sym) { |element,event| block } -> obj
+  # 
+  # Adds a listener to _obj_ for a native or defined user event type _sym_,
+  # then returns _obj_.
+  # 
+  #   Document['#example'].listen :click do |element, event|
+  #     puts "%s was clicked" % element.inspect
+  #   end
+  # 
+  # clicking element '#example' produces:
+  # 
+  #   #<Element: DIV id="example"> was clicked
+  # 
+  def listen(sym, &block)
+    type = sym.to_sym
+    events = @events ||= {}
+    events[type]     ||= {}
+    return self if events[type][block]
+    
+    custom    = DEFINED_EVENTS[type]
+    condition = block
+    real_type = type
+    
+    if custom
+      custom[:on_listen].call(self, block) if custom[:on_listen]
+      if custom[:condition]
+        condition = lambda {|element,event| custom[:condition].call(element,event) ? block.call(element,event) : true }
+      end
+      real_type = (custom[:base] || real_type).to_sym
+    end
+    
+    listener     = lambda { block.call(self,nil); }
+    native_event = NATIVE_EVENTS[real_type]
+    
+    if native_event
+      if native_event == 2
+        listener = lambda do |native_event|
+          event = `$v(native_event)`
+          event.kill! if condition.call(self,event) == false
+        end
+      end
+      self.add_listener(real_type, &listener)
+    end
+    
+    events[type][block] = listener
+    return self
+  end
+  
+  def add_listener(sym, &block) # :nodoc:
+    `var el=this.__native__,type=sym.__value__,fn=block.__block__`
+    `if(type==='unload'){var old=fn,that=this;fn=function(){that.m$remove_listener($q('unload'),fn);old();};}else{var collected = {};collected[this.__id__]=this}` # TODO: put this element into "collected"
+    `if(el.addEventListener){el.addEventListener(type,fn,false);}else{el.attachEvent('on'+type,fn);}`
+    return self
+  end
+  
+  # call-seq:
+  #   obj.unlisten(sym, &proc) -> obj
+  # 
+  # Unsets the function _proc_ as a listener for event type _sym_, then
+  # returns _obj_. _proc_ must be the self-same object originally assigned as
+  # a listener.
+  # 
+  #   proc_1 = proc {|element,event| puts "%s was clicked" % element.inspect }
+  #   proc_2 = proc {|element,event| puts "%s has two listeners" % element.inspect }
+  #   elem = Document['#example']
+  #   
+  #   elem.listen(:click, proc_1).listen(:click, proc_2)    #=> #<Element: DIV id="example">
+  #   elem.unlisten(:click, proc_2)                         #=> #<Element: DIV id="example">
+  # 
+  # clicking element '#example' produces:
+  # 
+  #   #<Element: DIV id="example"> was clicked
+  # 
+  def unlisten(sym, &block)
+    type   = sym.to_sym
+    events = @events
+    return self unless events && events[type] && events[type][block]
+    
+    listener = events[type].delete(block)
+    custom   = DEFINED_EVENTS[type]
+    
+    if custom
+      custom[:on_unlisten].call(self, block) if custom[:on_unlisten]
+      type = (custom[:base] || type).to_sym
+    end
+    
+    self.remove_listener(type, &listener) if NATIVE_EVENTS[type]
+    return self
+  end
+   
+  def remove_listener(sym, &block) # :nodoc:
+    `var el=this.__native__,type=sym.__value__,fn=block.__block__`
+    `if(this.removeEventListener){this.removeEventListener(type,fn,false);}else{this.detachEvent('on'+type,fn);}`
+    return self
+  end
+end

data/lib/source/redshift/validator.rb

@@ -0,0 +1,21 @@
+class Element
+  # knows element valid attributes & element valid styles
+  # if you try to set or get invalid attribute or style, warns A
+  # if you try to set an invalid value to an attribute or style, warns B
+  module Validator
+    # attributes shared by all elements; checked last
+    ATTRIBUTES = {
+      :class => lambda {|klass| true }
+      :id    => lambda {|id|    true }
+      :style => lambda {|style| true }
+      :title => lambda {|title| true }
+    }
+    
+    class A
+      ATTRIBUTES = {
+        :href => lambda {|href| true }
+        :rel  => lambda {|href| true }
+      }
+    end
+  end
+end

data/lib/source/redshift/window.rb

@@ -0,0 +1,11 @@
+module Window
+  `this.__native__ = window`
+  
+  def self.window
+    self
+  end
+  
+  def self.document
+    ::Document
+  end
+end

data/lib/source/redspec/index.html

@@ -0,0 +1,11 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+	<title>Redspec</title>
+	<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
+	<link rel="stylesheet" type="text/css" media="screen" href="lib/stylesheets/specs.sass" />
+	<script type="text/javascript" src="lib/red_spec/includes.red"></script>
+</head>
+<body>
+</body>
+</html>