red 4.1.0 → 4.1.1

data/lib/source/redshift/event.rb

@@ -0,0 +1,312 @@
+`function $v(event){
+  var doc=$u,result=$u,type=$u,target=$u,code=$u,key=$u,f_key=$u,wheel=$u,right_click=$u,page=$u,client=$u,related_target=$u;
+  event = event || window.event;
+  doc = document;
+  if(!event){return nil;};
+  result=c$Event.m$new(null);
+  type = event.type;
+  target = event.target || event.srcElement;
+  while(target&&target.nodeType==3){target=event.parentNode;};
+  if(/key/.test(type)){
+    code=event.which || event.keyCode;
+    key=c$Event.c$KEYS.m$_brac(code);
+    if(type=='keydown'){f_key=code-111;if(f_key>0&&f_key<13){key=$s('f'+f_key);};};
+    key=$T(key)?key:$s(String.fromCharCode(code).toLowerCase());
+  }else{
+    if(type.match(/(click|mouse|menu)/i)){
+      doc=(!doc.compatMode || doc.compatMode == 'CSS1Compat') ? doc.html : doc.body;
+      wheel=(type.match(/DOMMouseScroll|mousewheel/) ? (event.wheelDelta ? event.wheelDelta/40 : -(event.detail||0)) : nil);
+      right_click=event.which==3||event.button==2;
+      page={x:(event.pageX || event.clientX + doc.scrollLeft),y:(event.pageY || event.clientY + doc.scrollTop)};
+      client={x:(event.pageX ? event.pageX - window.pageXOffset : event.clientX),y:(event.pageY ? event.pageY - window.pageYOffset : event.clientY)};
+      if(type.match(/over|out/)){
+        switch(type){
+          case 'mouseover':related_target=event.relatedTarget || event.fromElement;break;
+          case 'mouseout':related_target=event.relatedTarget || event.toElement;break;
+        };
+        if(window.m$gecko_bool()){
+          try{while(related_target&&related_target.nodeType==3){related_target=related_target.parentNode;};}catch(e){related_target=false;};
+        }else{while(related_target&&related_target.nodeType==3){related_target.parentNode;};};
+      };
+    };
+  };
+  result.__native__=event;result.__code__=code;result.__key__=key;result.__type__=type;result.__target__=target;result.__wheel__=wheel;result.__right_click__=right_click;result.__related_target__=related_target;
+  result.__page__=page||{x:nil,y:nil};result.__client__=client||{x:nil,y:nil};
+  result.__shift__=event.shiftKey;result.__ctrl__=event.ctrlKey;result.__alt__=event.altKey;result.__meta__=event.metaKey;
+  return result;
+}`
+
+# +Event+ objects represent user interactions with the browser. Attempting to
+# create an +Event+ object by calling <tt>Event.new</tt> results in
+# +NewEventError+.
+# 
+# +Event+ objects are handled by the methods in the +UserEvents+ module.
+# 
+class Event
+  KEYS = {
+    8  => :backspace,
+    9  => :tab,
+    13 => :enter,
+    27 => :esc,
+    32 => :space,
+    37 => :left,
+    38 => :up,
+    39 => :right,
+    40 => :down,
+    46 => :delete
+  }
+  
+  # Exception raised by calling <tt>Event.new</tt>.
+  # 
+  class NewEventError < Exception
+  end
+  
+  def initialize(raise_error) # :nodoc:
+    raise(NewEventError, 'Events can only be initialized by user interactions with the browser') unless `raise_error === null`
+  end
+  
+  # call-seq:
+  #   evnt.alt? -> true or false
+  # 
+  # Returns +true+ if the alt key was depressed during the event, +false+
+  # otherwise.
+  # 
+  #   Document['#example'].listen(:click) {|element, event| puts "alt-clicked" if event.alt? }
+  # 
+  # alt-clicking element '#example' produces:
+  # 
+  #   alt-clicked
+  # 
+  def alt?
+    `this.__alt__`
+  end
+  
+  # call-seq:
+  #   evnt.base_type -> symbol
+  # 
+  # Returns a symbol representing _evnt_'s event type, or +:base+ type if
+  # _evnt_ is a defined event.
+  # 
+  #   UserEvents.define(:shift_click, :base => 'click', :condition => proc {|element,event| event.shift? })
+  #   Document['#example'].listen(:click)       {|element, event| puts event.base_type }
+  #   Document['#example'].listen(:shift_click) {|element, event| puts event.base_type }
+  # 
+  # clicking or shift-clicking on element '#example' produces:
+  # 
+  #   click
+  # 
+  def base_type
+    `$s(this.__type__)`
+  end
+  
+  # call-seq:
+  #   evnt.client -> {:x => integer, :y => integer}
+  # 
+  # Returns a hash representing _evnt_'s distance in pixels from the left
+  # (_x_) and top (_y_) edges of the browser viewport.
+  # 
+  #   Document['#example'].listen(:click) {|element,event| puts event.client.inspect }
+  # 
+  # clicking element '#example' at position (35,45) produces:
+  # 
+  #   {:x => 35, :y => 45}
+  # 
+  def client
+    {:x => `this.__client__.x`, :y => `this.__client__.y`}
+  end
+  
+  # call-seq:
+  #   evnt.code -> integer or nil
+  # 
+  # If _evnt_ involved a keystroke, returns the ASCII code of the key pressed,
+  # otherwise returns +nil+.
+  # 
+  #   Document['#example'].listen(:keypress) {|element, event| puts event.code }
+  # 
+  # typing "test\n" into textarea '#example produces:
+  # 
+  #   116
+  #   101
+  #   115
+  #   116
+  #   13
+  # 
+  def code
+    `this.__code__ || nil`
+  end
+  
+  # call-seq:
+  #   evnt.ctrl? -> true or false
+  # 
+  # Returns +true+ if the control key was depressed during the event, +false+
+  # otherwise.
+  # 
+  #   Document['#example'].listen(:click) {|element, event| puts "ctrl-clicked" if event.ctrl? }
+  # 
+  # ctrl-clicking element '#example' produces:
+  # 
+  #   ctrl-clicked
+  # 
+  def ctrl?
+    `this.__ctrl__`
+  end
+  
+  # call-seq:
+  #   evnt.key -> symbol or nil
+  # 
+  # If _evnt_ involved a keystroke, returns a symbol representing the key
+  # pressed, otherwise returns +nil+.
+  # 
+  #   Document['#example'].listen(:keypress) {|element, event| puts event.key.inspect }
+  # 
+  # typing "test\n" into textarea '#example produces:
+  # 
+  #   :t
+  #   :e
+  #   :s
+  #   :t
+  #   :enter
+  # 
+  def key
+    `this.__key__ || nil`
+  end
+  
+  # call-seq:
+  #   evnt.kill! -> evnt
+  # 
+  # Stops the event in place, preventing the default action as well as any
+  # further propagation, then returns _evnt_.
+  # 
+  def kill!
+    self.stop_propagation.prevent_default
+  end
+  
+  # call-seq:
+  #   evnt.meta? -> true or false
+  # 
+  # Returns +true+ if the meta key was depressed during the event, +false+
+  # otherwise.
+  # 
+  #   Document['#example'].listen(:click) {|element, event| puts "meta-clicked" if event.meta? }
+  # 
+  # meta-clicking element '#example' produces:
+  # 
+  #   meta-clicked
+  # 
+  def meta?
+    `this.__meta__`
+  end
+  
+  # call-seq:
+  #   evnt.page -> {:x => numeric, :y => numeric}
+  # 
+  # Returns a hash representing _evnt_'s distance in pixels from the left
+  # (_x_) and top (_y_) edges of the current page, including pixels that may
+  # have scrolled out of view.
+  # 
+  #   Document['#example'].listen(:click) {|element,event| puts event.page.inspect }
+  # 
+  # clicking element '#example' at position (35,45) after scrolling down 100
+  # pixels produces:
+  # 
+  #   {:x => 35, :y => 145}
+  # 
+  def page
+    {:x => `this.__page__.x`, :y => `this.__page__.y`}
+  end
+  
+  # call-seq:
+  #   evnt.prevent_default -> evnt
+  # 
+  # Instructs the event to abandon its default browser action, then returns
+  # _evnt_.
+  # 
+  def prevent_default
+    native = `this.__native__`
+    `native.preventDefault?native.preventDefault():native.returnValue=false`
+    return self
+  end
+  
+  # call-seq:
+  #   evnt.right_click? -> true or false
+  # 
+  # Returns +true+ if the event was a right click.
+  # 
+  #   elem = Document['#example'].listen(:click) {|element, event| puts "right-clicked" if event.right_click? }
+  # 
+  # right-clicking element '#example' produces:
+  # 
+  #   right-clicked
+  # 
+  def right_click?
+    `this.__right_click__`
+  end
+  
+  # call-seq:
+  #   evnt.shift? -> true or false
+  # 
+  # Returns +true+ if the shift key was depressed during the event, +false+
+  # otherwise.
+  # 
+  #   Document['#example'].listen(:click) {|element, event| puts "shift-clicked" if event.shift? }
+  # 
+  # shift-clicking element '#example' produces:
+  # 
+  #   shift-clicked
+  # 
+  def shift?
+    `this.__shift__`
+  end
+  
+  # call-seq:
+  #   evnt.stop_propagation -> evnt
+  # 
+  # Instructs the event to stop propagating, then returns _evnt_.
+  # 
+  def stop_propagation
+    native = `this.__native__`
+    `native.stopPropagation?native.stopPropagation():native.cancelBubble=true`
+    return self
+  end
+  
+  # call-seq:
+  #   evnt.target -> element
+  # 
+  # Returns the DOM element targeted by _evnt_, or +nil+ if no element was
+  # targeted. The target of an event may be a different element than _elem_.
+  # 
+  #   elem = Document['#outer']
+  #   
+  #   elem.listen :click do |element, event|
+  #     puts "%s was clicked" % event.target.inspect
+  #     puts "%s was indirectly clicked" % element.inspect
+  #   end
+  # 
+  # clicking element '#inner' inside '#outer' produces:
+  # 
+  #   #<Element: DIV id="inner"> was clicked
+  #   #<Element: DIV id="outer"> was indirectly clicked
+  # 
+  def target
+    `$E(this.__target__)`
+  end
+  
+  # call-seq:
+  #   evnt.wheel -> numeric or nil
+  # 
+  # Returns a floating point number representing the velocity of the wheel
+  # movement executed during _evnt_. Positive values indicate upward
+  # scrolling, negative values indicate downward scrolling. Returns +nil+ if
+  # _evnt_ did not involve the mouse wheel.
+  # 
+  #   Document['#example'].listen(:mouse_wheel) {|element, event| puts event.wheel }
+  # 
+  # wheeling the mousewheel downward by a single "click" over element
+  # '#example' produces:
+  # 
+  #   -1
+  # 
+  def wheel
+    `this.__wheel__`
+  end
+end

data/lib/source/redshift/redshift.red

@@ -0,0 +1,5 @@
+require 'chainable'
+require 'cookie'
+require 'request'
+require 'situated'
+require 'tween'

data/lib/source/redshift/request.rb

@@ -0,0 +1,276 @@
+require 'chainable'
+require 'code_events'
+
+class Request
+  include CodeEvents
+  include Chainable
+  
+  METHODS = %w(GET POST PUT DELETE)
+  OPTIONS = {
+    :url           => '',
+    :data          => {},
+    :link          => 'ignore',
+    :async         => true,
+    :format        => nil,
+    :method        => 'post',
+    :encoding      => 'utf-8',
+    :is_success    => nil,
+    :emulation     => true,
+    :url_encoded   => true,
+    :eval_scripts  => false,
+    :eval_response => false,
+    :headers       => {
+      'X-Requested-With' => 'XMLHttpRequest',
+      'Accept'           => 'text/javascript, text/html, application/xml, text/xml, */*'
+    }
+  }
+  
+  # call-seq:
+  #   Request.new(options = {}) -> request
+  # 
+  # Returns a new _request_ with the given options.
+  # 
+  def initialize(options = {})
+    `this.__xhr__ = typeof(ActiveXObject)=='undefined' ? new XMLHttpRequest : new ActiveXObject('MSXML2.XMLHTTP')`
+    @options = OPTIONS.merge(options)
+    `#{@options[:headers]}.__xhr__=this.__xhr__`  # MooTools sets the ResponseHeaders in the xhr
+    #def (@options[:headers]).[](name)             # only during execution, but allows you to get
+    #  `this.__xhr__.getResponseHeader(name)`      # at them at any time. I'm not sure whether it
+    #end                                           # is necessary for us to emulate this exactly.
+  end
+  
+  # call-seq:
+  #   req.cancel -> req
+  # 
+  # Cancels the request, fires its "cancel" callback, and returns _req_.
+  # 
+  def cancel
+    return self unless @running
+    @running = false
+    `this.__xhr__.abort`
+    `this.__xhr__.onreadystatechange=function(){;}`
+    `this.__xhr__=typeof(ActiveXObject)=='undefined' ? new XMLHttpRequest : new ActiveXObject('MSXML2.XMLHTTP')`
+    self.fire(:cancel)
+    return self
+  end
+  
+  # call-seq:
+  #   req.check(arg, ...) { |request,args_array| block } -> true or false
+  # 
+  # returns +true+ when Request object is not running or gets cancelled, otherwise returns false.
+  # also, seems equipped to 'chain' some additional function after itself
+  # 
+  def check(*args, &block)
+    return true unless @running
+    case @options[:link]
+    when 'cancel'
+      self.cancel
+      return true
+    when 'chain'
+      # self.chain(&block(self,args))
+      return false
+    end
+    return false
+  end
+  
+  # call-seq:
+  #   req.execute(options = {}) -> req
+  # 
+  # Returns +req+ immediately if the request is already running. Otherwise,
+  # opens a connection and sends the data provided with the specified options.
+  # 
+  def execute(options = {})
+    # return self unless self.check(options)
+    @options.update(options)
+    raise(TypeError, 'can\'t convert %s to a String' % @options[:url].inspect) unless [String].include?(@options[:url].class)
+    raise(TypeError, 'can\'t convert %s to a String' % @options[:method].inspect) unless [String, Symbol].include?(@options[:method].class)
+    raise(TypeError, 'can\'t convert %s to a Hash' % @options[:data].inspect) unless [Hash].include?(@options[:data].class)
+    raise(HttpMethodError, 'invalid HTTP method "%s" for %s' % [@options[:method],self]) unless METHODS.include?(method = @options[:method].to_s.upcase)
+    
+    @running = true
+    data = @options[:data].to_query_string
+    url = @options[:url]
+    
+    if @options[:format]
+      format = "format=%s" % @options[:format]
+      data   = data.empty? ? format : [format, data].join('&')
+    end
+    
+    if @options[:emulation] && %w(PUT DELETE).include?(method)
+      _method = "_method=%s" % method
+      data    = data.empty? ? _method : [_method, data].join('&')
+      method  = 'POST'
+    end
+    
+    if @options[:url_encoded] && method == 'POST'
+      encoding = @options[:encoding] ? "; charset=%s" % @options[:encoding] : ""
+      self.headers['Content-type'] = "application/x-www-form-urlencoded" + encoding
+    end
+    
+    if data && method == 'GET'
+      separator = url.include?('?') ? "&" : "?"
+      url       = [url, data].join(separator)
+      data      = nil
+    end
+    
+    `this.__xhr__.open(method.__value__, url.__value__, #{@options[:async]})`
+    `this.__xhr__.onreadystatechange = #{self.on_state_change}.__block__`
+    
+    @options[:headers].each do |k,v|
+      `this.__xhr__.setRequestHeader(k.__value__,v.__value__)`
+    # raise(HeaderError, "#{k} => #{v}")
+    end
+    
+    self.fire(:request)
+    `this.__xhr__.send($T(data)?data.__value__:'')`
+    self.on_state_change.call unless @options[:async]
+    return self
+  end
+  
+  # call-seq:
+  #   req.failure! -> req
+  # 
+  # Fires _req_'s "response" and "failure" callbacks, then returns _req_.
+  # 
+  def failure!
+    self.fire(:response).fire(:failure, @xhr);
+  end
+  
+  # call-seq:
+  #   req.headers -> hash
+  # 
+  # Returns _req_'s HTTP headers as a +Hash+.
+  # 
+  def headers
+    @options[:headers]
+  end
+  
+  # call-seq:
+  #   req.on_state_change -> proc
+  # 
+  # Returns a +Proc+ object
+  # 
+  def on_state_change
+    Proc.new do
+      `var xhr=this.__xhr__`
+      `if(xhr.readyState!=4||!#{@running}){return nil;}`
+      
+      @running = false
+      @status  = 0
+      
+      `try{#{@status}=xhr.status}catch(e){;}`
+      
+      if self.success?
+        @response = {:text => `$q(xhr.responseText)`, :xml => `xhr.responseXML`}
+        self.success!(self.process_scripts(@response[:text]), @response[:xml])
+      else
+        @response = {:text => nil, :xml => nil};
+        self.failure!
+      end
+      
+      `xhr.onreadystatechange=function(){;}`
+      
+      return nil
+    end
+  end
+  
+  # call-seq:
+  #   req.process_scripts(str) -> string or object
+  # 
+  # If the HTTP response consists of JavaScript alone or if _req_'s
+  # <tt>eval_response</tt> option is set to +true+, evaluates the entire
+  # text of the response as JavaScript and returns the result.
+  # 
+  # Otherwise, returns a copy of _str_ with any <tt><script></tt> tags and
+  # their content removed. If _req_'s <tt>eval_scripts</tt> option is set to
+  # +true+, evaluates the removed scripts.
+  # 
+  def process_scripts(str)
+    return Document.execute_js(str) if @options[:eval_response] || `/(ecma|java)script/.test(this.__xhr__.getResponseHeader('Content-Type'))`
+    return str.strip_scripts(@options[:eval_scripts])
+  end
+  
+  # call-seq:
+  #   req.success!(text, xml) -> req
+  # 
+  # Fires _req_'s "response" and "success" callbacks, then returns _req_.
+  # 
+  def success!(text, xml)
+    self.fire(:response, [text, xml]).fire(:success, [text, xml]).call_chain
+  end
+  
+  # call-seq:
+  #   req.success? -> true or false
+  # 
+  # Returns +true+ if _req_'s status is in the 200s, +false+ otherwise.
+  # 
+  def success?
+    `#{@status}>=200&&#{@status}<300`
+  end
+  
+  # +HeaderError+ is raised when a +Request+ is executed with headers that are
+  # rejected by the XMLHTTPRequest object.
+  # 
+  class HeaderError < StandardError
+  end
+  
+  # +HttpMethodError+ is raised when a +Request+ object's HTTP method is not
+  # one of +GET+, +POST+, +PUT+, or +DELETE+.
+  # 
+  class HttpMethodError < StandardError
+  end
+  
+  class ::String
+    # call-seq:
+    #   str.strip_scripts(evaluate = false) -> string
+    # 
+    # Returns a copy of _str_ with the contents of any <tt><script></tt> tags
+    # removed. If _evaluate_ is set to true, the stripped scripts will be
+    # evaluated.
+    # 
+    def strip_scripts(evaluate = false)
+      scripts = ''
+      result = `this.__value__.replace(/<script[^>]*>([\\s\\S]*?)<\\/script>/gi,function(){scripts.__value__+=arguments[1]+'\\n';return '';})`
+      Document.execute_js(scripts) if evaluate
+      return result
+    end
+  end
+  
+  class ::Hash
+    # call-seq:
+    #   hsh.to_query_string -> string
+    # 
+    # Returns a string representing _hsh_ formatted as HTTP data.
+    # 
+    def to_query_string(base = '')
+      query_string = []
+      self.each do |k,v|
+        next if v.nil?
+        k = base.empty? ? k.to_s : "%s[%s]" % [base,k]
+        case v
+        when Hash
+          result = v.to_query_string(k)
+        when Array
+          qs = {}
+          `for(var i=0,l=v.length;i<l;i++){#{qs[i] = v[i]}}`
+          #v.each_with_index do |v,i|
+          #  qs[i] = v
+          #end
+          result = qs.to_query_string(k)
+        else
+          result = "%s=%s" % [k, `$q(encodeURIComponent(v))`]
+        end
+        query_string.push(result)
+      end
+      return query_string.join('&')
+    end
+  end
+  
+  class HTML
+    
+  end
+  
+  class JSON
+    
+  end
+end