dima 0.0.1

data/lib/dima/html/field.rb

@@ -0,0 +1,367 @@
+# -*- encoding : utf-8 -*-
+require 'date'
+
+module Dima::Html
+
+  # Text editor support.
+  module TextEditor
+    def editor(opts)
+      if opts[:textarea]
+        editor = Node.new(tag: 'textarea', text: opts[:val])
+      else
+        editor = Node.new(tag: 'input', attributes: { type: 'text', value: opts[:val] })
+      end
+      editor[:name] = "dim[#{name}]"
+      editor.add_class('dim-main-content')
+      editor.add_class("#{opts[:type]}")
+      style = ''
+      style += "width: #{opts[:width]}px;" if opts[:width]
+      style += "height: #{opts[:height]}px;" if opts[:height]
+      editor.attributes[:style] = style unless Dima::Utils.empty?(style)
+      editor
+    end
+  end
+
+  # Field is used in a form.
+  class Field < Dima::Html::Element
+    include Dima::Init
+
+    # form holding this field
+    attr_accessor :form
+    # label describes this field
+    attr_accessor :label
+    # tooltip
+    attr_accessor :tooltip
+    # hint message
+    attr_accessor :hint
+    # is this field required?
+    attr_accessor :required
+    # element to be placed BEFORE the field content
+    attr_accessor :before
+    # element to be placed AFTER the field content
+    attr_accessor :after
+    # url property
+    attr_accessor :url
+    # text align: used for correct display in tables
+    attr_accessor :align
+    # edit mode switch
+    attr_accessor :edit
+
+    attr_accessor :has_errors
+
+    def validate
+      self.has_errors = false
+      self.has_errors = true if self.required and Dima::Utils.empty?(@val)
+    end
+
+    # Get current value of the field.
+    def val
+      @val
+    end
+
+    # Set the value of the field.
+    def val=(v)
+      @val = v
+    end
+
+    # Additional properties.
+    def options
+      @options ||= {}
+    end
+
+    def edit?
+      self.edit and not self.readonly
+    end
+
+    # Create html node for the field.
+    def to_n
+      field = Node.new(tag: 'div', attributes: { id: self.id, class: 'dim-field' })
+      field.add_class('dim-required') if required
+      field.add_class('dim-error') if has_errors
+      field << label_node
+      field << value_node
+      field
+    end
+
+    # Prepare content node.
+    def value_node
+      content = Node.new(tag: 'div', attributes: { class: 'dim-value' })
+      if empty? and not self.edit?
+        content << empty_node
+      else
+        content.add_class(align.to_s) if align
+        content << before_node
+        ## content + link node
+        link_node = url_node
+        if link_node and not self.edit
+          link_node << main_content_node
+          content << link_node
+        else
+          content << main_content_node
+        end
+        ##
+        content << after_node
+        content
+      end
+      content
+    end
+
+    # Empty node.
+    def empty_node
+      Node.new(tag: 'span', attributes: { class: 'dim-empty' }, text: '(empty)')
+    end
+
+    # Prepare label node for this field.
+    def label_node
+      unless @label == false
+        Node.new(tag: 'div', attributes: { class: 'dim-label' }, text: @label)
+      end
+    end
+
+    # Before node.
+    def before_node
+      Node.new(tag: 'span', attributes: { class: 'dim-before' }, text: self.before) if self.before
+    end
+
+    # After node.
+    def after_node
+      Node.new(tag: 'span', attributes: { class: 'dim-after' }, text: self.after) if self.after
+    end
+
+    # Url node.
+    def url_node
+      if self.url
+        if self.url.is_a?(Proc) and self.model
+          Node.new(tag: 'a', attributes: {href: self.url.call(self.model)})
+        else
+          Node.new(tag: 'a', attributes: {href: self.url.to_s})
+        end
+      end
+    end
+
+  end
+
+  # Simple field has a name associated with it.
+  # Using this name we can associate values from a model.
+  class SimpleField < Field
+    attr_accessor :name
+    attr_accessor :lambda
+    attr_accessor :width, :height
+    attr_accessor :readonly
+    attr_accessor :model
+
+    # Initialize this field from a model.
+    #
+    # The field can be initialized from a hash too.
+    def << (v)
+      if v and v.is_a?(Hash)
+        update_from_hash(v)
+      else
+        self.model = v
+        if self.lambda
+          self.val = self.lambda.call(v)
+        elsif self.name
+          self.val = Dima::Utils.get(v, self.name)
+        end
+      end
+    end
+
+    def >> (v)
+      Dima::Utils.set(v, self.name, self.val) if self.name and not self.readonly?
+    end
+
+    def main_content_node
+      simple_value_node
+    end
+
+    def empty?
+      Dima::Utils.empty?(self.val)
+    end
+
+    def readonly?
+      self.readonly
+    end
+
+    private
+
+    def update_from_hash(hash)
+      txt = hash[self.name.to_s]
+      txt = hash[self.name.to_sym] if txt.nil?
+      value_from_text(txt)
+    end
+
+  end
+
+  # Complex field.
+  class ComplexField < Field
+    attr_accessor :model
+
+    # fields for this component.
+    def fields
+      @fields ||= []
+    end
+
+    # Initialize this field from a model.
+    def << (v)
+      self.model = v
+      fields.each do |f|
+        f << v
+      end
+    end
+
+    def >> (v)
+      fields.each { |f| f >> v }
+    end
+
+    def empty?
+      fields.each do |f|
+        return false unless f.empty?
+      end
+      true
+    end
+
+    def main_content_node
+      cmplx = Node.new(tag: 'div', attributes: { class: 'dim-complex' })
+      fields.each do |f|
+        f.edit = self.edit
+        cmplx << f.main_content_node unless f.empty?
+      end
+      cmplx
+    end
+
+  end
+
+  # Text field.
+  class TextField < SimpleField
+    include Dima::Html::TextEditor
+    attr_accessor :textarea
+
+    def simple_value_node
+      if self.edit?
+        editor(val: self.val.to_s, type: 'dim-text', width: width, height: height, textarea: self.textarea)
+      else
+        Node.new(tag: 'span', attributes: { class: 'dim-main-content dim-text' }, text: self.val.to_s)
+      end
+    end
+
+    def value_from_text(val)
+      self.val = val
+    end
+
+  end
+
+  # Display email.
+  class EmailField < SimpleField
+    include Dima::Html::TextEditor
+
+    def simple_value_node
+      if self.edit?
+        editor(val: self.val.to_s, type: 'dim-email', width: width)
+      else
+        node = Node.new(tag: 'span', attributes: { class: 'dim-main-content dim-email' })
+        node << Node.new(tag: 'a', attributes: { href: 'mailto:' + self.val.to_s }, text: self.val.to_s)
+        node
+      end
+    end
+
+    def value_from_text(val)
+      self.val = val
+    end
+
+  end
+
+  # Display web-address.
+  class WebField < SimpleField
+    include Dima::Html::TextEditor
+
+    def simple_value_node
+      if self.edit?
+        editor(val: self.val.to_s, type: 'dim-web', width: width)
+      else
+        node = Node.new(tag: 'span', attributes: { class: 'dim-main-content dim-web' })
+        node << Node.new(tag: 'a', attributes: { href: self.val.to_s }, text: self.val.to_s)
+        node
+      end
+    end
+
+    def value_from_text(val)
+      self.val = val
+    end
+
+  end
+
+  # Display number.
+  class NumberField < SimpleField
+    include Dima::Html::TextEditor
+    attr_accessor :precision
+    attr_accessor :delimiter
+    attr_accessor :separator
+
+    def initialize(h = {})
+      super(h)
+      self.align = 'right' unless self.align
+    end
+
+    def simple_value_node
+      if self.edit?
+        editor(val: self.val.to_s, type: 'dim-number', width: width)
+      else
+        frmtValue = Dima::Utils.number_format(self.val, precision: self.precision, delimiter: self.delimiter, separator: self.separator)
+        node = Node.new(tag: 'span', attributes: { class: 'dim-main-content dim-number' })
+        node << Node.new(tag: 'code', text: frmtValue)
+        node
+      end
+    end
+
+    def value_from_text(val)
+      if precision == 0
+        self.val = val.to_i
+      else
+        self.val = val.to_f
+      end
+    end
+
+  end
+
+  # Display date.
+  class DateField < SimpleField
+    include Dima::Html::TextEditor
+    attr_accessor :formatter
+
+    def simple_value_node
+      frmtValue = self.val.strftime(self.formatter || Dima.config.date.formatter) if self.val
+      if self.edit?
+        editor(val: frmtValue, type: 'dim-date', width: width)
+      else
+        Node.new(tag: 'span', attributes: { class: 'dim-main-content dim-date' }, text: frmtValue)
+      end
+    end
+
+    def value_from_text(val)
+      self.val = Date.strptime(val, (self.formatter || Dima.config.date.formatter)) rescue nil
+    end
+
+  end
+
+  # Boolean field.
+  class BooleanField < SimpleField
+
+    def simple_value_node
+      if self.edit?
+        Node.new(tag: 'input', attributes: { name: "dim[#{name}]", class: 'dim-main-content dim-boolean', type: 'checkbox', checked: self.val })
+      else
+        Node.new(tag: 'input', attributes: { class: 'dim-main-content dim-boolean', type: 'checkbox', checked: self.val, disabled: true })
+      end
+    end
+
+    def value_from_text(val)
+      if Dima::Utils.empty?(val) || val.strip.downcase == 'false'
+        self.val = false
+      else
+        self.val = true
+      end
+    end
+
+  end
+
+end

data/lib/dima/html/form.rb

@@ -0,0 +1,305 @@
+# -*- encoding : utf-8 -*-
+module Dima::Html
+
+  ## forms
+
+  # Abstract form.
+  class AbstractForm < Dima::Html::Element
+    include Dima::Init
+    # Title for this form.
+    attr_accessor :title
+    # Title icon.
+    attr_accessor :icon
+    # Help text for this form.
+    attr_accessor :help
+    # Whether the form is collapsed?
+    attr_accessor :collapsed
+    # Submit button text.
+    attr_accessor :submit
+    # Form method.
+    attr_accessor :method
+
+    # Get form's actions.
+    def actions
+      @actions ||= []
+    end
+
+    def html
+      if defined?(Rails)
+        to_n.html.html_safe
+      else
+        to_n.html
+      end
+    end
+
+    def to_n
+      node = Node.new(tag: 'div', attributes: { id: self.id, class: 'dim-form' })
+      node << generate_title
+      content = Node.new(tag: 'div', attributes: { class: 'dim-form-content' })
+      content[:style] = 'display: none;' if self.collapsed
+      content << generate_content
+      node << content
+      node
+    end
+
+    protected
+
+    def generate_title
+      if self.title
+        ttl = Node.new(tag: 'div', attributes: { class: 'dim-form-title' })
+        ttl << generate_actions
+        active_title = Node.new(tag: 'span', attributes: { class: 'dim-active-title' })
+        collapse_node = Node.new(tag: 'i', attributes: { class: 'dim-collapse' })
+        collapse_node.add_class(self.collapsed ? 'icon-chevron-right' : 'icon-chevron-down')
+        active_title << collapse_node
+        active_title << Node.new(tag: 'img', attributes: { src: self.icon, class: 'dim-title-image' }) if self.icon
+        active_title << Node.new(tag: 'span', attributes: { class: 'dim-title-text' }, text: title)
+        active_title << Node.new(tag: 'script', attributes: { type: 'text/javascript' }, text: collapse_script)
+        ttl << active_title
+        ttl
+      end
+    end
+
+    def collapse_script
+      %Q{
+        $('##{id} .dim-active-title').click(function() {
+          var contentElement = $('##{id} .dim-form-content');
+          var collapseElement = $('##{id} .dim-collapse');
+          var is_collapsed = collapseElement.hasClass('icon-chevron-right');
+          if (is_collapsed) {
+            collapseElement.removeClass('icon-chevron-right');
+            collapseElement.addClass('icon-chevron-down');
+            contentElement.show();
+          } else {
+            collapseElement.removeClass('icon-chevron-down');
+            collapseElement.addClass('icon-chevron-right');
+            contentElement.hide();
+          }
+        });
+      }
+    end
+
+    def generate_actions
+      v = val if respond_to?(:val)
+      unless actions.empty?
+        acts = Node.new(tag: 'div', attributes: { class: 'dim-form-actions' })
+        actions.each { |a| acts << a.to_n(v) }
+        acts
+      end
+    end
+
+  end
+
+  # Form.
+  class Form < Dima::Html::AbstractForm
+    attr_accessor :edit
+    attr_accessor :error_fields
+    attr_accessor :auth_token
+
+    def validate
+      self.error_fields = []
+      (col1.fields + col2.fields).each do |f|
+        f.validate
+        self.error_fields << f if f.has_errors
+      end
+    end  
+
+    def valid?
+      validate
+      self.error_fields.empty?
+    end
+
+    # assign model value for this form
+    def val=(v)
+      @val = v
+      col1.fields.each { |f| f << v }
+      col2.fields.each { |f| f << v }
+    end
+
+    def val
+      @val
+    end
+
+    def << (v)
+      self.val = v
+    end
+
+    def >> (v)
+      col1.fields.each { |f| f >> v }
+      col2.fields.each { |f| f >> v }
+    end
+
+    # First column.
+    def col1
+      @col1 ||= FormFields.new
+    end
+
+    # Second column.
+    def col2
+      @col2 ||= FormFields.new
+    end
+
+    def generate_content
+      if edit
+        form = Node.new(tag: 'form', attributes: { method: (self.method || 'post'), 'accept-charset' => 'UTF-8' })
+        if self.auth_token
+          flds = Node.new(tag: 'div', attributes: { style: 'padding: 0; margin: 0; height: 0; width: 0; display: inline;' })
+          flds << Node.new(tag: 'input', attributes: { name: 'authenticity_token', type: 'hidden', value: self.auth_token } )
+          form << flds
+        end
+      else
+        form = Node.new(tag: 'div')
+      end
+      form << generate_cols
+      form << generate_submit if edit
+      form
+    end
+
+    # Update with request parameters.
+    def update(params)
+      col1.fields.each { |f| f >> @val }
+      col2.fields.each { |f| f >> @val }
+    end
+
+    protected
+
+    def generate_cols
+      col1.edit = col2.edit = self.edit
+      c1 = col1.to_n
+      if c1
+        c2 = col2.to_n
+        c1[:class] = 'dim-column dim-col100' unless c2
+        cont = Node.new(tag: 'div', attributes: { class: 'dim-form-content' })
+        cont << c1
+        cont << c2
+        cont << Node.new(tag: 'div', attributes: { style: 'padding:0;margin:0;clear:both;' })
+        cont
+      end
+    end
+
+    def generate_submit
+      div = Node.new(tag: 'div', attributes: { class: 'dim-form-buttom-actions'})
+      div << Node.new(tag: 'input', attributes: { type: 'submit', value: (self.submit || 'Submit') })
+      div
+    end
+
+  end
+
+  # Table.
+  class Table < Dima::Html::AbstractForm
+    attr_accessor :vals
+    attr_accessor :actions_width
+
+    # Get form's actions.
+    def item_actions
+      @item_actions ||= []
+    end
+
+    # 
+    def cols
+      @cols ||= FormFields.new
+    end
+
+    # Getting html node for this form.
+    def generate_content
+      generate_table
+      
+    end
+
+    def generate_table
+      tbl = Node.new(tag: 'table', attributes: { class: 'dim-table' })
+      tbl << generate_header
+      tbl << generate_body
+      tbl
+    end
+
+    def generate_header
+      thead = Node.new(tag: 'thead')
+      tr = Node.new(tag: 'tr')
+      cols.fields.each do |f|
+        if f.options[:col_width]
+          tr << Node.new(tag: 'th', text: f.label, attributes: { width: f.options[:col_width] })
+        else
+          tr << Node.new(tag: 'th', text: f.label)
+        end
+      end
+      tr << Node.new(tag: 'th', text: '', attributes: { width: actions_width || 100 }) unless item_actions.empty?
+      thead << tr
+      thead
+    end
+
+    def generate_body
+      tbody = Node.new(tag: 'tbody')
+      if vals and vals.any?
+        vals.each do |val|
+          tbody << generate_row(val)
+        end
+      else
+        tr = Node.new(tag: 'tr')
+        size = item_actions.empty? ? cols.size : cols.size + 1
+        td = Node.new(tag: 'td', attributes: { colspan: cols.size + 1, class: 'dim-empty' }, text: '(no data)')
+        tr << td
+        tbody << tr
+      end
+      tbody
+    end
+
+    def generate_row(val)
+      tr = Node.new(tag: 'tr')
+      cols.fields.each do |f|
+        f << val
+        td = Node.new(tag: 'td', attributes: { class: 'dim-field' })
+        td.add_class(f.align) if f.align
+        td << f.value_node
+        tr << td
+      end
+      unless item_actions.empty?
+        td = Node.new(tag: 'td', attributes: { class: 'dim-table-actions' })
+        item_actions.each do |a|
+          td << a.to_n(val)
+        end
+        tr << td
+      end
+      tr
+    end
+
+  end
+
+  private
+
+  # Form fields.
+  class FormFields
+    attr_accessor :edit
+
+    def fields
+      @fields ||= []
+    end
+
+    def << (field)
+      fields << field
+    end
+
+    def size
+      self.fields.size
+    end
+
+    def empty?
+      fields.empty?
+    end
+
+    def to_n
+      unless empty?
+        node = Node.new(tag: 'div', attributes: { class: 'dim-column dim-col50'})
+        fields.each do |f|
+          old_edit = f.edit
+          f.edit = self.edit
+          node << f.to_n
+          f.edit = old_edit
+        end
+        node
+      end
+    end
+
+  end
+
+end

data/lib/dima/html/node.rb

@@ -0,0 +1,58 @@
+# -*- encoding : utf-8 -*-
+module Dima::Html
+
+  class Node
+    include Dima::Init
+    attr_accessor :tag, :attributes, :text
+    attr_accessor :children
+
+    # Generate HTML for this node.
+    def html
+      h = ''
+      h << '<' << self.tag.to_s << generate_attributes << '>'
+      h << self.text.to_s if self.text
+      self.children.each { |c| h << c.html } if self.children
+      h << '</' << self.tag << '>'
+      h
+    end
+
+    # Add child to the node.
+    def << (node)
+      @children ||= []
+      @children << node if node
+    end
+
+    # Set attribute for the node.
+    def []= (k, v)
+      @attributes ||= {}
+      @attributes[k] = v
+    end
+
+    # Get attribute value for the node.
+    def [] (k)
+      @attributes[k] if @attributes
+    end
+
+    def add_class(k)
+      clazz = self[:class] || ''
+      clazz += ' ' + k
+      self[:class] = clazz.strip
+    end
+
+    private
+
+    def generate_attributes
+      props = ''
+      self.attributes.each do |k, v|
+        if v.is_a?(TrueClass) or v.is_a?(FalseClass)
+          props << ' ' << k.to_s if v
+        else
+          props << ' ' << k.to_s << '="' << v.to_s << '"'
+        end
+      end if self.attributes
+      props
+    end
+
+  end
+
+end