RubyGems - red - Versions diffs - 4.1.0 → 4.1.1 - Mend

red 4.1.0 → 4.1.1

Files changed (24) hide show

data/Manifest.txt +25 -0
data/lib/red/version.rb +1 -1
data/lib/source/redshift/accessors.rb +580 -0
data/lib/source/redshift/browser.rb +150 -0
data/lib/source/redshift/chainable.rb +75 -0
data/lib/source/redshift/code_events.rb +204 -0
data/lib/source/redshift/cookie.rb +142 -0
data/lib/source/redshift/document.rb +216 -0
data/lib/source/redshift/element.rb +417 -0
data/lib/source/redshift/event.rb +312 -0
data/lib/source/redshift/redshift.red +5 -0
data/lib/source/redshift/request.rb +276 -0
data/lib/source/redshift/selectors.rb +374 -0
data/lib/source/redshift/situated.rb +328 -0
data/lib/source/redshift/store.rb +48 -0
data/lib/source/redshift/transform.rb +199 -0
data/lib/source/redshift/tween.rb +66 -0
data/lib/source/redshift/user_events.rb +215 -0
data/lib/source/redshift/validator.rb +21 -0
data/lib/source/redshift/window.rb +11 -0
data/lib/source/redspec/index.html +11 -0
data/lib/source/redspec/lib/red_spec/red_spec.red +525 -0
data/lib/source/redspec/lib/stylesheets/specs.sass +290 -0
metadata +27 -2

data/lib/source/redshift/document.rb ADDED Viewed

@@ -0,0 +1,216 @@
+require 'selectors'
+# The +Document+ object enables access to top-level HTML elements like
+# <i><head></i>, <i><html></i>, and <i><body></i>.
+#
+# +Document+ also provides "DOM-ready" functionality with
+# <tt>Document.ready?</tt> and element-finding functionality through the
+# powerful <tt>Document.[]</tt> method.
+#
+module Document
+  `document.head=document.getElementsByTagName('head')[0]`
+  `document.html=document.getElementsByTagName('html')[0]`
+  `document.window=(document.defaultView||document.parentWindow)`
+  `c$Document.__native__= document`
+  # call-seq:
+  #   Document["#id"]      -> element or nil
+  #   Document["selector"] -> [element, ...]
+  #   Document[str, ...]   -> [element, ...]
+  #
+  # The first form returns the +Element+ identified by the id <i>str</i> (e.g.
+  # <i>'#my_id'</i>), or +nil+ if no such element is found. The second form
+  # returns the array of elements identified by the selector <i>str</i>.
+  # The third form returns the array of elements found by calling
+  # <tt>Document.[]</tt> on each arg. The fourth form returns _element_
+  # unchanged.
+  #
+  # The first form returns the +Element+ identified by the string
+  # <i>"#id"</i>, or +nil+ if no such element is found.
+  #
+  #   Document['#content']    #=> #<Element: DIV id="content">
+  #
+  # The second form returns the array of +Element+ objects that match the
+  # string <i>"selector"</i>, which takes the format of a CSS3 selector. See
+  # http://www.w3.org/TR/css3-selectors/ for details.
+  #
+  #
+  #
+  # Available Selectors
+  # Document[str] in its second form takes a selector string and scans the document
+  # returing an array of any elements that match the selector string.
+  #
+  # The selectors string takes the format of a CSS3 selector: http://www.w3.org/TR/css3-selectors/
+  #
+  # Class Selector
+  # Returns an array of elements that have the specified class name
+  # Document['.my_class'] #=> [#<Element: DIV class="my_class">, #<Element: DIV class="my_class">, #<Element: SPAN class="my_class">]
+  #
+  # Tag Selector
+  # Returns an array of elements that have the specified tag
+  # Document['a'] #=> [#<Element: A href="/foo/bar">, #<Element: A href="/foo/baz">, #<Element: A href="/foo/bat">]
+  #
+  def self.[](*args)
+    if args.length == 1
+      return self.find_by_string(args[0])
+    else
+      args.map do |str|
+        Document[str]
+      end.compact
+      #return self.find_many_with_array(args.unshift(obj))
+    end
+  end
+  # call-seq:
+  #   Document.body -> element
+  #
+  # Returns the <i><body></i> element of the current page.
+  #
+  #   Document.body   #=> #<Element: BODY>
+  #
+  def self.body
+    `$E(document.body)`
+  end
+  # call-seq:
+  #   Document.execute_js(str) -> str
+  #
+  # Executes _str_ as JavaScript, then returns _str_.
+  #
+  def self.execute_js(str)
+    return str if str == ''
+    if `window.execScript`
+      `window.execScript(str.__value__)`
+    else
+      `scriptElement = document.createElement('script')`
+      `scriptElement.setAttribute('type','text/javascript')`
+      `scriptElement.text = str`
+      `document.head.appendChild(scriptElement)`
+      `document.head.removeChild(scriptElement)`
+    end
+    return str
+  end
+  # call-seq:
+  #   Document.head -> element
+  #
+  # Returns the <i><head></i> element of the current page.
+  #
+  #   Document.head   #=> #<Element: HEAD>
+  #
+  def self.head
+    `$E(document.head)`
+  end
+  # call-seq:
+  #   Document.html -> element
+  #
+  # Returns the <i><html></i> element of the current page.
+  #
+  #   Document.html   #=> #<Element: HTML>
+  #
+  def self.html
+    `$E(document.html)`
+  end
+  # call-seq:
+  #   Document.ready? { block } -> nil
+  #
+  # When the DOM is finished loading, executes the given _block_, then returns
+  # +nil+.
+  #
+  #   Document.ready? do
+  #     puts self.title
+  #   end
+  #
+  # produces:
+  #
+  #   "RDoc Documentation"
+  #
+  def self.ready?(&block)
+    @proc = block
+    `document.addEventListener('DOMContentLoaded', function(){document.__loaded__=true;#{@proc.call};}.m$(this), false)`
+    return nil
+  end
+  # call-seq:
+  #   Document.title -> string
+  #
+  # Returns the title of the current page.
+  #
+  #   Document.title    #=> "RDoc Documentation"
+  #
+  def self.title
+    `$q(document.title)`
+  end
+  # Uses the Selector library to find native elements and retrun an array of extended elements
+  def self.find_all_by_selector(selector) # :nodoc:
+    `Array.fromCollection(Selectors.Utils.search(document, selector.__value__, {}));`
+  end
+  # Uses the browser's native getElementById to find an element. Returns an extended element.
+  def self.find_by_id(str) # :nodoc:
+    `$E(document.getElementById(str.__value__))`
+  end
+  # Finds an element from a provided string. If the string is a represents a single id ('#my_id') calls
+  # self.find_all_by_id, otherwise calls self.find_all_by_selector
+  def self.find_by_string(str) # :nodoc:
+    `str.__value__.match(/^#[a-zA-z_]*$/)` ? self.find_by_id(`$q(str.__value__.replace('#',''))`) : self.find_all_by_selector(str)
+  end
+  def self.find_many_with_array(ary) # :nodoc:
+    `for(var i=0,l=ary.length,result=[];i<l;++i){var el=#{Document[`ary[i]`]};if($T(el)){result.push(el);};}`
+    return `result`.flatten
+  end
+  # Walks the DOM from a particular element.  The first step it talks in the walk with either
+  # be the specified start_relation or the specified path.  If 'all' is set to false, the walk
+  # will termiante and return the single element. Otherwise, it will continue the walk until it
+  # has reached the end of the specified path.
+  # The walk will then termiante and return an array of all elements on the path.
+  #
+  # if an optional <tt>match_selector<tt> is provided, only element(s) that match
+  # the selector can be returned
+  #
+  # Examples:
+  # Document.walk(my_element, 'parentNode', nil, nil, false)
+  # will go down the parentNode path of my_element, starting at the my_element, and
+  # return just a single element
+  #
+  # Document.walk(my_element, 'parentNode', nil, nil, true)
+  # will go down the parentNode path of my_element, starting at my_element, and
+  # return an array of all elements on the parentNode path
+  #
+  # Document.walk(my_element, 'nextSibling', 'firstChild', nil, true)
+  # will go down the nextSibling path of my_element, starting at my_element's firstChild
+  # and return an array of all elements on the nextSibling path from that starting point.
+  #
+  # Document.walk(my_element, 'nextSibling', 'firstChild', '.my_class', true)
+  # will go down the nextSibling path of my_element, starting at my_element's firstChild
+  # and return an array of all elements on the nextSibling path from that starting point that
+  # have the class 'my_class'
+  #
+  def self.walk(element, path, startRelation, matchSelector, all) # :nodoc
+    `if(startRelation){startRelation = startRelation.__value__;};
+    var el = element.__native__[startRelation || path.__value__],elements = [];
+    while (el){
+      if (el.nodeType == 1 && (#{!matchSelector} || Element.match(el, #{matchSelector}))){
+        if (!all) {return $E(el);}
+        elements.push($E(el));
+      }
+      el = el[path.__value__];
+    }`
+    return `(all) ? elements : nil`
+  end
+  def self.window # :nodoc:
+    Window
+  end
+  def self.document # :nodoc
+    self
+  end
+end

data/lib/source/redshift/element.rb ADDED Viewed

@@ -0,0 +1,417 @@
+require 'document'
+require 'user_events'
+require 'code_events'
+require 'accessors'
+# +Element+ objects represent DOM elements from the browser.
+#
+class Element
+  `window.$E=function(element){if(element==null){return nil;};var E=c$Element.m$new(null);E.__native__=element;return E;}`
+  include UserEvents
+  include CodeEvents
+  def self.destroy(elem) # :nodoc:
+    `var el = elem.__native__ || elem`
+    `c$Element.m$empty(el)`
+    `c$Element.m$remove(el)`
+    return true
+  end
+  def self.empty(elem) # :nodoc:
+    `for (var c=(elem.__native__||elem).childNodes,i=c.length;i>0;){c$Element.m$destroy(c[--i]);};`
+    return true
+  end
+  def self.remove(elem) # :nodoc:
+    `var el = elem.__native__ || elem`
+    `(el.parentNode) ? el.parentNode.removeChild(el) : this`
+  end
+  # call-seq:
+  #   Element.new(sym, attributes = {}) -> element
+  #
+  # Returns a new +Element+ with the tag _sym_ and the given attributes.
+  #
+  #   Element.new(:div, :id => 'my_div', :class => 'inserted')    #=> #<Element: DIV id="my_div" class="inserted">
+  #
+  def initialize(tag, attributes = {})
+    `if(!tag){return nil;}`
+    `this.__native__ = document.createElement(tag.__value__)`
+    self.set_properties(attributes)
+  end
+  def ==(elem) # :nodoc:
+    `this.__native__ === elem.__native__`
+  end
+  def ===(elem) # :nodoc:
+    `this.__native__ === elem.__native__`
+  end
+  # call-seq:
+  #   elem[str] -> array
+  #
+  # *args?
+  #
+  def [](expression, *args)
+    `if (expression.__value__.match(/^#[a-zA-z_]*$/) && #{args.empty?}){return #{self}.__native__.getElementById(expression.__value__.replace('#',''));}`
+    expression = expression.split(',')
+    items = []
+    `for (var i = 0, l = expression.length, local = {}; i < l; i++){
+      var selector = expression[i].__value__, elements = Selectors.Utils.search(#{self}.__native__, selector, local);
+      elements = Array.fromCollection(elements);
+      items = (i == 0) ? elements : items.concat(elements);
+    }`
+    return items
+  end
+  # call-seq:
+  #   elem.children -> array
+  #
+  # Returns the array of _elem_'s child elements on the DOM tree.
+  #
+  #   <div id="container">
+  #     <div id="a_element"></div>
+  #       <div id="a_inner_element"></div>
+  #     </div>
+  #     <div id="b_element"></div>
+  #   </div>
+  #
+  #   Document['#container'].children   #=> [#<Element: DIV id="a_element">, #<Element: DIV id="b_element">]
+  #
+  def children(match_selector = nil)
+    Document.walk(self, 'nextSibling', 'firstChild', match_selector, true)
+  end
+  # TODO: re: the native object and event listeners; does it really do this stuff?
+  # Removes the element from the page and the DOM, destroys the element object, the native object,
+  # any attached event listeners, and frees their memory location. Returns +true+ if successful, +false+ otherwise.
+  # call-seq:
+  #   elem.destroy! -> true
+  #
+  # Removes _elem_ and all its children from the page and from the DOM, then
+  # returns +true+.
+  #
+  def destroy!
+    Element.destroy(self)
+    return true
+  end
+  def document # :nodoc:
+    `this.__native__.ownerDocument`
+  end
+  # call-seq:
+  #   elem.empty! -> true or false
+  #
+  # Removes _elem_'s inner text and child elements from the page.
+  #
+  def empty!
+    Element.empty(self)
+    return self
+  end
+  def eql?(elem) # :nodoc:
+    `this.__native__ === elem.__native__`
+  end
+  # call-seq:
+  #   elem.first_child -> element
+  #
+  # Returns the first child element of _elem_ on the DOM tree, or +nil+ if no
+  # such element is found.
+  #
+  #   <div id="container">
+  #     <div id="a_element"></div>
+  #     <div id="b_element"></div>
+  #     <div id="c_element"></div>
+  #     <div id="d_element"></div>
+  #   </div>
+  #
+  #   Document['#container'].first_child #=> #<Element: DIV id="a_element">
+  #
+  def first_child(match_selector = nil)
+    Document.walk(self, 'nextSibling', 'firstChild', match_selector, false)
+  end
+  # call-seq:
+  #   elem.insert(other, sym = :bottom) -> elem
+  #
+  # Returns _elem_ with _other_ inserted at location _sym_.
+  #
+  # Inserting into <tt>:bottom</tt> (default location):
+  #
+  #   <div id='a_element'>
+  #     <div id='b_element'></div>
+  #     <div id='c_element'></div>
+  #   </div>
+  #   <div id='d_element'></div>
+  #
+  #   elem  = Document['#a_element']
+  #   other = Document['#d_element']
+  #   elem.insert(other)
+  #
+  # produces:
+  #
+  #   <div id='a_element'>
+  #     <div id='b_element'></div>
+  #     <div id='c_element'></div>
+  #     <div id='d_element'></div>
+  #   </div>
+  #
+  # Inserting into <tt>:top</tt>:
+  #
+  #   <div id='a_element'>
+  #     <div id='b_element'></div>
+  #     <div id='c_element'></div>
+  #   </div>
+  #   <div id='d_element'></div>
+  #
+  #   elem  = Document['#a_element']
+  #   other = Document['#d_element']
+  #   elem.insert(other, :top)
+  #
+  # produces:
+  #
+  #   <div id='a_element'>
+  #     <div id='d_element'></div>
+  #     <div id='b_element'></div>
+  #     <div id='c_element'></div>
+  #   </div>
+  #
+  # Inserting <tt>:before</tt>:
+  #
+  #   <div id='a_element'>
+  #     <div id='b_element'></div>
+  #     <div id='c_element'></div>
+  #   </div>
+  #   <div id='d_element'></div>
+  #
+  #   elem  = Document['#a_element']
+  #   other = Document['#d_element']
+  #   elem.insert(other, :before)
+  #
+  # produces:
+  #
+  #   <div id='d_element'></div>
+  #   <div id='a_element'>
+  #     <div id='b_element'></div>
+  #     <div id='c_element'></div>
+  #   </div>
+  #
+  def insert(element, where = :bottom)
+    self.send("insert_#{where.to_s}", element)
+    return self
+  end
+  def insert_after(element) # :nodoc
+    `if (!element.parentNode) return`
+    `next = #{self}.__native__.nextSibling`
+    `(next) ? #{self}.__native__.parentNode.insertBefore(#{element}.__native__, next) : #{self}__native__.parentNode.appendChild(#{element}.__native__)`
+    return true
+  end
+  def insert_before(element) # :nodoc:
+    `if (#{self}.__native__.parentNode) #{self}.__native__.parentNode.insertBefore(#{element}.__native__, #{self}.__native__)`
+    return true
+  end
+  def insert_bottom(element) # :nodoc
+    `#{self}.__native__.appendChild(#{element}.__native__)`
+    return true
+  end
+  alias :insert_inside :insert_bottom
+  def insert_top(element) # :nodoc:
+    `first = #{self}.__native__.firstChild`
+    `(first) ? #{self}.__native__.insertBefore(#{element}.__native__, first) : #{self}.__native__.appendChild(#{element}.__native__)`
+    return true
+  end
+  # call-seq:
+  #   elem.inspect -> string
+  #
+  # Returns a string representation of _elem_ including its tag name, classes,
+  # and id.
+  #
+  #   <div style="width:300px" id="a_element" class="draggable container">
+  #
+  #   Document['#a_element'].inspect    #=> "#<Element: DIV id=\"a_element\" class=\"draggable container\">"
+  #
+  def inspect
+    attributes = [`$q(this.__native__.tagName.toUpperCase())`]
+    attributes << `$q('id="'+this.__native__.id+'"')` if `this.__native__.id!==''`
+    attributes << `$q('class="'+this.__native__.className+'"')` if `this.__native__.className!==''`
+    "#<Element: %s>" % attributes.join(' ')
+  end
+  # call-seq:
+  #   elem.is_body? -> true or false
+  #
+  # Returns +true+ if the element is the body element, +false+ otherwise.
+  #
+  #   Document['#my_div'].is_body?   #=> false
+  #   Document.body.is_body?         #=> true
+  #
+  def is_body?
+    `(/^(?:body|html)$/i).test(#{self}.__native__.tagName)`
+  end
+  # call-seq:
+  #   elem.last_child -> element or nil
+  #
+  # Returns the last child element of _elem_ on the DOM tree, or +nil+ if no
+  # such element is found.
+  #
+  #   <div id="container">
+  #     <div id="a_element"></div>
+  #     <div id="b_element"></div>
+  #     <div id="c_element"></div>
+  #     <div id="d_element"></div>
+  #   </div>
+  #
+  #   Document['#container'].last_child   #=> #<Element: DIV id="d_element">
+  #
+  def last_child(match_selector = nil)
+    Document.walk(self, 'previousSibling', 'lastChild', match_selector, false)
+  end
+  # call-seq:
+  #   elem.next_element -> element or nil
+  #
+  # Returns the sibling element immediately following _elem_ on the DOM tree,
+  # or +nil+ if no such element is found.
+  #
+  #   <div id='container'>
+  #     <div id='a_element'></div>
+  #     <div id='b_element'></div>
+  #     <div id='c_element'></div>
+  #     <div id='d_element'></div>
+  #   </div>
+  #
+  #   Document['#b_element'].next_element   #=> #<Element: DIV id="c_element">
+  #
+  def next_element(match_selector = nil)
+    Document.walk(self, 'nextSibling', nil, match_selector, false)
+  end
+  # call-seq:
+  #   elem.next_elements -> array
+  #
+  # Returns the array of sibling elements that follow _elem_ on the DOM tree.
+  #
+  #   <div id='container'>
+  #     <div id='a_element'></div>
+  #     <div id='b_element'></div>
+  #     <div id='c_element'></div>
+  #     <div id='d_element'></div>
+  #   </div>
+  #
+  #   elem = Document['#b_element']   #=> #<Element: DIV id="b_element">
+  #   elem.previous_elements          #=> [#<Element: DIV id="c_element">, #<Element: DIV id="d_element">]
+  #
+  def next_elements(match_selector = nil)
+    Document.walk(self, 'nextSibling', nil, match_selector, true)
+  end
+  # call-seq:
+  #   elem.parent -> element or nil
+  #
+  # Returns the parent element of _elem_ on the DOM tree, or +nil+ if no such
+  # element is found.
+  #
+  #   <div id="container">
+  #     <div id="a_element"></div>
+  #     <div id="b_element"></div>
+  #     <div id="c_element"></div>
+  #     <div id="d_element"></div>
+  #   </div>
+  #
+  #   Document['#c_element'].parent   #=> #<Element: DIV id="container">
+  #   Document.body.parent            #=> #<Element: HTML>
+  #   Document.body.parent.parent     #=> nil
+  #
+  def parent(match_selector = nil)
+    Document.walk(self, 'parentNode', nil, match_selector, false)
+  end
+  # call-seq:
+  #   elem.parents -> array
+  #
+  # Returns the array of _elem_'s ancestors on the DOM tree.
+  #
+  #   <div id='container'>
+  #     <div id='a_element'></div>
+  #     <div id='b_element'>
+  #       <div id='b_inner_element'></div>
+  #     </div>
+  #     <div id='c_element'></div>
+  #     <div id='d_element'></div>
+  #   </div>
+  #
+  #   Document['#b_inner_element'].parents    #=> [#<Element: DIV id="b_element">, #<Element: DIV id="container">, <Element: BODY>, <Element: HTML>]
+  #   Document.html.parents                   #=> []
+  #
+  def parents(match_selector = nil)
+    Document.walk(self, 'parentNode', nil, match_selector, true)
+  end
+  # call-seq:
+  #   elem.previous_element -> element or nil
+  #
+  # Returns the sibling element immediately preceding _elem_ on the DOM tree,
+  # or +nil+ if no such element is found.
+  #
+  #   <div id='container'>
+  #     <div id='a_element'></div>
+  #     <div id='b_element'></div>
+  #     <div id='c_element'></div>
+  #     <div id='d_element'></div>
+  #   </div>
+  #
+  #   Document['#b_element'].previous_element   #=> #<Element: DIV id="a_element">
+  #
+  def previous_element(match_selector = nil)
+    Document.walk(self, 'previousSibling', nil, match_selector, false)
+  end
+  # call-seq:
+  #   elem.previous_elements -> array
+  #
+  # Returns the array of sibling elements that precede _elem_ on the DOM tree.
+  #
+  #   <div id='container'>
+  #     <div id='a_element'></div>
+  #     <div id='b_element'></div>
+  #     <div id='c_element'></div>
+  #     <div id='d_element'></div>
+  #   </div>
+  #
+  #   elem = Document['#c_element']   #=> #<Element: DIV id="c_element">
+  #   elem.previous_elements          #=> [#<Element: DIV id="a_element">, #<Element: DIV id="b_element">]
+  #
+  def previous_elements(match_selector = nil)
+    Document.walk(self, 'previousSibling', nil, match_selector, true)
+  end
+  # call-seq:
+  #   elem.remove! -> elem
+  #
+  # Removes _elem_ and all of its child elements from the page, then returns
+  # _elem_.
+  #
+  def remove!
+    Element.remove(self)
+    return self
+  end
+  # call-seq:
+  #   elem.to_s -> string
+  #
+  # FIX: Incomplete
+  #
+  def to_s
+  end
+end