dress 0.0.1 → 0.0.2

data/README.html

@@ -0,0 +1,152 @@
+<h1
+>XSLT(not!) with Elegant Dress</h1
+><p
+>You'd swear XSLT is a joke, but it's not. It's cruelty. XSLT is like this: it's good to rid the city of this horrible vermin infestation-- Let's nuke the city. It's an out-of-proportion insanity. It's Turing-complete, and it's XML.</p
+><p
+>Hmm.</p
+><p
+>But what it is, is just a set of transformations on fragments of your XML document. The beauty of XSLT (they say), is that XSLT itself is XML, so you can (in principle) use XSLT to transform itself.</p
+><p
+>Hmm.</p
+><p
+>Oh I know, how about let's use Ruby?</p
+><h1
+>Transformation Elegant Dress</h1
+><p
+>Honestly, there's not much to it. A <code
+  >Dress</code
+  > is just a sequence of transformations you perform on a DOM tree. Unlike XSLT though, the transformations are performed directly on the DOM tree. That is to say, they are destructive.</p
+><p
+>This is a simple dress,</p
+><pre
+><code
+  >require 'dress'
+doc = &quot;&lt;my&gt;&lt;brain&gt;&lt;/brain&gt;&lt;/my&gt;&quot;
+dress = Dress {
+ match(&quot;brain&quot;) do
+   set(&quot;size&quot;,&quot;pea&quot;)
+ end
+}
+result = dress.on(doc)
+puts result.to_s
+# &lt;my&gt;&lt;brain &quot;size&quot;=&quot;pea&quot;&gt;&lt;/brain&gt;&lt;/my&gt;
+</code
+  ></pre
+><p
+>We can have more matchers,</p
+><pre
+><code
+  >dress = Dress {
+ match(&quot;brain&quot;) do
+   set(&quot;size&quot;,&quot;pea&quot;)
+ end
+ match(&quot;my&quot;) do
+   each { |e| e.name = &quot;homer&quot;}
+ end
+}
+result = dress.on(doc)
+puts result.to_s
+# &lt;homer&gt;&lt;brain &quot;size&quot;=&quot;pea&quot;&gt;&lt;/brain&gt;&lt;/homer&gt;
+</code
+  ></pre
+><p
+>Note that match always yield a <code
+  >Nokogiri::Nodeset</code
+  >. But sometimes we'd like to operate on just one node (or the first one we find). For that there's the <code
+  >at</code
+  > matcher.</p
+><pre
+><code
+  >dress = Dress {
+  at(&quot;my&quot;) do
+    me.name = &quot;homer&quot;
+  end
+}
+</code
+  ></pre
+><p
+><code
+  >me</code
+  > is always the object yielded by the matcher string. For <code
+  >match</code
+  > it would be a Nodeset, and for <code
+  >at</code
+  >, it would be an Element.</p
+><p
+>We can define helper methods on a Dress. This is one that implements a counter,</p
+><pre
+><code
+  >dress = Dress {
+  def count
+    @count ||= 0
+    @count += 1
+    @count
+  end
+
+  match(&quot;brain&quot;) do
+    each { |e| e[&quot;area&quot;] = count.to_s }
+  end
+}
+puts dress.on(Nokogiri.make { my { brain; brain; brain; brain }}).to_s
+# &lt;my&gt;&lt;brain area=&quot;1&quot;&gt;&lt;/brain&gt;&lt;brain area=&quot;2&quot;&gt;&lt;/brain&gt;&lt;brain area=&quot;3&quot;&gt;&lt;/brain&gt;&lt;brain area=&quot;4&quot;&gt;&lt;/brain&gt;&lt;/my&gt;
+</code
+  ></pre
+><p
+>We can combine dresses into lines,</p
+><pre
+><code
+  >d1 = Dress { ... }
+d2 = Dress { ... }
+(d1 | d2).on(doc)
+</code
+  ></pre
+><p
+>We can link lines together,</p
+><pre
+><code
+  >d3 = Dress { ... }
+d4 = Dress { ... }
+((d1 | d2) | (d3 | d4)).on(doc)
+</code
+  ></pre
+><p
+>A dress is a class inheriting from Dress.</p
+><pre
+><code
+  >class FancyDress &lt; Dress
+  def helper1
+  end
+  def helper2
+  end
+  match(...) { ... }
+  ...
+end
+
+class PrettyDress &lt; Dress
+  ...
+end
+</code
+  ></pre
+><p
+>Then we can combine these dresses,</p
+><pre
+><code
+  >(FancyDress | PrettyDress).on(document)
+</code
+  ></pre
+><p
+>You can of course mix that with dynamic dresses,</p
+><pre
+><code
+  >(FancyDress | PrettyDress | Dress do ... end).on(doc)
+</code
+  ></pre
+><h1
+>That Wasn't So Hard, Was It?</h1
+><p
+>So Ruby saved us all from XSLT. Minus all the XSLT-inspired buckets of tears, the world is a better place. FTW.</p
+><h1
+>Copyright</h1
+><p
+>Copyright (c) 2009 Howard Yeh. See LICENSE for details.</p
+>

data/README.markdown

@@ -0,0 +1,139 @@
+# XSLT(not!) with Elegant Dress
+
+You'd swear XSLT is a joke, but it's not. It's
+cruelty. XSLT is like this: it's good to rid the
+city of this horrible vermin infestation-- Let's
+nuke the city. It's an out-of-proportion
+insanity. It's Turing-complete, and it's XML.
+
+Hmm.
+
+But what it is, is just a set of transformations
+on fragments of your XML document. The beauty of
+XSLT (they say), is that XSLT itself is XML, so
+you can (in principle) use XSLT to transform
+itself.
+
+Hmm.
+
+Oh I know, how about let's use Ruby?
+
+# Transformation Elegant Dress
+
+Honestly, there's not much to it. A `Dress` is
+just a sequence of transformations you perform on
+a DOM tree. Unlike XSLT though, the
+transformations are performed directly on the DOM
+tree. That is to say, they are destructive.
+
+This is a simple dress,
+
+    require 'dress'
+    doc = "<my><brain></brain></my>"
+    dress = Dress {
+     match("brain") do
+       set("size","pea")
+     end
+    }
+    result = dress.on(doc)
+    puts result.to_s
+    # <my><brain "size"="pea"></brain></my>
+
+
+We can have more matchers,
+
+    dress = Dress {
+     match("brain") do
+       set("size","pea")
+     end
+     match("my") do
+       each { |e| e.name = "homer"}
+     end
+    }
+    result = dress.on(doc)
+    puts result.to_s
+    # <homer><brain "size"="pea"></brain></homer>
+
+
+Note that match always yield a
+`Nokogiri::Nodeset`. But sometimes we'd like to
+operate on just one node (or the first one we
+find). For that there's the `at` matcher.
+
+    dress = Dress {
+      at("my") do
+        me.name = "homer"
+      end
+    }
+
+`me` is always the object yielded by the matcher
+string. For `match` it would be a Nodeset, and for
+`at`, it would be an Element.
+
+We can define helper methods on a Dress. This is
+one that implements a counter,
+
+    dress = Dress {
+      def count
+        @count ||= 0
+        @count += 1
+        @count
+      end
+
+      match("brain") do
+        each { |e| e["area"] = count.to_s }
+      end
+    }
+    puts dress.on(Nokogiri.make { my { brain; brain; brain; brain }}).to_s
+    # <my><brain area="1"></brain><brain area="2"></brain><brain area="3"></brain><brain area="4"></brain></my>
+
+
+
+We can combine dresses into lines,
+
+    d1 = Dress { ... }
+    d2 = Dress { ... }
+    (d1 | d2).on(doc)
+
+
+We can link lines together,
+
+    d3 = Dress { ... }
+    d4 = Dress { ... }
+    ((d1 | d2) | (d3 | d4)).on(doc)
+
+
+A dress is a class inheriting from Dress.
+
+    class FancyDress < Dress
+      def helper1
+      end
+      def helper2
+      end
+      match(...) { ... }
+      ...
+    end
+
+    class PrettyDress < Dress
+      ...
+    end
+
+
+Then we can combine these dresses,
+
+    (FancyDress | PrettyDress).on(document)
+
+You can of course mix that with dynamic dresses,
+
+    (FancyDress | PrettyDress | Dress do ... end).on(doc)
+
+
+# That Wasn't So Hard, Was It?
+
+So Ruby saved us all from XSLT. Minus all the
+XSLT-inspired buckets of tears, the world is a
+better place. FTW.
+
+# Copyright
+
+Copyright (c) 2009 Howard Yeh. See LICENSE for details.

data/Rakefile

@@ -5,7 +5,7 @@ begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|
     gem.name = "dress"
-    gem.summary = %Q{DOM transformation based on nokogiri}
+    gem.summary = %Q{DOM transformation based on Nokogiri}
     gem.description = %Q{Inspired by the horror of XSLT}
     gem.email = "hayeah@gmail.com"
     gem.homepage = "http://github.com/hayeah/dress"

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/dress.gemspec

@@ -0,0 +1,57 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{dress}
+  s.version = "0.0.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Howard Yeh"]
+  s.date = %q{2010-01-07}
+  s.description = %q{Inspired by the horror of XSLT}
+  s.email = %q{hayeah@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.html",
+     "README.markdown",
+     "README.textile"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "dress.gemspec",
+     "lib/dress.rb",
+     "spec/dress_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/hayeah/dress}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{DOM transformation based on Nokogiri}
+  s.test_files = [
+    "spec/dress_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+  end
+end
+

data/lib/dress.rb

@@ -90,3 +90,112 @@ end
 def Dress(&block)
   Dress.style(&block)
 end
+
+# TODO move to monkey patch
+class Nokogiri::XML::Builder
+  def n(*docs)
+    docs.each do |doc|
+      case doc
+      when String
+        self << doc
+      when Nokogiri::XML::Node
+        insert(doc)
+        #self << doc.to_s
+        #self.doc.children.each 
+      else
+        raise "bad node: #{doc}" 
+      end
+    end
+  end
+
+  def t(*texts)
+    texts.each do |text|
+      self.text(text.to_s)
+      self.text(" ")
+    end
+  end
+end
+
+class Dress::Maker
+  require 'active_support'
+  require 'active_support/core_ext'
+
+  class_inheritable_hash :layout_defs
+  self.layout_defs = {}
+  
+  class << self
+    
+    
+    def layouts
+      #read_inheritable_attribute(:layouts).keys
+      layout_defs.keys
+    end
+    
+    def layout(name=nil,&block)
+      layout_defs[name] = block
+    end
+
+    def with(name,page,*args,&block)
+      content = self.new.send(page,*args,&block)
+      l = layout(name).clone
+      l.at("content").replace(content)
+      l
+    end
+
+    def render(page,*args,&block)
+      self.new.render(page,*args,&block)
+    end
+
+    def render_with(layout,page,*args,&block)
+      self.new.render_with(layout,page,*args,&block)
+    end
+  end
+
+  def render(page,*args,&block)
+    # use default layout
+    render_with(nil,page,*args,&block)
+  end
+
+  def render_with(layout,page,*args,&block)
+    content = self.send(page,*args,&block)
+    l = self.instance_eval(&self.class.layout_defs[layout])
+    l.at("content").replace(content)
+    l
+  end
+
+  def method_missing(method,*args,&block)
+    Nokogiri.make {
+      #builder = self
+      d = self.send(method,*args,&block)
+    }
+  end
+end
+
+def DressMaker(&block)
+  c = Class.new(Dress::Maker)
+  c.class_eval(&block)
+  c
+end
+
+
+# TODO break this out to a separate loadable file
+class Dress::ActiveView < Dress::Maker
+  require 'action_pack'
+  require 'action_view'
+  extend ActionView::Helpers
+  include ActionView::Helpers
+  DEFAULT_CONFIG = ActionView::DEFAULT_CONFIG unless defined?(DEFAULT_CONFIG)
+
+  def config
+    self.config = DEFAULT_CONFIG unless @config
+    @config
+  end
+
+  def config=(config)
+    @config = ActiveSupport::OrderedOptions.new.merge(config)
+  end
+
+  def initialize(controller)
+    @controller = controller
+  end
+end

data/spec/dress_spec.rb

@@ -109,3 +109,39 @@ describe "Dress" do
     node.xpath("//bar/@b").map(&:value).should == ["2"]
   end
 end
+
+describe "Dress::Maker" do
+  it "renders" do
+    d = DressMaker { 
+      layout { n(wrapper_helper) }
+      layout(:foo) { foo { content }}
+      
+      def content1
+        some_stuff(:a => "10", :b => "20") { inside }
+      end
+
+      def wrapper_helper
+        wrap1 { wrap2 { content }}
+      end
+    }
+    d.render(:content1).to_s.should == '<wrap1><wrap2><some_stuff a="10" b="20"><inside></inside></some_stuff></wrap2></wrap1>'
+    d.render_with(:foo,:content1).to_s.should == '<foo><some_stuff a="10" b="20"><inside></inside></some_stuff></foo>'
+  end
+
+  class D1 < Dress::Maker
+    layout {  foo { content }}
+  end
+
+  class D2 < D1
+    def bar
+      "bar"
+    end
+  end
+  
+  it "inherit layouts" do
+    #p D1.layout_defs
+    #p D2.layout_defs
+    D2.layouts.should_not be_empty
+    #D1.render(:bar)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dress
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Howard Yeh
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-28 00:00:00 -08:00
+date: 2010-01-07 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -30,18 +30,23 @@ extensions: []
 
 extra_rdoc_files: 
 - LICENSE
-- README
+- README.html
+- README.markdown
+- README.textile
 files: 
 - .document
 - .gitignore
 - LICENSE
-- README
+- README.markdown
 - Rakefile
 - VERSION
+- dress.gemspec
 - lib/dress.rb
 - spec/dress_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
+- README.html
+- README.textile
 has_rdoc: true
 homepage: http://github.com/hayeah/dress
 licenses: []
@@ -69,7 +74,7 @@ rubyforge_project:
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: DOM transformation based on nokogiri
+summary: DOM transformation based on Nokogiri
 test_files: 
 - spec/dress_spec.rb
 - spec/spec_helper.rb