forma 0.0.0 → 0.1.0

data/lib/forma/form.rb

@@ -0,0 +1,257 @@
+# -*- encoding : utf-8 -*-
+module Forma
+  # Form.
+  class Form
+    include Forma::Html
+    include Forma::FieldHelper
+    include Forma::WithTitleElement
+    include Forma::Utils
+    attr_accessor :collapsible, :collapsed
+    attr_accessor :icon, :title, :title_actions
+    attr_accessor :model, :parent_field, :edit
+    attr_accessor :model_name
+
+    def initialize(h = {})
+      h = h.symbolize_keys
+      # general
+      @id = h[:id]
+      # @theme = h[:theme] || 'blue'
+      # title properties
+      @title = h[:title]
+      @icon = h[:icon]
+      @collapsible = h[:collapsible]
+      @collapsed = h[:collapsed]
+      # submit options
+      @url = h[:url]
+      @submit = h[:submit] || 'Save'
+      @wait_on_submit = h[:wait_on_submit].blank? ? true : (not not h[:wait_on_submit])
+      @method = h[:method]
+      @auth_token = h[:auth_token]
+      # tabs
+      @tabs = h[:tabs] || []
+      @selected_tab = h[:selected_tab] || 0
+      # model, errors and editing options
+      @model = h[:model]
+      @errors = h[:errors]
+      @edit = h[:edit]
+      @model_name = h[:model_name]
+      # actions
+      @title_actions = h[:title_actions] || []
+      @bottom_actions = h[:bottom_actions] || []
+      @multipart = (not not h[:multipart])
+    end
+
+    def to_html
+      el(
+        'div',
+        attrs: { id: @id, class: [ 'ff-form' ] },
+        children: [
+          title_element,
+          body_element,
+        ]
+      )
+    end
+
+    def submit(txt = nil)
+      @submit = txt if txt.present?
+      @submit
+    end
+
+    def title_action(url, h={})
+      h[:url] = url
+      @title_actions << Action.new(h)
+    end
+
+    def bottom_action(url, h={})
+      h[:url] = url
+      h[:as] = 'button' unless h[:as].present?
+      @bottom_actions << Action.new(h)
+    end
+
+    # Adds a new tab and ibject body content.
+    def tab(opts={})
+      tab = Tab.new(opts)
+      @tabs << tab
+      yield tab if block_given?
+      tab
+    end
+
+    # Adding a new field to this form.
+    def add_field(f)
+      @tabs = [ Tab.new ] if @tabs.empty?
+      @tabs[0].col1.add_field(f)
+    end
+
+    private
+
+    def body_element
+      el(
+        (@edit and parent_field.nil?) ? 'form' : 'div',
+        attrs: {
+          enctype: ('multipart/form-data' if @multipart),
+          class: (@wait_on_submit ? ['ff-form-body', 'ff-wait-on-submit', 'ff-collapsible-body'] : ['ff-form-body', 'ff-collapsible-body']),
+          action: (@url if @edit), method: (@method if @edit),
+          style: ({display: 'none'} if @collapsible && @collapsed)
+        },
+        children: [
+          (errors_element if @errors.present?),
+          (auth_token_element if (@edit == true and parent_field.nil?)),
+          tabs_element,
+          bottom_actions,
+        ]
+      )
+    end
+
+    def errors_element
+      many = @errors.is_a?(Array)
+      children = (many ? @errors.map { |e| el('li', text: e.to_s) } : [ el('span', text: @errors.to_s) ])
+      el((many ? 'ul' : 'div'), attrs: { class: 'ff-form-errors' }, children: children)
+    end
+
+    def auth_token_element
+      if @auth_token.present?
+        el('div', attrs: { style: {padding: 0, margin: 0, height: 0, width: 0, display: 'inline'} }, children: [
+          el('input', attrs: { type: 'hidden', name: 'authenticity_token', value: @auth_token })
+        ])
+      end
+    end
+
+    def field_element(fld)
+      def field_error_element(errors)
+        many = errors.length > 1
+        children = (many ? errors.map { |e| el('li', text: e.to_s)  } : [el('div', text: errors[0].to_s)])
+        el('div', attrs: { class: 'ff-field-errors' }, children: children)
+      end
+      # X---- field initialization ----X
+      fld.model = @model
+      fld.parent = self.parent_field
+      fld.model_name = self.model_name
+      # X------------------------------X
+      has_errors = (@edit and @model.present? and fld.respond_to?(:has_errors?) and fld.has_errors?)
+      if fld.label != false
+        label_text = fld.localized_label
+        label_hint = fld.localized_hint
+        label_element = el('div', attrs: { class: (fld.required ? ['ff-label', 'ff-required'] : ['ff-label'])},
+          text: label_text,
+          children: [
+            (el('i', attrs: { class: 'ff-field-hint', 'data-toggle' => 'tooltip', title: label_hint }) if label_hint.present?)
+          ]
+        )
+      end
+      value_element = el('div', attrs: { class: (fld.required ? ['ff-value', 'ff-required'] : ['ff-value']) }, children: [
+        fld.to_html(@edit), (field_error_element(fld.errors) if has_errors),
+      ])
+      el(
+        'div', attrs: {
+          id: ("fld_#{fld.id}" if fld.id), class: (has_errors ? ['ff-field', 'ff-error'] : ['ff-field']) },
+          children: [ label_element, value_element ]
+      )
+    end
+
+    def tabs_element
+      def column_element(col, hasSecondCol)
+        if col
+          el('div', attrs: { class: ['ff-col', (hasSecondCol ? 'ff-col-50' : 'ff-col-100')]}, children: [
+            el('div', attrs: { class: 'ff-col-inner' }, children: col.fields.map { |fld| field_element(fld) })
+          ])
+        end
+      end
+      def tab_actions(tab)
+        if tab.actions.any?
+          el('div', attrs: { class: 'ff-tab-actions' }, children: tab.actions.map { |a| a.to_html(@model) })
+        end
+      end
+      def tab_element(tab)
+        hasSecondCol = (not tab.col2.fields.empty?)
+        col1 = column_element(tab.col1, hasSecondCol)
+        col2 = column_element(tab.col2, hasSecondCol)
+        el('div', attrs: { class: 'ff-tab-content',style: ({ display: 'none' } if @tabs.index(tab) != @selected_tab) },
+          children: [
+            tab_actions(tab),
+            el('div', attrs: { class: 'ff-cols'}, children: [col1, col2])
+          ]
+        )
+      end
+      def tabs_header
+        if @tabs.length > 1
+          el('ul', attrs: { class: 'ff-tabs-header' }, children: @tabs.map { |tab|
+            el('li', attrs: { class: ('ff-selected' if @tabs.index(tab) == @selected_tab) }, children: [
+              (el('img', attrs: { src: tab.icon }) if tab.icon),
+              (el('span', text: tab.title || 'No Title'))
+            ])
+          })
+        end
+      end
+      el(
+        'div',
+        attrs: { class: 'ff-tabs' },
+        children: [
+          tabs_header,
+          el('div', attrs: { class: 'ff-tabs-body'}, children: @tabs.map { |tab| tab_element(tab) })
+        ]
+      )
+    end
+
+    def bottom_actions
+      edit = (@edit and parent_field.nil?)
+      if edit || @bottom_actions.any?
+        children = @bottom_actions.map { |a| a.to_html(@model) }
+        save_action = el('button', attrs: { type: 'submit', class: 'btn btn-primary' }, text: @submit) if edit
+        el('div', attrs: { class: 'ff-bottom-actions' }, children: [save_action] + children )
+      end
+    end
+  end
+
+  # This is a tab.
+  class Tab
+    include Forma::FieldHelper
+    attr_reader :title, :icon, :actions
+
+    def initialize(h = {})
+      h = h.symbolize_keys
+      @title = h[:title]
+      @icon = h[:icon]
+      @col1 = h[:col1]
+      @col2 = h[:col2]
+      @actions = h[:actions] || []
+    end
+
+    # Adding field to this tab.
+    def add_field(f)
+      col1.add_field(f)
+    end
+
+    # Returns the first column of this tab.
+    def col1
+      @col1 = Col.new if @col1.blank?
+      yield @col1 if block_given?
+      @col1
+    end
+
+    # Returns the second column of this tab.
+    def col2
+      @col2 = Col.new if @col2.blank?
+      yield @col2 if block_given?
+      @col2
+    end
+
+    def action(url, h={})
+      h[:url] = url
+      @actions << Action.new(h)
+    end
+  end
+
+  # Form may have up to two columns.
+  class Col
+    include Forma::FieldHelper
+    attr_reader :fields
+
+    def initialize(fields = [])
+      @fields = fields
+    end
+
+    def add_field(f)
+      @fields << f
+    end
+  end
+end

data/lib/forma/helpers.rb

@@ -0,0 +1,139 @@
+# -*- encoding : utf-8 -*-
+module Forma
+  module Helpers
+    def forma_for(model, opts = {})
+      opts[:model] = model
+      opts[:edit] = true
+      opts[:auth_token] = form_authenticity_token if defined?(Rails)
+      opts[:method] = 'post' if opts[:method].blank?
+      f = Forma::Form.new(opts)
+      yield f if block_given?
+      f.to_html.to_s
+    end
+
+    def view_for(model, opts = {})
+      opts[:model] = model
+      opts[:edit] = false
+      f = Forma::Form.new(opts)
+      yield f if block_given?
+      f.to_html.to_s
+    end
+
+    def table_for(models, opts = {}, &block)
+      opts[:models] = models
+      opts[:context] = block
+      t = Forma::Table.new(opts)
+      yield t if block_given?
+      t.to_html.to_s
+    end
+
+    module_function :forma_for
+    module_function :view_for
+  end
+
+  module FieldHelper
+    def complex_field(opts = {})
+      field = Forma::ComplexField.new(opts)
+      yield field if block_given?
+      add_field(field)
+    end
+
+    def map_field(name, opts = {})
+      opts[:name] = name
+      field = Forma::MapField.new(opts)
+      yield field if block_given?
+      add_field(field)
+    end
+
+    def subform(name, opts = {})
+      opts[:name] = name
+      field = Forma::SubformField.new(opts)
+      yield field.form if block_given?
+      add_field(field)
+    end
+
+    def text_field(name, opts={})
+      opts[:name] = name
+      field = Forma::TextField.new(opts)
+      yield field if block_given?
+      add_field(field)
+    end
+
+    def password_field(name, opts={})
+      opts[:password] = true
+      text_field(name, opts)
+    end
+
+    def email_field(name, opts={})
+      opts[:name] = name
+      field = Forma::EmailField.new(opts)
+      yield field if block_given?
+      add_field(field)
+    end
+
+    def date_field(name, opts={})
+      opts[:name] = name
+      field = Forma::DateField.new(opts)
+      yield field if block_given?
+      add_field(field)
+    end
+
+    def boolean_field(name, opts={})
+      opts[:name] = name
+      field = Forma::BooleanField.new(opts)
+      yield field if block_given?
+      add_field(field)
+    end
+
+    def image_field(name, opts={})
+      opts[:name] = name
+      field = Forma::ImageField.new(opts)
+      yield field if block_given?
+      add_field(field)
+    end
+
+    def number_field(name, opts = {})
+      opts[:name] = name
+      field = Forma::NumberField.new(opts)
+      yield field if block_given?
+      add_field(field)
+    end
+
+    def combo_field(name, opts = {})
+      opts[:name] = name
+      field = Forma::ComboField.new(opts)
+      yield field if block_given?
+      add_field(field)
+    end
+
+    def select_field(name, search_url, opts = {})
+      opts[:name] = name
+      opts[:search_url] = search_url
+      field = Forma::SelectField.new(opts)
+      yield field if block_given?
+      add_field(field)
+    end
+  end
+
+  module WithTitleElement
+    def title_element
+      def active_title
+        el(
+          'span',
+          attrs: { class: (self.collapsible ? ['ff-active-title', 'ff-collapsible'] : ['ff-active-title']) },
+          children: [
+            (el('i', attrs: { class: (self.collapsed ? ['ff-collapse', 'ff-collapsed'] : ['ff-collapse']) }) if self.collapsible),
+            (el('img', attrs: { src: self.icon }) if self.icon),
+            (el('span', text: self.title)),
+          ].reject { |x| x.blank? }
+        )
+      end
+      if self.title.present?
+        title_acts = el('div', attrs: { class: 'ff-title-actions' },
+          children: self.title_actions.map { |a| a.to_html(@model) }
+        ) if self.title_actions.any?
+        el('div', attrs: { class: 'ff-title' }, children: [ active_title, title_acts ])
+      end
+    end
+  end
+end

data/lib/forma/html.rb

@@ -1,3 +1,164 @@
 # -*- encoding : utf-8 -*-
-require 'forma/html/attributes'
-require 'forma/html/element'
+
+# Utilities for html text generation.
+module Forma::Html
+
+  # Attribute creation.
+  def attr(*params)
+    if params.length == 2
+      SimpleAttr.new(params[0].to_s, params[1].to_s)
+    elsif params.length == 1 and params[0].is_a?(Hash)
+      StyleAttr.new(params[0])
+    elsif params.length == 1
+      ClassAttr.new(params[0])
+    else
+      raise "illegal attr specification: #{params}"
+    end
+  end
+
+  # You can easily create elements using this method.
+  #
+  # ```
+  # include Forma::Html
+  # element = el("div", attrs = {id: 'main', class: 'header', style: {'font-size' => '20px'}})
+  # html = element.to_s
+  # ```
+  def el(tag, opts = {})
+    opts = opts.symbolize_keys
+    h = { text: opts[:text], html: opts[:html] }
+    if opts[:attrs]
+      attributes = []
+      opts[:attrs].each do |k, v|
+        if k == :class || k == :style
+          attributes << attr(v)
+        else
+          attributes << attr(k, v)
+        end
+      end
+      h[:attrs] = attributes
+    end
+    h[:children] = opts[:children]
+    Element.new(tag, h)
+  end
+
+  module_function :attr
+  module_function :el
+
+  private
+
+  class Attr; end
+
+  # Simple attribute.
+  class SimpleAttr < Attr
+    attr_reader :name, :value
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+
+    def to_s
+      if @name.present? and @value.present?
+        %Q{#{@name}="#{@value}"}
+      end
+    end
+  end
+
+  # Class attribute.
+  class ClassAttr < Attr
+    attr_reader :values
+    def initialize(values)
+      @values = values
+    end
+
+    def to_s
+      if @values.present?
+        if @values.is_a?(Array)
+          %Q{class="#{@values.join(" ")}"}
+        else
+          %Q{class="#{@values}"}
+        end
+      end
+    end
+  end
+
+  # Style attribute.
+  class StyleAttr < Attr
+    attr_reader :styles
+    def initialize(styles)
+      @styles = styles
+    end
+
+    def to_s
+      if @styles.present?
+        %Q{style="#{@styles.map{ |k,v| "#{k}:#{v}" }.join(";")}"}
+      end
+    end
+  end
+
+  # Element class.
+  class Element
+    attr_reader :tag, :id, :attrs
+    attr_accessor :text
+
+    def initialize(tag, h)
+      @tag = tag.to_s
+      if h[:text]; @text = h[:text]
+      elsif h[:html]; @text = h[:html].html_safe
+      end
+      @attrs = h[:attrs] || []
+      @children = []
+      h[:children].each { |c| @children << c } if h[:children]
+      ids = @attrs.select { |x| x.is_a?(SimpleAttr) and x.name == "id" }.map { |x| x.value }
+      @id = ids[0] if ids.length > 0
+      @classes = @attrs.select { |x| x.is_a?(ClassAttr) }.map{ |x| x.values }.flatten
+    end
+
+    def klass
+      @classes
+    end
+
+    def to_s
+      generate_html.html_safe
+    end
+
+    def attrs_by_name(name)
+      if name.to_s == 'class' then attrs.select { |x| x.is_a?(ClassAttr) }
+      elsif name.to_s == 'style' then attrs.select { |x| x.is_a?(SimpleAttr) }
+      else attrs.select { |x| (x.respond_to?(:name) and x.name == name.to_s) }
+      end
+    end
+
+    private
+
+    def generate_html
+      h = ''
+      h << '<' << @tag << generate_tag_and_attributes.to_s << '>'
+      h << generate_inner_html
+      h << '</' << @tag << '>'
+      h
+    end
+
+    def generate_tag_and_attributes
+      attrs = @attrs.map{|a| a.to_s}.reject{|s| s.blank? }.join(" ")
+      ' ' << attrs unless attrs.blank?
+    end
+
+    def generate_inner_html
+      h = ''
+      if @text.html_safe?
+        h << @text
+      else
+        h << ERB::Util.html_escape(@text)
+      end
+      h << generate_children unless @children.blank?
+      h
+    end
+
+    def generate_children
+      h = ''
+      @children.each { |c| h << c.to_s }
+      h
+    end
+  end
+
+end

data/lib/forma/railtie.rb

@@ -0,0 +1,15 @@
+# -*- encoding : utf-8 -*-
+require 'forma/helpers'
+
+module Forma
+
+  class Engine < ::Rails::Engine
+  end
+
+  class Railtie < Rails::Railtie
+    initializer 'forma.helpers' do
+      ActionView::Base.send :include, Forma::Helpers
+    end
+  end
+
+end

data/lib/forma/table.rb

@@ -0,0 +1,115 @@
+# -*- encoding : utf-8 -*-
+module Forma
+  class Table
+    include Forma::Html
+    include Forma::FieldHelper
+    include Forma::WithTitleElement
+    attr_reader :collapsible, :collapsed, :icon, :title
+    attr_reader :title_actions
+
+    def initialize(h = {})
+      h = h.symbolize_keys
+      @id = h[:id]
+      # title properties
+      @title = h[:title]
+      @icon = h[:icon]
+      @collapsible = h[:collapsible]
+      @collapsed = h[:collapsed]
+      # values and fields
+      @models = h[:models]
+      @fields = h[:fields] || []
+      @paginate = h[:paginate]
+      # actions
+      @title_actions = h[:title_actions] || []
+      @item_actions = h[:item_actions] || []
+      # context
+      @context = h[:context]
+    end
+
+    def to_html
+      el(
+        'div',
+        attrs: { id: @id, class: ['ff-table'] },
+        children: [
+          title_element,
+          body_element,
+        ]
+      )
+    end
+
+    def title_action(url, h={})
+      h[:url] = url
+      @title_actions << Action.new(h)
+    end
+
+    def item_action(url, h={})
+      h[:url] = url
+      @item_actions << Action.new(h)
+    end
+
+    def add_field(f)
+      @fields << f
+    end
+
+    def paginate(h={})
+      @paginate = true
+      @paginate_options = h
+    end
+
+    private
+
+    def body_element
+      el(
+        'div', attrs: {
+          class: ['ff-table-body', 'ff-collapsible-body'],
+          style: ( {display: 'none'} if @collapsible && @collapsed ),
+        },
+        children: [ table_element, pagination_element ]
+      )
+    end
+
+    def table_element
+      def table_header_element
+        children = @fields.map { |f|
+          f.model = @models.first
+          label_text = f.localized_label
+          label_hint = f.localized_hint
+          el('th', attrs: { class: 'ff-field' }, text: label_text, children: [
+            (el('i', attrs: { class: 'ff-field-hint', 'data-toggle' => 'tooltip', title: label_hint }) if label_hint.present?)
+          ])
+        }
+        children << el('th', attrs: { style: {width: '100px'} }) if @item_actions.any?
+        el('thead', children: [
+          el('tr', children: children)
+        ])
+      end
+      def table_row(model)
+        children = @fields.map { |fld|
+          fld.model = model
+          el('td', children: [ fld.to_html(false) ])
+        }
+        if @item_actions.any?
+          children << el('td', children: @item_actions.map { |act| act.to_html(model) })
+        end
+        el('tr', children: children)
+      end
+      def table_body_element
+        children = 
+        el('tbody', children: @models.map { |model| table_row(model) })
+      end
+      if @models and @models.any?
+        el('table', attrs: { class: 'ff-common-table' }, children: [ table_header_element, table_body_element ])
+      else
+        el('div', attrs: { class: ['ff-empty', 'ff-table-empty'] }, text: Forma.config.texts.table_empty)
+      end
+    end
+
+    def pagination_element
+      if @paginate and @context
+        self_from_block = eval("self", @context.binding)
+        s = self_from_block.send(:will_paginate, @models, @paginate_options)
+        el('div', html: s.to_s)
+      end
+    end
+  end
+end

data/lib/forma/utils.rb

@@ -0,0 +1,24 @@
+# -*- encoding : utf-8 -*-
+module Forma
+  module Utils
+    def singular_name(model)
+      if model.respond_to?(:model_name); model.model_name.singular_route_key # Mongoid
+      elsif model.class.respond_to?(:table_name); model.class.table_name.singularize # ActiveModel
+      else; '' # Others
+      end
+    end
+
+    def extract_value(val, name)
+      def simple_value(model, name)
+        if model.respond_to?(name); model.send(name)
+        elsif model.respond_to?('[]'); model[name] || model[name.to_sym]
+        end
+      end
+      name.to_s.split('.').each { |n| val = simple_value(val, n) if val }
+      val
+    end
+
+    module_function :singular_name
+    module_function :extract_value
+  end
+end