formidable 0.0.1

data/lib/formidable/renderers/nokogiri.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+begin
+  require "nokogiri"
+rescue LoadError
+  raise LoadError, "You have to install nokogiri gem if you want to use nokogiri renderer!"
+end
+
+module Formidable
+  module Renderers
+    class Nokogiri < Renderer
+      register(Form) do |element|
+        raise NotImplemented, "We'll implement the renderer soon"
+      end
+
+      register(Elements::TextField) do |element|
+        raise NotImplemented, "We'll implement the renderer soon"
+      end
+
+      register(Elements::TextArea) do |element|
+        raise NotImplemented, "We'll implement the renderer soon"
+      end
+
+      register(Elements::HiddenField) do |element|
+        raise NotImplemented, "We'll implement the renderer soon"
+      end
+
+      register(Elements::Submit) do |element|
+        raise NotImplemented, "We'll implement the renderer soon"
+      end
+
+      register(Elements::Button) do |element|
+        raise NotImplemented, "We'll implement the renderer soon"
+      end
+      
+      register(Elements::Group) do |element|
+        raise NotImplemented, "We'll implement the renderer soon"
+      end
+      
+      register(Elements::Fieldset) do |element|
+        raise NotImplemented, "We'll implement the renderer soon"
+      end
+      
+      register(Elements::FileField) do |element|
+        raise NotImplemented, "We'll implement the renderer soon"
+      end
+      
+      register(Elements::EmailField) do |element|
+        raise NotImplemented, "We'll implement the renderer soon"
+      end
+    end
+  end
+end

data/lib/formidable/renderers/string.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+
+# TODO: support for errors (validate before render)
+module Formidable
+  module Renderers
+    class Renderer
+      attr_reader :element
+      def initialize(element)
+        @element = element
+      end
+
+      def tag(name, attributes = nil, &block)
+        "<#{name}#{hash_to_attributes_string(attributes) if attributes}>#{"\n#{block.call}\n" if block}</#{name}>"
+      end
+
+      def self_close_tag(name, attributes = nil)
+        "<#{name}#{hash_to_attributes_string(attributes) if attributes} />"
+      end
+
+      def render
+        raise NotImplementedError, "You are supposed to redefine #render method in subclasses of Renderer"
+      end
+
+      protected
+      def hash_to_attributes_string(hash)
+        hash.inject("") do |buffer, pair|
+          attribute, value = pair
+          if value
+            buffer += " #{attribute}='#{value}'" # TODO: h(value)
+          end
+          buffer
+        end
+      end
+    end
+
+    class SimpleInputRenderer < Renderer
+      def render
+        self_close_tag(:input, element.attributes) + "\n"
+      end
+    end
+
+    class SimpleTagRenderer < Renderer
+      def render
+        tag(element.name, element.attributes) { element.content } + "\n"
+      end
+    end
+
+    class LabeledInputRenderer < SimpleInputRenderer
+      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
+      end
+    end
+
+    class Button < SimpleInputRenderer
+      def render
+        tag(:button, element.attributes)
+      end
+    end
+    
+    class Fieldset < SimpleInputRenderer
+      def render
+        tag(:fieldset) do
+          element.elements.map do |element|
+            element.render
+          end.join("\n")
+        end
+      end
+    end
+
+    class Blank < Renderer
+      def render
+        ""
+      end
+    end
+
+    class Group < Renderer
+      def render
+        element.elements.map do |element|
+          element.render
+        end.join("\n")
+      end
+    end
+    
+    class Form < Renderer
+      def render
+        if method = element.attributes[:method]
+          set_method(method)
+        end
+
+        tag(:form, element.attributes) do
+          element.elements.map do |element|
+            element.render
+          end.join("\n")
+        end
+      end
+      
+      protected
+      def set_method(method)
+        if method
+          if ["GET", "POST"].include?(method)
+            element.attributes[:method] = method
+          elsif ["PUT", "DELETE"].include?(method)
+            element.attributes[:method] = "POST"
+            hidden_field(:_method, value: method)
+          else
+            raise ArgumentError, "Method can be GET, POST, PUT or DELETE, but not #{method}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/formidable/rendering.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module Formidable
+  module Rendering
+    RendererNotAssigned = Class.new(StandardError)
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+      klass.extend Module.new {
+        def inherited(subclass)
+          subclass.renderer(default_renderer)
+        end
+      }
+    end
+
+    attr_writer :renderer
+    def renderer
+      @renderer ||= begin
+        renderer = self.class.default_renderer
+        renderer.new(self) unless renderer.nil?
+      end
+    end
+
+    def render
+      if renderer.nil?
+        raise RendererNotAssigned, "You have to assign renderer. You can set default_renderer via #{self.class}.renderer(renderer_class) or you can set renderer per instance via #renderer=(renderer_instance) method."
+      elsif renderer && ! renderer.respond_to?(:render)
+        raise RendererNotAssigned, "You assigned #{self.renderer.inspect} to the #{self.inspect}, but it doesn't respond to #render method"
+      else
+        renderer.render
+      end
+    end
+
+    module ClassMethods
+      attr_reader :default_renderer
+
+      def renderer(default_renderer)
+        @default_renderer = default_renderer
+      end
+    end
+  end
+end

data/lib/formidable/validations.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+
+=begin rdoc
+  Co musi validace delat:
+    - mixin s instancnima metodama:
+      - errors
+      - validations
+      - valid?
+      - validate
+    - mixin s makrama (taky instancni metody)
+    - vlastni validacni klasy
+=end
+
+module Formidable
+  class Errors < Hash
+    alias_method :on,  :[]
+    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
+      end
+    end
+  end
+
+  module Validations
+    def errors
+      @errors ||= Array.new
+    end
+
+    def validations
+      @validations ||= Array.new
+    end
+
+    def valid?
+      @errors || self.validate
+    end
+
+    def validate
+      self.validations.inject(true) do |is_valid, validation|
+        validation_passed = validation.valid?
+        unless validation_passed
+          self.errors.push(validation.message)
+        end
+        is_valid && validation_passed
+      end
+    end
+  end
+
+  module GroupValidations # TODO: better name
+    include Validations
+    def errors
+      @errors ||= Errors.new
+    end
+
+    def before_validate
+    end
+
+    def validate
+      self.before_validate
+      self.elements.each do |element|
+        unless element.valid?
+          errors[element.name] = element.errors
+        end
+      end
+      self.errors.empty?
+    end
+  end
+
+  class Validations::Validation
+    def self.register(method_name)
+      Elements::Element.register_validation(self, method_name)
+    end
+
+    attr_reader :element
+    def initialize(element)
+      @element = element
+    end
+
+    def valid?
+      raise NotImplementedError, "You have to redefine #valid? in subclasses of the Validation class"
+    end
+
+    def message
+      raise NotImplementedError, "You have to redefine #message in subclasses of the Validation class"
+    end
+  end
+end

data/lib/formidable/validations/class.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+# validate_class Fixnum
+# validate_class Numeric
+module Formidable
+  module Validations
+    class ValidateClass < Validation
+      register(:validate_class)
+
+      def initialize(element, klass)
+        @klass = klass
+        super(element)
+      end
+
+      def valid?
+        element.cleaned_data.is_a?(@klass)
+      end
+
+      def message
+        "can't be empty"
+      end
+    end
+  end
+end

data/lib/formidable/validations/confirmation.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+# NOTE: this could be done via validate_equality with block as well
+# confirmation = text_field(:password_confirmation)
+# text_field(:password).validate_confirmation(confirmation)
+
+# text_field(:password).validate_confirmation do
+#   text_field(:password_confirmation)
+# end
+module Formidable
+  module Validations
+    class ValidateConfirmation < Validation
+      register(:validate_confirmation)
+
+      def initialize(element, confirmation_field, &block)
+        set_confirmation_field(confirmation_field, block)
+        super(element)
+      end
+
+      def valid?
+        @confirmation_field.cleaned_data == element.cleaned_data
+      end
+
+      def message
+        "can't be empty"
+      end
+
+      protected
+      def set_confirmation_field(field, callable)
+        @confirmation_field = begin
+          if field && callable.nil
+            field
+          elsif field.nil? && callable
+            callable.call
+          else
+            raise ArgumentError, "You are supposed to provide field or callable"
+          end
+        end
+      end
+    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/equality.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+# validate_equality
+# validates_in [true, false, nil]
+# it can work as validate_length (0..10) as well
+module Formidable
+  module Validations
+    class ValidateEquality < Validation
+      register(:validate_equality)
+
+      def initialize(element, *values)
+        @values = values
+        super(element)
+      end
+
+      def valid?
+        @values.include?(element.cleaned_data)
+      end
+
+      def message
+        "can't be empty"
+      end
+    end
+  end
+end

data/lib/formidable/validations/format.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+# validate_format /\d+/
+module Formidable
+  module Validations
+    class ValidateFormat < Validation
+      register(:validate_format)
+
+      def initialize(element, format)
+        @format = format
+        super(element)
+      end
+
+      def valid?
+        element.cleaned_data.match(@format)
+      end
+
+      def message
+        "can't be empty"
+      end
+    end
+  end
+end

data/lib/formidable/validations/length.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module Formidable
+  module Validations
+    class ValidateLength < Validation
+      # element.validate_length(10)
+      # element.validate_length(10..20)
+      # element.validate_length([10, 20])
+      register(:validate_length)
+
+      attr_reader :length
+      def initialize(element, length)
+        super(element)
+        @length = length
+      end
+
+      def valid?
+        length === element.length
+      end
+
+      def message # TODO: user can set message
+        if length.respond_to?(:first)
+          message_for_range
+        else
+          message_for_integer
+        end
+      end
+
+      protected
+      def message_for_integer
+        "has to be #{length} characters long"
+      end
+
+      def message_for_range
+        "has to be between #{length.first} and #{length.last} characters long"
+      end
+    end
+  end
+end