formidable 0.0.1 → 0.1

data/.gitignore

@@ -8,3 +8,5 @@
 
 /*.gem
 .bundle
+
+.rvmrc

data/formidable.gemspec

@@ -14,17 +14,17 @@ Gem::Specification.new do |s|
   s.summary = "" # TODO: summary
   s.description = "" # TODO: long description
   s.cert_chain = nil
-  s.email = Base64.decode64("c3Rhc3RueUAxMDFpZGVhcy5jeg==\n")
+  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
@@ -32,7 +32,7 @@ Gem::Specification.new do |s|
   else
     s.post_install_message = CHANGELOG.new.version_changes
   end
-  
+
   # RubyForge
   s.rubyforge_project = "formidable"
 end

data/lib/formidable/elements.rb

@@ -1,49 +1,65 @@
 # 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
+    class BasicElement
+      attr_accessor :tag, :name, :raw_data, :content
+      attr_writer :cleaned_data
       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)
+      include Rendering
+
+      def initialize(tag, name, attributes = Hash.new, raw_data = nil)
+        @tag, @name, @attributes = tag, name, attributes
+        @attributes.merge!(name: name) if name
+        self.raw_data = raw_data if raw_data
       end
-      
-      def set_raw_data(raw_data)
-        @raw_data = self.attributes[:value] = raw_data
+
+      def cleaned_data
+        @cleaned_data || self.raw_data
       end
     end
 
-    class ElementList < Element # pro form, group, fieldset
+    require "formidable/coercions"
+    require "formidable/validations"
+
+    class Element < BasicElement
+      include Validations
+      include Coercions
+    end
+
+    class ElementList < BasicElement # 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)
+        define_method(method_name) do |*args, &block|
+          element = klass.new(*args, &block)
           elements << element
-          warn "Overriding method #{name}" if self.class.method_defined?(name)
-          self.class.send(:define_method, name) do
-            element
+          unless element.name.nil?
+            if self.class.method_defined?(element.name)
+              warn "Overriding method #{element.name}"
+            end
+            self.class.send(:define_method, element.name) do
+              element
+            end
           end
           element
         end
       end
 
       include GroupValidations
-      def initialize(*args, &block)
-        super(*args) # we need to get elements first
+
+      # This is pretty much just a copy of Element#initialize, it's because
+      # if we'd use super, then the Element#raw_data=(raw_data) would be called,
+      # but we actually need to trigger the ElementList#raw_data=(raw_data).
+      def initialize(tag, name, attributes = Hash.new, raw_data = nil, &block)
+        @tag, @name, @attributes = tag, name, attributes
+        @attributes.merge!(name: name) if name
+        self.raw_data = raw_data if raw_data
         self.instance_eval(&block) if block
       end
 
@@ -51,24 +67,52 @@ module Formidable
         @elements ||= Array.new
       end
 
-      def cleaned_data
+      def content
+        self.elements.inject(String.new) do |buffer, element|
+          buffer += "\n" + element.render
+        end
+      end
+
+      def raw_data
         self.elements.inject(Hash.new) do |result, element|
-          result[element.name] = element.cleaned_data
+          if element.name && element.raw_data
+            result[element.name] = element.raw_data
+          end
           result
         end
       end
 
-      def raw_data
+      def raw_data=(raw_data)
+        return if raw_data.nil?
+        raw_data.each do |key, value|
+          element = self.send(key)
+          element.raw_data = value
+        end
+      end
+
+      def cleaned_data
         self.elements.inject(Hash.new) do |result, element|
-          result[element.name] = element.raw_data
+          if element.name && element.raw_data
+            result[element.name] = element.cleaned_data
+          end
           result
         end
       end
 
-      protected
-      def set_raw_data(raw_data)
+      # TODO: this should be done dynamically, something like:
+      # def name
+      #   self.parent.name + @name
+      # end
+      def set_prefix(prefix)
         self.elements.each do |element|
-          element.set_raw_data(raw_data[element.name]) if raw_data
+          if element.respond_to?(:elements) && element.name
+            element.set_prefix("#{prefix}[#{element.name}]")
+          end
+          if element.attributes[:name]
+            element.attributes[:name] = begin
+              "#{prefix}[#{element.attributes[:name]}]"
+            end
+          end
         end
       end
     end
@@ -77,10 +121,11 @@ module Formidable
       renderer Renderers::Form
 
       # TODO: prefix should be in the form definition (name or namespace)
-      def initialize(prefix = nil, attributes = Hash.new, raw_data = nil)
+      def initialize(action, method = "POST", prefix = nil, attributes = Hash.new, raw_data = nil)
         self.setup
-        super(prefix, attributes, raw_data)
-        set_raw_data(raw_data)
+        super(:form, nil, attributes.merge!(action: action, method: method), raw_data)
+        set_prefix(prefix) if prefix
+        self.raw_data = raw_data
       end
 
       def setup
@@ -97,9 +142,18 @@ module Formidable
       end
       alias_method :update!, :update
     end
-    
 
-    class TextField < Element
+    class Input < Element
+      def initialize(name, attributes = Hash.new, raw_data = nil)
+        super(:input, name, attributes, raw_data)
+      end
+
+      def raw_data=(raw_data)
+        self.attributes[:value] = super(raw_data)
+      end
+    end
+
+    class TextField < Input
       ElementList.register(self, :text_field)
 
       def initialize(name, attributes = Hash.new, raw_data = nil)
@@ -112,29 +166,46 @@ module Formidable
     class TextArea < Element
       ElementList.register(self, :text_area)
 
-      renderer Renderers::LabeledInputRenderer
+      renderer Renderers::SimpleTagRenderer
+
+      def initialize(*args, &block)
+        super(:textarea, *args, &block)
+      end
+
+      def raw_data=(raw_data)
+        @raw_data = self.content = raw_data
+      end
     end
 
-    class HiddenField < Element
+    class HiddenField < Input
       ElementList.register(self, :hidden_field)
 
-      renderer Renderers::LabeledInputRenderer
+      renderer Renderers::SimpleInputRenderer
+
+      def initialize(name, attributes = Hash.new, raw_data = nil)
+        super(name, attributes.merge!(type: "hidden"), raw_data)
+      end
     end
 
-    class Submit < Element
+    class Submit < Input
       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)
+      def initialize(value = "Submit", attributes = Hash.new)
+        super(nil, attributes.merge(value: value, type: "submit"))
       end
     end
 
     class Button < Element
       ElementList.register(self, :button)
 
-      renderer Renderers::Button
+      renderer Renderers::SimpleTagRenderer
+
+      def initialize(attributes = Hash.new, &block)
+        self.content = block.call
+        super(:button, nil, attributes)
+      end
     end
 
     class Group < ElementList
@@ -159,20 +230,94 @@ module Formidable
         super(:legend, attributes)
       end
     end
-    
-    class FileField < Element
+
+    class FileField < Input
       ElementList.register(self, :file_field)
 
       renderer Renderers::LabeledInputRenderer
 
-      def initialize(*args)
-        super(*args)
+      def initialize(name, attributes = Hash.new)
+        super(name, attributes.merge!(type: "file"))
         self.form.multipart = true
       end
     end
 
-    class EmailField < TextField
+    class EmailField < Input
       ElementList.register(self, :email_field)
+
+      renderer Renderers::LabeledInputRenderer
+
+      def initialize(name = :email, attributes = Hash.new, raw_data = nil)
+        super(name, attributes.merge!(type: "email"), raw_data)
+      end
+    end
+
+    class PasswordField < Input
+      ElementList.register(self, :password_field)
+
+      renderer Renderers::LabeledInputRenderer
+
+      def initialize(name = :password, attributes = Hash.new)
+        super(name, attributes.merge!(type: "password"))
+      end
+    end
+
+    class Select < ElementList
+      include Validations # for validations purposes it behaves just as an element # TODO: doesn't workf
+      # The reason is simple, Validations are already included in GroupValidations, so it doesn't really include the mixin here
+
+      ElementList.register(self, :select)
+
+      renderer Renderers::SimpleTagRenderer
+
+      def initialize(name, attributes = Hash.new, &block)
+        super(:select, name, attributes, &block)
+      end
+
+      def selected
+        self.elements.find do |element|
+          element.attributes[:selected]
+        end
+      end
+
+      def raw_data
+        self.selected.raw_data if self.selected
+      end
+
+      def raw_data=(raw_data)
+        if raw_data.nil?
+          self.selected.attributes.delete(:selected)
+        else
+          self.elements.find do |element|
+            if element.raw_data == raw_data
+              element.attributes[:selected] = true
+            end
+          end
+        end
+      end
+
+      def cleaned_data
+        self.selected && self.selected.cleaned_data
+      end
+    end
+
+    class Option < Element
+      Select.register(self, :option)
+
+      renderer Renderers::SimpleTagRenderer
+
+      def initialize(value, attributes = Hash.new, &block)
+        self.content = block.call
+        super(:option, nil, attributes.merge!(value: value))
+      end
+
+      def raw_data
+        @raw_data ||= self.attributes[:value]
+      end
+
+      def cleaned_data
+        @cleaned_data ||= self.raw_data
+      end
     end
 
     # zna to svoje name => vi kde v params to najit

data/lib/formidable/renderers/string.rb

@@ -10,7 +10,7 @@ module Formidable
       end
 
       def tag(name, attributes = nil, &block)
-        "<#{name}#{hash_to_attributes_string(attributes) if attributes}>#{"\n#{block.call}\n" if block}</#{name}>"
+        "<#{name}#{hash_to_attributes_string(attributes) if attributes}>#{block.call if block}</#{name}>"
       end
 
       def self_close_tag(name, attributes = nil)
@@ -25,7 +25,9 @@ module Formidable
       def hash_to_attributes_string(hash)
         hash.inject("") do |buffer, pair|
           attribute, value = pair
-          if value
+          if value == true
+            buffer += " #{attribute}"
+          elsif value
             buffer += " #{attribute}='#{value}'" # TODO: h(value)
           end
           buffer
@@ -41,25 +43,24 @@ module Formidable
 
     class SimpleTagRenderer < Renderer
       def render
-        tag(element.name, element.attributes) { element.content } + "\n"
+        tag(element.tag, element.attributes) { element.content }
       end
     end
 
-    class LabeledInputRenderer < SimpleInputRenderer
+    class LongTagRenderer < SimpleTagRenderer
       def render
-        id = element.attributes[:id]
-        raise "You have to provide id attribute if you want to use LabeledInputRenderer!" if id.nil?
-        buffer = tag(:label, for: id) { element.attributes[:title] } + "\n"
-        buffer + super
+        super + "\n"
       end
     end
 
-    class Button < SimpleInputRenderer
+    class LabeledInputRenderer < SimpleInputRenderer
       def render
-        tag(:button, element.attributes)
+        id = element.attributes[:id] || (element.attributes[:id] = "random-#{element.object_id}")
+        buffer = tag(:label, for: id) { element.attributes[:title] || element.attributes[:placeholder] } + "\n"
+        buffer + super
       end
     end
-    
+
     class Fieldset < SimpleInputRenderer
       def render
         tag(:fieldset) do
@@ -83,20 +84,27 @@ module Formidable
         end.join("\n")
       end
     end
-    
+
     class Form < Renderer
-      def render
+      # = form.render
+      # = form.render do
+      #   %div= form.submit
+      def render(&block)
         if method = element.attributes[:method]
           set_method(method)
         end
 
-        tag(:form, element.attributes) do
-          element.elements.map do |element|
-            element.render
-          end.join("\n")
+        block ||= begin
+          Proc.new do
+            element.elements.map do |element|
+              element.render
+            end.join("\n")
+          end
         end
+
+        tag(:form, element.attributes, &block)
       end
-      
+
       protected
       def set_method(method)
         if method

data/lib/formidable/validations.rb

@@ -17,19 +17,15 @@ module Formidable
     alias_method :add, :[]=
   end
 
-  module Elements
-    class Element
-      def self.register_validation(klass, method_name) # TODO: pridavat to spis do validations mixinu nez primo do elementu
-        define_method(method_name) do |*args, &block|
-          validation = klass.new(self, *args, &block)
-          validations << validation
-          self
-        end
+  module Validations
+    def self.register_validation(klass, method_name)
+      define_method(method_name) do |*args, &block|
+        validation = klass.new(self, *args, &block)
+        validations << validation
+        self
       end
     end
-  end
 
-  module Validations
     def errors
       @errors ||= Array.new
     end
@@ -39,10 +35,11 @@ module Formidable
     end
 
     def valid?
-      @errors || self.validate
+      self.validate
     end
 
     def validate
+      self.errors.clear
       self.validations.inject(true) do |is_valid, validation|
         validation_passed = validation.valid?
         unless validation_passed
@@ -54,15 +51,31 @@ module Formidable
   end
 
   module GroupValidations # TODO: better name
-    include Validations
+    def self.register_validation(klass, method_name)
+      define_method(method_name) do |*args, &block|
+        validation = klass.new(self, *args, &block)
+        validations << validation
+        self
+      end
+    end
+
     def errors
       @errors ||= Errors.new
     end
 
+    def validations
+      @validations ||= Array.new
+    end
+
+    def valid?
+      self.validate
+    end
+
     def before_validate
     end
 
     def validate
+      self.errors.clear
       self.before_validate
       self.elements.each do |element|
         unless element.valid?
@@ -75,7 +88,8 @@ module Formidable
 
   class Validations::Validation
     def self.register(method_name)
-      Elements::Element.register_validation(self, method_name)
+      Validations.register_validation(self, method_name)
+      GroupValidations.register_validation(self, method_name)
     end
 
     attr_reader :element

data/lib/formidable/validations/confirmation.rb

@@ -12,7 +12,7 @@ module Formidable
     class ValidateConfirmation < Validation
       register(:validate_confirmation)
 
-      def initialize(element, confirmation_field, &block)
+      def initialize(element, confirmation_field = nil, &block)
         set_confirmation_field(confirmation_field, block)
         super(element)
       end
@@ -22,13 +22,13 @@ module Formidable
       end
 
       def message
-        "can't be empty"
+        "has to match #{@confirmation_field.name}"
       end
 
       protected
       def set_confirmation_field(field, callable)
         @confirmation_field = begin
-          if field && callable.nil
+          if field && callable.nil?
             field
           elsif field.nil? && callable
             callable.call
@@ -41,18 +41,18 @@ module Formidable
   end
 end
 
-module Validatable
-  class ValidatesConfirmationOf < ValidationBase #:nodoc:
-    option :case_sensitive
-    default :case_sensitive => true
-    
-    def valid?(instance)
-      return instance.send(self.attribute) == instance.send("#{self.attribute}_confirmation".to_sym) if case_sensitive
-      instance.send(self.attribute).to_s.casecmp(instance.send("#{self.attribute}_confirmation".to_sym).to_s) == 0
-    end
-    
-    def message(instance)
-      super || "doesn't match confirmation"
-    end
-  end
-end
+# module Validatable
+#   class ValidatesConfirmationOf < ValidationBase #:nodoc:
+#     option :case_sensitive
+#     default :case_sensitive => true
+#
+#     def valid?(instance)
+#       return instance.send(self.attribute) == instance.send("#{self.attribute}_confirmation".to_sym) if case_sensitive
+#       instance.send(self.attribute).to_s.casecmp(instance.send("#{self.attribute}_confirmation".to_sym).to_s) == 0
+#     end
+#
+#     def message(instance)
+#       super || "doesn't match confirmation"
+#     end
+#   end
+# end

data/lib/formidable/validations/presence.rb

@@ -5,6 +5,15 @@ module Formidable
     class ValidatePresence < Validation
       register(:validate_presence)
 
+      def initialize(*args)
+        super(*args)
+
+        # HTML 5
+        unless element.attributes.has_key?(:required)
+          element.attributes[:required] = true
+        end
+      end
+
       def valid?
         ! element.cleaned_data.nil?
       end

data/lib/formidable/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Formidable
-  VERSION = "0.0.1"
+  VERSION = "0.1"
 end

metadata

@@ -4,9 +4,8 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 0
   - 1
-  version: 0.0.1
+  version: "0.1"
 platform: ruby
 authors: 
 - Jakub Stastny aka Botanicus
@@ -14,12 +13,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: 
-date: 2010-03-30 00:00:00 +01:00
+date: 2010-11-03 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
 description: ""
-email: stastny@101ideas.cz
+email: 
 executables: []
 
 extensions: []
@@ -76,12 +75,13 @@ has_rdoc: true
 homepage: http://github.com/botanicus/formidable
 licenses: []
 
-post_install_message: "[\e[32mVersion 0.0.1\e[0m] Support for renderers\n"
+post_install_message: 
 rdoc_options: []
 
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
@@ -90,6 +90,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       - 9
       version: "1.9"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
@@ -99,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: formidable
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: ""