formidable 0.0.1

data/.gitignore

@@ -0,0 +1,10 @@
+*~
+.*.swp
+.#*
+
+.DS_Store
+.cache
+.yardoc
+
+/*.gem
+.bundle

data/CHANGELOG

@@ -0,0 +1,2 @@
+= Version 0.0.1
+  * Support for renderers

data/Gemfile

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+# gem "nokogiri"
+
+gem "nake"
+gem "rspec"
+gem "code-cleaner"

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Jakub Stastny aka Botanicus & Pavel Kunc
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,78 @@
+h1. About
+
+Formidable takes care about your forms. You write a class and
+
+* Get logic out of your views.
+* Get logic out of your controllers (presenter pattern).
+* Validations will work even if the form can't be mapped directly to the models.
+* You can unit test your forms directly without touching the template layer at all.
+
+* Validations
+* Coercions
+
+Forms contains quite complex logic which definitely shouldn't be in your views
+
+h2. Defining Forms
+
+h2. Saving Forms
+
+h2. Validations
+
+h2. Renderers
+
+h2. Custom Fields
+
+h2. Ideas
+
+JS validation plugin
+
+h1. Usage
+
+h2. Form Definitions
+
+<pre>
+
+</pre>
+
+h2. Controller Code
+
+<pre>
+class Posts
+  def new
+    @form ||= PostForm.new
+    @form.attributes[:method] = "POST"
+  end
+  
+  def edit
+    @form ||= PostForm.new
+    @form.attributes[:method] = "PUT"
+  end
+  
+  def create(raw_data)
+    @form = PostForm.new(nil, raw_data)
+    if @form.save
+      redirect url(:posts)
+    else
+      self.new
+    end
+  end
+  
+  def update(id, raw_data)
+    @form = PostForm.new(nil, raw_data)
+    if @form.update(id)
+      redirect url(:posts)
+    else
+      self.edit
+    end
+  end
+end
+</pre>
+
+You can find more examples at the @examples@ directory.
+
+h1. Links
+
+* "Source Code":http://github.com/botanicus/formidable
+* "Wiki":http://wiki.github.com/botanicus/formidable
+* "API Docs":http://rdoc.info/projects/botanicus/formidable
+* "Bug reporting":http://github.com/botanicus/formidable/issues

data/TODO.txt

@@ -0,0 +1,3 @@
+- code & specs
+- release 0.0.1
+- rubyflow, twitter

data/deps.rip

@@ -0,0 +1,5 @@
+#!/usr/bin/env rip install
+
+# Syntax:
+# repository [tag or commit to install]
+# git://github.com/botanicus/rubyexts.git

data/examples/basic.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+
+require "formidable"
+require "formidable/validations/presence"
+
+class BasicForm < Formidable::Elements::Form
+  def setup(&block)
+    text_field(:name, id: "basic_form-name")
+      .validate_presence
+      .coerce { |value| value.to_i }
+    
+    text_field(:rating, id: "basic_form-rating")
+      .validate_presence
+      .coerce(Integer)
+    
+    fieldset(:i_brake_it) do
+      legend("yyyy", id: 'xxx')
+      text_field(:nono, id: "nono").validate_presence
+    end
+    
+    group(:i_m_group) do
+      text_field(:groupa, id: 'xy')
+    end
+    block.call if block
+    submit("Save")
+  end
+  
+  def save
+    
+  end
+end
+
+class MyForm < BasicForm
+  def setup
+    super do
+      text_field(:super_duper, id: 'super_duper')
+    end
+  end
+end

data/examples/post.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+
+# text_field, text_area -> value = raw_data[key]
+# raw_data == user: {}, tags: [{name: "Ruby"}]
+# form = PostForm.new(@post.values, Author.all)
+class PostForm < Formidable::Form
+  namespace :post
+  def initialize(raw_data, authors)
+    super(raw_data)
+    @authors = authors
+  end
+
+  text_field(:title)
+    .validate_presence.
+  text_field(:title) do
+    validate_presence
+  end
+  
+  check_box(:published)
+  text_area
+  
+  group(:tydenni_menu) do
+    check_box :svickova
+    check_box :knedlo_zelo
+    validate do
+      self.fields.inject(0) do |sum, check_box|
+        sum += 1 if check_box.selected?
+        sum
+      end
+    end
+  end
+  
+  select(:author) do
+    @authors.each do |author|
+      option selected: (author == raw_data[:author])
+    end
+  end
+  
+  submit(value: "Save")
+  button(type: "submit") { "Save" }
+
+  field(:password, id: "sdf") do
+    validate_length (0..10)
+    validate do
+      form.password_confirmation == value
+    end
+  end
+
+  field(:password_confirmation) do
+    validate { form.password == value }
+  end
+  
+  fields_for(:author) do
+    field()
+  end
+  
+  # <fieldset>
+  # <legend>User</legend>
+  # </fieldset>
+  fieldset("User") do
+    field(:name)
+  end
+
+  field(:tags, id: -> { |tag| "tag-#{tag.id}"}, array: true)
+end

data/examples/posts/config.ru

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+class Posts
+  def self.dispatcher(action)
+    Proc.new do |env|
+      self.new(env).send(action)
+    end
+  end
+
+  def initialize(env)
+    @env = env
+  end
+
+  def index
+  end
+
+  def new
+    @form ||= PostForm.new
+    @form.attributes[:method] = "POST"
+  end
+  
+  def edit
+    @form ||= PostForm.new
+    @form.attributes[:method] = "PUT"
+  end
+  
+  def create(raw_data)
+    @form = PostForm.new(nil, raw_data)
+    if @form.save
+      redirect url(:posts)
+    else
+      self.new
+    end
+  end
+  
+  def update(id, raw_data)
+    @form = PostForm.new(nil, raw_data)
+    if @form.update(id)
+      redirect url(:posts)
+    else
+      self.edit
+    end
+  end
+end
+
+map("/posts") do
+  Posts.dispatcher(:index)
+end

data/examples/posts/form.html.haml

@@ -0,0 +1,19 @@
+/ You might not need to have a template for your form. In case you
+/ don't have any special need, just use form.render and that's it.
+
+/ Specify renderer you want to use.
+= form.errors.render(ErrorsListRenderer.new)
+
+/ Haml tags can take hash as an argument, so why not simply use form.attributes.
+%form{form.attributes}
+  / Render tags you want to display.
+  = form.post.title.render
+  / Iterate over elements
+  - form.post.tags.each do |tag|
+    = tag.render
+  / Or write fully customized HTML.
+  %label{for: "input-body"}
+  - if form.post.errors.on(:title)
+    %input#input-title.errors{name: "post[title]", value: form.post.title}
+  - else
+    %input#input-title{name: "post[title]", value: form.post.title}

data/examples/posts/models.rb

@@ -0,0 +1,7 @@
+# encoding: utf-8
+
+class Post < Sequel::Model
+end
+
+class Tag < Sequel::Model
+end

data/formidable.gemspec

@@ -0,0 +1,38 @@
+#!/usr/bin/env gem build
+# encoding: utf-8
+
+# Run ./form.gemspec or gem build form.gemspec
+# NOTE: we can't use require_relative because when we run gem build, it use eval for executing this file
+require File.expand_path("../lib/formidable/version", __FILE__)
+require "base64"
+
+Gem::Specification.new do |s|
+  s.name = "formidable"
+  s.version = Formidable::VERSION
+  s.authors = ["Jakub Stastny aka Botanicus", "Pavel Kunc"]
+  s.homepage = "http://github.com/botanicus/formidable"
+  s.summary = "" # TODO: summary
+  s.description = "" # TODO: long description
+  s.cert_chain = nil
+  s.email = Base64.decode64("c3Rhc3RueUAxMDFpZGVhcy5jeg==\n")
+  s.has_rdoc = true
+  
+  # files
+  s.files = `git ls-files`.split("\n")
+  
+  s.require_paths = ["lib"]
+  
+  # Ruby version
+  s.required_ruby_version = ::Gem::Requirement.new(">= 1.9")
+  
+  begin
+    require "changelog"
+  rescue LoadError
+    warn "You have to have changelog gem installed for post install message"
+  else
+    s.post_install_message = CHANGELOG.new.version_changes
+  end
+  
+  # RubyForge
+  s.rubyforge_project = "formidable"
+end

data/formidable.pre.gemspec

@@ -0,0 +1,8 @@
+#!/usr/bin/env gem build
+# encoding: utf-8
+
+# You might think this is a terrible mess and guess what, you're
+# right mate! However say thanks to authors of RubyGems, not me.
+eval(File.read("form.gemspec")).tap do |specification|
+  specification.version = "#{specification.version}.pre"
+end

data/lib/formidable.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+# TODO: linked list rather than arrays
+# plnenei dat
+
+require "formidable/elements"
+require "formidable/rendering"
+require "formidable/validations"
+require "formidable/renderers/string"

data/lib/formidable/coercions.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+module Formidable
+  module Coercions
+    MissingCoercion       = Class.new(StandardError)
+    IncompatibleInterface = Class.new(StandardError)
+
+    def self.coercions
+      @coercions ||= Hash.new do |hash, key|
+        raise MissingCoercion, "No coercion defined for #{key}"
+      end
+    end
+
+    # default coercions
+    coercions[:integer] = Proc.new { |value| value.to_i }
+    coercions[:float]   = Proc.new { |value| value.to_f }
+
+    def self.included(klass)
+      if ! klass.method_defined?(:raw_data) || ! klass.method_defined?(:cleaned_data=)
+        raise IncompatibleInterface, "You are supposed to define #{klass}#raw_data and #{klass}#cleaned_data= in order to get coercions running!"
+      end
+    end
+
+    def cleaned_data
+      @cleaned_data ||= self.coerce!
+    end
+
+    def coercions
+      @coercions ||= Array.new
+    end
+
+    def coerce(type = nil, &block)
+      if type && block.nil?
+        coercions << Coercions.coercions[type]
+      elsif type.nil? && block
+        coercions << block
+      else
+        raise ArgumentError, "provide block or type"
+      end
+    end
+
+    def coerce!
+      self.cleaned_data = begin
+        coercions.inject(self.raw_data) do |coercion, raw_data|
+          coercion.call(raw_data)
+        end
+      end
+    end
+  end
+end

data/lib/formidable/elements.rb

@@ -0,0 +1,196 @@
+# encoding: utf-8
+
+require "formidable/coercions"
+require "formidable/rendering"
+require "formidable/validations"
+require "formidable/renderers/string"
+
+module Formidable
+  module Elements
+    class Element
+      include Rendering
+      include Validations
+      include Coercions
+
+      attr_accessor :name, :raw_data, :content
+      attr_reader :attributes
+
+      def initialize(name, attributes = Hash.new, raw_data = nil)
+        @name, @attributes, @raw_data = name, attributes, raw_data
+        @attributes.merge!(name: name, value: raw_data)
+      end
+      
+      def set_raw_data(raw_data)
+        @raw_data = self.attributes[:value] = raw_data
+      end
+    end
+
+    class ElementList < Element # pro form, group, fieldset
+      # We had a few beers and we decided that this is pretty cool :)
+      # This will define DSL method for creating email_field
+      # @example Formidable::ElementList.register self, :email_field
+      def self.register(klass, method_name)
+        define_method(method_name) do |name, *args, &block|
+          element = klass.new(name, *args, &block)
+          elements << element
+          warn "Overriding method #{name}" if self.class.method_defined?(name)
+          self.class.send(:define_method, name) do
+            element
+          end
+          element
+        end
+      end
+
+      include GroupValidations
+      def initialize(*args, &block)
+        super(*args) # we need to get elements first
+        self.instance_eval(&block) if block
+      end
+
+      def elements
+        @elements ||= Array.new
+      end
+
+      def cleaned_data
+        self.elements.inject(Hash.new) do |result, element|
+          result[element.name] = element.cleaned_data
+          result
+        end
+      end
+
+      def raw_data
+        self.elements.inject(Hash.new) do |result, element|
+          result[element.name] = element.raw_data
+          result
+        end
+      end
+
+      protected
+      def set_raw_data(raw_data)
+        self.elements.each do |element|
+          element.set_raw_data(raw_data[element.name]) if raw_data
+        end
+      end
+    end
+
+    class Form < ElementList
+      renderer Renderers::Form
+
+      # TODO: prefix should be in the form definition (name or namespace)
+      def initialize(prefix = nil, attributes = Hash.new, raw_data = nil)
+        self.setup
+        super(prefix, attributes, raw_data)
+        set_raw_data(raw_data)
+      end
+
+      def setup
+        raise NotImplementedError, "You are supposed to redefine the setup method in subclasses of Element!"
+      end
+
+      def save(*args)
+        raise NotImplementedError, "You have to redefine this method in subclasses!"
+      end
+      alias_method :save!, :save
+
+      def update(*args)
+        raise NotImplementedError, "You have to redefine this method in subclasses!"
+      end
+      alias_method :update!, :update
+    end
+    
+
+    class TextField < Element
+      ElementList.register(self, :text_field)
+
+      def initialize(name, attributes = Hash.new, raw_data = nil)
+        super(name, attributes.merge!(type: "text"), raw_data)
+      end
+
+      renderer Renderers::LabeledInputRenderer
+    end
+
+    class TextArea < Element
+      ElementList.register(self, :text_area)
+
+      renderer Renderers::LabeledInputRenderer
+    end
+
+    class HiddenField < Element
+      ElementList.register(self, :hidden_field)
+
+      renderer Renderers::LabeledInputRenderer
+    end
+
+    class Submit < Element
+      ElementList.register(self, :submit)
+
+      renderer Renderers::SimpleInputRenderer
+
+      def initialize(value = "Submit", attributes = Hash.new, raw_data = Hash.new)
+        super(:submit, attributes.merge(value: value, type: "submit"), raw_data)
+      end
+    end
+
+    class Button < Element
+      ElementList.register(self, :button)
+
+      renderer Renderers::Button
+    end
+
+    class Group < ElementList
+      ElementList.register(self, :group)
+
+      renderer Renderers::Group
+    end
+
+    class Fieldset < ElementList
+      ElementList.register(self, :fieldset)
+
+      renderer Renderers::Fieldset
+    end
+
+    class Legend < Element
+      Fieldset.register(self, :legend)
+
+      renderer Renderers::SimpleTagRenderer
+
+      def initialize(content, attributes = Hash.new)
+        self.content = content
+        super(:legend, attributes)
+      end
+    end
+    
+    class FileField < Element
+      ElementList.register(self, :file_field)
+
+      renderer Renderers::LabeledInputRenderer
+
+      def initialize(*args)
+        super(*args)
+        self.form.multipart = true
+      end
+    end
+
+    class EmailField < TextField
+      ElementList.register(self, :email_field)
+    end
+
+    # zna to svoje name => vi kde v params to najit
+    # {date: "27-07-2010"} => {date: #<Date:x0>}
+    class DateSelectField < Element
+      # TOHLE BUDE V SUPERCLASS
+      # jak to ma dostat params?
+      def deserialize
+        # [:post, :title]
+        self.name.inject(params) do |hash, key|
+          hash[key]
+        end
+      end
+
+      # TOHLE BUDE TADY
+      def deserialize
+        Date.new(super)
+      end
+    end
+  end
+end