aurita-gui 0.3.2 → 0.3.3

data/History.txt

@@ -1,3 +1,13 @@
+=== 0.3.3 / 2009-01-24
+
+* Added form helpers for template rendering. 
+* Extended API by convenience shortcuts: 
+  Content for elements can be set markaby-like now: 
+
+    HTML.div 'content here' :class => :highlighted
+
+* Minor bug fixes. 
+
 === 0.3.1 / 2009-01-15
 
 * Added specs for Element and HTML. 

data/TODO

@@ -20,6 +20,18 @@
 
 = DONE =============================================
 
+- Provide markaby-like syntax, Example: 
+
+    HTML.div 'content here' :class => :highlight
+
+  and
+    
+    HTML.build { 
+      div 'content' { 
+        h1 'header'
+      }
+    }
+
 - Decorate required fields. 
   Required fields are always rendered. 
  

data/aurita-gui.gemspec

@@ -14,7 +14,7 @@ as stand-alone library in any context (such as rails).
 As there seems to be a lack of ruby form generators, i decided to release this 
 part of Aurita in a single gem with no dependencies. 
   EOF
-  s.version = '0.3.2'
+  s.version = '0.3.3'
   s.author = 'Tobias Fuchs'
   s.email = 'fuchs@atomnode.net'
   s.date = Time.now

data/lib/aurita-gui.rb

@@ -1,6 +1,7 @@
 
 require('aurita-gui/element')
 require('aurita-gui/html')
+require('aurita-gui/javascript')
 require('aurita-gui/form')
 require('aurita-gui/table')
 require('aurita-gui/button')

data/lib/aurita-gui/button.rb

@@ -50,7 +50,7 @@ module GUI
   #
   #   b = Submit_Button.new(:class => :css_class) { 'click me' }
   #
-  class Submit_Button < Element
+  class Submit_Button < Button
     def initialize(params, &block)
       params[:tag]  = :input
       params[:type] = :submit unless params[:type]
@@ -70,7 +70,7 @@ module GUI
   #
   # Note that reset buttons in forms are considered 
   # bad style in terms of usability. 
-  class Reset_Button < Element
+  class Reset_Button < Button
     def initialize(params, &block)
       params[:tag]  = :input
       params[:type] = :reset unless params[:type]

data/lib/aurita-gui/element.rb

@@ -59,19 +59,28 @@ module GUI
     
     @@element_count = 0
     
-    attr_accessor :attrib, :content, :parent, :tag, :force_closing_tag
+    attr_accessor :attrib, :content, :parent, :force_closing_tag, :tag
     
-    def initialize(params={}, &block) 
+    def initialize(*args, &block) 
+
+      params = {}
+      case args[0]
+      when Hash 
+        params = args[0]
+      else
+        params = args[1] 
+        params ||= {}
+        params[:content] = args[0]
+      end
 
       @@element_count += 1
       @id          = @@element_count
       @parent      = params[:parent]
       @force_closing_tag = params[:force_closing_tag]
+
       params[:tag] = :div if params[:tag].nil?
-      @tag     = params[:tag]
-      if [ :div, :label, :button, :textarea ].include? @tag then
-        @force_closing_tag = true
-      end
+      @tag = params[:tag]
+
       params.delete(:parent)
       params.delete(:force_closing_tag)
 
@@ -104,6 +113,16 @@ module GUI
     def dom_id=(value)
       @attrib[:id] = value if @attrib
     end
+    # Alias definition for #dom_id=(value)
+    # Define explicitly so built-in method #id
+    # is not invoked instead
+    def id=(value)
+      @attrib[:id] = value
+    end
+    # Alias definition for #dom_id()
+    def id
+      @attrib[:id]
+    end
 
     # Render this element to a string and append another 
     # element. 
@@ -118,7 +137,6 @@ module GUI
     end
     alias to_a to_ary
 
-
     # Redirect methods to setting or retreiving tag 
     # attributes. 
     def method_missing(meth, value=nil)
@@ -135,16 +153,6 @@ module GUI
     def type=(type)
       @attrib[:type] = type
     end
-    # Alias definition for #dom_id=(value)
-    # Define explicitly so built-in method #id
-    # is not invoked instead
-    def id=(value)
-      @attrib[:id] = value
-    end
-    # Alias definition for #dom_id()
-    def id
-      @attrib[:id]
-    end
 
     # Do not redirect random access operators. 
     def [](index)
@@ -186,6 +194,10 @@ module GUI
       }
       
       out = ''
+      if (!(@force_closing_tag.instance_of?(FalseClass)) && 
+          [ :div, :label, :button, :textarea ].include?(@tag)) then
+        @force_closing_tag = true
+      end
       if @force_closing_tag || content.to_s != '' then
         out << "<#{@tag}"
         out << attrib_string if attrib_string.length > 0

data/lib/aurita-gui/form.rb

@@ -72,12 +72,13 @@ module GUI
       else 
         @content = field
       end
+      field.dom_id = field.name.to_s.gsub('.','_') unless field.dom_id
       css_classes = field.class.to_s.split('::')[-1].downcase + '_wrap form_field' 
       css_classes << ' required' if field.required?
       css_classes << ' invalid' if field.invalid?
       params = { :tag => :li, 
                  :content => @content, 
-                 :id => field.dom_id + '_wrap', 
+                 :id => field.dom_id.to_s + '_wrap', 
                  :class => css_classes }
       super(params)
     end
@@ -142,14 +143,32 @@ module GUI
   #   }
   #   textarea = GUI::Textarea.new(:name => :comment, :label => 'Comment')
   #   form.add(textarea)
-  #  
-  # In case you want to override the form action (default: /aurita/dispatch), 
-  # use :action_url: 
   #
-  #   Form.new(:action_url => '/where/to/send/form')
-  # or
-  #   Form.action_url = '/where/to/send/form'
+  # === Rails
   #
+  # In Rails, you could use form instances like: 
+  #
+  #    class ItemController < ActionController::Base
+  #      def add
+  #        @form = Form.new(:action => 'where/to/send')
+  #        @form[:title].required! 
+  #      end
+  #    end
+  #
+  # And in view 'item/add': 
+  #
+  #   <% 
+  #     @form[:title].value = 'Enter a title here' 
+  #     @form[:description].disabled! unless @may_edit_description
+  #   %>
+  #
+  #   <%= @form.string %>
+  #
+  # You can also use form template helpers from 
+  # Aurita::GUI::Form_Field_Helpers. 
+  # You'd have to define you own form builder class, but that's 
+  # quite simple (see comments on module Form_Field_Helpers). 
+  # I'll soon provide a Rails-specific form builder, though. 
   #
   # == Render modes
   #
@@ -173,6 +192,7 @@ module GUI
   #                   :id     => :the_form_id, 
   #                   :action => :where_to_send)
   #
+  #
   # You can either set all attributes in the 
   # constructor call ...
   #
@@ -286,14 +306,11 @@ module GUI
   #
   class Form < Element
 
-    attr_accessor :method, :target, :action, :fields, :elements, :element_map, :values, :field_decorator, :content_decorator
+    attr_accessor :fields, :elements, :element_map, :values, :field_decorator, :content_decorator
   
     def initialize(params={}, &block)
-      @action        = params[:action]
-      @method        = params[:method]
       @fields        = params[:fields]
       @values        = params[:values]
-      @method      ||= :post
       @fields      ||= []
       @elements      = []
       @element_map   = {}
@@ -307,8 +324,12 @@ module GUI
       end
       params.delete(:fields)
       params.delete(:values)
+      params.delete(:title)
+      params[:method]  = 'POST' unless params[:method]
+      params[:enctype] = 'multipart/form-data' unless params[:enctype]
       params[:tag]     = 'form'
       params[:content] = content()
+      params[:action]  = @action
       super(params)
     end
 
@@ -331,7 +352,7 @@ module GUI
     def []=(index, form_field)
       @content = false # Invalidate
       if !index.kind_of? Numeric
-        @element_map[index,to_s] = form_field 
+        @element_map[index.to_s] = form_field 
         @elements.collect { |e|
           e = form_field if e.name.to_s == index.to_s
         }
@@ -477,6 +498,19 @@ module GUI
       HTML.form(@attrib) { content() }
     end
 
+    # Returns opening tag of this form instance. 
+    # Useful for template helper methods. 
+    # Example: 
+    #
+    #   form = Form.new(:action => 'where/to/send')
+    #   puts form.header_string
+    # -->
+    #   '<form action="where/to/send" enctype="multipart/form-data" method="POST">'
+    #
+    def header_string
+      HTML.form(@attrib).string.gsub('</form>','')
+    end
+
     # Render this form to a string
     def string
       element().to_s

data/lib/aurita-gui/form/date_field.rb

@@ -12,7 +12,11 @@ module GUI
       @date_format   = params[:date_format]
       @date_format ||= 'mdy'
       @year_range    = params[:year_range]
+      @year_range  ||= (2009..2020)
 
+      if params[:value] then set_date(params[:value]) end
+
+      params.delete(:value)
       params.delete(:date_format)
       params.delete(:date)
       params.delete(:day)
@@ -24,7 +28,7 @@ module GUI
 
     def year_element
       if !@year_element then
-        @year_element = Select_Field.new(:name  => @attrib[:name] + '_year', 
+        @year_element = Select_Field.new(:name  => @attrib[:name].to_s + '_year', 
                                          :class => :year_select, 
                                          :value => @year, :options => @year_range)
       end
@@ -32,7 +36,7 @@ module GUI
     end
     def month_element
       if !@month_element then
-        @month_element = Select_Field.new(:name  => @attrib[:name] + '_month', 
+        @month_element = Select_Field.new(:name  => @attrib[:name].to_s + '_month', 
                                           :class => :month_select, 
                                           :value => @month, :options => (1..12))
       end
@@ -40,7 +44,7 @@ module GUI
     end
     def day_element
       if !@day_element then
-        @day_element = Select_Field.new(:name  => @attrib[:name] + '_day', 
+        @day_element = Select_Field.new(:name  => @attrib[:name].to_s + '_day', 
                                         :class => :day_select, 
                                         :value => @day, :options => (1..31))
       end
@@ -68,7 +72,7 @@ module GUI
       case date 
       when Hash then
         @value = date
-      when Datetime then
+      when ::DateTime then
         @value = { :year  => date.year, 
                    :month => date.month, 
                    :day   => date.day }
@@ -77,13 +81,15 @@ module GUI
                    :month => date.month, 
                    :day   => date.day }
       when String then
-        date = Datetime.strptime(date)
+        date = (::DateTime).strptime(date, "%Y%m%d")
         @value = { :year  => date.year, 
                    :month => date.month, 
                    :day   => date.day }
       else
       end
+      @year, @month, @day = @value[:year], @value[:month], @value[:day]
     end
+    alias set_date value=
 
     def value
       { :day => @day, :month => @month, :year => @year }

data/lib/aurita-gui/form/datetime_field.rb

@@ -21,7 +21,7 @@ module GUI
 
     def hour_element
       if !@hour_element then
-        @hour_element = Select_Field.new(:name  => @attrib[:name] + '_hour', 
+        @hour_element = Select_Field.new(:name  => @attrib[:name].to_s + '_hour', 
                                          :class => :hour_select, 
                                          :value => @hour, :options => (0..23))
       end
@@ -29,7 +29,7 @@ module GUI
     end
     def minute_element
       if !@minute_element then
-        @minute_element = Select_Field.new(:name  => @attrib[:name] + '_minute', 
+        @minute_element = Select_Field.new(:name  => @attrib[:name].to_s + '_minute', 
                                           :class => :minute_select, 
                                           :value => @minute, :options => (0..59))
       end
@@ -37,7 +37,7 @@ module GUI
     end
     def second_element
       if !@second_element then
-        @second_element = Select_Field.new(:name  => @attrib[:name] + '_second', 
+        @second_element = Select_Field.new(:name  => @attrib[:name].to_s + '_second', 
                                            :class => :second_select, 
                                            :value => @second, :options => (0..59))
       end

data/lib/aurita-gui/form/template_helper.rb

@@ -0,0 +1,109 @@
+
+require('aurita-gui/form')
+
+module Aurita
+module GUI
+
+  # Provides wrapper methods for every 
+  # form field type. 
+  # Include this module in your template 
+  # helper class. 
+  #
+  # Form_Helper methods each return a string 
+  # for a respective Form_Field element. 
+  # Rendering respects the form instances'
+  # @field_decorator, but not @content_decorator, 
+  # so you have to wrap form contents manually 
+  # in your helper method. 
+  #
+  # Example: (what your template helper could look like)
+  #
+  #   module Form_Helper_Class_Methods
+  #     def form_for(params, &block)
+  #       form = Form.new(params, &block)
+  #       render form.header_string        # <form ...> tag is prepared by form instance
+  #       render '<ul class="form_fields">'   # begin content wrap
+  #       yield(form)
+  #       render '</ul>'                      # end content wrap
+  #       render '</form>'                 # Closing tag for a form should always be </form>
+  #     end
+  #   end
+  # 
+  # Usage, e.g. in ERB templates: 
+  #
+  #   <% form_for(:action => '/where/to/send') do |f| %>
+  #     <%= f.text(:name => :title) { 'Value for this field' } %>
+  #     <%= f.select(:name => :color, :options => [ :blue, :red, :green ], :value => :red)
+  #   <% end %>
+  #
+  # Form_Helper automatically extends Aurita::GUI::Form 
+  # when included. 
+  #
+  module Form_Field_Helper
+
+    def text(params, &block)
+      params[:type] = :text
+      @field_decorator.new(Input_Field.new(params, &block)).string
+    end
+
+    def boolean(params, &block)
+      @field_decorator.new(Boolean_Field.new(params, &block)).string
+    end
+
+    def password(params, &block)
+      params[:type] = :password
+      @field_decorator.new(Password_Field.new(params, &block)).string
+    end
+
+    def select(params, &block)
+      @field_decorator.new(Select_Field.new(params, &block)).string
+    end
+
+    def radio(params, &block)
+      @field_decorator.new(Radio_Field.new(params, &block)).string
+    end
+
+    def checkbox(params, &block)
+      @field_decorator.new(Checkbox_Field.new(params, &block)).string
+    end
+
+    def textarea(params, &block)
+      @field_decorator.new(Textarea_Field.new(params, &block)).string
+    end
+
+    def hidden(params, &block)
+      @field_decorator.new(Hidden_Field.new(params, &block)).string
+    end
+
+    def file(params, &block)
+      @field_decorator.new(File_Field.new(params, &block)).string
+    end
+
+    def fieldset(params, &block)
+      @field_decorator.new(Fieldset.new(params, &block)).string
+    end
+
+    def date(params, &block)
+      @field_decorator.new(Date_Field.new(params, &block)).string
+    end
+
+    def datetime(params, &block)
+      @field_decorator.new(Datetime_Field.new(params, &block)).string
+    end
+
+    def custom(params, &block)
+      klass = params[:element]
+      params.delete(:element)
+      @field_decorator.new(klass.new(params, &block)).string
+    end
+
+  end
+
+  # Extend class Aurita::GUI::Form by helper 
+  # methods. 
+  class Form
+    include Form_Field_Helper
+  end
+
+end
+end

data/lib/aurita-gui/html.rb

@@ -66,6 +66,20 @@ module GUI
   #
   #   HTML.a(:href => 'http://domain.com', :content => 'click me')
   #
+  # Or as first argument: 
+  #
+  #   HTML.a('click me', :href => 'http://domain.com')
+  #
+  # So the following statements are equivalent: 
+  #
+  #   e = HTML.div 'hello', :class => 'highlight'
+  #   e = HTML.div(:class => :highlight) { 'hello' }
+  #   e = HTML.div(:class => :highlight, :content => 'hello')
+  #
+  # In all cases, e.to_s renders: 
+  #
+  #   <div class="highlight">hello</div>
+  #
   # == Further Examples
   #
   # There are some few usage principles that are 
@@ -217,12 +231,12 @@ module GUI
       Element.new(:tag => :br)
     end
     
-    def self.render(meth_name, attrib_hash={}, &block)
-      raise ::Exception.new('Missing attributes for HTML.' << meth_name.inspect) unless attrib_hash
-      attrib_hash[:tag] = meth_name
-#      cont = yield if block_given?
-#      attrib_hash[:content] = cont
-      Element.new(attrib_hash, &block)
+    def self.render(meth_name, *args, &block)
+      raise ::Exception.new('Missing attributes for HTML.' << meth_name.inspect) unless args
+
+      e = Element.new(*args, &block)
+      e.tag = meth_name
+      e
     end
 
     def self.build(&block)
@@ -231,19 +245,19 @@ module GUI
     end
     
     
-    def self.a(attrib_hash={}, &block)
-      render(:a, attrib_hash, &block)
+    def self.a(*attribs, &block)
+      render(:a, *attribs, &block)
     end
 
     # p is defined in Kernel, so we have to 
     # redirect it manually (method_missing won't be 
     # triggered for it)
-    def self.p(attrib_hash={}, &block)
-      render(:p, attrib_hash, &block)
+    def self.p(*attribs, &block)
+      render(:p, *attribs, &block)
     end
 
-    def self.method_missing(meth_name, attrib_hash={}, &block)
-      render(meth_name, attrib_hash, &block) 
+    def self.method_missing(meth_name, *attribs, &block)
+      render(meth_name, *attribs, &block) 
     end
 
 =begin
@@ -259,68 +273,7 @@ EOC
 =end
 
   end # class
-
-  # A minimalistic generator for javascript calls. 
-  # Usage: 
-  #
-  #   my_element.onclick = Javascript.new("alert('an alert message');")
-  #
-  # or just: 
-  #  
-  #   my_element.onclick = Javascript.my_function('foo', 2, 'bar')
-  #   --> my_function('foo', 2, 'bar'); 
-  #
-  # For namespaces: 
-  #
-  #   my_element.onclick = Javascript[:Foo].my_function(1,2)
-  #   --> Foo.my_function('foo', 2, 'bar'); 
-  #
-  # Method #string renders the code passed in constructir, 
-  # enclosed in <script> tags: 
-  #
-  # Javascript.new("alert('message');").string
-  #   --> 
-  #   <script language="Javascript" type="text/javascript">
-  #   alert('message'); 
-  #   </script>
-  #
-  class Javascript
-    
-    def initialize(script)
-      @script = script
-    end
-    
-    # Renders script to a <script> block. 
-    def code_block
-      '<script language="Javascript" type="text/javascript">' << "\n" << 
-        @script + "\n" << 
-      '</script>'
-    end
-
-    def string
-      @script
-    end
-    alias to_s string
-
-    def self.[](namespace) 
-      return self.new(namespace.to_s + '.')
-    end
-
-    def self.method_missing(meth, *args)
-      args = args.collect { |arg|
-        if arg.instance_of? String then
-          '\'' << arg << '\''
-        else
-          arg
-        end
-      }
-      args_string = args.join(',')
-      meth.to_s << '(' << args_string + ');'
-    end
-
-  end # class
-
-    
+  
 end # module
 end # module
 

data/lib/aurita-gui/javascript.rb

@@ -0,0 +1,158 @@
+
+module Aurita
+module GUI
+
+  # A minimalistic generator for javascript calls. 
+  #
+  # Javascript is a simple string factory so you can 
+  # write pieces of javascript code in ruby instead of 
+  # using plain old strings. 
+  # This does not introduce functionality, it just 
+  # eases the rendering of ruby objects to javascript: 
+  # Aurita::GUI::Javascript  renders method parameters 
+  # to their respective meaning in javascript, and also 
+  # understands namespaces, variables, and object 
+  # notation. 
+  #
+  # Sometimes i needed somethind like this in ERB 
+  # templates: 
+  #
+  #   <%= button(:class => :cancel, :onclick => "Aurita.cancel_form('#{form.dom_id}"')) %>
+  #
+  # Now i can do the same in pure ruby: 
+  #
+  #   <%= button(:class => :cancel, :onclick => js.Aurita.cancel_form(form.dom_id)) %>
+  #
+  # Just by defining a helper method in 5 lines of 
+  # code (see below, section Template helper example). 
+  #
+  # == Usage with block: 
+  #
+  #   Javascript.build { |j|
+  #     j.Some.Namespace.do_stuff() 
+  #     j.bla(123, { :gna => 23, :blu => '42' }) 
+  #     j.alert("escape 'this' string")
+  #   }
+  #
+  #   -->
+  #   Some.Namespace.do_stuff(); bla(123,{gna: 23, blu: '42' }); alert('escape \'this\' string'); 
+  #
+  # == Calling class methods
+  #
+  # For a single call of a javascipt method, you can also use: 
+  #
+  #   my_element.onclick = Javascript.alert('an alert message')
+  #   --> alert('an alert message'); 
+  #  
+  # This also provides method chaining. Uppercase 
+  # methods are interpreted as namespaces. 
+  #
+  #   my_element.onclick = Javascript.Some.Namespace.my_function('foo', 2, 'bar')
+  #   --> <div onclick="Some_Namespace.my_function('foo', 2, 'bar'); "> ... </div>
+  #
+  # == Template helper example
+  #
+  # In Aurita, there's a simple helper, defined as 
+  #
+  #    def js(&block) 
+  #      if block_given? then 
+  #        Javascript.build(&block)
+  #      else
+  #        Javascript
+  #      end
+  #    end
+  #
+  # It works like that: 
+  #
+  #    input = Input_Field.new(:onchange => js.Aurita.notify_change_of(:this))
+  #    -->  <input onchange="Aurita.notify_change_of(this); " />
+  # or
+  #    input.onfocus = js.Aurita.notify_focus_on(:this)
+  #    -->  <input onchange="Aurita.notify_change_of(this); " 
+  #                onfocus="Aurita.notify_focus_of(this); " />
+  #
+  # == Render to <script> tag
+  #
+  # Method #to_tag renders the code enclosed in <script> tags: 
+  #
+  # Javascript.new("alert('message');").to_tag
+  #   --> 
+  #   <script language="Javascript" type="text/javascript">
+  #   alert('message'); 
+  #   </script>
+  #
+  class Javascript
+    
+    def initialize(script='')
+      @script = script
+      @scripy ||= ''
+    end
+
+    def self.build(&block)
+      if block.arity > 0 then
+        yield(Javascript.new)
+      else 
+        self.class_eval(&block) 
+      end
+    end
+    
+    # Renders script to a <script> block. 
+    def to_tag
+      '<script language="Javascript" type="text/javascript">' << "\n" << 
+        @script + "\n" << 
+      '</script>'
+    end
+
+    def string
+      @script
+    end
+    alias to_s string
+
+    def self.[](namespace) 
+      return self.new(namespace.to_s + '.')
+    end
+
+    def method_missing(meth, *args)
+      args = args.collect { |arg|
+        arg = to_js(arg)
+      }
+      args_string = args.join(',') if args.size > 0
+      meth = meth.to_s
+      # Uppercase method => method call
+      meth << '(' << args_string.to_s << '); ' if meth[0] > 96
+      # Uppercase method => Namespace
+      meth << '.' if meth[0] < 97
+      @script << meth
+      return self
+    end
+    alias render method_missing
+    def self.method_missing(meth, *args)
+      return self.new().__send__(meth, *args)
+    end
+
+  protected
+
+    def to_js(arg)
+      case arg
+      when String: 
+        arg.gsub!("'","\\\\'")
+        "'#{arg}'"
+      when Hash: 
+        obj = []
+        arg.each_pair { |k,v|
+          v = to_js(v)
+          obj << "#{k}: #{v}"
+        }
+        "{#{obj.join(', ')}}"
+      when Symbol
+        arg.to_s
+      else
+        arg
+      end
+    end
+
+  end # class
+
+end
+end
+

data/spec/element.rb

@@ -16,6 +16,15 @@ describe Aurita::GUI::Element, "basic rendering" do
     e.tag.should == :tagname
   end
 
+  it "should provide a shortcut for content as first constructor argument" do
+    e = Element.new('I am the content')
+    e.string.should == '<div>I am the content</div>'
+    e = Element.new('I am the content', :tag => :p)
+    e.string.should == '<p>I am the content</p>'
+    e.class = 'highlight'
+    e.string.should == '<p class="highlight">I am the content</p>'
+  end
+
   it "should have :div as default attribute" do
     e = Element.new()
     e.tag.should == :div

data/spec/form.rb

@@ -22,7 +22,7 @@ describe Aurita::GUI::Form, "basic rendering" do
 
   it "should wrap form fields as list elements (<li>...</li>)" do
     @form.add(@text_field)
-    @form.to_s.should == '<form><ul class="form_fields"><li class="input_field_wrap form_field" id="textfield_wrap"><input type="text" name="textfield" id="textfield" /></li></ul></form>'
+    @form.to_s.should == '<form method="POST" enctype="multipart/form-data"><ul class="form_fields"><li class="input_field_wrap form_field" id="textfield_wrap"><input type="text" name="textfield" id="textfield" /></li></ul></form>'
   end
 
 end

data/spec/html.rb

@@ -8,7 +8,7 @@ describe Aurita::GUI::HTML, "basic rendering" do
   before do
     @e = HTML.build { 
       div(:class => :outer) { 
-        h2(:id => :header) { 'Header' } + 
+        h2('Header', :id => :header) +
         p(:id => :content) { 'Content' }
       }
     }
@@ -23,6 +23,13 @@ describe Aurita::GUI::HTML, "basic rendering" do
     HTML.p { 'string' }.to_s.should == '<p>string</p>'
   end
 
+  it "should also accept the first constructor argument as content" do
+    e = HTML.p 'I am the content' 
+    e.to_s.should == Element.new(:tag => :p) { 'I am the content' }.to_s
+    e = HTML.div 'foo', :class => 'highlight'
+    e.to_s.should == '<div class="highlight">foo</div>'
+  end
+
   it "should provide a build mechanism that delegates class methods" do
     @e.to_s = '<div class="outer"><h2 id="header">Header</h2><p id="content">Content</p></div>'
   end

data/spec/javascript.rb

@@ -0,0 +1,25 @@
+
+require('rubygems')
+require('aurita-gui/javascript')
+
+include Aurita::GUI
+
+describe Aurita::GUI::Javascript, "basic rendering" do
+  before do
+  end
+
+  it "should provide a nice DSL" do
+    js = Javascript.build { |j|
+      j.Some.Namespace.do_stuff() 
+      j.bla(123, { :gna => 23, :blu => '42' }) 
+      j.alert("escape 'this' string")
+    }
+    js.to_s.should == "Some.Namespace.do_stuff(); bla(123,{gna: 23, blu: '42'}); alert('escape \\'this\\' string'); "
+  end
+
+  it "should render on class method calls" do
+    Javascript.Some.Namespace.do_stuff(23, 'wombat').to_s.should == "Some.Namespace.do_stuff(23,'wombat'); "
+  end
+
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: aurita-gui
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors: 
 - Tobias Fuchs
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-20 00:00:00 +01:00
+date: 2009-01-25 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -35,6 +35,7 @@ files:
 - LICENSE
 - lib/aurita-gui
 - lib/aurita-gui.rb
+- lib/aurita-gui/javascript.rb
 - lib/aurita-gui/button.rb
 - lib/aurita-gui/form.rb
 - lib/aurita-gui/html.rb
@@ -55,9 +56,10 @@ files:
 - lib/aurita-gui/form/radio_field.rb
 - lib/aurita-gui/form/hidden_field.rb
 - lib/aurita-gui/form/text_field.rb
+- lib/aurita-gui/form/template_helper.rb
 - lib/aurita-gui/form/input_field.rb
 - lib/aurita-gui/form/date_field.rb
-- spec/;
+- spec/javascript.rb
 - spec/form.rb
 - spec/html.rb
 - spec/element.rb

data/spec/;

@@ -1,14 +0,0 @@
-
-class Context_Loader
-
-  def self.render(element)
-    puts 'loader: ' << element.to_s + ' end loader'
-
-  def run(&block)
-    class_eval(&block)
-  end
-
-end
-
-l = Context_Loader.new()
-l.run { 'foo' }