jam 0.2

data/lib/jam/template.rb

@@ -0,0 +1,224 @@
+require 'jam/nokogiri'
+require 'jam/libxml'
+
+module Jam
+
+  # Jam Templates are data-driven templates. They take
+  # valid XML/XHTML documents and expand them based on
+  # the data structures provided.
+  #
+  #--
+  # TODO: Should rendered output have document headers like <?xml or a doctype for HTML.
+  #++
+  class Template
+    DEFAULT_ADAPTER = 'Nokogiri'
+
+    attr :engine
+    #attr :adapter
+    #attr :file
+
+    # New template from source file.
+    #
+    # * +file+ is the file location of a source.
+    # * +adapter+ is either :nokogiri, :libxml or :rexml.
+    # * +options+ are per-adapter and passed through to the underlying adapter's parser
+    #
+    def self.load(file, adapter=DEFAULT_ADAPTER, *options)
+      new(File.read(file), adapter, *options)
+    end
+
+    # New template from source string.
+    #
+    # * +source+ can be either a String or an IO object.
+    # * +adapter+ is either :nokogiri, :libxml or :rexml.
+    # * +options+ are per-adapter and passed through to the underlying adapter's parser
+    #
+    def initialize(source, adapter=DEFAULT_ADAPTER, *options)
+      #@engine  = Engine.new(adapter)
+      @engine = Jam.const_get(adapter.to_s).new(*options)
+      @source = source
+    end
+
+    #
+    def document
+      @document ||= engine.document(@source)
+    end
+
+    #
+    # TODO: Should we render as doc, this might add a header, or render as root where it does not.
+    #
+    def render(data)
+      engine.interpolate(document, data).root.to_s
+    end
+
+    alias_method :expand, :render
+
+    #
+    def to_s
+      document.to_s
+    end
+
+
+=begin
+    # Interpolate data into document, returning the document object.
+    #
+    def interpolate(data)
+      interpolate_node(data, document)
+    end
+
+    #
+    def jam(data)
+      interpolate_node(data, document)
+    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(data, node)
+      case data
+      when nil
+        adapter.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 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 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
+            set = adapter.search(node, qry)
+            adapter.attribute(set, att, val)
+          else
+            adapter.attribute(node, att, val)
+          end
+        else
+          set = adapter.search(node, qry)
+          if set.size > 0
+            interpolate_node(val, set)
+          end
+        end
+      end
+    end
+
+    # Interpolate attribute.
+    #
+    #def interpolate_attribute(nodes, data)
+    #
+    #end
+
+    # Interpolate array sequence.
+    #
+    def interpolate_sequence(nodes, data)
+      adapter.each_node(nodes) do |node|
+        parent = node.parent
+        data.each do |new_data|
+          new_node = interpolate_node(new_data, node.dup)
+          parent << new_node
+          node.remove
+        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);
+      #adapter.empty(node)
+      adapter.replace(nodes, data.to_s)
+    end
+=end
+
+  end #class Template
+
+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/meta/abstract

@@ -0,0 +1,2 @@
+Jam is a data-driven template system.
+

data/meta/author

@@ -0,0 +1 @@
+Trans <transfire@gmail.com>

data/meta/created

@@ -0,0 +1 @@
+2008-12-16

data/meta/homepage

@@ -0,0 +1 @@
+http://rubyworks.github.com/jam

data/meta/package

@@ -0,0 +1 @@
+jam

data/meta/project

@@ -0,0 +1 @@
+rubyworks

data/meta/status

@@ -0,0 +1 @@
+beta

data/meta/summary

@@ -0,0 +1 @@
+Jam is a data-driven template system.

data/meta/timestamp

@@ -0,0 +1 @@
+2009-06-14 17:24:46

data/meta/title

@@ -0,0 +1 @@
+Jam

data/meta/version

@@ -0,0 +1 @@
+0.2

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification 
+name: jam
+version: !ruby/object:Gem::Version 
+  version: "0.2"
+platform: ruby
+authors: []
+
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-23 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Jam is a data-driven templater system. Jam provides 100% sepearation between logic and presentation.  Jam can operate on the back-end via Ruby or on the front-end via Javascript/jQuery off-loading some of the back-end work load, while also providing 100% SOC
+email: 
+executables: 
+- jam
+extensions: []
+
+extra_rdoc_files: 
+- README
+- MANIFEST
+- TODO
+- HISTORY
+files: 
+- bin/jam
+- demo/array.rb
+- demo/attribute.rb
+- demo/demi/fixtures/ex1.html
+- demo/demi/fixtures/samples.yaml
+- demo/demi/integration/01_jam.rd
+- demo/demi/integration/02_xpath.rd
+- demo/demi/integration/samples.rd
+- demo/demi/unit/hpricot.rd
+- demo/demi/unit/libxml.rd
+- demo/demi/unit/nokogiri.rd
+- demo/demi/unit/rexml.rd
+- demo/hash.rb
+- demo/helloworld.rb
+- demo/object.rb
+- demo/table.rb
+- js/jquery.jam.js
+- lib/jam/cherry.rb
+- lib/jam/css2xpath.rb
+- lib/jam/css_to_xpath.rb
+- lib/jam/engine.rb
+- lib/jam/hpricot.rb
+- lib/jam/libxml.rb
+- lib/jam/nokogiri.rb
+- lib/jam/rexml.rb
+- lib/jam/template.rb
+- lib/jam.rb
+- meta/abstract
+- meta/author
+- meta/created
+- meta/homepage
+- meta/package
+- meta/project
+- meta/status
+- meta/summary
+- meta/timestamp
+- meta/title
+- meta/version
+- TODO
+- README
+- HISTORY
+- MANIFEST
+has_rdoc: true
+homepage: http://rubyworks.github.com/jam
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --title
+- jam api
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: jam
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Jam is a data-driven template system.
+test_files: []
+