formalize 0.0.1

data/lib/formalize/field.rb

@@ -0,0 +1,159 @@
+require 'uri'
+require "formalize/helpers"
+
+class BasicField
+  include Helpers
+
+  def initialize(id, opts={})
+    @errors = []
+    @opts = opts
+    @opts[:name] = id
+  end
+
+  def input(attrs = @opts)
+    input = tag(:input, attrs)
+    attrs[:label] ? tag_content(:label, "#{ attrs[:label] } #{ input }") : input
+  end
+
+  def errors
+    # REVIEW: What gets returned when @errors is empty?
+    unless @errors.empty?
+      list_items = @errors.collect { |error| tag_content(:li, error)}.join("\n")
+      tag_content(:ul, list_items)
+    end
+  end
+
+  def errors=(message)
+    @errors.push(message)
+  end
+
+  def value
+    @opts[:value]
+  end
+
+  def value=(val)
+    @opts[:value] = val
+  end
+
+  def valid?
+    @errors.empty?
+  end
+
+  def validate
+    validate_presence if @opts.has_key?(:required)
+    validate_length if @opts.has_key?(:maxlength)
+    unless @opts[:value].nil? || @opts[:value].is_a?(Array) || @opts[:value].strip.empty?
+      validate_format if @opts.has_key?(:pattern)
+    end
+  end
+
+  def validate_presence
+    if @opts[:required] == true && @opts[:value].strip.empty?
+      @errors << "#{ @opts[:name].capitalize } must not be blank"
+    end
+  end
+
+  def validate_length
+    if @opts[:value].size > @opts[:maxlength].to_i
+      @errors << "#{ @opts[:name].capitalize } must not be more than #{ @opts[:maxlength] } characters long"
+    end
+  end
+
+  def validate_format
+    re = Regexp.new(@opts[:pattern])
+    unless  re =~ @opts[:value]
+      @errors << "#{ @opts[:name].capitalize } must be in a valid format"
+    end
+  end
+
+end
+
+class TextField < BasicField
+  def initialize(id, opts={})
+    super
+    @opts[:type] = :text
+  end
+end
+
+class EmailField < BasicField
+  def initialize(id, opts={})
+    super
+    @opts[:type] = :email
+    @opts[:pattern] ||= /^[^@]+@[^@]+\.[a-zA-Z]{2,6}$/
+  end
+end
+
+class UrlField < BasicField
+  def initialize(id, opts={})
+    super
+    @opts[:type] = :url
+    # REVIEW: The HTML this renders isn't great. Maybe only apply this on post?
+    @opts[:pattern] ||= /^#{URI::regexp(['http', 'https'])}$/
+  end
+end
+
+class TextareaField < BasicField
+  def initialize(id, opts={})
+    super
+    @opts[:type] = :textarea
+  end
+  def input(attrs = @opts)
+    value = attrs.delete(:value)
+    input = tag_content(:textarea, value, attrs)
+    attrs[:label] ? tag_content(:label, "#{ attrs[:label] } #{ input }") : input
+  end
+end
+
+class RadioField < BasicField
+  attr_accessor :opts
+  def initialize(id, opts={})
+    super
+    @opts[:type] = :radio
+  end
+end
+
+class CheckboxField < BasicField
+  attr_accessor :opts
+  def initialize(id, opts={})
+    super
+    @opts[:type] = :checkbox
+  end
+  def input
+    attrs = @opts.dup
+    attrs[:name] = attrs[:name].to_s << '[]'
+    super(attrs)
+  end
+end
+
+class Group < BasicField
+  def initialize(id, &block)
+    super
+    @choices = []
+    instance_eval(&block)
+  end
+  def input
+    @choices.collect { |choice| choice.input }.join("\n")
+  end
+end
+
+class RadioGroup < Group
+  def choice(value, choice_opts={})
+    choice_opts[:value] = value
+    @choices.push(RadioField.new(@opts[:name], choice_opts))
+  end
+  def value=(val)
+    @opts[:value] = val
+    @choices.each { |choice| choice.opts[:checked] = (choice.opts[:value] === val.to_sym) }
+  end
+end
+
+class CheckboxGroup < Group
+  def choice(value, choice_opts={})
+    choice_opts[:value] = value
+    @choices.push(CheckboxField.new(@opts[:name], choice_opts))
+  end
+  def value=(values)
+    @opts[:value] = values
+    @choices.each { |choice| choice.opts[:checked] = (values.include?(choice.opts[:value].to_s)) }
+  end
+end

data/lib/formalize/helpers.rb

@@ -0,0 +1,35 @@
+module Helpers
+
+  # TODO: This leaves a extra space when there are no attributes
+  def tag(name, opts = {})
+    attributes = tag_attributes(opts)
+    "<#{ name } #{ attributes }>"
+  end
+
+  # TODO: This leaves a extra space when there are no attributes
+  def tag_content(name, content, opts = {})
+    attributes = tag_attributes(opts)
+    "<#{ name } #{ attributes }>#{ content }</#{ name }>"
+  end
+
+  def tag_attributes(opts)
+    opts.sort.collect do |key, val|
+      next if key == :label  # REVIEW: Move to a NonStandardAttributes constant?
+      case val
+      when TrueClass
+        "#{ key }"
+      when FalseClass
+        ""
+      when Array
+        # REVIEW Comma or no comma? Not sure what attributes this could be used with
+        "#{ key }='#{ val.join(',') }'"
+      when Regexp
+        pattern = val.inspect[1..-2]
+        "#{ key }='#{ pattern }'"
+      else
+        "#{ key }='#{ val }'"
+      end
+    end.join(' ').squeeze(' ')
+  end
+
+end

data/lib/formalize/version.rb

@@ -0,0 +1,3 @@
+module Formalize
+  VERSION = "0.0.1"
+end

data/lib/formalize.rb

@@ -0,0 +1,59 @@
+require "formalize/version"
+require "formalize/field"
+
+module Form
+
+  def text(id, opts={})
+    @fields ||= {}
+    @fields[id] = TextField.new(id, opts)
+  end
+
+  def email(id, opts={})
+    @fields ||= {}
+    @fields[id] = EmailField.new(id, opts)
+  end
+
+  def url(id, opts={})
+    @fields ||= {}
+    @fields[id] = UrlField.new(id, opts)
+  end
+
+  def textarea(id, opts={})
+    @fields ||= {}
+    @fields[id] = TextareaField.new(id, opts)
+  end
+
+  def radio(id, &block)
+    @fields ||= {}
+    @fields[id] = RadioGroup.new(id, &block)
+  end
+
+  def checkbox(id, &block)
+    @fields ||= {}
+    @fields[id] = CheckboxGroup.new(id, &block)
+  end
+
+  def option(val, opts={})
+  end
+
+  def fill(params)
+    @fields.each do |id, field|
+      field.value = params[id.to_s] unless params[id.to_s].nil?
+      field.validate
+    end
+    self
+  end
+
+  def valid?
+    @fields.values.all? { |field| field.valid? }
+  end
+
+  def [](id)
+    @fields[id]
+  end
+
+  def to_s
+    @fields.values.collect { |field| "#{ field.errors }\n<p>#{ field.input }</p>\n" }.join.squeeze("\n").strip
+  end
+
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: formalize
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Alex Edwards
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-22 00:00:00.000000000 Z
+dependencies: []
+description: This is a very basic (and untested!) RubyGem to simplify web form creation,
+  validation and processing. It is designed for use with the Sinatra framework.
+email:
+- ajmedwards@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/formalize/field.rb
+- lib/formalize/version.rb
+- lib/formalize/helpers.rb
+- lib/formalize.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Form processing and validation for Sinatra.
+test_files: []