nform 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 71b2f87653d2d3d13a8bbad3e3c312b7bbf7d22a
+  data.tar.gz: 5ce2e00185bb43437f9572183a228082799b7d97
+SHA512:
+  metadata.gz: 76f4261d63c26976981e7eaf961e5f0237ba0c737bc26e867a06aad2403f71d36f856078a60573e17e2c164b687f03e2e9238e6ae43b25ad9905a12c234d45dc
+  data.tar.gz: abb4f49d0931d307ba9f88b163f654c6556635c77d7cbec482ceecb6579a7b229c9471fc1bb3db30632152fc30b7e3e396f2527aef03f964c65b2f927d039cf2

data/lib/nform/attributes.rb

@@ -0,0 +1,105 @@
+require 'active_support/core_ext/hash'
+require 'nform/coercions'
+
+module NForm
+  module Attributes
+    def attribute(name,coerce:nil,required:false,default:nil)
+      attribute_set[name.to_sym] = {coerce: coerce, required: required, default: default}
+    end
+
+    def attribute_set
+      @attribute_set ||= {}
+    end
+
+    def undefined_attributes(option)
+      unless %i|raise ignore|.include?(option)
+        raise ArgumentError, "Unknown option `#{option}` for undefined attributes. Options are :raise or :ignore"
+      end
+      @undef_attr = option
+    end
+
+    def __undef_attr
+      @undef_attr ||= :raise
+    end
+
+    def define_attributes
+      attribute_set.each do |name,options|
+        define_method(name) do
+          instance_variable_get("@#{name}")
+        end
+
+        # TODO: must use coercion set
+        c = get_coercion(options[:coerce])
+        define_method("#{name}=") do |input|
+          instance_variable_set("@#{name}", c.call(input,self))
+        end
+      end
+    end
+
+    def get_coercion(coerce_option)
+      case
+      when coerce_option.nil?
+        proc{|n| n }
+      when coerce_option.is_a?(Symbol)
+        NForm::Coercions.fetch(coerce_option)
+      when coerce_option.respond_to?(:call)
+        coerce_option
+      when coerce_option.is_a?(Enumerable)
+        chain = coerce_option.map{|o| get_coercion(o) }
+        proc do |input,scope|
+          chain.reduce(input){|i,c| c.call(i,scope) }
+        end
+      else
+        raise Error, "Invalid coerce option given"
+      end
+    end
+
+    def self.extended(base)
+      base.include(InstanceMethods)
+    end
+
+    module InstanceMethods
+      def initialize(input={})
+        i = input.symbolize_keys
+        require_attributes!(i)
+        self.class.define_attributes
+        set_attributes!(i)
+        set_missing_defaults
+      end
+
+      def to_hash
+        self.class.attribute_set.each.with_object({}) do |(k,v),memo|
+          memo[k] = send(k)
+        end
+      end
+
+      private
+      def require_attributes!(input_hash)
+        required = self.class.attribute_set.map{|name,options| name if options[:required]}.compact
+        missing  = (required - input_hash.keys)
+        if missing.any?
+          raise ArgumentError, "Missing required attributes: #{missing.inspect}"
+        end
+      end
+
+      def set_attributes!(input_hash)
+        input_hash.each do |k,v|
+          if self.class.__undef_attr == :raise
+            raise ArgumentError, "Undefined attribute: #{k}" unless respond_to?("#{k}=")
+          end
+          send "#{k}=", v if respond_to?("#{k}=")
+        end
+      end
+
+      def set_missing_defaults
+        self.class.attribute_set.each do |name, options|
+          default = options[:default]
+          unless default.nil?
+            send("#{name}=",default) if send(name).nil?
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/nform/builder.rb

@@ -0,0 +1,219 @@
+require 'nform/core_ext'
+require 'active_support/core_ext/string'
+
+module NForm
+  class Builder
+    include HTML
+
+    attr_reader :object, :form_class
+    def initialize(object, id: nil, form_class: nil, action: nil, method: nil)
+      @object = object
+      @form_id = id
+      @form_class = form_class
+      @action = action
+      @http_method = method
+    end
+
+    def form_id
+      @form_id || object_name.dasherize
+    end
+
+    def action
+      @action or
+      "/#{collection_name.dasherize}" + (new_object? ? "" : "/#{object.id}")
+    end
+
+    def http_method
+      @http_method || (new_object? ? "POST" : "PATCH")
+    end
+
+    def new_object?
+      object.respond_to?(:new?) ? object.new? : true
+    end
+
+    def object_name
+      @object_name || detect_object_name(object).underscore
+    end
+
+    def collection_name
+      object_name.pluralize
+    end
+
+    def method_tag
+      tag(:input, type:"hidden", name:"_method", value:http_method) if http_method != "POST"
+    end
+
+    def errors
+      @errors = if object.respond_to?(:errors)
+        object.errors
+      else
+        {}
+      end
+    end
+
+    def base_errors
+      if e = errors[:base]
+        tag(:ul, class: 'base errors') do
+          if e.respond_to?(:map)
+            zjoin e.map{|m| base_error(m) }
+          else
+            base_error(e)
+          end
+        end
+      end
+    end
+
+    def base_error(e)
+      tag(:li){ e }
+    end
+
+    def render
+      tag(:form, id: form_id, class: form_class, action:action, method:"POST") do
+        body = yield(self) if block_given?
+        zjoin(method_tag,base_errors,body)
+      end
+    end
+
+    def title
+      sjoin (new_object? ? "Create" : "Edit"), object_name.titleize
+    end
+
+    def param(*args)
+      object_name + args.map{|a|"[#{a}]"}.join
+    end
+
+    # allow "label: false" to prevent label being generated so that function that call label_for
+    # can all consistently omit the label when label value is given as false
+    def label_for(k, label: nil)
+      tag(:label, for: k.to_s.dasherize){ label || k.to_s.titleize } unless label == false
+    end
+
+    def input_for(k, type: "text", default: nil, **args)
+      val = object.send(k) || default
+      opts = {type:type, id:k.to_s.dasherize, name:param(k), value:val}.merge(args)
+      tag(:input,opts)
+    end
+
+    def error_for(k)
+      tag(:span, class: 'error'){ errors[k] } if errors[k]
+    end
+
+    def text_field(k, label: nil, default: nil, **args)
+      zjoin label_for(k, label:label), input_for(k,default:default,**args), error_for(k)
+    end
+
+    def number_field(k, label: nil, default: nil, **args)
+      opts = {type:'number', pattern: '\d*'}.merge(args)
+      zjoin label_for(k, label:label), input_for(k,type:'number',default:default,**opts), error_for(k)
+    end
+
+    def password_field(k, label: nil, **args)
+      zjoin label_for(k, label:label), input_for(k,type:"password",**args), error_for(k)
+    end
+
+    def hidden_field(k,**args)
+      input_for(k, type: "hidden",**args)
+    end
+
+    def text_area(k, label: nil, default: nil,**args)
+      val = object.send(k) || default
+      zjoin(
+        label_for(k, label:label),
+        tag(:textarea, id:k.to_s.dasherize, name:param(k),**args){ "#{val}" if val },
+        error_for(k)
+      )
+    end
+
+    def bool_field(k, label: nil,**args)
+      checked = ( !object.send(k) || object.send(k) == "false" ) ? false : true
+      zjoin label_for(k, label: label),
+            tag(:input, type:'hidden',name:param(k), value:"false"),
+            tag(:input, type:'checkbox', id: k.to_s.dasherize, name:param(k), value:"true", checked:checked,**args),
+            error_for(k)
+    end
+
+    def select(k, options:, label: nil, blank: true,**args)
+      opts = options.map{|value,text| option_for(k,value,text) }
+      opts.unshift option_for(k,nil,nil) if blank
+      zjoin(
+        label_for(k, label: label),
+        tag(:select, id:k.to_s.dasherize, name:param(k), **args){
+          zjoin opts
+        },
+        error_for(k)
+      )
+    end
+
+    def option_for(k,value,text)
+      opts = {value: value}
+      opts[:selected] = true if object.send(k) == value
+      tag(:option, opts){text ? text : value}
+    end
+
+    def association_select(association,key_method: :id, label_method: :name, label: nil, **args)
+      aname = detect_object_name(association)
+      key = (aname.underscore + "_id").to_sym
+      options = Hash[ association.map{|i| [i.send(key_method), i.send(label_method)]}]
+
+      unless label == false
+        label ||= aname.underscore.titleize
+      end
+
+      select(key,options: options, label: label, **args)
+    end
+
+    def date_input(k, label: nil, start_year: nil, end_year: nil, default:{})
+      start_year ||= Date.today.year
+      end_year ||= start_year+20
+      val = get_value(object,k)
+      tag :div, class: "date-input" do
+        zjoin label_for(nil,label:(label||k.to_s.titleize)),
+              tag(:input, date_attrs(k,:month,"MM",01,12,get_value(val,:month, default[:month]))),
+              tag(:input, date_attrs(k,:day,"DD",01,31,get_value(val,:day, default[:day]))),
+              tag(:input, date_attrs(k,:year,"YYYY",start_year,end_year,get_value(val,:year, default[:year]))),
+              error_for(k)
+      end
+    end
+
+    def date_attrs(k,time,ph,min,max,val)
+      { class: "date-#{time}", type: "number", name: param(k,time),
+        placeholder: ph, min: min, max: max, step: 1, value: val }
+    end
+
+    def submit_button(**args)
+      text = args.delete(:text)
+      tag(:button,**args){ text || (new_object? ? "Create" : "Save") }
+    end
+
+    private
+    def detect_object_name(o)
+      if o.is_a?(Symbol)
+        o.to_s
+      elsif o.is_a?(Class)
+        o.name
+      elsif o.respond_to?(:object_name)
+        o.object_name
+      elsif o.respond_to?(:model)
+        o.model
+      elsif o.is_a?(Enumerable)
+        detect_object_name(o.first)
+      else
+        o.class
+      end.to_s.demodulize
+    end
+
+    def get_value(object,key,default=nil)
+      if object.nil?
+        nil
+      elsif object.respond_to?(key)
+        object.send(key)
+      elsif object.respond_to? :fetch
+        object.fetch(key,nil)
+      else
+        raise BuilderError, "Undefined object method: #{key}"
+      end or default
+    end
+  end
+
+  BuilderError = Class.new(Error)
+end

data/lib/nform/coercions.rb

@@ -0,0 +1,55 @@
+require 'nform/core_ext'
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/object'
+
+module NForm
+  class CoercionSet
+    def [](key)
+      set[key.to_sym]
+    end
+
+    def []=(key,val)
+      set[key.to_sym] = val
+    end
+
+    def fetch(key)
+      if v = set[key]
+        v
+      else
+        raise Error, "Undefined coercion: #{key}"
+      end
+    end
+
+    def respond_to_missing?(name,*)
+      set.has_key?(name.to_sym)
+    end
+
+    def method_missing(name,*args,&block)
+      if set[name.to_sym]
+        set[name.to_sym].call(*args,&block)
+      else
+        super
+      end
+    end
+
+    private
+    def set
+      @set ||= {}
+    end
+  end
+
+  Coercions = CoercionSet.new
+  Coercions[:to_presence] = proc {|v| v.presence }
+  Coercions[:to_bool]     = proc { |v| !(v.nil? || v == false || v == 'false') }
+  Coercions[:to_float]    = proc { |v| v.to_f }
+  Coercions[:to_integer]  = proc { |v| v.to_i }
+  Coercions[:to_string]   = proc {|v| v.to_s.strip }
+  Coercions[:to_symbol]   = proc {|v| v.to_sym unless v.nil? }
+  Coercions[:to_number]   = proc do |v|
+    if v && v.is_a?(String)
+      v.gsub(/,/,'').to_f
+    else
+      v
+    end
+  end
+end

data/lib/nform/core_ext.rb

@@ -0,0 +1,12 @@
+require 'active_support'
+
+module NForm
+  module Hashable
+    # A convenience method for making a hash with the
+    # given methods on self as the keys and return for
+    # the given methods as the values
+    def hash_of(*keys)
+      keys.each.with_object({}){|k,h| h[k] = send(k) }
+    end
+  end
+end

data/lib/nform/form.rb

@@ -0,0 +1,44 @@
+require 'nform/core_ext'
+
+module NForm
+  class Form
+    extend NForm::Attributes
+    include NForm::Validations
+
+    def valid?
+      errors.clear
+      validate!
+      true
+    rescue ValidationError
+      false
+    end
+
+    def validate!
+      yield if block_given?
+      validation_error! if errors.any?
+    end
+
+    private
+    def validation_error!(hash={})
+      errors.merge(hash)
+      raise ValidationError.new(errors)
+    end
+  end
+
+  class ValidationError < Error
+    attr_reader :errors
+    def initialize(errors={})
+      @errors = errors
+    end
+
+    def message
+      "\nPlease correct the following errors:\n#{error_messages}"
+    end
+
+    def error_messages
+      if errors.any?
+        errors.map{|k,v| "#{k.to_s.humanize}: #{v}"}.join("\n")
+      end
+    end
+  end
+end

data/lib/nform/helpers.rb

@@ -0,0 +1,7 @@
+module NForm
+  module Helpers
+    def form_view(*args,&block)
+      NForm::Builder.new(*args).render &block
+    end
+  end
+end

data/lib/nform/html.rb

@@ -0,0 +1,50 @@
+module NForm
+  # Helper Methods for generating HTML markup
+  module HTML
+    VOID_ELEMENTS = %i|area base br col embed hr img input keygen link meta param source track wbr|
+    BOOL_ATTRIBUTES = %i|allowfullscreen async autofocus autoplay checked compact controls declare default defaultchecked defaultmuted defaultselected defer disabled draggable enabled formnovalidate hidden indeterminate inert ismap itemscope loop multiple muted nohref noresize noshade novalidate nowrap open pauseonexit readonly required reversed scoped seamless selected sortable spellcheck translate truespeed typemustmatch visible|
+
+    # Generate an HTML Tag
+    def tag(name, attributes={}, &block)
+      open = sjoin name, attrs(attributes)
+      body = block.call if block_given?
+      if VOID_ELEMENTS.include?(name.to_sym)
+        raise BuilderError, "Void elements cannot have content" if body
+        "<#{open}>"
+      else
+        "<#{open}>#{body}</#{name}>"
+      end
+    end
+
+    def attrs(hash={})
+      hash.delete_if{|k,v| v.nil? || v == "" }
+          .map{|k,v| attr_string(k,v) }
+          .compact
+          .join(" ")
+    end
+
+    def attr_string(k,v)
+      if BOOL_ATTRIBUTES.include?(k)
+        attr_key(k) if v
+      else
+        %Q|#{attr_key(k)}="#{v}"|
+      end
+    end
+
+    def attr_key(k)
+      k.is_a?(Symbol) ? k.to_s.gsub("_","-") : k
+    end
+
+    def zjoin(*args)
+      args.delete_if{|a| a.nil? || a == ""}.join('')
+    end
+
+    def sjoin(*args)
+      args.delete_if{|a| a.nil? || a == ""}.join(' ')
+    end
+
+    def njoin(*args)
+      args.delete_if{|a| a.nil? || a == ""}.join("\n")
+    end
+  end
+end

data/lib/nform/service.rb

@@ -0,0 +1,47 @@
+require 'nform/core_ext'
+
+module NForm
+  # Services expect valid input
+  # A service performs a single action
+  # A service should not accept unfiltered user input,
+  # but accept a form object when user input is required
+  class Service
+    include Hashable
+
+    attr_reader :form
+    def initialize(input)
+      @form = get_form(input)
+    end
+
+    def call
+      raise "Must be defined in subclass"
+    end
+
+    def self.call(*args)
+      new(*args).call
+    end
+
+    def self.form_class(klass=nil)
+      @@form_class = klass || const_get(:Form)
+    end
+
+    private
+    def get_form(input)
+      input.is_a?(@@form_class) ? input : @@form_class.new(input)
+    end
+
+    def error!(message)
+      raise ServiceError.new(message)
+    end
+
+    def validate!
+    end
+  end
+
+  class ServiceError < Error
+    attr_reader :message
+    def initialize(message="Unknown Error")
+      @message = message
+    end
+  end
+end

data/lib/nform/validations.rb

@@ -0,0 +1,62 @@
+module NForm
+  # A Module of simple validation methods.
+  # Including objects are required to implement a simple API:
+  # 1. Keys passed in to a validation must match instance method names
+  # 2. Objects must provide an errors object which responds to []
+  #
+  # When called, validators will return true/false indicating whether
+  # the validation passed or failed
+  module Validations
+    def errors
+      @errors ||= {}
+    end
+
+    def validate_presence_of(*keys)
+      pass = true
+      keys.each do |key|
+        unless respond_to?(key) && send(key) && send(key) != ""
+          errors[key] = "#{key.to_s.humanize} is required"
+          pass = false
+        end
+      end
+      pass
+    end
+
+    def validate_numericality_of(*keys)
+      pass = true
+      keys.each do |key|
+        val = send(key)
+        return true if val.is_a?(Numeric)
+        unless (val.respond_to?(:to_i) || val.respond_to?(:to_f)) &&
+           (val == val.to_i.to_s || val == val.to_f.to_s)
+          errors[key] = "#{key.to_s.humanize} must be a number"
+          pass = false
+        end
+      end
+      pass
+    end
+
+    def validate_length_of(key,length)
+      val = send(key)
+      if val && val.respond_to?(:length) && val.length >= length
+        true
+      else
+        errors[key] = "#{key.to_s.humanize} must be at least #{length} characters long"
+        false
+      end
+    end
+
+    def validate_confirmation_of(attribute)
+      confirm_key = attribute.to_s.concat("_confirmation").to_sym
+      if !respond_to?(confirm_key)
+        errors[attribute] = "#{attribute.to_s.humanize} requires confirmation"
+        false
+      elsif send(attribute) != send(confirm_key)
+        errors[confirm_key] = "#{attribute.to_s.humanize} confirmation does not match"
+        false
+      else
+        true
+      end
+    end
+  end
+end

data/lib/nform.rb

@@ -0,0 +1,20 @@
+module NForm
+  # A base error class for any NForm exceptions to extend
+  Error = Class.new(StandardError)
+end
+
+# Food for thought:
+# Not all this code is really required,
+# the library could be configured to not require all
+# and let the user just require the bits they want instead...
+# In that case, this list should be used as the basis for
+# `require nform/all`
+# For now, continuing to load all.
+require 'nform/helpers'
+require 'nform/html'
+require 'nform/builder'
+require 'nform/attributes'
+require 'nform/validations'
+require 'nform/coercions'
+require 'nform/form'
+require 'nform/service'

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: nform
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Andrew Burleson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: A nifty form builder and such.
+email: burlesona@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/nform.rb
+- lib/nform/attributes.rb
+- lib/nform/builder.rb
+- lib/nform/coercions.rb
+- lib/nform/core_ext.rb
+- lib/nform/form.rb
+- lib/nform/helpers.rb
+- lib/nform/html.rb
+- lib/nform/service.rb
+- lib/nform/validations.rb
+homepage: http://github.com/burlesona/nform
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: A form library
+test_files: []