aura 0.0.1.pre10

data/lib/sequel/plugins/aura_subtyped.rb

@@ -0,0 +1,83 @@
+# Sequel plugin: AuraSubtyped
+# Ensures a model has subtypes.
+#
+module Sequel
+module Plugins
+module AuraSubtyped
+  module InstanceMethods
+    def template
+      subtype.try(:template) || 'show'
+    end
+
+    # Method: subtype (AuraSubtyped)
+    # Returns the subtype for the given page.
+    #
+    # ## Description
+    #    Returns an {Aura::Subtype}, or nil.
+    #
+    def subtype
+      re   = nil
+      re ||= @values[:subtype]
+
+      if parent && parent.subtype && parent.subtype.allowed_subtypes
+        re ||= parent.subtype.allowed_subtypes.first
+      end
+
+      self.class.subtype re.to_sym  if re
+    end
+  end
+
+  module ClassMethods
+    def subtyped?
+      true
+    end
+
+    # Class method: subtype_ (AuraSubtyped)
+    # Returns the definition for a given subtype.
+    #
+    # ## Description
+    # If options are given, sets the options for the given subtype.
+    #
+    # This can also be called as an instance method.
+    #
+    # ## Usage
+    #     class Page
+    #       subtype NAME,
+    #         :name     => FULL_NAME,
+    #         :template => TEMPLATE
+    #     end
+    #
+    # ## Example
+    #
+    # #### Subtype example
+    # This example defines a subtype called 'portfolio'.
+    # The template it will use is `:page/portfolio`.
+    #
+    #     class Page
+    #       subtype :portfolio,
+    #         :name     => "Portfolio page",
+    #         :template => "portfolio"
+    #     end
+    #
+    def subtype(name, options=nil)
+      @@subtypes ||= Hash.new
+
+      return @@subtypes[name]  if options.nil?
+      raise ArgumentError  unless options.is_a? Hash
+
+      @@subtypes[name] = Aura::Subtype.new(options.merge({:id => name }))
+    end
+
+    def subtypes
+      @@subtypes ||= Hash.new
+
+      @@subtypes[:default] ||= Aura::Subtype.new :id => :default,
+        :name     => 'Default',
+        :template => 'show'
+
+      @@subtypes.values.sort_by { |st| st._id.to_s }
+    end
+  end
+end
+end
+end

data/lib/terra.rb

@@ -0,0 +1,185 @@
+# Module: Terra
+# Terra is a form builder.
+# 
+# #### Form DSL
+# Configure your form with a Ruby DSL like so.
+# 
+#     form = Terra::Form.new
+#     form.configure do
+#       text :name, "Name"
+#       text :email, "Email address"
+# 
+#       fieldset :options, "Options" {
+#         textarea :body, "Body", :class => "hello"
+#         options  :type, "Type",
+#           :options => {
+#             :red => "Red",
+#             :blue => "Blue"
+#           }
+#       }
+#     end
+# 
+# ## Using in Aura models
+# 
+# #### Using in Aura models
+# In your models, simply use the `form` method to enclose
+# the Terra form DSL in.
+# 
+#     class BlogPost < Sequel::Model
+#       form {
+#         text :title, "Title"
+#         text :body,  "Body"
+#       }
+#     end
+# 
+# #### Accessing
+# You'll then be able to access it like so:
+# 
+#     BlogPost.form
+#     BlogPost.form.fieldsets
+# 
+# #### AuraEditable
+# In Aura, by default, if you model uses the {AuraEditable} plugin,
+# simply define a form and you'll have new/edit pages in the admin
+# for your model, automagically.
+#
+#     [app/models/book.rb (rb)]
+#     class Book < Sequel::Model
+#       plugin :aura_editable
+#
+#       form {
+#         # ...
+#       }
+#      end
+# 
+# ## Info
+# 
+# #### Defining fields
+# Where `text` is the type of field, `:id` is the name of the
+# field, `"Field name"` is what's to be displayed, and
+# `{ options_hash }` is an optional list of settings. The field
+# type can be any of `text`|`textarea`|`options`|`checkbox`.
+# 
+#     form {
+#       text :id, "Field name", { options_hash }
+#
+#       textarea :body, "Body text"
+#       options :category, "Category"
+#     }
+# 
+# #### View example
+# You'll then be able to use it in your views like so:
+# 
+#     [app/views/_form.haml (haml)]
+#     - form.fieldsets.each do |set|
+# 
+#       -# The fieldset title
+#       %h3= set.to_s
+# 
+#       -# Form fields (generates <p>..<label>..<input> for each field)
+#       - set.fields.each do |field|
+#         = field.to_html
+# 
+# ## Methods
+#
+# #### Form methods
+# Here are some more useful {Terra::Form} methods.
+# 
+#     form.fieldsets                 # Returns an array of fieldsets
+#     set = form.fieldset(:default)  # Returns a fieldset by name
+# 
+# #### Fieldset methods
+# Here are some more useful {Terra::Fieldset} methods.
+#
+#     set.fields                # Returns a fieldset's fields
+#     set.to_html               # Returns <fieldset>..</fieldset> HTML
+#     set.to_html(object)       # Same as above, but tries to get data from `object.field_name`
+#     set.name                  # Returns the name of the field
+#     field = set.field(:name)  # Returns a field by name
+# 
+# #### Field methods
+# Here are some more useful {Terra::Field} methods.
+#
+#     field.to_html             # <p>..<label>..<input>..</p>
+#     field.to_html(val)        # Like above, but with a certain value
+#     field.input_html          # just <input>
+#     field.label_html          # just <label>
+# 
+# No, there's no `form.to_html`. Geez, don't even think about it--
+# just render each of the fields/fieldsets.
+# 
+# ## In practice
+#
+# #### HAML example
+# This is how you would render a form in HAML.
+# 
+#     [app/views/_form.haml (haml)]
+#     %form{ :method => 'post', :action => '/save' }
+#       - form.fieldsets.each do |set|
+#         !~ set.to_html(@object)
+#    
+#       %p.submit
+#         %button{ :type => 'submit' } Save
+#    
+#     # HAML tip: use !~ instead of = to have your textareas
+#     # flow correctly by supressing HAML's extra whitespaces.
+# 
+# #### More
+# 
+#     [app/views/_form.haml (haml)]
+#     = form.fieldsets.first.to_html
+#     = form.fieldsets.first.fields.first.to_html
+# 
+#     = form.fieldset(:default).to_html
+#     = form.fieldset(:default).field(:name).to_html
+#     = form.fieldset(:default).field(:name).to_html("Hello") # value
+# 
+# ## Fields
+#
+# #### Text
+# Text fields
+#
+#     form.configure {
+#       text :name
+#       text :name, "First name"
+#       text :name, "First name", :class => 'title'
+#     }
+#
+# #### Options
+# For dropdowns and radio buttons and such
+#
+#     form.configure {
+#       options :category, "Category"
+#
+#       # Choosing how to render it
+#       options :category, "Category", :type => 'radio'
+#       options :category, "Category", :type => 'dropdown'
+#
+#       # Giving an options hash
+#       options :category, "Category", :options =>
+#         { 'a' => 'Apple', 'b' => 'Banana' }
+#
+#       # Or a hash array
+#       options :category, "Category", :options =>
+#         [{ 'a' => 'Apple'},
+#          { 'b' => 'Banana' }
+#         ].to_hash_array
+#
+#       # Or lambda
+#       options :category, "Category", :options =>
+#         lambda { |record|
+#           Categories.all.map { |c| { c.id => c.name } }.to_hash_array
+#         }
+#
+#       # Not implemented yet
+#       options :category, "Category", :multi => true
+#     }
+#
+module Terra
+  PREFIX = File.dirname(__FILE__)
+  autoload :Field,    "#{PREFIX}/terra/field"
+  autoload :Fields,   "#{PREFIX}/terra/fields"
+  autoload :Fieldset, "#{PREFIX}/terra/fieldset"
+  autoload :Form,     "#{PREFIX}/terra/form"
+end
+

data/lib/terra/ext.rb

@@ -0,0 +1,16 @@
+# Ensure that Terra is loaded first.
+require File.join(File.dirname(__FILE__), '../terra')
+
+module Terra
+  module Fields
+    # Class: Html (Terra::Fields)
+    # Inherits: {Terra::Field}
+    # An HTML field.
+    #
+    class Html < Textarea
+      def html_wrap(s)
+        "<p class='html #{options[:class] || ''}'>#{s}</p>"
+      end
+    end
+  end
+end

data/lib/terra/field.rb

@@ -0,0 +1,98 @@
+# Class: Field (Terra)
+# A field.
+#
+# ## Description
+# See {Terra} for information on how to use the form builder.
+#
+module Terra
+  class Field
+    attr_accessor :name
+    attr_accessor :title
+    attr_accessor :options
+
+    def self.create(fieldset, type, name, title, options)
+      klass = Fields::get(type) || Fields::Text
+      klass.new(fieldset, name, title, options)
+    end
+
+    def initialize(fieldset, name, title, options={})
+      @fieldset = fieldset
+      @name     = name
+      @title    = title
+      @options  = options
+    end
+
+    # Attribute: fieldset (Terra::Field)
+    # Returns the fieldset parent.
+    attr_reader :fieldset
+
+    # Attribute: form (Terra::Field)
+    # Returns the parent Form.
+    def form
+      fieldset.form
+    end
+
+    def inspect
+      "#<Field (#{self.class.to_s.split('::').last}): '#{name}'>"
+    end
+
+    # Method: id (Terra::Field)
+    # Returns the HTML ID for the field.
+    def id
+      "field_#{name}"
+    end
+
+    # Method: label_html (Terra::Field)
+    # Returns the HTML code for the <label> tag.
+    def label_html
+      "<label for='#{id}'>#{title}:</label>"
+    end
+
+    # Method: input_name (Terra::Field)
+    # Returns the HTML name attribute for the field's input element.
+    def input_name
+      form.name_for name
+    end
+
+    # Method: input_html (Terra::Field)
+    # Usage:  input_html(value='', item=nil)
+    # Returns the HTML code for the input value.
+    #
+    # ## Description
+    # If a `value` is supplied, it will be used for the value of the input
+    # element.
+    #
+    def input_html(val='', item=nil)
+      "<input id='#{id}' type='text' name='#{input_name}' value='#{h val}' />"
+    end
+
+    # Method: to_html (Terra::Field)
+    # Usage:  to_html(value='', item=nil)
+    # Returns the HTML code.
+    #
+    # ## Description
+    # If a `value` is supplied, it will be used for the value of the input
+    # element.
+    #
+    def to_html(val='', item=nil)
+      html_wrap [ label_html, input_html(val, item=nil) ].join("\n")
+    end
+
+    # Method: html_wrap (Terra::Field)
+    # Usage:  html_wrap(html)
+    # Wraps the given HTML code with the field's field wrapper.
+    #
+    # ## Description
+    # If you don't like `<p>` as the field wrapper, reimplement this.
+    #
+    def html_wrap(s)
+      "<p class='#{options[:class] || ''}'>#{s}</p>"
+    end
+
+  protected
+    def h(str)
+      Rack::Utils.escape_html str.to_s
+    end
+  end
+end
+

data/lib/terra/fields.rb

@@ -0,0 +1,122 @@
+# Module: Fields (Terra)
+# A module that is the namespace for all types of fields.
+#
+# ## Description
+# See {Terra} for information on how to use the form builder.
+#
+module Terra
+  module Fields
+    def all
+      constants.map { |c| c.to_s.underscore.to_sym }
+    end
+
+    module_function :all
+
+    def get(klass)
+      begin
+        const_get(klass.to_s.split('_').map { |s| s.capitalize }.join('').to_sym)
+      rescue NameError
+        nil
+      end
+    end
+
+    module_function :get
+  end
+end
+
+module Terra
+  module Fields
+    # Class: Text (Terra::Fields)
+    # Inherits: {Terra::Field}
+    # A text field.
+    class Text < Field
+    end
+
+    # Class: Password (Terra::Fields)
+    # Inherits: {Terra::Field}
+    # A password field.
+    class Password < Field
+      def input_html(val='', item=nil)
+        "<input id='#{h id}' type='password' name='#{h input_name}' value='#{h val}'>"
+      end
+    end
+
+    # Class: Textarea (Terra::Fields)
+    # Inherits: {Terra::Field}
+    # A text area field.
+    class Textarea < Field
+      def input_html(val='', item=nil)
+        "<textarea id='#{h id}' type='text' name='#{h input_name}'>#{h val}</textarea>"
+      end
+    end
+
+    # Class: Checkbox (Terra::Fields)
+    # Inherits: {Terra::Field}
+    # A checkbox field.
+    class Checkbox < Field
+      def to_html(val='', item=nil)
+        html_wrap [ input_html(val, item), label_html ].join("\n")
+      end
+
+      def input_html(val='', item=nil)
+        truthy = val && !val.empty?
+
+        selected = ''
+        selected = " selected='selected'"  if truthy
+
+        inputs = [ "<input type='hidden' name='#{h input_name}' value='0'>" ]
+        inputs+= [ "<input id='#{h id}' type='password' name='#{h input_name}' value='1'#{selected}>" ]
+
+        inputs.join("\n")
+      end
+    end
+
+    # Class: Options (Terra::Fields)
+    # Inherits: {Terra::Field}
+    # A field for radio buttons or dropdowns.
+    class Options < Field
+      def input_html(val='', item=nil)
+        return input_html_radio(val, item)  if options[:type].to_s == 'radio'
+        input_html_select(val, item)
+      end
+
+      def input_html_select(val='', item=nil)
+        opts = @options[:options] || []
+        opts = opts.call(item)  if opts.respond_to?(:call)
+
+        select = [ "<select id='#{h id}' name='#{h input_name}'>" ]
+        select+= opts.map { |opt|
+          opt = opt.flatten  if opt.is_a? Hash
+          key, text = opt
+          text ||= key
+
+          selected = ''
+          selected = " selected='selected'"  if val.to_s == key.to_s
+
+          "<option value='#{h key}'#{selected}>#{h text}</option>"
+        }
+        select+= [ "</select>" ]
+
+        select.join("\n")
+      end
+
+      def input_html_radio(val='', item=nil)
+        opts = @options[:options] || []
+        opts.map do |opt|
+          opt = opt.flatten  if opt.is_a? Hash
+          key, text = opt
+          text ||= key
+
+          selected = ''
+          selected = " selected='selected'"  if val.to_s == key.to_s
+
+          [ "<label for='#{h id}'>",
+            "<input type='radio' id='#{h id}' name='#{h input_name}' value='#{h key}'#{selected}>",
+            "<span>#{h text}</span>",
+            "</label>"
+          ]
+        end.flatten.join("\n")
+      end
+    end
+  end
+end