sequel-crushyform 0.0.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Mickael Riga
+
+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.md

@@ -0,0 +1,298 @@
+CRUSHYFORM
+==========
+
+Crushyform is a Sequel plugin that helps building forms. 
+It basically does them for you so that you can forget about the boring part.
+The kind of thing which is good to have in your toolbox for building a CMS.
+
+We tried to make it as modular as possible but with sensible default values.
+
+I am also aware that this documentation is new and might lack some crucial information
+but feel free to drop me a line if you have any question.
+
+HOW TO INSTALL ?
+================
+
+Crushyform is a Ruby Gem so you can install it with:
+
+    sudo gem install sequel-crushyform
+
+HOW TO USE ? (THE BASICS)
+=========================
+
+Crushyform is also a Sequel plugin so you can add the crushyform methods to all your models with:
+
+    ::Sequel::Model.plugin :crushyform
+
+Or you can just add it to one model that way:
+
+    class BlogPost < ::Sequel::Model
+      plugin :crushyform
+      # More useful code from you
+    end
+
+Once you have it, that is when the magic begins.
+You already can have a form for it:
+
+    BlogPost.new.crushyform # Returns a nice form
+
+This will return a form for your new model. Without any effort.  
+If you try with an existing entry, it works as well (wow!).  
+If you try with an entry that is not valid, error messages are incorporated (even more wow!).
+
+Obviously you have a bit more control on that.
+To start with, this method have arguments which are:
+
+- List of columns (all of them by default)
+- Action URL (when nil, which is the default option, the fields are not wrapped in a form tag)
+- HTTP Method (POST by default)
+
+So you can do that:
+
+    BlogPost.new.crushyform( [:title,:body], "/new_blog", "GET" ) # Returns a nice form
+
+Which will return a form (wrapped this time) with only the 2 fields :title and :body.
+Options give the action URL and method.
+
+Now say you want to have all the default options, but you want a wrapping form tag, you can do that:
+
+    BlogPost.new.crushyform( model.crushyform_schema.keys, "/new_blog" ) # Returns a nice form (a crushy form to be precise)
+
+You have to put the default value `model.crushyform_schema.keys` because in the order of priority, the list of columns is more important
+
+This is due to the fact that in a real case scenario we are more likely to use the version without a wrapping form tag.
+Mainly because we want to add some other hidden inputs like a destination, a method override in order to generate a PUT request or a pseudo XHR value.
+
+Another reason might be that you want to add other fields to the tag. 
+The default tag is pretty basic and is always considered multipart/form-data for simplicity.
+
+CSS CLASSES
+===========
+
+Here is the list of CSS classes used in order to style the forms.
+That should be enough, drop me a line if you feel something is missing.
+
+- crushyfield-required is the class for the default required flag
+- crushyfield is used on the wrapping paragraph tag of every fields
+- crushyfield-error is used on the wrapping paragraph tag of a field containing errors
+- crushyfield-error-list is on the span that wraps the list of errors (is just a span, not an html list though)
+
+THE CRUSHYFIELDS
+================
+
+As mentioned before, the form is more like a way to gather all the fields we're interested to have in a form.
+Which means you can have more control than that.
+You can have just one field at a time.
+In order to do that, you have 2 methods:
+
+- Model#crushyinput(column,options) which only gives you the input tag for the field
+- Model#crushyfield(column,options) which does the same but wrapped in a paragraph tag with a label and an error list
+
+Regarding the options, you have plenty of them.
+We'll see later how we can set all of them in the crushyform schema but they all can be overriden when requesting the input tag.
+Here is the list of schema-related options:
+
+- :type is the crushyform type that is used for the field (default is :string)
+- :input_name is the name used for the input tag (default is model[columnname])
+- :input_value is the input value used for the input tag
+- :input_type is the input type used for the input tag (default is text when applicable)
+- :input_class is the class value used for the input tag
+- :html_escape has to be set to false if you do not want the value to be escaped (default is true)
+- :required text that says that the field is required (default is just blank). A ready-made value for that field is also available if you put `true` instead of a text. It is an asterisk with span class `crushyfield_required`
+
+As you can see, a lot of things can be overriden at the last level.
+There is another option just for Model#crushyfield that is called :name.
+This is basically the name of the field in the label tag.
+By default, this is the name of the column in a human readable way, which means
+there are no underscore signs and foreign keys like :author_id will have the name: Author.
+
+Here is an example:
+
+    BlogPost[4].crushyfield( :title , { :name => "Enter Title", :required => true })
+
+This will give you a full field for the column :title with a label saying "Enter Title" and an asterisk that says the field is required.
+As mentioned before the :required can be the text to put, but for consistency, it is recommanded to wrap it in the same span with the class crushyfield-required.
+So if you want to simply write required:
+
+    <span class='crushyfield-required'> required</span>
+
+But really this is good only if the text is different for that specific field.
+You usually want to override the class method Model::crushyfield_required.
+The default implementation is:
+
+    def self.crushyfield_required
+      "<span class='crushyfield-required'> *</span>"
+    end
+
+TYPES OF FIELD
+==============
+
+- :string is the default one so it is used when the field is :string type or anyone that is not in the list like :integer for instance
+- :none returns a blank string
+- :boolean
+- :text
+- :date is in the format YYYY-MM-DD because it is accepted by sequel setters as-is
+- :time is in the format HH:MM:SS because it is accepted by sequel setters as-is
+- :datetime is in the format YYYY-MM-DD HH:MM:SS because it is accepted by sequel setters as-is
+- :parent is a dropdown list to chose from
+- :attachment is for attachments (who guessed?).
+
+MORE ABOUT DATE/TIME FIELDS
+---------------------------
+
+As you can see date/time/datetime field is a text input with a format specified on the side.
+We used to deal with it differently in the past, but nowadays this is the kind of field that is better to keep basic and offer a better interface with javascript.
+Better to give it a special :input_class through the options and make it a nice javascript date picker 
+instead of trying to complicate something that is gonna be ugly at the end anyway.
+
+Also if you want to use a proper time field (just time with no date), don't forget to declare it all lowercase in your schema.
+Otherwise it will use the Time ruby class which is a time including the date:
+
+  set_schema do
+    primary_key :id
+    Time :opening_hour   # type is :datetime
+    time :opening_hour   # type is :time
+  end
+
+MORE ABOUT ATTACHMENT FIELD
+---------------------------
+
+Regarding the :attachment type, it should be able to work with any kind of system. 
+We made it simple and customizable enough to adapt to many attachment solutions.
+A called it :attachment because I never really use blobs, but it might be used with blobs as well.
+Once again because it is very basic.
+
+This is typically the kind of field that cannot really be guessed by crushyform.
+So you have to declare it as an :attachment.
+We see how it is done in the following chapter.
+
+Also when it can, crushyform tries to put a thumbnail of the attachment, above the file input when possible.
+It is done with an instance method that can be overriden by you: Model#to_thumb( column ).
+By default, it does the right job if you're using another Gem we've done called [Stash-Magic](https://github.com/mig-hub/stash_magic) .
+Otherwise crushyform assumes that the column contains the relative URL of an image.
+
+MORE ABOUT PARENT FIELDS
+------------------------
+
+The :parent field type is quite straight foreward and there is not much to say in order to be able to use it.
+It is interesting to see how it works though.
+You have a dropdown with all parents name instead of just a crude ID number.
+One interesting thing is that this dropdown is available for you to use for an Ajax update or whatever:
+
+    Author.to_dropdown( 3, "Choose your Author" )
+
+Both options are optional. The first one is the ID of the author that is selected (default is `nil`).
+And the second option is the text for the nil option (default is "** UNDEFINED **").
+
+This dropdown is cached in `Model::dropdown_cache` and is automatically reseted when you create, update or destroy an entry.
+Alternatively, you can do it with `Model::reset_dropdown_cache`.
+
+Another interesting thing is the way crushyform comes up with names.
+You rarely would have to do anything because it maintains an ordered list of columns that are appropriate for a name.
+The current list is in a constant:
+
+    LABEL_COLUMNS = [:title, :label, :fullname, :full_name, :surname, :lastname, :last_name, :name, :firstname, :first_name, :caption, :reference, :file_name, :body]
+
+In the worst case scenario, if it cannot find a column, crushyform will call it with the class name followed by the ID number.
+
+Alternatively, you can specify your own column:
+
+    Author.label_column = :my_label_column
+
+Or you can override the final instance method `Model::to_label`:
+
+    def to_label
+      self.my_label_column
+    end
+
+The good thing that this method is very useful in many places of CMS of your application, and even the front end:
+
+    @author.to_label
+
+It could even work with addresses.
+Crushyform turns a multi-line text in a one liner if it is the label column.
+
+    # Say the class Address has a column called :body which is the best choice for a label
+    #
+    # 4, Virginia Street
+    # Flat C
+    
+    @address.to_label # => 4, Virginia Street Flat C
+
+You get the idea.
+
+CRUSHYFORM SCHEMA
+=================
+
+So now some people might think that this is weird that you have to put the options each time you ask for a field.
+Well, the good news is that you don't.
+Most of the options on Model#crushyfield are just for specific cases where you want to override/force something.
+Instead you have a crushyform_schema:
+
+    BlogPost.crushyform_schema
+    # returns something like:
+    # {
+    #   :title => { :type => :string },
+    #   :body => { :type => :text },
+    #   :created_on => { :type => :date },
+    #   :picture => { :type => :string }
+    # }
+
+As you can see, it is already filled for you with the bare minimum.
+Unfortunately the picture is a string, but a string that is really an image URL.
+You can fix that with:
+
+    BlogPost.crushyform_schema[:picture].update({ :type => :attachment })
+
+Alright now when you ask for the form or just the :picture field, it is gonna be an file upload field.
+But you also want the :title to be displayed as a mandatory field:
+
+    BlogPost.crushyform_schema[:title].update({ :required => true })
+
+You get the idea.
+
+But there is even a better way if you use the :schema plugin at the same time.
+You can add an option called :crushyform for each column.
+For instance, in order to do the same thing as before:
+
+    class BlogPost < ::Sequel::Model
+      plugin :schema
+      plugin :crushyform
+      set_schema do
+		    primary_key :id
+		    String :title, :crushyform => {:required => true}
+		    text :body
+		    Date :created_on
+		    String :picture, :crushyform => {:type => :attachment}
+		  end
+		  create_table unless table_exists?
+		end
+		
+CUSTOM TYPE OF FIELD
+====================
+
+You can obviously create a type of field that is not implemented in crushyform.
+If this is a useful one, it is probably better to fork the project on Github and send me a pull request.
+That way, you'll help crushyform being more interesting.
+
+Otherwise, the list of types is a Hash. Key is the name, and the value is a Proc with a couple of arguments.
+A dummy example could be:
+
+    Author.crushyform_types.update({
+      :dummy_type => proc do |instance, column_name, options|
+        "<p>You cannot change column: #{column_name}</p>"
+      end
+    })
+
+So it returns a string.
+Pretty simple.
+
+CHANGE LOG
+==========
+
+0.0.1 First version
+
+COPYRIGHT
+=========
+
+(c) 2011 Mickael Riga - see file LICENCE for details

data/lib/sequel_crushyform.rb

@@ -0,0 +1,145 @@
+module ::Sequel::Plugins::Crushyform
+  
+  module ClassMethods
+    def crushyform_version; [0,0,1]; end
+    # Schema
+    def crushyform_schema
+      @crushyform_schema ||= default_crushyform_schema
+    end
+    def default_crushyform_schema
+      out = {}
+      db_schema.each do |k,v|
+        out[k] = if v[:db_type]=='text'
+          {:type=>:text}
+        else
+          {:type=>v[:type]}
+        end
+      end
+      @schema.columns.each{|c|out[c[:name]]=out[c[:name]].update(c[:crushyform]) if c.has_key?(:crushyform)} if respond_to?(:schema)
+      association_reflections.each{|k,v|out[v[:key]]={:type=>:parent} if v[:type]==:many_to_one}
+      out
+    end
+    # Types
+    def crushyform_types
+      @crushyform_types ||= {
+        :none => proc{''},
+        :string => proc do |m,c,o|
+          "<input type='%s' name='%s' value='%s' id='%s' class='%s' />%s\n" % [o[:input_type]||'text', o[:input_name], o[:input_value], m.crushyid_for(c), o[:input_class], o[:required]]
+        end,
+        :boolean => proc do |m,c,o|
+          crushid = m.crushyid_for(c)
+          s = ['checked', nil]
+          s.reverse! unless o[:input_value]
+          out = "<span class='%s'>"
+          out += "<input type='radio' name='%s' value='true' id='%s' %s /> <label for='%s'>Yes</label> "
+          out += "<input type='radio' name='%s' value='false' id='%s-no' %s /> <label for='%s-no'>No</label>"
+          out += "</span>\n"
+          out % [o[:input_class], o[:input_name], crushid, s[0], crushid, o[:input_name], crushid, s[1], crushid]
+        end,
+        :text => proc do |m,c,o|
+          "<textarea name='%s' id='%s' class='%s'>%s</textarea>%s\n" % [o[:input_name], m.crushyid_for(c), o[:input_class], o[:input_value], o[:required]]
+        end,
+        :date => proc do |m,c,o|
+          o[:input_value] = "%s-%s-%s" % [o[:input_value].year, o[:input_value].month, o[:input_value].day] if o[:input_value].is_a?(Sequel.datetime_class)
+          o[:required] = "%s Format: yyyy-mm-dd" % [o[:required]]
+          crushyform_types[:string].call(m,c,o)
+        end,
+        :time => proc do |m,c,o|
+          o[:input_value] = "%s:%s:%s" % [o[:input_value].hour, o[:input_value].min, o[:input_value].sec] if o[:input_value].is_a?(Sequel.datetime_class)
+          o[:required] = "%s Format: hh:mm:ss" % [o[:required]]
+          crushyform_types[:string].call(m,c,o)
+        end,
+        :datetime => proc do |m,c,o|
+          o[:input_value] = "%s-%s-%s %s:%s:%s" % [o[:input_value].year, o[:input_value].month, o[:input_value].day, o[:input_value].hour, o[:input_value].min, o[:input_value].sec] if o[:input_value].is_a?(Sequel.datetime_class)
+          o[:required] = "%s Format: yyyy-mm-dd hh:mm:ss" % [o[:required]]
+          crushyform_types[:string].call(m,c,o)
+        end,
+        :parent => proc do |m,c,o|
+          parent_class = association_reflection(c.to_s.sub(/_id$/,'').to_sym).associated_class
+          option_list = parent_class.to_dropdown(o[:input_value])
+          "<select name='%s' id='%s' class='%s'>%s</select>\n" % [o[:input_name], m.crushyid_for(c), o[:input_class], option_list]
+        end,
+        :attachment => proc do |m,c,o|
+          "%s<input type='file' name='%s' id='%s' class='%s' />%s\n" % [m.to_thumb(c), o[:input_name], m.crushyid_for(c), o[:input_class], o[:required]]
+        end
+      }
+    end
+    # What represents a required field
+    # Can be overriden
+    def crushyfield_required; "<span class='crushyfield-required'> *</span>"; end
+    # Stolen from ERB
+    def html_escape(s)
+      s.to_s.gsub(/&/, "&amp;").gsub(/\"/, "&quot;").gsub(/>/, "&gt;").gsub(/</, "&lt;")
+    end
+    # Cache dropdown options for children classes to use  
+    # Meant to be reseted each time an entry is created, updated or destroyed  
+    # So it is only rebuild once required after the list has changed  
+    # Maintaining an array and not rebuilding it all might be faster  
+    # But it will not happen much so that it is fairly acceptable  
+    def to_dropdown(selection=nil, nil_name='** UNDEFINED **')
+      dropdown_cache.inject("<option value=''>#{nil_name}</option>\n") do |out, row|
+        selected = 'selected' if row[0]==selection
+        "%s%s%s%s" % [out, row[1], selected, row[2]]
+      end
+    end
+    def dropdown_cache
+      @dropdown_cache ||= label_dataset.inject([]) do |out,row|
+        out.push([row.id, "<option value='#{row.id}' ", ">#{row.to_label}</option>\n"])
+      end
+    end
+    def reset_dropdown_cache; @dropdown_cache = nil; end
+    # Generic column names for label
+    LABEL_COLUMNS = [:title, :label, :fullname, :full_name, :surname, :lastname, :last_name, :name, :firstname, :first_name, :caption, :reference, :file_name, :body]
+    # Column used as a label
+    def label_column; @label_column ||= LABEL_COLUMNS.find{|c|columns.include?(c)}; end
+    def label_column=(n); @label_column=n; end
+    # Dataset selecting only columns used for building names
+    def label_dataset; select(:id, label_column); end
+  end
+  
+  module InstanceMethods
+    def crushyform(columns=model.crushyform_schema.keys, action=nil, meth='POST')
+      fields = columns.inject(""){|out,c|out+crushyfield(c.to_sym)}
+      action.nil? ? fields : "<form action='%s' method='%s' enctype='multipart/form-data'>%s</form>\n" % [action, meth, fields]
+    end
+    # crushyfield is crushyinput but with label+error
+    def crushyfield(col, o={})
+      field_name = o[:name] || col.to_s.sub(/_id$/, '').tr('_', ' ').capitalize
+      error_list = errors.on(col).map{|e|" - #{e}"} if !errors.on(col).nil?
+      "<p class='crushyfield %s'><label for='%s'>%s</label><span class='crushyfield-error-list'>%s</span><br />\n%s</p>\n" % [error_list&&'crushyfield-error', crushyid_for(col), field_name, error_list, crushyinput(col, o)]
+    end
+    def crushyinput(col, o={})
+      o = model.crushyform_schema[col].dup.update(o)
+      o[:input_name] ||= "model[#{col}]"
+      o[:input_value] = o[:input_value].nil? ? self.__send__(col) : o[:input_value]
+      o[:input_value] = model.html_escape(o[:input_value]) if (o[:input_value].is_a?(String) && o[:html_escape]!=false)
+      o[:required] = o[:required]==true ? model.crushyfield_required : o[:required]
+      crushyform_type = model.crushyform_types[o[:type]] || model.crushyform_types[:string]
+      crushyform_type.call(self,col,o)
+    end
+    # This ID is used to have a unique reference for the input field.
+    #
+    #   Format: <id>-<class>-<column>
+    #
+    # If you plan to have more than one form for a new entry in the same page
+    # you'll have to override this method because records without an id
+    # have just 'new' as a prefix.
+    # Which means there could be a colision.
+    def crushyid_for(col); "%s-%s-%s" % [id||'new',self.class.name,col]; end
+    # Used to determine a humanly readable representation of the entry on one line of text
+    def to_label; model.label_column.nil? ? "#{model} #{id}" : self.__send__(model.label_column).to_s.tr("\n\r", ' '); end
+    # Provide a thumbnail for the column
+    def to_thumb(c)
+      current = self.__send__(c)
+      if model.respond_to?(:stash_reflection) && model.stash_reflection.key?(c)
+        !current.nil? && current[:type][/^image\//] ? "<img src='#{file_url(c, 'stash_thumb.gif')}?#{::Time.now.to_i.to_s}' /><br />\n" : ''
+      else
+        "<img src='#{current}?#{::Time.now.to_i.to_s}' width='100' onerror=\"this.style.display='none'\" />\n"
+      end
+    end
+    # Reset dropdowns on hooks
+    def after_save; model.reset_dropdown_cache; super; end
+    def after_destroy; model.reset_dropdown_cache; super; end
+  end
+  
+end

data/sequel-crushyform.gemspec

@@ -0,0 +1,12 @@
+Gem::Specification.new do |s| 
+  s.name = 'sequel-crushyform'
+  s.version = "0.0.1"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "A Sequel plugin that helps building forms"
+  s.description = "A Sequel plugin that helps building forms. It basically does them for you so that you can forget about the boring part. The kind of thing which is good to have in your toolbox for building a CMS."
+  s.files = `git ls-files`.split("\n").sort
+  s.require_path = './lib'
+  s.author = "Mickael Riga"
+  s.email = "mig@mypeplum.com"
+  s.homepage = "http://github.com/mig-hub/sequel-crushyform"
+end

data/test/spec_crushyform.rb

@@ -0,0 +1,360 @@
+require 'rubygems'
+require 'bacon'
+Bacon.summary_on_exit
+
+F = ::File
+D = ::Dir
+ROOT = F.dirname(__FILE__)+'/..'
+$:.unshift(ROOT+'/lib')
+
+require 'sequel'
+::Sequel::Model.plugin :crushyform
+DB = ::Sequel.sqlite
+
+class Haiku < ::Sequel::Model
+  plugin :schema
+  set_schema do
+    primary_key :id
+    String :title, :crushyform=>{:type=>:custom}
+    text :body
+    Boolean :published
+    foreign_key :author_id, :authors
+  end
+  create_table unless table_exists?
+  many_to_one :author
+  one_to_many :reviews
+  def validate
+    errors[:title] << "is not good"
+    errors[:title] << "smells like shit"
+  end
+end
+
+class Author < ::Sequel::Model
+  plugin :schema
+  set_schema do
+    primary_key :id
+    String :name
+    String :surname
+  end
+  create_table unless table_exists?
+  one_to_many :haikus
+end
+Author.create(:name=>'Ray',:surname=>'Bradbury')
+Author.create(:name=>'Jorge Luis',:surname=>'Borges')
+
+DB.create_table :reviews do
+  primary_key :id
+  String :title
+  text :body
+  Integer :rate
+  foreign_key :haiku_id, :haikus
+end
+class Review < ::Sequel::Model
+  many_to_one :haiku
+end
+
+class TestDateTime < ::Sequel::Model
+  plugin :schema
+  set_schema do
+    primary_key :id
+    Date :birth
+    time :meeting
+    DateTime :when
+    DateTime :created_at
+    DateTime :updated_at
+  end
+  create_table unless table_exists?
+end
+
+class ShippingAddress < ::Sequel::Model
+  plugin :schema
+  set_schema do
+    primary_key :id
+    text :address_body
+    String :postcode
+    String :city
+  end
+  create_table unless table_exists?
+end
+ShippingAddress.create(:address_body=>"3 Mulholland Drive\n\rFlat C", :postcode=>'90210', :city=>'Richville')
+
+require 'stash_magic'
+class Attached < ::Sequel::Model
+  plugin :schema
+  set_schema do
+    primary_key :id
+    String :filename, :crushyform=>{:type=>:attachment}
+    String :filesize, :crushyform=>{:type=>:none}
+    String :filetype, :crushyform=>{:type=>:none}
+    String :map, :crushyform=>{:type=>:attachment}
+  end
+  create_table unless table_exists?
+  ::StashMagic.with_public_root ROOT+'/test'
+end
+
+# ========
+# = Test =
+# ========
+
+describe 'Crushyform when schema plugin is not used' do
+  
+  should 'have a correct default crushyform_schema' do
+    Review.default_crushyform_schema.should=={
+      :id       => {:type=>:integer},
+      :title    => {:type=>:string},
+      :body     => {:type=>:text},
+      :rate     => {:type=>:integer},
+      :haiku_id => {:type=>:parent}
+    }
+  end
+  
+  should 'build the default crushyform_schema on the first query' do
+    Review.respond_to?(:schema).should==false
+    Review.crushyform_schema.should==Review.default_crushyform_schema
+  end
+  
+  should 'have an updatable crushyform_schema' do
+    Review.crushyform_schema[:body][:type] = :custom
+    Review.crushyform_schema.should.not==Review.default_crushyform_schema
+    Review.crushyform_schema[:body][:type] = :text
+  end
+  
+end
+
+describe 'Crushyform when schema plugin is used' do
+  
+  should 'use schema declaration for building the default crushyform_schema' do
+    Haiku.default_crushyform_schema.should=={
+      :id         => {:type=>:integer},
+      :title      => {:type=>:custom},
+      :body       => {:type=>:text},
+      :published  => {:type=>:boolean},
+      :author_id  => {:type=>:parent}
+    }
+  end
+  
+end
+
+describe 'Crushyform miscellaneous helpers' do
+  
+  should 'know its crushyform version' do
+    Haiku.crushyform_version.size.should==3
+  end
+  
+  should 'have a correct default crushyid' do
+    ShippingAddress.new.crushyid_for(:address_body).should=='new-ShippingAddress-address_body'
+    ShippingAddress.first.crushyid_for(:address_body).should=='1-ShippingAddress-address_body'
+  end
+  
+  should 'not mark texts as type :string, but :text' do
+    Haiku.db_schema[:body][:type].should==:string
+    Haiku.crushyform_schema[:body][:type].should==:text
+  end
+  
+  should 'guess label columns using a list of common column names' do
+    Haiku.label_column.should==:title
+    Author.label_column.should==:surname # Respect order of search
+  end
+  
+  should 'set Model::label_column' do
+    TestDateTime.label_column.should==nil
+    TestDateTime.label_column = :birth
+    TestDateTime.label_column.should==:birth
+    TestDateTime.label_column = nil
+  end
+  
+  should 'have a shortcut for dataset only with columns relevant for building a dropdown' do
+    a = Author.label_dataset.first
+    a.surname.should=='Bradbury'
+    a.name.should==nil
+  end
+  
+  should 'have a label based on Model::label_column' do
+    Author.first.to_label.should=='Bradbury'
+  end
+  
+  should 'Have a fallback label when label_column is nil' do
+    ShippingAddress.first.to_label.should=="ShippingAddress 1"
+  end
+  
+  should 'avoid line breaks if label column is a multiline field' do
+    ShippingAddress.label_column = :address_body
+    ShippingAddress.first.to_label.should=="3 Mulholland Drive  Flat C"
+  end
+  
+  should 'build correct dropdowns' do
+    options = Author.to_dropdown(1)
+    options.lines.count.should==3
+    options.should.match(/<option[^>]+value='1'[^>]+selected>Bradbury<\/option>/)
+    options = Author.to_dropdown
+    options.should.not.match(/selected/)
+  end
+  
+  should 'have custom wording for nil value for parent dropdowns' do
+    options = Author.to_dropdown(1,"Pick an Author")
+    options.should.match(/^<option value=''>Pick an Author<\/option>/)
+  end
+  
+  should 'cache parent dropdowns' do
+    Author.insert(:name=>'Matsuo', :surname=>'Basho') # insert or delete do not trigger hooks
+    Author.to_dropdown(1).lines.count.should==3
+    Author.reset_dropdown_cache
+    Author.to_dropdown(1).lines.count.should==4
+    Author.order(:id).last.delete
+  end
+  
+  should 'have parent dropdown cache reseted when list is changed' do
+    a = Author.create(:name=>'Yasunari', :surname=>'Kawabati')
+    Author.to_dropdown(1).lines.count.should==4
+    a.update(:surname=>'Kawabata')
+    Author.to_dropdown(1).should.match(/Kawabata/)
+    a.destroy
+    Author.to_dropdown(1).lines.count.should==3
+  end
+  
+  should 'have a generic entry point overridable for grabbing thumbnails' do
+    Attached.new.respond_to?(:to_thumb).should==true
+  end
+  
+  should 'have a thumbnail by default that use the content of column as path and invisible if path is broken' do
+    a = Attached.new.to_thumb(:filename)
+    a.should.match(/^<img.*\/>$/)
+    a.should.match(/src='\?\d*'/)
+    a.should.match(/onerror=\"this.style.display='none'\"/)
+    a = Attached.new.set(:filename=>'/book.png').to_thumb(:filename)
+    a.should.match(/^<img.*\/>$/)
+    a.should.match(/src='\/book\.png\?\d*'/)
+    a.should.match(/onerror=\"this.style.display='none'\"/)
+  end
+  
+  should 'have a special thumbnail behavior adapted to StashMagic if that Gem is used on the specific field' do
+    a = Attached.new.set(:map=>"{:type=>'image/png',:name=>'map.png',:size=>20}")
+    b = Attached.new.set(:map=>"{:type=>'application/pdf',:name=>'map.pdf',:size=>20}")
+    Attached.stash :map # I do it only here so that I could enter test values as a simple string
+    field = a.to_thumb(:map)
+    field.should.match(/^<img.*\/><br \/>$/)
+    field.should.match(/src='\/stash\/Attached\/tmp\/map\.stash_thumb\.gif\?\d*'/)
+    field.should.not.match(/onerror=\"this.style.display='none'\"/)
+    # No preview if field is nil or not an image
+    a.map = nil
+    a.to_thumb(:map).should==''
+    b.to_thumb(:map).should==''
+  end
+end
+
+describe 'Crushyfield types' do
+  
+  should 'have a type that does nothing' do
+    Attached.new.crushyinput(:filesize).should==''
+  end
+  
+  should 'escape html by default on text fields' do
+    Haiku.new.crushyinput(:title, {:input_value=>"<ScRipT >alert('test');</ScRipT >"}).should.match(/&lt;ScRipT &gt;alert\('test'\);&lt;\/ScRipT &gt;/)
+    Haiku.new.crushyinput(:body, {:input_value=>"<ScRipT >alert('test');</ScRipT >"}).should.match(/&lt;ScRipT &gt;alert\('test'\);&lt;\/ScRipT &gt;/)
+    TestDateTime.new.crushyinput(:birth, {:input_value=>"<ScRipT >alert('test');</ScRipT >"}).should.match(/&lt;ScRipT &gt;alert\('test'\);&lt;\/ScRipT &gt;/)
+    TestDateTime.new.crushyinput(:meeting, {:input_value=>"<ScRipT >alert('test');</ScRipT >"}).should.match(/&lt;ScRipT &gt;alert\('test'\);&lt;\/ScRipT &gt;/)
+    TestDateTime.new.crushyinput(:when, {:input_value=>"<ScRipT >alert('test');</ScRipT >"}).should.match(/&lt;ScRipT &gt;alert\('test'\);&lt;\/ScRipT &gt;/)
+  end
+  
+  should 'not escape html on text field if specified' do
+    Haiku.new.crushyinput(:title, {:input_value=>"<ScRipT >alert('test');</ScRipT >", :html_escape => false}).should.should.match(/<ScRipT >alert\('test'\);<\/ScRipT >/)
+    Haiku.new.crushyinput(:body, {:input_value=>"<ScRipT >alert('test');</ScRipT >", :html_escape => false}).should.should.match(/<ScRipT >alert\('test'\);<\/ScRipT >/)
+  end
+  
+  should 'not keep one-shot vars like :input_value in the crushyform_schema' do
+    Haiku.crushyform_schema[:title][:input_value].should==nil
+  end
+  
+  should 'be able to turn the :string input into other similar types like password or hidden' do
+    Haiku.new.crushyinput(:title, {:input_type=>'password'}).should.match(/type='password'/)
+  end
+  
+  should 'set booleans correctly' do
+    Haiku.new.published.should==nil
+    Haiku.new.crushyinput(:published).should.match(/<input[^>]+value='false'[^>]+checked \/>/)
+    Haiku.new.crushyinput(:published,{:input_value=>true}).should.match(/<input[^>]+value='true'[^>]+checked \/>/)
+    Haiku.new.crushyinput(:published,{:input_value=>false}).should.match(/<input[^>]+value='false'[^>]+checked \/>/)
+  end
+  
+  should 'have :required option which is a text representing requirement and defaulting to blank' do
+    Review.new.crushyinput(:title).should.not.match(/#{Regexp.escape Review.crushyfield_required}/)
+    Review.new.crushyinput(:title,{:required=>" required"}).should.match(/required/)
+  end
+  
+  should 'use the default requirement text when :required option is true instead of a string' do
+    Review.new.crushyinput(:title,{:required=>true}).should.match(/#{Regexp.escape Review.crushyfield_required}/)
+  end
+  
+  should 'format date/time/datetime correctly' do
+    TestDateTime.new.db_schema[:meeting][:type].should== :time # Check that the correct type is used for following tests (see README)
+    TestDateTime.new.crushyinput(:birth).should.match(/value=''/)
+    TestDateTime.new.crushyinput(:birth,{:input_value=>::Time.now}).should.match(/value='\d{4}-\d{1,2}-\d{1,2}'/)
+    TestDateTime.new.crushyinput(:meeting).should.match(/value=''/)
+    TestDateTime.new.crushyinput(:meeting,{:input_value=>::Time.now}).should.match(/value='\d{1,2}:\d{1,2}:\d{1,2}'/)
+    TestDateTime.new.crushyinput(:when).should.match(/value=''/)
+    TestDateTime.new.crushyinput(:when,{:input_value=>::Time.now}).should.match(/value='\d{4}-\d{1,2}-\d{1,2} \d{1,2}:\d{1,2}:\d{1,2}'/)
+  end
+  
+  should 'add format instructions for date/time/datetime after :required bit' do
+    TestDateTime.new.crushyinput(:birth,{:required=>true}).should.match(/#{Regexp.escape Review.crushyfield_required} Format: yyyy-mm-dd/)
+    TestDateTime.new.crushyinput(:meeting,{:required=>true}).should.match(/#{Regexp.escape Review.crushyfield_required} Format: hh:mm:ss/)
+    TestDateTime.new.crushyinput(:when,{:required=>true}).should.match(/#{Regexp.escape Review.crushyfield_required} Format: yyyy-mm-dd hh:mm:ss/)
+  end
+  
+  should 'build parent field with a wrapped version of parent_model#to_dropdown' do
+    Haiku.new.crushyinput(:author_id).should.match(/^<select.*>#{Regexp.escape Author.to_dropdown}<\/select>$/)
+  end
+  
+  should 'display a preview with an attachment field whenever it is possible' do
+    a = Attached.new.set(:filename=>'/book.png')
+    a.crushyinput(:filename).should.match(/^#{Regexp.escape a.to_thumb(:filename)}<input type='file'.*\/>\n$/)
+  end
+  
+  should 'have field wrapped with a correct label' do
+    ShippingAddress.new.crushyfield(:address_body).should.match(/<label for='#{Regexp.escape ShippingAddress.new.crushyid_for(:address_body)}'>Address body<\/label>/)
+    ShippingAddress.first.crushyfield(:address_body).should.match(/<label for='#{Regexp.escape ShippingAddress.first.crushyid_for(:address_body)}'>Address body<\/label>/)
+    ShippingAddress.new.crushyfield(:address_body,{:name=>'Address Lines'}).should.match(/<label for='#{Regexp.escape ShippingAddress.new.crushyid_for(:address_body)}'>Address Lines<\/label>/)
+  end
+  
+  should 'have errors reported for fields' do
+    h = Haiku.new
+    h.valid?.should==false
+    h.crushyfield(:title).should.match(/<span class='crushyfield-error-list'> - is not good - smells like shit<\/span>/)
+    h.crushyfield(:title).should.match(/^<p class='crushyfield crushyfield-error'/)
+    h.crushyfield(:body).should.match(/<span class='crushyfield-error-list'><\/span>/)
+    h.crushyfield(:body).should.match(/^<p class='crushyfield '/)
+    # Not validated
+    Haiku.new.crushyfield(:title).should.match(/<span class='crushyfield-error-list'><\/span>/)
+    Haiku.new.crushyfield(:title).should.match(/^<p class='crushyfield '/)
+  end
+  
+end
+
+describe 'Crushyform' do
+  
+  should 'have a helper for creating the whole form with all current values (no per-field customization)' do
+    form = Haiku.new.crushyform([:title,:body,:author_id], '/receive_haiku', 'POST')
+    form.should.match(/action='\/receive_haiku'/)
+    form.should.match(/method='POST'/)
+    Haiku.new.crushyform([:title,:body,:author_id], '/receive_haiku').should==form # default to POST
+    Haiku.new.crushyform(['title','body','author_id'], '/receive_haiku').should==form # turn keys into symbols
+  end
+  
+  should 'have only fields not wrapped with a form tag if action is nil' do
+    form = Haiku.new.crushyform([:title,:body,:author_id])
+    form.should.not.match(/form/)
+    form.should.not.match(/action/)
+    form.should.not.match(/enctype/)
+  end
+  
+  should 'use crushyform_schema keys by default for the list of field to put in the form' do
+    form = Haiku.new.crushyform
+    form.should.not==''
+    Haiku.crushyform_schema.keys.each do |k|
+      form.should.match(/#{Haiku.new.crushyid_for(k)}/)
+    end
+  end
+  
+end
+
+::FileUtils.rm_rf(ROOT+'/test/stash') if F.exists?(ROOT+'/test/stash')

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: sequel-crushyform
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Mickael Riga
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-17 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: A Sequel plugin that helps building forms. It basically does them for you so that you can forget about the boring part. The kind of thing which is good to have in your toolbox for building a CMS.
+email: mig@mypeplum.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- LICENSE
+- README.md
+- lib/sequel_crushyform.rb
+- sequel-crushyform.gemspec
+- test/spec_crushyform.rb
+has_rdoc: true
+homepage: http://github.com/mig-hub/sequel-crushyform
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- ./lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: A Sequel plugin that helps building forms
+test_files: []
+