red_query 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in red_query.gemspec
+gemspec

data/README.rdoc

@@ -0,0 +1,33 @@
+# jQuery based Framework for Red
+
+Provides DOM, Ajax, JSON functionality for Red. Heavy usage of jQuery.
+Its been developed for my personal fork of Red: http://github.com/julius/red
+
+## Usage
+
+Of course you need jQuery and your own source. 
+In addition you need a little startup code.
+
+``` html
+  <script src="jquery.js"></script>
+  <!-- red_query startup code -->
+  <script type='text/javascript'>
+    jQuery.noConflict();
+    jQuery(document).ready(function(){
+      if (typeof c$Document !== "undefined")
+  	    c$Document.m$ready_bang();
+      else
+  	    throw "BIG problem with Red code";
+    });
+  </script>
+  <script src="your_red_file.js"></script>
+```
+
+Your main Red file should
+
+    require 'red_query'
+
+And your compilation should include
+
+    red -I/path/to/red_query your_red_file
+

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/red_query.rb

@@ -0,0 +1,20 @@
+require 'red_query/version'
+require 'red_query/observable'
+require 'red_query/json'
+require 'red_query/singleton'
+require 'red_query/string'
+require 'red_query/returning'
+
+# ESSENTIALS
+require 'red_query/ajax'
+require 'red_query/browser'
+require 'red_query/cookie'
+require 'red_query/events'
+require 'red_query/document'
+require 'red_query/history'
+require 'red_query/location'
+require 'red_query/timer'
+require 'red_query/interval'
+
+module RedQuery
+end

data/lib/red_query/ajax.rb

@@ -0,0 +1,59 @@
+module Ajax
+  def self.request(options)
+    options[:data] = options[:data] || {}
+    params = options[:data].to_query_string
+    success_callback = Proc.new { |text| options[:success].call(String.new(text)) }
+    error_callback = Proc.new { |msg| options[:problem].call(String.new(msg)) }
+    
+    `jQuery.ajax({
+      url:#{options[:url]}.__value__, 
+      type:#{options[:method]}.__value__, 
+      data:#{params}.__value__,
+      success: function(msg) { return #{success_callback}.m$call(msg); },
+      error: function(xhr,msg) { return #{error_callback}.m$call(msg); }
+    })`
+  end
+  
+  def self.requestJSON(options)
+    orig_success = options[:success]
+    options[:success] = Proc.new { |text| orig_success.call(JSON.parse(text)) }
+    
+    self.request(options)
+  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|
+        if `#{v} === false` 
+          v = "false"
+        end
+        if `#{v} === true` 
+          v = "true"
+        end
+        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
+end

data/lib/red_query/browser.rb

@@ -0,0 +1,23 @@
+class Browser
+  @@history = nil
+  
+  def self.ie?
+    return `jQuery.browser.msie`
+  end
+  
+  def self.version
+    `parseInt(jQuery.browser.version)`
+  end
+  
+  def self.history
+    if @@history.nil?
+      if Browser.ie? && Browser.version < 8
+        @@history = ::HistoryIE.new
+      else
+        @@history = ::HistoryNormal.new
+      end
+    end
+    
+    @@history
+  end
+end

data/lib/red_query/cookie.rb

@@ -0,0 +1,144 @@
+# The excelent Cookie class stolen from Redshift
+# removed Redshift::Document dependency
+
+# 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
+  }
+  
+  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 = `document.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
+    
+    `document.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

data/lib/red_query/document.rb

@@ -0,0 +1,28 @@
+require 'element'
+
+module Document
+  def self.as_element
+    return @elem if @elem
+    @elem = Element.new(`jQuery(document)`)
+  end
+  
+  def self.[](css_selector)
+    self.query(css_selector)
+  end
+  
+  def self.find(css_selector)
+    self.query(css_selector)
+  end
+  
+  def self.query(css_selector)
+    self.as_element.find(css_selector)
+  end
+  
+  def self.ready?(&block)
+    @ready_proc = block
+  end
+  
+  def self.ready!
+    @ready_proc.call if @ready_proc
+  end
+end

data/lib/red_query/element.rb

@@ -0,0 +1,270 @@
+
+# represents one or more jQuery Elements
+class Element < Array
+  
+  @@element_id_count = 0
+  
+  def [](index)
+    Element.new(`jQuery(#{@jq_native}[#{index}])`)
+  end
+  
+  def length
+    `#{@jq_native}.length`
+  end
+  
+  def size
+    length
+  end
+  
+  def each
+    length.times { |i| yield self[i] }
+  end
+  
+  def initialize(jq_native)
+    `#{self}.__jq_native__ = #{jq_native}`
+    @jq_native = jq_native
+  end
+  
+  def self.from_html(html)
+    Element.new(jq_native_from_html(html))
+  end
+  
+  def self.jq_native_from_html(html)
+    `jQuery(#{html}.__value__)`
+  end
+  
+  # returns attr('id') of element. if none exists, one will be assigned
+  def id
+    id = attr('id')
+    return id unless id == ""
+    
+    @@element_id_count += 1
+    id = "red_query_elem_#{@@element_id_count}"
+    attr('id', id)
+    return id
+  end
+  
+  def append(elem)
+    `#{@jq_native}.append(#{elem}.__jq_native__)`
+  end
+  
+  def prepend(elem)
+    `#{@jq_native}.prepend(#{elem}.__jq_native__)`
+  end
+
+  def after(elem)
+    `#{@jq_native}.after(#{elem}.__jq_native__)`
+  end
+  
+  def before(elem)
+    `#{@jq_native}.before(#{elem}.__jq_native__)`
+  end
+  
+  def attr(name, value = nil)
+    if value.nil?
+      String.new(`#{@jq_native}.attr(#{name}.__value__)`)
+    else
+      `#{@jq_native}.attr(#{name}.__value__, #{value}.__value__)`
+    end
+  end
+  
+  def click(&block)
+    callback = mouse_event(block)
+    `#{@jq_native}.click(function (event) { return #{callback}.m$call(event); })`
+  end  
+  
+  def add_class(css_class)
+    `#{@jq_native}.addClass(#{css_class}.__value__)`
+  end
+
+  def has_class(css_class)
+    `#{@jq_native}.hasClass(#{css_class}.__value__)`
+  end
+  
+  def remove_class(css_class)
+    `#{@jq_native}.removeClass(#{css_class}.__value__)`
+  end
+
+  def css(key, value = nil, debug = false)
+    if value.nil?
+      String.new(`#{@jq_native}.css(#{key}.__value__)`)
+    else
+      `#{@jq_native}.css(#{key}.__value__, #{value}.__value__)`
+    end
+  end
+
+  def find(css_selector)
+    e = Element.new(`#{@jq_native}.find(#{css_selector}.__value__)`)
+#    raise "[red_query/Element.find] Not found: #{css_selector}" unless e.length > 0
+    return e
+  end
+  
+  def find_first(css_selector)
+    result = find(css_selector)
+    # return nil unless result
+    result[0]
+  end
+  
+  def self.[](css_selector)
+    self.find(css_selector)
+  end
+  
+  def focus
+    `#{@jq_native}.focus()`
+  end
+  
+  def html(value = nil)
+    if value.nil?
+      String.new(`#{@jq_native}.html()`)
+    else
+      `#{@jq_native}.html(#{value}.__value__)`
+    end
+  end
+  
+  def height
+    `#{@jq_native}.height()`
+  end
+  
+  def left(pos = nil)
+    if pos.nil?
+      `#{@jq_native}.offset().left`
+    else
+      `#{@jq_native}.left(#{pos})`
+    end
+  end
+  
+  def key_event(block)
+    Proc.new { |native_event|
+      block.call({
+        :code  => `#{native_event}.keyCode`,
+        :shift => `#{native_event}.shiftKey`,
+        :ctrl  => `#{native_event}.ctrlKey`,
+        :meta  => `#{native_event}.metaKey`,
+        :prevent => Proc.new { `#{native_event}.preventDefault()` },
+      })
+    }
+  end
+  
+  def key_down(&block)
+    callback = key_event(block)
+    `#{@jq_native}.keydown(function (event) { return #{callback}.m$call(event); })`
+  end
+  
+  def key_press(&block)
+    callback = key_event(block)
+    `#{@jq_native}.keydown(function (event) { return #{callback}.m$call(event); })`
+  end
+  
+  def key_up(&block)
+    callback = key_event(block)
+    `#{@jq_native}.keydown(function (event) { return #{callback}.m$call(event); })`
+  end
+  
+  def mouse_event(block)
+    preventer = Proc.new { `#{native_event}.preventDefault()` }
+    
+    Proc.new { |native_event|
+      # `console.log(#{native_event})`
+      block.call({
+        :client_x => `#{native_event}.clientX`,
+        :client_y => `#{native_event}.clientY`,
+        :page_x => `#{native_event}.pageX`,
+        :page_y => `#{native_event}.pageY`,
+        :screen_x => `#{native_event}.screenX`,
+        :screen_y => `#{native_event}.screenY`,
+        :prevent => preventer,
+      })
+    }
+  end
+  
+  def mouse_down(&block)
+    callback = mouse_event(block)
+    `#{@jq_native}.mousedown(function (event) { return #{callback}.m$call(event); })`
+  end
+  
+  def mouse_up(&block)
+    callback = mouse_event(block)
+    `#{@jq_native}.mouseup(function (event) { return #{callback}.m$call(event); })`
+  end
+  
+  def hover(over_block, out_block)
+    over_fn = mouse_event(over_block)
+    out_fn = mouse_event(out_block)
+    `#{@jq_native}.hover(function(event){return #{over_fn}.m$call(event);}, function(event){return #{out_fn}.m$call(event);})`
+  end
+
+  # only for jquery 1.3+
+  # def mouse_enter(&block)
+  #   callback = mouse_event(block)
+  #   `#{@jq_native}.mouseenter(function (event) { return #{callback}.m$call(event); })`
+  # end
+  # 
+  # def mouse_leave(&block)
+  #   callback = mouse_event(block)
+  #   `#{@jq_native}.mouseleave(function (event) { return #{callback}.m$call(event); })`
+  # end
+  
+  def mouse_over(&block)
+    callback = mouse_event(block)
+    `#{@jq_native}.mouseover(function (event) { return #{callback}.m$call(event); })`
+  end
+
+  def mouse_move(&block)
+    callback = mouse_event(block)
+    `#{@jq_native}.mousemove(function (event) { return #{callback}.m$call(event); })`
+  end
+
+  def mouse_out(&block)
+    callback = mouse_event(block)
+    `#{@jq_native}.mouseout(function (event) { return #{callback}.m$call(event); })`
+  end
+
+  def name
+    attr("name")
+  end
+  
+  def name=(value)
+    attr("name", value)
+  end
+  
+  def remove
+    `#{@jq_native}.remove()`
+  end
+  
+  def submit(&block)
+    `#{@jq_native}.submit(function () { return #{block.call} })`
+  end
+  
+  def top(pos = nil)
+    if pos.nil?
+      `#{@jq_native}.offset().top`
+    else
+      `#{@jq_native}.top(#{pos})`
+    end
+  end
+
+  def scroll_top(pos = nil)
+    if pos.nil?
+      `#{@jq_native}.scrollTop()`
+    else
+      # `#{@jq_native}.scrollTop(#{pos})`
+      `#{@jq_native}.animate({scrollTop: #{pos}}, 500, "swing")`
+    end
+  end
+
+  def value(str = nil)
+    if str.nil?
+      String.new(`#{@jq_native}.val()`)
+    else
+      `#{@jq_native}.val(str.__value__)`
+    end
+  end
+
+  def width
+    `#{@jq_native}.width()`
+  end
+
+  def parent
+    Element.new(`jQuery(#{@jq_native}.parent().get(0))`)
+  end
+end

data/lib/red_query/events.rb

@@ -0,0 +1,40 @@
+module Events
+  # Defines allowed Events
+  # eg:
+  # class Foo
+  #   include Events
+  #   def initialize
+  #     init_events :bar, :bat, :bitz
+  #   end
+  # end
+  def init_events(*event_names)
+    @events = {}
+    event_names.each { |name| @events[name] = [] }
+  end
+  
+  def add_events(*event_names)
+    event_names.each { |name| 
+      @events[name] = []
+    }
+  end
+  
+  def has_event?(event_name)
+    !!@events[event_name]
+  end
+  
+  # registers Proc for given _event_name_
+  #
+  # eg:
+  # foo = Foo.new (Foo includes Events)
+  # foo.on("bar") { |event| puts event[:stuff] }
+  def on(event_name, &block)
+    raise "invalid event '#{event_name.inspect}' on #{self.class}" if @events[event_name].nil?
+    @events[event_name].push(block)
+  end
+  
+  # fires event to all Procs registered for given _event_name_
+  def fire(event_name, event = nil)
+    raise "invalid event '#{event_name.inspect}' on #{self.class}" if @events[event_name].nil?
+    @events[event_name].each { |block| block.call(event) }
+  end
+end

data/lib/red_query/history.rb

@@ -0,0 +1,30 @@
+class HistoryNormal
+  def set(hash)
+    `location.hash = "#" + #{hash}.__value__`
+    true
+  end
+  
+  def get
+    String.new(`location.hash.substr(1)`)
+  end
+end
+
+class HistoryIE
+  def initialize
+    @iframe = Element.from_html('<iframe style="display:none" src="javascript:false;"></iframe>')
+    Document.query('head')[0].append(@iframe)
+  end
+  
+  def set(hash)
+    `var d = #{@iframe}.__jq_native__.contentWindow.document;
+    d.open();
+    d.close();
+    d.location.hash = #{hash}.__value__;
+    `
+    true
+  end
+  
+  def get
+    String.new(`#{@iframe}.contentWindow.document.location.hash`)
+  end
+end

data/lib/red_query/interval.rb

@@ -0,0 +1,9 @@
+class Interval
+  def initialize(time, &block)
+    @timer = `setInterval(function () { #{block.call} }, #{time})`
+  end
+  
+  def clear
+    `clearInterval(#{@timer})`
+  end
+end

data/lib/red_query/json.rb

@@ -0,0 +1,149 @@
+class JSON
+  # ======= Parsing =============================================
+  def self.parse(text)
+    raise "[JSON.parse] empty JSON-String" if text == ""
+    json_native = `eval("("+#{text}.__value__+")");`
+    JSON.translate(json_native)
+  end
+  
+  def self.classify(js_native)
+    type = String.new(`typeof #{js_native}`)
+    if (type == 'object' && `!#{js_native}`)
+      return "null"
+    end
+    if (type == 'object' && `Object.prototype.toString.apply(#{js_native}) === '[object Array]'`)
+      return "array"
+    end
+    type
+  end
+  
+  def self.translate_array(js_native)
+    js_natives = []
+    `for (var i=0; i<#{js_native}.length; i++) { #{js_natives}.push(#{js_native}[i]); }`
+
+    js_natives.collect { |x| JSON.translate(x) }
+  end
+  
+  def self.translate_object(js_native)
+    stuff = []
+    `for(var member in #{js_native}){#{stuff}.push(new Array($q(member), #{js_native}[member]));}`
+
+    obj = {}
+    stuff.each { |x|
+      key = x[0]
+      value = x[1]
+      obj[key] = JSON.translate(value)
+    }
+    return obj
+  end
+  
+  def self.translate(js_native)
+    type = JSON.classify(js_native)
+    if (type == 'string')
+      return String.new(js_native)
+    end
+    
+    if (type == 'number' || type == 'boolean')
+      return js_native
+    end
+    
+    if (type == 'array')
+      return JSON.translate_array(js_native)
+    end
+    
+    if (type == 'object')
+      return JSON.translate_object(js_native)
+    end
+    
+    return nil
+  end
+  
+  # ======= Stringify =============================================
+  def self.classify_ruby(stuff)
+    if (stuff.class)
+      return stuff.class.inspect.split("::").last
+    end
+    "Boolean"
+  end
+  
+  def self.stringify_string(str)
+    `
+    var cx = /[\\u0000\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]/g,
+            escapable = /[\\\\\\"\\x00-\\x1f\\x7f-\\x9f\\u00ad\\u0600-\\u0604\\u070f\\u17b4\\u17b5\\u200c-\\u200f\\u2028-\\u202f\\u2060-\\u206f\\ufeff\\ufff0-\\uffff]/g,
+            gap,
+            indent,
+            meta = {    // table of character substitutions
+                '\\b': '\\\\b',
+                '\\t': '\\\\t',
+                '\\n': '\\\\n',
+                '\\f': '\\\\f',
+                '\\r': '\\\\r',
+                '"' : '\\\\"',
+                '\\\\': '\\\\\\\\'
+            },
+            rep;
+
+    
+    function quote(string) {
+      escapable.lastIndex = 0;
+            return escapable.test(string) ?
+                '"' + string.replace(escapable, function (a) {
+                    var c = meta[a];
+                    return typeof c === 'string' ? c :
+                        '\\\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+                }) + '"' :
+                '"' + string + '"';
+        }
+    
+    `
+    value = String.new(`quote(#{str}.__value__)`)
+  end
+  
+  def self.stringify_array(stuff)
+    stuff.map! { |elem| JSON.stringify(elem) }
+    return '[' + stuff.join(',') + ']'
+  end
+  
+  def self.stringify_hash(stuff)
+    pairs = []
+    stuff.each { |key, value| pairs.push(JSON.stringify(key) + ':' + JSON.stringify(value)) }
+    return '{' + pairs.join(',') + '}'
+  end
+  
+  def self.stringify(stuff)
+    type = JSON.classify_ruby(stuff)
+    
+    if (type == "Numeric" || type == "Boolean")
+      return stuff.inspect
+    end
+    
+    if (type == "String")
+      return JSON.stringify_string(stuff)
+    end
+    
+    if (type == "Symbol")
+      return JSON.stringify_string(stuff.to_s)
+    end
+    
+    if (type == "Array")
+      return JSON.stringify_array(stuff)
+    end
+    
+    if (type == "Hash")
+      return JSON.stringify_hash(stuff)
+    end
+    
+    "null"
+  end
+  
+  def self.generate(stuff)
+    self.stringify(stuff)
+  end
+end
+
+
+class Hash
+  def to_json
+    JSON.generate(self)
+  end
+end

data/lib/red_query/location.rb

@@ -0,0 +1,5 @@
+module Location
+  def self.href(url)
+    `location.href = #{url}.__value__`
+  end
+end

data/lib/red_query/observable.rb

@@ -0,0 +1,35 @@
+module Observable
+  def add_observer(observer)
+    @_observers = [] unless @_observers
+    @_observers.push(observer)
+  end
+  
+  def changed(state=true)
+    @_observe_state = state
+  end
+  
+  def changed?
+    !!@_observe_state
+  end
+  
+  def count_observers
+    return @_observers.size if @_observers
+    0
+  end
+  
+  def delete_observers
+    @_observers = []
+  end
+  
+  def delete_observer(observer)
+    return unless @_observers
+    @_observers.delete(observer)
+  end
+  
+  def notify_observers(a, b, c, d, e, f, g, h)
+    return unless @_observers
+    @_observers.each { |o| o.update(a, b, c, d, e, f, g, h) }
+    @_observe_state = false
+  end
+end
+

data/lib/red_query/returning.rb

@@ -0,0 +1,4 @@
+def returning(x, &block)
+  block.call(x)
+  return x
+end

data/lib/red_query/singleton.rb

@@ -0,0 +1,10 @@
+module Singleton
+  def self.instance
+    if !@__instance__
+      @__instance__ = self.new
+      # puts "new instance of #{@__instance__.class}"
+    end
+    @__instance__
+  end
+end
+

data/lib/red_query/string.rb

@@ -0,0 +1,14 @@
+
+# useful web extensions for strings
+
+class String
+  
+  # encodes string to URI-Component
+  def to_uri_component
+    String.new(`encodeURIComponent(#{self}.__value__)`)
+  end
+  
+  def substr(index, length)
+    String.new(`#{self}.__value__.substr(#{index}, #{length})`)
+  end
+end

data/lib/red_query/timer.rb

@@ -0,0 +1,9 @@
+class Timer
+  def initialize(time, &block)
+    @timer = `setTimeout(function () { #{block.call} }, #{time})`
+  end
+  
+  def clear
+    `clearTimeout(#{@timer})`
+  end
+end

data/lib/red_query/version.rb

@@ -0,0 +1,3 @@
+module RedQuery
+  VERSION = "0.0.1"
+end

data/red_query.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+$:.push File.expand_path('../lib', __FILE__)
+require 'red_query/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'red_query'
+  s.version     = RedQuery::VERSION
+  s.authors     = ['Julius Eckert']
+  s.email       = ['eckert.julius@gmail.com']
+  s.homepage    = ''
+  s.summary     = %q{Provides DOM, Ajax, JSON functionality for Red. Heavy usage of jQuery.}
+  s.description = %q{Provides DOM, Ajax, JSON functionality for Red. Heavy usage of jQuery.}
+
+  s.rubyforge_project = 'red_query'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+  
+  s.add_dependency 'red'
+  s.add_development_dependency 'rake'
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification 
+name: red_query
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Julius Eckert
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-12 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id001
+  name: red
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id002
+  name: rake
+  prerelease: false
+  type: :development
+description: Provides DOM, Ajax, JSON functionality for Red. Heavy usage of jQuery.
+email: 
+- eckert.julius@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- lib/red_query.rb
+- lib/red_query/ajax.rb
+- lib/red_query/browser.rb
+- lib/red_query/cookie.rb
+- lib/red_query/document.rb
+- lib/red_query/element.rb
+- lib/red_query/events.rb
+- lib/red_query/history.rb
+- lib/red_query/interval.rb
+- lib/red_query/json.rb
+- lib/red_query/location.rb
+- lib/red_query/observable.rb
+- lib/red_query/returning.rb
+- lib/red_query/singleton.rb
+- lib/red_query/string.rb
+- lib/red_query/timer.rb
+- lib/red_query/version.rb
+- red_query.gemspec
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: red_query
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Provides DOM, Ajax, JSON functionality for Red. Heavy usage of jQuery.
+test_files: []
+