aurita-gui 0.2.0 → 0.3.0

data/TODO

@@ -2,3 +2,27 @@
 - Implement <fieldset>
 - Implement <optgroup>
 
+- Implement field visibility using 
+  field.visible = true/false, wrapped in 
+  def form.fields=(fields)
+    @element_map.each_pair { |fieldname, element|
+      unless fields.include?(fieldname) 
+        @element_map[fieldname].visible = false
+      end
+    }
+  end
+
+= DONE =============================================
+
+- Decorate required fields. 
+  Required fields are always rendered. 
+ 
+  field = Text_Field.new(:required => true)
+  field.required = true | false
+
+- Hide fields (render as hidden input field)
+
+  field = Text_Field.new(:hidden => true)
+  field.hidden = true
+  field.hide
+  field.show

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.2.0'
+  s.version = '0.3.0'
   s.author = 'Tobias Fuchs'
   s.email = 'fuchs@atomnode.net'
   s.date = Time.now
@@ -29,7 +29,7 @@ part of Aurita in a single gem with no dependencies.
 
   s.has_rdoc = true
   s.rdoc_options << '--title' << 'Aurita::GUI' <<
-                    '--main' << './cheatsheet.rb' <<
+                    '--main' << 'Aurita::GUI::HTML' <<
                     '--line-numbers'
 
   s.homepage = 'http://aurita.wortundform.de/'

data/cheatsheet.rb

@@ -12,6 +12,7 @@ include Aurita::GUI
 # This is the most convenient way to build 
 # HTML using aurita-gui. 
 # (Thanks to oGMo for demanding more magic)
+
 t1 = HTML.build { 
   div(:class => :css_class, 
       :onmouseover => "do_something_with(this);") { 
@@ -25,6 +26,33 @@ t1 = HTML.build {
 puts t1.to_s
 puts '-----------------------------------------'
 
+# Note that all method calls are redirected to 
+# class HTML, so this won't work as expected: 
+
+HTML.build { 
+  div { 
+    h2 { compute_string() } 
+  } 
+}
+
+# --> <compute_string />
+# This is due to a class_eval restriction every 
+# builder struggles with at the moment. 
+# (There is mixico, but it is not portable). 
+#
+# To come by this inconvenience, use, for 
+# example: 
+
+HTML.build { 
+  div { 
+    HTML.h2 { compute_string() }
+  }
+}
+
+# --> <div>computed string here</div>
+# This works, as explicit calls to class methods 
+# of HTML are not rendered using class_eval. 
+
 # The previous example effectively does the 
 # following: 
 t2 = HTML.div(:class => :css_class, 

data/fieldtest.rb

@@ -0,0 +1,64 @@
+
+require('rubygems')
+require('aurita-gui')
+require('test/unit/assertions')
+
+include Test::Unit::Assertions
+
+include Aurita::GUI
+
+form = Form.new(:name   => :the_form, 
+                :id     => :the_form_id, 
+                :action => :where_to_send)
+# You can either set all attributes in the 
+# constructor call ...
+text = Input_Field.new(:name => :description, 
+                       :class => :the_css_class, 
+                       :label => 'Enter description', 
+                       :onfocus => "alert('input focussed');", 
+                       :value => 'some text')
+# Or set them afterwards: 
+text.onblur = "alert('i lost focus :(');"
+
+puts "\nDefault ---------------------------------\n"
+puts text.to_s
+puts "\nDisabled --------------------------------\n"
+text.disable! 
+puts text.to_s
+puts "\nEnabled ---------------------------------\n"
+text.enable! 
+puts text.to_s
+puts "\nReadonly --------------------------------\n"
+text.readonly! 
+puts text.to_s
+puts "\nEditable --------------------------------\n"
+text.editable! 
+puts text.to_s
+
+puts "\nTo hidden -------------------------------\n"
+puts text.to_hidden_field.to_s
+
+# Add it to the form: 
+form.add(text)
+puts "\nThe Form --------------------------------\n"
+
+# Access it again, via name: 
+assert_equal(form[:description], text)
+# Or by using its index: 
+assert_equal(form[0], text)
+
+# This is useful! 
+form[:description].value = 'change value'
+
+checkbox = Checkbox_Field.new(:name => :enable_me, 
+                              :value => :foo, 
+                              :label => 'Check me', 
+                              :options => [ :foo, :bar ] )
+form.add(checkbox)
+form[:description].required = true
+checkbox.required = true
+form.fields = [ :description, :enable_me ]
+form.delete_field(:enable_me)
+puts form.to_s
+
+

data/lib/aurita-gui/element.rb

@@ -50,9 +50,11 @@ module GUI
     
     def initialize(params={}, &block) 
       @@element_count += 1
-      @id      = @@element_count
-      @parent  = params[:parent]
+      @id          = @@element_count
+      @parent      = params[:parent]
+      @force_close = params[:force_closing_tag]
       params.delete(:parent)
+      params.delete(:force_closing_tag)
 
       params[:tag] = :div if params[:tag].nil?
 
@@ -158,12 +160,12 @@ module GUI
         end
       }
       
-      if content.to_s != '' then
-        '<' << @tag.to_s << ' ' << attrib_string << '>' << "\n" << 
-        content.to_s + 
-        '</' << @tag.to_s << '>' << "\n" 
+      if @force_close || content.to_s != '' then
+        '<' << @tag.to_s << ' ' << attrib_string << '>' << "\n  " << 
+        content.to_s.gsub("\n","\n  ") + "\n" << 
+        '</' << @tag.to_s << '>'
       else
-        '<' << @tag.to_s << ' ' << attrib_string << '/>' << "\n" 
+        '<' << @tag.to_s << ' ' << attrib_string << '/>' 
       end
       
     end

data/lib/aurita-gui/form.rb

@@ -27,7 +27,7 @@ module GUI
 
     def initialize(field)
       label_params = { :for => field.dom_id }
-      label_params[:id] = field.dom_id.to_s + '_label' 
+      label_params[:id] = field.dom_id.to_s + '_label'
       label = field.label
       @content = [ HTML.label(label_params) { label }, field ]
       params = { :tag => :li, 
@@ -39,31 +39,146 @@ module GUI
 
   end
 
+  # Usage examples: 
+  #
+  #   form = Form.new(:method   => :put  # default: :post
+  #                   :action   => '/where/to/send/form/'
+  #                   :onsubmit => "alert('submitting');") { 
+  #     [ 
+  #       Input_Field.new(:name => :description, :label => 'Description'), 
+  #       Select_Field.new(:name => :category, :label => 'Select category')
+  #     ]
+  #   }
+  #   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'
+  #
+  #
+  # == Render modes
+  #
+  # There are several ways to influence the rendering of a 
+  # field. 
+  # Available modes are: 
+  #
+  #   * editable: Default mode, opposite of readonly mode. 
+  #   * disabled: Set the disabled="disabled" attribute. Element will 
+  #               be rendered as input field, but can't be modified 
+  #               by the user. 
+  #   * readonly: Unlike in disabled mode, element will not be rendered 
+  #               as input field, but as a <div> containing the field's value. 
+  #   * required: Always render this field. If it is not included in the 
+  #               form's field configuration, render it as hidden field. 
+  #   * hidden:   Render as hidden field. 
+  #
+  # === Examples
+  #
+  #   form = Form.new(:name   => :the_form, 
+  #                   :id     => :the_form_id, 
+  #                   :action => :where_to_send)
+  #
+  # You can either set all attributes in the 
+  # constructor call ...
+  #
+  #   text = Input_Field.new(:name => :description, 
+  #                          :class => :the_css_class, 
+  #                          :label => 'Enter description', 
+  #                          :onfocus => "alert('input focussed');", 
+  #                          :value => 'some text')
+  #
+  # Or set them afterwards: 
+  #
+  #   text.onblur = "alert('i lost focus :(');"
+  # 
+  # Default mode: 
+  #
+  #   puts text.to_s
+  #
+  # Disabled mode: 
+  #
+  #   text.disable! 
+  #   puts text.to_s
+  # 
+  # Re-enable: 
+  #
+  #   text.enable! 
+  #   puts text.to_s
+  #
+  # Readonly: 
+  #
+  #   text.readonly! 
+  #   puts text.to_s
+  #
+  # Back to editable: 
+  #
+  #   text.editable! 
+  #   puts text.to_s
+  # 
+  # Render to hidden field: 
+  #
+  #   puts text.to_hidden_field.to_s
+  #
+  # Set to hidden (will only influence handling when 
+  # rendered by a form): 
+  #
+  #   text.hidden = true
+  # 
+  # Add it to the form: 
+  #
+  #   form.add(text)
+  #
+  # === Modifying form elements  
+  #
+  # Access it again, by name: 
+  # 
+  #   assert_equal(form[:description], text)
+  #
+  # Or by using its index: 
+  #
+  #   assert_equal(form[0], text)
+  # 
+  # This is useful! 
+  #
+  #   form[:description].value = 'change value'
+  #
+  #   checkbox = Checkbox_Field.new(:name => :enable_me, 
+  #                                 :value => :foo, 
+  #                                 :label => 'Check me', 
+  #                                 :options => [ :foo, :bar ] )
+  #   form.add(checkbox)
+  #
+  # Modifying a field element *after* adding it to the 
+  # form also works, as the form instance only references 
+  # its form elements: 
+  #
+  #   checkbox.required = true 
+  #
+  # The all form instance this checkbox has been added to 
+  # now recognize it as a required field. 
+  #
+  #   form.fields = [ :description, :enable_me ]
+  #   form.delete_field(:enable_me)
+  #
+  # And this is something i personally really like: 
+  #
+  #   form[:description].required = true
+  #
+  # Now, checkbox is not included in the form's field 
+  # configuration, but as it is a required field, it 
+  # will be rendered as hidden field. 
+  #
+  #   puts form.to_s
+  #
+  #
   class Form < Element
 
     attr_accessor :method, :target, :action, :fields, :elements, :element_map
   
-    # Usage examples: 
-    #
-    #   form = Form.new(:method   => :put  # default: :post
-    #                   :action   => '/where/to/send/form/'
-    #                   :onsubmit => "alert('submitting');") { 
-    #     [ 
-    #       Input_Field.new(:name => :description, :label => 'Description'), 
-    #       Select_Field.new(:name => :category, :label => 'Select category')
-    #     ]
-    #   }
-    #   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'
-    #
-    #
     def initialize(params, &block)
       @action       = params[:action]
       @method       = params[:method]
@@ -160,6 +275,10 @@ module GUI
     #
     def values=(value_hash={})
       @values = value_hash
+      @values.each_pair { |field_name, value|
+        element = @element_map[field_name.to_s]
+        element.value = value if element
+      }
     end
     alias set_values values=
 
@@ -179,9 +298,25 @@ module GUI
           @element_map[field.name.to_s] = field
         }
       end
+      @fields.uniq!
       return @fields
     end
 
+    # Remove field with name=field_name from 
+    # list of elements to be rendered in the form. 
+    # The element will not be deleted from the form, 
+    # so it can be enabled again using 
+    #
+    #   form.fields << :field_name
+    #
+    def delete_field(field_name)
+      if field_name.kind_of? Numeric then
+        @fields.delete_at(field_name)
+      else
+        @fields.delete(field_name.to_s)
+      end
+    end
+
     # Return underlying HTML element instance (HTML.ul), 
     # without wrapping HTML.form element. 
     def content
@@ -193,9 +328,7 @@ module GUI
       fields().each { |field|
         element = @element_map[field.to_s]
         if element then
-          value   = @values[element.name.to_s] 
-          value ||= @values[element.name.to_s.intern] 
-          element.value = value if value
+           element = element.to_hidden_field() if element.hidden?
           if element.kind_of? Aurita::GUI::Hidden_Field then
             @content << element
           else
@@ -203,16 +336,21 @@ module GUI
           end
         end
       }
-      cont = @content
-      @content = HTML.ul(:class => :form_fields) { cont }
+      # Render required field as hidden field if not 
+      # included in form field config: 
+      @elements.each { |element| 
+        if !fields.include?(element.name.to_s) && element.required? then
+          @content << element.to_hidden_field()
+        end
+      }
+      @content = HTML.ul(:class => :form_fields) { @content }
       return @content
     end
 
     # Render this form to an HTML.form instance. 
     # Wraps result of #content. 
     def element
-      cont = content()
-      HTML.form(@attrib) { cont }
+      HTML.form(@attrib) { content() }
     end
 
     # Render this form to a string

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

@@ -25,19 +25,60 @@ module GUI
   #   i.onclick = "alert('i have been clicked');"
   #   i.class   = 'css_class'
   #
+  # To indicate a required form field, set the :required flag: 
+  #
+  #   i = Input_Field.new(:required => true, :name => :description)
+  #
+  # Or
+  #
+  #   i.required = true
+  #
+  # A required field will always be rendered, even 
+  # if it is not included in the form field settings. 
+  # In this case, it is rendered as hidden field. 
+  #
+  # To force rendering a form element as hidden field, 
+  # set the :hidden flag: 
+  #
+  #   i = Input_Field.new(:hidden => true, :name => :hide_me)
+  #
+  # Or
+  #
+  #   i.hidden = true
+  #
+  # There is also a readonly render mode for form fields 
+  # In readonly mode, a field element will be rendered as 
+  # div element, containing the field value. 
+  # This is useful for delete forms. 
+  #
+  #   i = Input_Field.new(:readonly => true, :name => :description)
+  #
+  # Or
+  #
+  #   i.readonly = true # or i.readonly! 
+  #
+  # And back to editable render mode: 
+  #
+  #   i.redonly = false 
+  #
+  # Or 
+  #
+  #   i.editable! 
   #
   class Form_Field < Element
 
-    attr_accessor :type, :form, :label, :value
+    attr_accessor :type, :form, :label, :value, :required, :hidden
 
     def initialize(params)
       # @value  = params[:value]
       raise Form_Error.new('Must provide parameter :name for ' << self.class.to_s) unless params[:name]
-      @form   = params[:parent]
-      @form ||= params[:form]
-      @label  = params[:label]
+      @form     = params[:parent]
+      @form   ||= params[:form]
+      @label    = params[:label]
       # Get value from params unless set by derived constructor: 
-      @value  = params[:value] unless @value 
+      @value    = params[:value] unless @value 
+      @required = params[:required]
+      @hidden   = params[:hidden]
       # Do not delete parameter value, as it is a 
       # standard for <input> elements. 
       # Field types not supporting the value attribute
@@ -47,47 +88,170 @@ module GUI
       params.delete(:form)
       params.delete(:parent)
       params.delete(:label)
+      params.delete(:required)
+      params.delete(:hidden)
       params[:parent] = @form
       super(params)
     end
 
+=begin
     def form=(form_instance)
       @form = form_instance
       @params[:parent] = @form
     end
+=end
 
+    # Virtual method. 
     def element
       raise Form_Error.new('Cannot render abstract class Form_Field')
     end
+
+    # Render this form field element to a 
+    # readonly element. 
+    # Will not affect this element instance. 
     def readonly_element
+      # Todo: Add CSS classes 'readonly' and self.class
       HTML.div(@attrib) { @value }
     end
 
+    # Render this form field element to a 
+    # Hidden_Field instance. Will not affect 
+    # this element instance. 
+    def to_hidden_field
+      Hidden_Field.new(:type  => :hidden, 
+                       :name  => @attrib[:name], 
+                       :id    => dom_id.to_s, 
+                       :value => @value)
+    end
+
+    # Render this form field element to string. 
     def to_s
       return element().string unless @readonly
       return readonly_element().string
     end
     alias string to_s
 
+    # Set field element to editable mode. 
+    # See Aurita::GUI::Form for more information 
+    # on rendering modes. 
     def editable!
-      @reaonly = false
+      @readonly = false
+      remove_class(:readonly)
     end
+
+    # Set field element to readonly mode. 
+    # See Aurita::GUI::Form for more information 
+    # on rendering modes. 
     def readonly!
-      @attrib[:class] = @attrib[:class].to_s << ' readonly'
       @readonly = true
+      add_class(:readonly)
     end
+    # Whether this field element is in readonly mode. 
     def readonly? 
       @readonly
     end
+    # Set :readonly flag (true | false). 
+    def readonly=(is_readonly)
+      @readonly = is_readonly
+      if is_readonly then 
+        add_class(:readonly) 
+      else 
+        remove_class(:readonly) 
+      end
+    end
+
+    # Set field element to disabled mode. 
+    # See Aurita::GUI::Form for more information 
+    # on rendering modes. 
     def disable! 
       @attrib[:disabled] = true
+      add_class(:disabled)
     end
+    # Set field element to enabled mode (default).
+    # See Aurita::GUI::Form for more information 
+    # on rendering modes. 
     def enable! 
       @attrib.delete(:disabled)
+      remove_class(:disabled)
+    end
+    def disabled=(is_disabled)
+      @disabled = is_disabled
+      if is_disabled then 
+        add_class(:disabled) 
+      else 
+        remove_class(:disabled) 
+      end
+    end
+
+    # Set :required flag (true | false). 
+    def required=(is_required)
+      @required = is_required
+      if is_required then 
+        add_class(:required) 
+      else 
+        remove_class(:required) 
+      end
+    end
+
+    # Set field element to required mode. 
+    # See Aurita::GUI::Form for more information 
+    # on rendering modes. 
+    def required!
+      @required = true
+      add_class(:required)
+    end
+    # Set field element to optional mode (default). 
+    def optional!
+      @required = false
+      remove_class(:required)
+    end
+    # Whether this field element is a required field. 
+    def required?
+      (@required == true)
+    end
+
+    # Set hidden flag for this element. 
+    # See Aurita::GUI::Form for more information 
+    # on rendering modes. 
+    def hide!
+      @hidden = true
+    end
+    # Remove :hidden flag from this element. 
+    def show!
+      @hidden = false
+    end
+    # Whether this field element is hidden. 
+    def hidden?
+      (@hidden == true)
+    end
+
+  protected
+
+    def css_classes
+      css_classes = @attrib[:class]
+      if css_classes.kind_of? Array
+        css_classes.flatten! 
+      elsif css_classes.kind_of? String
+        css_classes = css_classes.split(' ') 
+      else # e.g. Symbol
+        css_classes = [ css_classes ]
+      end
+      css_classes.collect { |c| c.to_sym if c }
+      return css_classes
+    end
+
+    def add_class(css_class_name)
+      @attrib[:class] = (css_classes << css_class_name.to_sym)
+    end
+
+    def remove_class(css_class_name)
+      classes = css_classes
+      classes.delete(css_class_name.to_sym)
+      @attrib[:class] = classes
     end
 
-  end
+  end # class
 
 
-end
-end
+end # module
+end # module

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

@@ -31,6 +31,7 @@ module GUI
       super(params)
     end
     def element
+      @attrib[:value] = @value
       HTML.input(@attrib)
     end
   end

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

@@ -8,13 +8,15 @@ module GUI
     def initialize(params, &block)
       params[:tag] = :textarea
       # Move value parameter to @content: 
-      @content     = params[:value]
+      @value       = params[:value]
+      super(params)
       params.delete(:value)
-      super(params, &block)
-      @value       = @content
+      @value       = yield.to_s if block_given?
     end
     def element
-      HTML.textarea(@attrib) { @value }
+      # Always close <textarea> tags! 
+      @attrib[:force_closing_tag] = true
+      HTML.textarea(@attrib) { @value.to_s }
     end
   end
   

data/lib/aurita-gui/html.rb

@@ -4,34 +4,212 @@ require('aurita-gui/element')
 module Aurita
 module GUI
 
-  #  Aurita::GUI::HTML is a convenient factory for 
-  #  Aurita::GUI::Element. Almost every class method 
-  #  is redirected to generate a correspoding 
-  #  Element instance. 
+  # == About
   #
-  #  It implements an object-oriented, minimalistic 
-  #  generator for HTML code. 
-  #  For tags without enclosed content (i.e. without 
-  #  closing tag): 
+  # Aurita::GUI is a library for convenient, simple 
+  # HTML generation for web applications. 
   #
-  #    HTML.br  
-  #    # --> '<br />'
+  # It is a stand-alone library isolated from the 
+  # Aurita Web Application Framework, where Aurita::GUI 
+  # is used to support design of OO-accessible GUI 
+  # elements. 
   #
-  #    HTML.hr(:class => 'divide')  
-  #    # --> '<hr class="divide" />'
+  # Other than other builder implementations (there 
+  # are many), Aurita::GUI is not just a collection 
+  # of template helpers. It is data persistent and 
+  # maintains object hierarchies. 
+  # That is: The HTML hierarchy you build is not just 
+  # rendered to a string - you can access and modify a 
+  # generated HTML hierarchy before rendering it. 
   #
-  #  This is effectively a wrapper for 
+  # This is especially useful (and necessary) when 
+  # generating forms. 
   #
-  #    Element.new(:tag => :hr, :class => 'divide')
+  # Aurita::GUI is designed to be especially useful
+  # for automated form generation (Lore ORM uses it 
+  # to generate forms for models). 
   #
-  #  Enclosed content is passed in a block: 
+  # Of course there is also Aurita::GUI::Template_Helper 
+  # for templates, but this is just one possible 
+  # implementation that wraps common tasks in methods. 
+  # You can easily write your own template helpers 
+  # and use them e.g. in Rails, Merb or Ramaze projects. 
   #
-  #    HTML.a(:href => 'http://domain.com') { 'click me' }
-  #    # --> '<a href="http://domain.com">click me</a>'
   #
-  
-  XHTML_TAGS = [ :html, :div, :p, :input, :select, :option, :ul, :ol, :li ]
-
+  # Aurita::GUI::HTML is a convenient factory for 
+  # Aurita::GUI::Element, the base class to almost 
+  # every instance this library generates. 
+  # HTML's class methods are redirected to generate a 
+  # correspoding Element instance. 
+  #
+  # It implements an object-oriented, minimalistic 
+  # generator for HTML code. 
+  # For tags without enclosed content (i.e. without 
+  # closing tag): 
+  #
+  #   HTML.br  
+  #   # --> '<br />'
+  #
+  #   HTML.hr(:class => 'divide')  
+  #   # --> '<hr class="divide" />'
+  #
+  # This is effectively a wrapper for 
+  #
+  #   Element.new(:tag => :hr, :class => 'divide')
+  #
+  # Enclosed content is passed in a block: 
+  #
+  #   HTML.a(:href => 'http://domain.com') { 'click me' }
+  #   # --> '<a href="http://domain.com">click me</a>'
+  #
+  # Or as a constructor parameter: 
+  #
+  #   HTML.a(:href => 'http://domain.com', :content => 'click me')
+  #
+  # == Further Examples
+  #
+  # There are some few usage principles that are 
+  # consistent for every class of Aurita::GUI. 
+  # One of them: If a parameter can be passed as constructor 
+  # argument, there are also getter and setter methods 
+  # for this parameter: 
+  #
+  #   d = HTML.div { 'the content' }
+  #   d.content = 'i changed the content'
+  #   d.onclick = "alert('you clicked me');"
+  #
+  #
+  # === The basics
+  # 
+  # This is the most convenient way to build 
+  # HTML using aurita-gui. 
+  # (Thanks to oGMo for demanding more magic)
+  #
+  #   t1 = HTML.build { 
+  #     div(:class => :css_class, 
+  #         :onmouseover => "do_something_with(this);") { 
+  #       ul(:id => :the_list) { 
+  #         li(:class => :first) { 'foo' } +
+  #         li(:class => :second) { 'bar' } +
+  #         li(:class => :third) { 'batz' }
+  #       }
+  #     }
+  #   }
+  #   puts t1.to_s
+  #
+  # Note that all method calls are redirected to 
+  # class HTML, so this won't work as expected: 
+  #  
+  #   HTML.build { 
+  #     div { 
+  #       h2 { compute_string() } 
+  #     } 
+  #   }.to_s
+  #  
+  # --> <div><h2><compute_string /></h2></div>
+  #
+  # This is due to a class_eval restriction every 
+  # builder struggles with at the moment. 
+  # (There is mixico, but it is not portable). 
+  #
+  # To come by this inconvenience, use, for 
+  # example: 
+  #  
+  #   HTML.build { 
+  #     div { 
+  #       HTML.h2 { compute_string() }
+  #     }
+  #   }.to_s
+  #  
+  # --> <div><h2>computed string here</h2></div>
+  #
+  # This works, as explicit calls to class methods 
+  # of HTML are not rendered using class_eval. 
+  # 
+  # The previous example effectively does the 
+  # following: 
+  #
+  #   t2 = HTML.div(:class => :css_class, 
+  #                 :onmouseover => "do_something_with(this);") { 
+  #     HTML.ul(:id => :the_list) { 
+  #         HTML.li(:class => :first) { 'foo' } +
+  #         HTML.li(:class => :second) { 'bar' } + 
+  #         HTML.li(:class => :third) { 'batz' }
+  #     }
+  #   }
+  #   assert_equal(t1.to_s, t2.to_s)
+  # 
+  # Element is not a full Enumerable implementation (yet), 
+  # but it offers random access operators ...
+  # 
+  #   assert_equal(t1[0].tag, :ul)  # First element of div is <ul>
+  # 
+  #   t1[0][1] = HTML.li(:class => :changed) { 'wombat' }
+  # 
+  # ... as well as #each ... 
+  #  
+  #   t1[0].each { |element|
+  #     element.id = 'each_change'
+  #   }
+  #  
+  # ... empty? and length. More to come in future releases. 
+  #  
+  #   assert_equal(t1[0].length, 3) # List has 3 entries
+  #   assert_equal(t1[0].empty?, false) # List has 3 entries
+  #  
+  #  
+  # === Form builder
+  #  
+  #   form = Form.new(:name   => :the_form, 
+  #                   :id     => :the_form_id, 
+  #                   :action => :where_to_send)
+  #
+  # You can either set all attributes in the 
+  # constructor call ...
+  #
+  #   text = Input_Field.new(:name => :description, 
+  #                          :class => :the_css_class, 
+  #                          :onfocus => "alert('input focussed');", 
+  #                          :value => 'some text')
+  # Or set them afterwards: 
+  #
+  #   text.onblur = "alert('i lost focus :(');"
+  # 
+  # Enable / disable: 
+  #
+  #   text.disable! 
+  #   text.enable! 
+  #
+  # Set an element to readonly mode (display value only): 
+  #   text.readonly! 
+  # 
+  # And back to editable mode: 
+  #
+  #   text.editable! 
+  #
+  # Add it to the form: 
+  #   form.add(text)
+  #
+  # Access it again, via name: 
+  #
+  #   assert_equal(form[:description], text)
+  #
+  # Or by using its index: 
+  #
+  #   assert_equal(form[0], text)
+  #
+  # This is useful! 
+  #
+  #   form[:description].value = 'change value'
+  # 
+  #   checkbox = Checkbox_Field.new(:name => :enable_me, 
+  #                             :value => :foo, 
+  #                             :label => 'Check me', 
+  #                             :options => [ :foo, :bar ] )
+  #   form.add(checkbox)
+  #
+  #   puts form.to_s
+  # 
   class HTML
 
     # Statically defined as <br /> must not have any attributes. 
@@ -43,7 +221,6 @@ module GUI
       raise ::Exception.new('Missing attributes for HTML.' << meth_name.inspect) unless attrib_hash
       attrib_hash[:tag] = meth_name
       cont = yield if block_given?
-    # cont = self.class_eval(&block) 
       attrib_hash[:content] = cont
       Element.new(attrib_hash)
     end
@@ -70,6 +247,7 @@ module GUI
     end
 
 =begin
+    XHTML_TAGS = [ :html, :div, :p, :input, :select, :option, :ul, :ol, :li ]
     for t in XHTML_TAGS do 
       meth = <<EOC
         def self.#{t.to_s}(attribs=nil, &block)

data/valuetest.rb

@@ -0,0 +1,50 @@
+
+require('rubygems')
+require('aurita-gui')
+require('test/unit/assertions')
+
+include Test::Unit::Assertions
+
+include Aurita::GUI
+
+form = Form.new(:name   => :the_form, 
+                :id     => :the_form_id, 
+                :action => :where_to_send)
+# You can either set all attributes in the 
+# constructor call ...
+text = Input_Field.new(:name => :description, 
+                       :class => :the_css_class)
+
+# Enable / disable: 
+form.add(text)
+
+checkbox = Checkbox_Field.new(:name => :enable_me, 
+                              :label => 'Check me', 
+                              :options => [ :foo, :bar ] )
+form.add(checkbox)
+
+textarea = Textarea_Field.new(:name => :message, 
+                              :label => 'Tell me something', 
+                              :value => 'Dear Sir ...')
+form.add(textarea)
+# You also can change values after adding them to the form: 
+textarea.value.gsub!('Sir','Madam')
+
+# Finally. form.values=(hash) replaces form values: 
+form.values = { :enable_me => :foo, :description => 'The description' }
+
+puts form.to_s
+
+assert_equal(form[0].value, 'The description')
+assert_equal(form[1].value, :foo)
+
+h = HTML.build {
+  p(:class => :oaragraph) { 
+    div(:id => :content) { 
+      'Here is text'
+    }
+  }
+}
+
+p h[0].content = 'Bla'
+puts h.to_s

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: aurita-gui
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Tobias Fuchs
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-12 00:00:00 +01:00
+date: 2009-01-13 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -22,6 +22,7 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- fieldtest.rb
 - cheatsheet.rb
 - History.txt
 - lib
@@ -29,6 +30,7 @@ files:
 - bin
 - TODO
 - test
+- valuetest.rb
 - LICENSE
 - lib/aurita-gui
 - lib/aurita-gui.rb
@@ -64,7 +66,7 @@ rdoc_options:
 - --title
 - Aurita::GUI
 - --main
-- ./cheatsheet.rb
+- Aurita::GUI::HTML
 - --line-numbers
 require_paths: 
 - lib