lilu 0.1.0

data/lib/lilu.rb

@@ -0,0 +1,268 @@
+require 'rubygems'
+require 'hpricot'
+require 'active_support'
+
+class Hpricot::Elem
+  attr_accessor :cache_search
+  alias :_search :search
+  def search(expr,&block)
+    if @_inner_html
+      self.inner_html= @_inner_html 
+      @_inner_html = nil
+    end
+    if cache_search
+      @_search ||= {}
+      @_search[expr] || @_search[expr] = _search(expr,&block)
+    else
+      _search(expr,&block)
+    end
+  end
+
+  def _inner_html=(html)
+    @_inner_html = html
+  end
+
+  alias :_output :output
+  def output(out, opts={})
+    if @_inner_html
+      if empty? and ElementContent[@stag.name] == :EMPTY
+        @stag.output(out, opts.merge(:style => :empty))
+      else
+        @stag.output(out, opts)
+        out << @_inner_html
+        if @etag
+          @etag.output(out, opts)
+        elsif !opts[:preserve]
+          ETag.new(@stag.name).output(out,opts)
+        end
+      end
+    else
+      _output(out,opts)
+    end
+  end
+
+end
+module Lilu
+
+  module Version ; MAJOR, MINOR, TINY = 0, 1, 0 ; end
+
+  class Action
+    attr_accessor :element
+    attr_reader :renderer
+    def initialize(element,renderer)
+      @element, @renderer = element, renderer
+      renderer.action = self
+    end
+  end
+
+
+  class Populate < Action
+    def for(method,data,&block)
+      return element.collect {|e| self.element = e ; renderer.instance_eval { action.for(method,data,&block) } } if element.is_a?(Hpricot::Elements)
+
+      element.cache_search = true
+      update_action = Update.new(element,renderer)
+      parent = element.parent
+      element_html = element.to_html
+      data.send(method) do |*objects| 
+        update_action.element = element
+        update_action.with(block.call(*objects))
+
+        parent.insert_after(Hpricot.make(element.to_html),element) 
+        element = Hpricot.make(element_html)
+      end
+      renderer.action = self 
+
+      Hpricot::Elements[element].remove
+    end
+  end
+
+  class Remove < Action
+    def initialize(*args)
+      super(*args)
+      return element.remove if element.is_a?(Hpricot::Elements)
+      Hpricot::Elements[element].remove
+    end
+  end
+
+  class Replace < Action
+    def with(new_element=nil,&block)
+      return element.collect {|e| self.element = e ; renderer.instance_eval { action.with(new_element) } } if element.is_a?(Hpricot::Elements)
+      case new_element
+      when String
+        element.swap new_element
+      when Hpricot::Elem
+        Hpricot::Elements[new_element].remove
+        element.parent.insert_after(new_element,element)
+        Hpricot::Elements[element].remove
+      when Proc
+        with(new_element.call.to_s)
+      when nil
+        with(block.call) if block_given?
+      else
+        element.swap new_element.to_s
+      end
+    end
+  end
+
+  class Update < Action
+
+    def with(arg=nil,&block)
+      return element.collect {|e| self.element = e ; renderer.instance_eval { action.with(arg,&block) } } if element.is_a?(Hpricot::Elements)
+      case arg
+      when Hash
+        arg.each_pair do |path,value|
+          value = value.call if value.is_a?(Proc)
+          case path
+          when String
+            elem = element.at(path)
+            raise ElementNotFound.new("Element #{elem} not found") unless elem
+
+            saved_element = element
+            self.element = elem
+            res = with(value,&block)
+            self.element = saved_element
+            res
+          when Replacing
+            Replace.new(path.element,renderer).with value.to_s
+          when renderer
+            element._inner_html = value.to_s
+          else
+            element[path] = value.to_s
+          end
+        end
+      when Proc
+        with arg.call
+      when nil
+        with renderer.instance_eval(&block) if block_given?
+      else  
+        element._inner_html = arg.to_s
+      end
+    end
+
+
+  end
+
+  class Use < Action
+    def initialize(*args)
+      super(*args)
+      raise ArgumentError.new("Use action can not accept :all parameter") if element.is_a?(Hpricot::Elements)
+      renderer.doc = element
+    end
+  end
+
+  # Experimental stuff
+  class Replacing
+    attr_reader :element
+    def initialize(renderer,element)
+      @renderer = renderer
+      case element
+      when String
+        @element = renderer.element_at(element)
+      when Hpricot::Elem, Hpricot::Elements
+        @element = element
+      end
+    end
+  end
+  #
+
+  class ElementNotFound < Exception
+    def initialize(element)
+      super("Element #{element} was not found")
+    end
+  end
+
+  class Renderer
+    attr_accessor :action, :doc
+    attr_reader :instructions, :html_source
+
+    def element
+      action.element
+    end
+
+    def initialize(instructions,html_source,local_assignments={})
+      @instructions = instructions
+      @html_source = html_source
+      @doc = Hpricot(@html_source)
+      @view = local_assignments["___view"] if local_assignments.is_a?(Hash)
+      inject_local_assignments(local_assignments)
+    end
+
+
+    def apply
+      eval(@instructions) do |*name|
+        name = name.first 
+        name = 'layout' if name.nil?
+        instance_variable_get("@content_for_#{name}")
+      end
+      @doc.to_html
+    end
+
+    %w[update populate remove use replace].each {|method_name| module_eval <<-EOL
+      def #{method_name}(*path)
+        elem = find_elements(*path)
+        path.pop if path.first == :all
+        raise ElementNotFound.new(path) unless elem
+        Lilu::#{method_name.camelize}.new(elem,self)
+      end
+      EOL
+    }
+
+
+    def mapping(opts={})
+      opts
+    end
+
+    # Helper for partials
+    def partial(name,opts={})
+      render({:partial => name}.merge(opts))
+    end
+
+    # Helper for lambda
+    alias_method :L, :lambda
+
+    def element_at(path)
+      doc.at(path)
+    end
+
+    def method_missing(sym,*args)
+      return @view.send(sym,*args) if @view and @view.respond_to?(sym)
+      return instance_variable_get("@#{sym}") if args.empty? and instance_variables.member? "@#{sym}"
+      return @controller.send(sym, *args) if @controller and @controller.respond_to?(sym)
+      raise NoMethodError.new(sym.to_s)
+    end
+
+    # Helper for replacing
+    def replacing(element)
+      Replacing.new(self,element)
+    end
+
+    protected
+
+    def find_elements(*path)
+      path_first, path_second = path[0], path[1]
+      case path_first
+      when Hpricot::Elem, Hpricot::Elements
+        path_first
+      when :all
+        raise InvalidArgument.new("if :all is specified, second argument with path should be specified as well") unless path_second
+        doc.search(path_second)
+      else
+        doc.at(path_first)
+      end
+    end
+
+    def inject_local_assignments(local_assignments)
+      case local_assignments
+      when Hash
+        local_assignments.each_pair {|ivar,val| instance_variable_set(ivar.to_s.starts_with?('@') ? ivar : "@#{ivar}", val) }
+      when Binding
+        eval("instance_variables",local_assignments).each {|ivar| instance_variable_set(ivar, eval("instance_variable_get('#{ivar}')",local_assignments)) }
+      else
+        local_assignments.instance_variables.each {|ivar| instance_variable_set(ivar.to_s.starts_with?('@') ? ivar : "@#{ivar}", local_assignments.instance_variable_get(ivar)) }
+      end
+    end
+
+  end
+
+end

data/lib/lilu_camping.rb

@@ -0,0 +1,22 @@
+module Lilu
+  module Camping
+    def self.for(app,path)
+      app.module_eval do
+        include Lilu::Camping
+        @@templates = path
+      end
+    end
+
+    def render(m,layout=true)
+      @content_for_layout = render_lilu(m)
+      render_lilu("layout") if layout
+    end
+
+    protected
+
+    def render_lilu(m)
+      Lilu::Renderer.new(IO.read("#{@@templates}/templates/#{m}.lilu"),IO.read("#{@@templates}/templates/#{m}.html"),binding).apply
+    end
+  end
+end
+

data/lib/lilu_view.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/lilu'
+module Lilu
+  class View
+    def initialize(view)
+      @view = view
+    end
+    def render(template, local_assigns = {})
+      lilu_file_path = local_assigns[:lilu_file_path]
+      local_assigns.delete :lilu_file_path
+      @view.instance_eval do
+        local_assigns.merge!("content_for_layout" => @content_for_layout,"controller" => @controller,"___view" => self)
+        Lilu::Renderer.new(template,IO.read(lilu_file_path.gsub(/#{File.extname(lilu_file_path)}$/,'.html')),@assigns.merge(local_assigns)).apply
+      end
+    end
+  end
+end

data/spec/lilu_spec.rb

@@ -0,0 +1,223 @@
+require File.dirname(__FILE__) + '/../lib/lilu'
+require 'ostruct'
+describe "Newly created ", Lilu::Renderer do
+
+  before(:each) do
+    @instructions = "remove('html')"
+    @html_source = "<html></html>"
+    @renderer = Lilu::Renderer.new(@instructions,@html_source)
+  end
+
+  it "should load instructions" do
+    @renderer.instructions.should == @instructions
+  end
+
+  it "should load html source" do
+    @renderer.html_source.should == @html_source
+  end
+end
+
+describe "Newly created ", Lilu::Renderer, " with local assignments" do
+
+  before(:all) do
+    @test_variable = "Lilu"
+  end
+
+  { "binding" => lambda {|s| s.instance_eval "binding" },
+    "Hash with variable names without @ prefix" => { "test_variable" => "Lilu" },
+    "Hash with variable names with @ prefix" => { "@test_variable" => "Lilu" },
+    "Object with instance variables" => Object.new.instance_eval { @test_variable = "Lilu" ; self}
+     }.each_pair do |name, val|
+    it "should load instance variable from #{name}" do
+      @instructions = "remove('html')"
+      @html_source = "<html></html>"
+      val = val.call(self) if val.is_a?(Proc) # hack to support binding test
+      @renderer = Lilu::Renderer.new(@instructions,@html_source,val)
+      @renderer.instance_variable_get(:@test_variable).should == @test_variable
+    end
+  end
+end
+
+describe Lilu::Renderer do
+
+  %w[update populate remove use replace].each do |verb|
+    it "should raise an exception if element is not found when using #{verb} verb" do
+      @instructions = %{#{verb}("#some-missing-data") }
+      @html_source = %{<div id="some-data">Lola</div>}
+      @renderer = Lilu::Renderer.new(@instructions,@html_source)
+      lambda { @renderer.apply }.should raise_error(Lilu::ElementNotFound)
+    end
+  end
+
+  it "should remove element on remove(path) construct" do
+    @instructions = %{remove("#some-data") }
+    @html_source = %{<div id="some-data">Lola</div>}
+    @renderer = Lilu::Renderer.new(@instructions,@html_source)
+    Hpricot(@renderer.apply).at("#some-lilu-data").should be_nil
+  end
+
+  it "should remove all elements on remove(:all,path) construct" do
+    @instructions = %{remove(:all,".not-for-public") }
+    @html_source = %{<div class="not-for-public">Lola</div><br /><div class="not-for-public">1</div>}
+    @renderer = Lilu::Renderer.new(@instructions,@html_source)
+    Hpricot(@renderer.apply).to_s.should == "<br />"
+  end
+
+
+  it "should update element details on update(path).with(String) construct" do
+    @instructions = %{update("#some-data").with("Lilu")}
+    @html_source = %{<div id="some-data">Lola</div>}
+    @renderer = Lilu::Renderer.new(@instructions,@html_source)
+    Hpricot(@renderer.apply).at("#some-data").inner_html.should == "Lilu"
+  end
+
+  it "should update element details on update(path).with Hash construct" do
+    @instructions = %{update("#some-data").with :id => "some-lilu-data", "a" => { :href => "/", self => "is here" }   }
+    @html_source = %{<div id="some-data">Lola <a href="#">is there</a></div>}
+    @renderer = Lilu::Renderer.new(@instructions,@html_source)
+    result = Hpricot(@renderer.apply)
+    result.at("#some-lilu-data").inner_html.should == "Lola <a href=\"/\">is here</a>"
+  end
+
+  it "should populate element details on populate(path).for(:each,@blogs) { block }  construct" do
+    @blogs = [OpenStruct.new(:url => "http://railsware.com", :blog_id => 1, :name => "Railsware"),OpenStruct.new(:url => "http://railsware.com/", :blog_id => 2, :name => "Railsware!")]
+    @instructions = %{populate("#blog-example").for(:each,@blogs) {|blog| mapping 'a' => {:href => blog.url, self => blog.name}, :id => blog.blog_id } }
+    @html_source = %{<ul id="blogs"><li id="blog-example"><a href="#">My Blog</a></li></ul>}
+    @renderer = Lilu::Renderer.new(@instructions,@html_source,self)
+    result = Hpricot(@renderer.apply)
+    result.at("#blogs/#2/a")[:href].should == "http://railsware.com/"
+    result.at("#blogs/#1/a").inner_html.should == "Railsware"
+    result.at("#blogs/#blog-example").should be_nil
+  end
+
+  it "should populate element details on populate(:all,path).for(:each,@blogs) { block }  construct" do
+    @blogs = [OpenStruct.new(:url => "http://railsware.com", :blog_id => 1, :name => "Railsware")]
+    @instructions = %{populate(:all,".blog-example").for(:each,@blogs) {|blog| mapping 'a' => {:href => blog.url, self => blog.name}, :id => blog.blog_id } }
+    @html_source = %{<ul id="blogs1"><li id="blog-example" class="blog-example"><a href="#">My Blog</a></li></ul><ul id="blogs2"><li id="blog-example" class="blog-example"><a href="#">My Blog</a></li></ul>}
+    @renderer = Lilu::Renderer.new(@instructions,@html_source,self)
+    result = Hpricot(@renderer.apply)
+    result.at("#blogs1/#1/a")[:href].should == "http://railsware.com"
+    result.at("#blogs1/#1/a").inner_html.should == "Railsware"
+    result.at("#blogs1/#blog-example").should be_nil
+    result.at("#blogs2/#1/a")[:href].should == "http://railsware.com"
+    result.at("#blogs2/#1/a").inner_html.should == "Railsware"
+    result.at("#blogs2/#blog-example").should be_nil
+
+  end
+
+  it "should update all elements, matched by path on update(:all, path).with Hash construct" do
+    @instructions = %{update(:all, "a").with :href => "#", self => 'Stay here'}
+    @html_source = %{<a href="http://java.net">C'mon, Java!</a><a href="http://www.php.net">Go away!</a>}
+    @renderer = Lilu::Renderer.new(@instructions,@html_source)
+    result = Hpricot(@renderer.apply)
+    (result/"a").each { |elem| elem.inner_html.should == 'Stay here'; elem[:href].should == '#' }
+  end
+
+  it "should update all elements, matched by path on update(:all, path).with Hash construct, taking in account each element content" do
+    @instructions = 'update(:all, "a").with :href => L{"#{element[:href]}/download"}, self => L{"Download #{element.inner_html}"}'
+    links =  {"http://java.net" => "C'mon, Java!", "http://www.php.net" => "Go away!"}
+    @html_source = ""
+    links.each_pair {|url,name| @html_source << %{<a href="#{url}">#{name}</a>} }
+    @renderer = Lilu::Renderer.new(@instructions,@html_source)
+    result = Hpricot(@renderer.apply)
+    links.each_pair do |url,name|
+      result.at("//a[@href='#{url}/download']").inner_html.should == "Download #{name}"
+    end
+  end
+
+  it "should update all elements, matched by path on update(:all, path).with Block construct, taking in account each element content" do
+    @instructions = 'update(:all, "a").with { mapping :href => "#{element[:href]}/download", self => "Download #{element.inner_html }" }'
+    links =  {"http://java.net" => "C'mon, Java!", "http://www.php.net" => "Go away!"}
+    @html_source = ""
+    links.each_pair {|url,name| @html_source << %{<a href="#{url}">#{name}</a>} }
+    @renderer = Lilu::Renderer.new(@instructions,@html_source)
+    result = Hpricot(@renderer.apply)
+    links.each_pair do |url,name|
+      result.at("//a[@href='#{url}/download']").inner_html.should == "Download #{name}"
+    end
+  end
+
+  it "should update all elements, matched by path on update(:all, path).with Lambda construct, taking in account each element content" do
+    @instructions = 'update(:all, "a").with L{ mapping :href => "#{element[:href]}/download", self => "Download #{element.inner_html }" }'
+    links =  {"http://java.net" => "C'mon, Java!", "http://www.php.net" => "Go away!"}
+    @html_source = ""
+    links.each_pair {|url,name| @html_source << %{<a href="#{url}">#{name}</a>} }
+    @renderer = Lilu::Renderer.new(@instructions,@html_source)
+    result = Hpricot(@renderer.apply)
+    links.each_pair do |url,name|
+      result.at("//a[@href='#{url}/download']").inner_html.should == "Download #{name}"
+    end
+  end
+
+  it "should remove everything outside of specified element on use(path)" do
+    @instructions = "use('#main')"
+    @html_source = '<html><body><div id="main">Blablabla</div></body></html>'
+    @renderer = Lilu::Renderer.new(@instructions,@html_source)
+    result = Hpricot(@renderer.apply)
+    result.to_s.should == '<div id="main">Blablabla</div>'
+  end
+
+  it "should raise ArgumentError if use is called with :all argument" do
+    @instructions = "use(:all,'#main')"
+    @html_source = '<html><body><div id="main">Blablabla</div></body></html>'
+    @renderer = Lilu::Renderer.new(@instructions,@html_source)
+    lambda { Hpricot(@renderer.apply) }.should raise_error(ArgumentError)
+  end
+
+  it "should replace element with another using replace().with String construct" do
+    @instructions = "replace('#main').with 'Hello!'"
+    @html_source = '<html><body><div id="main">Blablabla</div></body></html>'
+    @renderer = Lilu::Renderer.new(@instructions,@html_source)
+    result = Hpricot(@renderer.apply)
+    result.to_s.should == '<html><body>Hello!</body></html>'
+  end
+
+  it "should replace element with another using replace().with Block construct" do
+    @instructions = "replace('#main').with { 'Hello!' }"
+    @html_source = '<html><body><div id="main">Blablabla</div></body></html>'
+    @renderer = Lilu::Renderer.new(@instructions,@html_source)
+    result = Hpricot(@renderer.apply)
+    result.to_s.should == '<html><body>Hello!</body></html>'
+  end
+
+  it "should replace element with another using replace().with Lambda construct" do
+    @instructions = "replace('#main').with  L{ 'Hello!' }"
+    @html_source = '<html><body><div id="main">Blablabla</div></body></html>'
+    @renderer = Lilu::Renderer.new(@instructions,@html_source)
+    result = Hpricot(@renderer.apply)
+    result.to_s.should == '<html><body>Hello!</body></html>'
+  end
+
+  it "should replace all elements with another using replace(:all,).with String construct" do
+    @instructions = "replace(:all,'.main').with 'Hello!'"
+    @html_source = '<html><body><div class="main">Blablabla</div><div class="main">Blublublu</div></body></html>'
+    @renderer = Lilu::Renderer.new(@instructions,@html_source)
+    result = Hpricot(@renderer.apply)
+    result.to_s.should == '<html><body>Hello!Hello!</body></html>'
+  end
+
+  it "should replace all elements with another using replace(:all,).with String construct" do
+    @instructions = "replace(:all,'.main').with 'Hello!'"
+    @html_source = '<html><body><div class="main">Blablabla</div><div class="main">Blublublu</div></body></html>'
+    @renderer = Lilu::Renderer.new(@instructions,@html_source)
+    result = Hpricot(@renderer.apply)
+    result.to_s.should == '<html><body>Hello!Hello!</body></html>'
+  end
+
+  it "should replace element with another using replace().with Element construct" do
+    @instructions = "replace('#main').with element_at('#helper')"
+    @html_source = '<html><body><div id="main">Blablabla</div><div id="helper">Lilu</div></body></html>'
+    @renderer = Lilu::Renderer.new(@instructions,@html_source)
+    result = Hpricot(@renderer.apply)
+    result.to_s.should == '<html><body><div id="helper">Lilu</div></body></html>'
+  end
+
+  it "should replace all elements with another using replace(:all,).with Element construct" do
+    @instructions = "replace(:all,'.main').with element_at('#helper')"
+    @html_source = '<html><body><div class="main">Blablabla</div><div class="main">Blublublua</div><div id="helper">Lilu</div></body></html>'
+    @renderer = Lilu::Renderer.new(@instructions,@html_source)
+    result = Hpricot(@renderer.apply)
+    result.to_s.should == '<html><body><div id="helper">Lilu</div></body></html>'
+  end
+
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: lilu
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-05-16 00:00:00 +03:00
+summary: View subsystem that allows to keep pure HTML for views
+require_paths: 
+- lib
+email: yrashk@verbdev.com
+homepage: 
+rubyforge_project: 
+description: View subsystem that allows to keep pure HTML for views
+autorequire: 
+- rake
+- hpricot
+- lib/lilu
+- lib/lilu_view
+- lib/lilu_camping
+default_executable: fixturease.rb
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Yurii Rashkovskii
+- Michael Holub
+files: 
+- lib/lilu.rb
+- lib/lilu_view.rb
+- lib/lilu_camping.rb
+- spec/lilu_spec.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: 
+- hprico
+dependencies: []
+