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

red 4.1.0 → 4.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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