jam 0.2

data/lib/jam.rb

@@ -0,0 +1,2 @@
+require 'jam/template'
+

data/lib/jam/cherry.rb

@@ -0,0 +1 @@
+# Cherry Adaptor

data/lib/jam/css2xpath.rb

@@ -0,0 +1,104 @@
+module Jam
+
+  def self.css_to_xpath(rule)
+    regElement    = /^([#.]?)([a-z0-9\\*_-]*)((\|)([a-z0-9\\*_-]*))?/i
+    regAttr1      = /^\[([^\]]*)\]/i
+    regAttr2      = /^\[\s*([^~=\s]+)\s*(~?=)\s*"([^"]+)"\s*\]/i
+    regPseudo     = /^:([a-z_-])+/i
+    regCombinator = /^(\s*[>+\s])?/i
+    regComma      = /^\s*,/i
+
+    index = 1;
+    parts = ["//", "*"]
+    lastRule = nil
+
+    while rule.length && rule != lastRule
+      lastRule = rule
+
+      # Trim leading whitespace
+      rule = rule.gsub(/^\s*|\s*$/, "")  #.replace
+      break if rule.length == 0
+
+      # Match the element identifier
+      m = regElement.match(rule)
+      if m
+        if !m[1]
+          # XXXjoe Namespace ignored for now
+          if m[5]
+            parts[index] = m[5]
+          else
+            parts[index] = m[2]
+          end
+        elsif (m[1] == '#')
+            parts.push("[@id='" + m[2] + "']") 
+        elsif (m[1] == '.')
+            parts.push("[contains(@class, '" + m[2] + "')]") 
+        end        
+        rule = rule.substr(m[0].length)
+      end
+
+      # Match attribute selectors
+      m = regAttr2.match(rule)
+      if m
+        if m[2] == "~="
+          parts.push("[contains(@" + m[1] + ", '" + m[3] + "')]")
+        else
+          parts.push("[@" + m[1] + "='" + m[3] + "']")
+        end
+        rule = rule.substr(m[0].length)
+      else
+        m = regAttr1.match(rule)
+        if m
+          parts.push("[@" + m[1] + "]")
+          rule = rule.substr(m[0].length)
+        end
+      end
+
+      # Skip over pseudo-classes and pseudo-elements, which are of no use to us
+      m = regPseudo.match(rule)
+      while m
+        rule = rule.substr(m[0].length)
+        m = regPseudo.match(rule)
+      end
+
+      # Match combinators
+      m = regCombinator.match(rule)
+      if m && m[0].length
+        if m[0].index(">")
+          parts.push("/")
+        elsif m[0].index("+")
+          parts.push("/following-sibling::")
+        else
+          parts.push("//")
+        end
+        index = parts.length
+        parts.push("*")
+        rule = rule.substr(m[0].length)
+      end
+
+      m = regComma.match(rule)
+      if m
+        parts.push(" | ", "//", "*")
+        index = parts.length - 1
+        rule = rule.substr(m[0].length)
+      end
+    end
+    
+    xpath = parts.join("")
+    return xpath
+  end
+
+end #module Jam
+
+
+class String
+
+  #
+  def substr(start, ending=-1)
+    str = self[start..ending]
+    self[start..ending] = ''
+    str
+  end
+
+end
+

data/lib/jam/css_to_xpath.rb

@@ -0,0 +1,132 @@
+
+# css_to_xpath - generic CSS to XPath selector transformer
+#
+# * @author      Andrea Giammarchi
+# * @license     Mit Style License
+# * @blog        http://webreflection.blogspot.com/
+# * @project     http://code.google.com/p/css2xpath/
+# * @version     0.1 - Converts correctly every SlickSpeed CSS selector [http://mootools.net/slickspeed/]
+# * @note        stand alone vice-versa subproject [http://code.google.com/p/css2xpath/]
+# * @info        http://www.w3.org/TR/CSS2/selector.html
+# * @credits     some tips from Aristotle Pagaltzis [http://plasmasturm.org/log/444/]
+#
+
+module Jam
+
+  def self.css_to_xpath(css)
+    CSStoXPath.css_to_xpath(css)
+  end
+
+  module CSStoXPath
+    extend self
+
+    RULES = []
+
+    def rule(re_from, re_to=nil, &block)
+      RULES << [re_from, re_to || block]
+    end
+
+    # add @ for attribs
+    rule /\[([^\]~\$\*\^\|\!]+)(=[^\]]+)?\]/, '[@\1\2]'
+
+    # multiple queries
+    rule /\s*,\s*/, "|"
+
+    # , + ~ >
+    rule /\s*(\+|~|>)\s*/, '\1'
+
+    # * ~ + >
+    rule /([a-zA-Z0-9\_\-\*])~([a-zA-Z0-9\_\-\*])/ , '\1/following-sibling::\2'
+    rule /([a-zA-Z0-9\_\-\*])\+([a-zA-Z0-9\_\-\*])/, '\1/following-sibling::*[1]/self::\2'
+    rule /([a-zA-Z0-9\_\-\*])>([a-zA-Z0-9\_\-\*])/ , '\1/\2'
+
+    # all unescaped stuff escaped
+    rule /\[([^=]+)=([^'|"][^\]]*)\]/, '[\1=\'\2\']'
+
+    # all descendant or self to //
+    rule /(^|[^a-zA-Z0-9\_\-\*])(#|\.)([a-zA-Z0-9\_\-]+)/, '\1*\2\3'
+    rule /([\>\+\|\~\,\s])([a-zA-Z\*]+)/, '\1//\2'
+    rule /\s+\/\//, '//'
+
+    # :first-child
+    rule /([a-zA-Z0-9\_\-\*]+):first-child/, '*[1]/self::\1'
+
+    # :last-child
+    rule /([a-zA-Z0-9\_\-\*]+):last-child/, '\1[not(following-sibling::*)]'
+
+    # :only-child
+    rule /([a-zA-Z0-9\_\-\*]+):only-child/, '*[last()=1]/self::\1'
+
+    # :empty
+    rule /([a-zA-Z0-9\_\-\*]+):empty/, '\1[not(*) and not(normalize-space())]'
+
+    # :not
+    rule /([a-zA-Z0-9\_\-\*]+):not\(([^\)]*)\)/ do |s, a, b|
+      return a.concat("[not(", css_to_xpath(b).gsub(/^[^\[]+\[([^\]]*)\].*$/, '\1'), ")]") 
+    end
+
+    # :nth-child
+    rule /([a-zA-Z0-9\_\-\*]+):nth-child\(([^\)]*)\)/ do |s, a, b|
+      case b
+      when "n"
+        return a
+      when "even"
+        return "*[position() mod 2=0 and position()>=0]/self::" + a
+      when "odd"
+        return a + "[(count(preceding-sibling::*) + 1) mod 2=1]"
+      else
+        b = (b || "0").gsub(/^([0-9]*)n.*?([0-9]*)$/, '\1+\2').split("+")
+        b[1] = b[1] || "0"
+        return "*[(position()-".concat(b[1], ") mod ", b[0], "=0 and position()>=", b[1], "]/self::", a)
+      end
+    end
+
+    # :contains(selectors)
+    rule /:contains\(([^\)]*)\)/ do |s, a|
+      # return "[contains(css:lower-case(string(.)),'" + a.toLowerCase() + "')]"; // it does not work in firefox 3*/
+      return "[contains(string(.),'" + a + "')]"
+    end
+
+    # |= attrib
+    rule /\[([a-zA-Z0-9\_\-]+)\|=([^\]]+)\]/, '[@\1=\2 or starts-with(@\1,concat(\2,\'-\'))]'
+
+    # *= attrib
+    rule /\[([a-zA-Z0-9\_\-]+)\*=([^\]]+)\]/, '[contains(@\1,\2)]'
+
+    # ~= attrib
+    rule /\[([a-zA-Z0-9\_\-]+)~=([^\]]+)\]/, '[contains(concat(' ',normalize-space(@\1),' '),concat(' ',\2,' '))]'
+
+    # ^= attrib
+    rule /\[([a-zA-Z0-9\_\-]+)\^=([^\]]+)\]/, '[starts-with(@\1,\2)]'
+
+    # $= attrib
+    rule /\[([a-zA-Z0-9\_\-]+)\$=([^\]]+)\]/ do |s, a, b|
+      return '[substring(@'.concat(a, ',string-length(@', a, ')-', b.length - 3, ')=', b, ']')
+    end
+
+    # != attrib
+    rule /\[([a-zA-Z0-9\_\-]+)\!=([^\]]+)\]/, '[not(@\1) or @\1!=\2]'
+
+    # ids and classes
+    rule /#([a-zA-Z0-9\_\-]+)/ , '[@id=\'\1\']'
+    rule /\.([a-zA-Z0-9\_\-]+)/, '[contains(concat(\' \',normalize-space(@class),\' \'),\' \1 \')]'
+
+    # normalize multiple filters
+    rule /\]\[([^\]]+)/, ' and (\1)'
+
+    def css_to_xpath(css)
+      RULES.each do |f, t|
+        case t
+        when Proc
+          css = css.gsub(f, &t)
+        else
+          css = css.gsub(f, t)
+        end
+      end
+      return ".//" + css;
+    end
+
+  end
+
+end
+

data/lib/jam/engine.rb

@@ -0,0 +1,169 @@
+#require 'facets/hash/to_h'
+
+module Jam
+
+  # = Jam Engine
+  #
+  # The Engine class serves as the base class for the various Jam adapters.
+  #
+  #--
+  # TODO: Can we normalize parser options across all backends. REXML seems a limiting factor.
+  #++
+
+  class Engine
+
+    # Interpolate data into document, returning the document object.
+    #
+    def interpolate(node, data)
+      interpolate_node(node, data)
+    end
+
+  private
+
+    # Converts plain keys to css selectors.
+    #
+    # TODO: Change to use special attribute instead of 'id'?
+    #
+    def prepare_data(data)
+      d = {}
+      data.each do |key, val|
+        case key.to_s
+        when /^<(.*?)>(.*)$/
+          d["#{$1}#{$2}"] = val
+        when /^\w/
+          d["##{key}"] = val
+        else
+          d[key.to_s] = val
+        end
+      end
+      return d
+    end
+
+    # Interpolate data.
+    #
+    def interpolate_node(node, data)
+      case data
+      when nil
+        remove(node)
+      when Array
+        interpolate_sequence(node, data)
+      when String, Numeric
+        interpolate_scalar(node, data)
+      when Hash
+        interpolate_mapping(node, data)
+      else
+        interpolate_object(node, data)
+      end
+      return node
+    end
+
+    # Interpolate mapping.
+    #
+    def interpolate_mapping(node, data)
+      data = prepare_data(data)
+
+      data.each do |id, val|
+        att = false
+        qry = id.to_s
+
+        result = qry.match(/^((.*?)\/)?([@](.*?))$/);
+        if result
+          att = result[4]
+          qry = result[2] #+ '[@' + att + ']'
+        else
+          att = false
+        end
+
+        if att
+          #qry = qry + '[@' + att + ']';
+          #search(node,qry).attr(att,val);
+          if qry
+            #if tag == false
+            #  qry = '#' + qry
+            #end
+            nodeset = search(node, qry)
+            attribute(nodeset, att, val)
+          else
+            attribute(node, att, val)
+          end
+        else
+          nodeset = search(node, qry)
+          #if nodeset.size > 0
+            interpolate_node(nodeset, val)
+          #end
+        end
+      end
+    end
+
+    # Interpolate object.
+    #
+    def interpolate_object(node, data)
+      data = Hash[data.instance_variables.map{ |iv| [iv[1..-1], data.instance_variable_get(iv)] }]
+      interpolate_mapping(node, data)
+    end
+
+    # Interpolate attribute.
+    #
+    #def interpolate_attribute(nodes, data)
+    #
+    #end
+
+    # Interpolate array sequence.
+    #
+    def interpolate_sequence(nodes, data)
+      each_node(nodes) do |node|
+        parent = node.parent
+        data.each do |new_data|
+          new_node = interpolate_node(node.dup, new_data)
+          append(parent, new_node)
+          remove(node)
+        end
+      end
+    end
+
+    # Interpolate value.
+    #
+    # TODO This should have some special HTML features ?
+    #
+    # TODO Should we have two modes --one with and one without the extra HTML features?
+    #
+    def interpolate_scalar(nodes, data)
+      #var all_special = new Array;
+
+      # text inputs
+      #var special = this.find('input[@type=text]');
+      #special.val(data.toString());
+      #all_special.concat(special);
+      # textarea
+      # TODO
+
+      #this.not(special).empty();
+      #this.not(special).append(data.toString());
+      #alert(data);
+      #empty(node)
+      replace_content_with_text(nodes, data.to_s)
+    end
+
+  end #class Engine
+
+end #module Jam
+
+
+
+=begin
+# Interpolate list.
+
+function interpolate_list(node, data) {
+  temp = node.copy(true)
+  node.empty!
+  for (var d in data) {
+    nc = temp.copy(true);
+    interpolate_children( nc, d )
+    for (var c in nc.children) {
+      node.add(c);
+    };
+  };
+};
+=end
+
+

data/lib/jam/hpricot.rb

@@ -0,0 +1,137 @@
+require 'hpricot'
+require 'jam/engine'
+
+module Hpricot
+
+  class Doc
+    def jam(data, opts={})
+      engine = ::Jam::Hpricot.new()
+      engine.interpolate(self, data)
+    end
+  end
+
+  class Elem
+    # This turns the Elem into an Elements object containing it.
+    def jam(data, opts={})
+      engine = ::Jam::Hpricot.new()
+      engine.interpolate(::Hpricot::Elements[self], data)
+    end
+  end
+
+  class Elements
+    def jam(data, opts={})
+      engine = ::Jam::Hpricot.new()
+      engine.interpolate(self, data)
+    end
+  end
+
+end
+
+module Jam
+
+  # Hpricot Adaptor
+  #
+  class Hpricot < Engine
+
+    #
+    def initialize(*options)
+      @options = options
+    end
+
+    #
+    def document(source)
+      ::Hpricot.parse(source) #, *@options)
+    end
+
+    #
+    def search(node, qry)
+      node.search(qry)
+    end
+
+    # deep copy # TODO: works?
+    def copy(node)
+      node.dup 
+    end
+
+    #
+    def remove(node)
+      node.remove
+    end
+
+    #
+    def empty(ns)
+      ns.empty
+    end
+
+    #
+    def append(ns, child)
+      ns.append(child.to_s)
+    end
+
+    #
+    def replace(ns, child)
+      empty(ns)
+      append(ns, child)
+    end
+
+    #
+    def remove(node)
+      node.remove
+    end
+
+    #
+    def replace_content_with_text(node, text)
+      case node
+      when ::Hpricot::Elements
+        node.inner_html = text
+      when ::Array
+        node.each do |n|
+          n.inner_html = text
+        end
+      else
+
+      end
+    end
+
+    #
+    def attribute(ns, att, val)
+      ns.set(att, val)
+    end
+
+    # Remove jam nodes that ask for it, and all jam attributes.
+    #
+    def cleanup(node)
+      #node = node.root if ::Nokogiri::XML::Document === node
+      # remove unwanted tags
+      node.search("//*[@jam='erase']").each do |n|
+        unwrap(n)
+      end
+      # remove jam attributes
+
+      #
+      node
+    end
+
+    # Unwrap a node, such that the outer tag is
+    # removed, leaving only it's own children.
+    #
+    def unwrap(node)
+      node.each_child{ |n| node.parent.insert_before(n, node) }
+      ::Hpricot::Elements[node].remove
+    end
+
+    # Iterate over each node.
+    #
+    def each_node(nodes)
+      unless ::Hpricot::Elements === nodes
+        nodes = [nodes]
+      end
+      nodes.each do |node|
+        yield(node)
+      end
+    end
+
+  end
+
+end
+