radiant-forms-extension 2.0.0

data/lib/forms/site_controller_extensions.rb

@@ -0,0 +1,19 @@
+module Forms
+  module SiteControllerExtensions
+    def self.included(base)
+      base.class_eval {
+        before_filter :find_response
+        
+        def find_response
+          if request.session[:form_response]
+            @response = Response.find(request.session[:form_response])
+          else
+            @response = nil
+          end
+          
+          @response
+        end
+      }
+    end
+  end
+end

data/lib/forms/tags.rb

@@ -0,0 +1,277 @@
+module Forms
+  module Tags
+    include Radiant::Taggable
+    
+    class TagError < StandardError; end
+  
+    desc %{
+      Render a form and its contents
+      <pre><code><r:form name="object[key]" [method, url] /></code></pre>
+      
+      * *name* the name of the form
+      * *method* url submission method [ post, get, delete, put ]
+      * *url* address to submit the form to
+    }
+    tag 'form' do |tag|
+      
+      unless tag.attr['name'].blank?
+        if tag.locals.form = Form.find_by_title(tag.attr['name'])
+          tag.attr['id'] ||= 'form_' + tag.locals.form.title
+          tag.attr['method'] ||= 'post'
+          tag.attr['action'] ||= tag.locals.form.action.nil? ? "/forms/#{tag.locals.form.id}" : tag.locals.form.action      
+          return render_form(tag.locals.form, tag)
+        else
+          raise TagError, "Could not find '#{tag.attr['name']}' form"
+        end
+      else
+        tag.expand
+      end
+    
+    end
+
+    desc %{ 
+      Render a @<label />@ tag to be used inside a form
+      <pre><code><r:form:label for="object[key]" /></code></pre>
+      
+      **Required**
+      * *for* the name of the field you are relating the tag to
+      
+      _A label is a piece of text which activates its related input when clicked_
+    }
+    tag 'form:label' do |tag|
+      raise_error_if_missing 'form:label', tag.attr, 'for'
+      
+      tag.attr['for'] = tag.attr['for'].gsub('[','_').gsub(']','') unless tag.attr['for'].nil?
+    
+      %(<label #{form_attrs(tag)}>#{tag.expand}</label>)
+    end
+
+    %w(text password reset checkbox radio hidden file button).each do |type|
+      desc %{
+        Render a @<#{type}>...</#{type}>@ tag to be used in a form
+        <pre><code><r:form:#{type} name="object[key]" /></code></pre>
+
+        **Required**
+        * *name* the name of the data to be sent
+        
+        **Optional**
+        * *class* css class names
+        * *placeholder* default text, which is cleared when clicked
+        * *maxlength* the maximum amount of characters
+      }
+      tag "form:#{type}" do |tag|
+        raise_error_if_missing "form:#{type}", tag.attr, 'name'
+        
+        value = tag.attr['value']
+        tag.attr['type'] = type
+        
+        %(<input type="#{type}" value="#{value}" #{form_attrs(tag)} />)
+      end
+    end
+  
+    desc %{
+      Renders a @<select>...</select>@ tag to be used in a form
+    
+      <pre><code><r:form:select name="object[key]"><r:option value="text" /></r:form:select></code></pre>
+      
+      **Required**
+      * *name* the name of the data to be sent
+      
+      **Optional**
+      * *class* css class names
+      
+      _@<r:option />@ tags may be nested inside the tag to automatically generate options_
+    }
+    tag 'form:select' do |tag|
+      raise_error_if_missing 'form:select', tag.attr, 'name'
+      
+      tag.locals.parent_tag_name = tag.attr['name']
+      tag.locals.parent_tag_type = 'select'
+      
+      %(<select #{form_attrs(tag)}>#{tag.expand}</select>)
+    end
+  
+    desc %{
+      Renders a series of @<input type="radio"/>@ tags to be used in a form
+    
+      <pre><code><r:form:radios name="object[value]" value="text"><r:option value="text" /></r:form:radios></code></pre>
+      
+      **Required**
+      * *name* the name of the data to be sent
+      
+      **Optional**
+      * *class* css class names
+      
+      _@<r:option />@ tags may be nested inside the tag to automatically generate options_
+    }
+    tag 'form:radios' do |tag|
+      raise_error_if_missing 'form:radios', tag.attr, 'name'
+      
+      tag.locals.parent_tag_name = tag.attr['name']
+      tag.locals.parent_tag_type = 'radios'
+      tag.expand
+    end
+  
+    desc %{
+      Renders an @<option/>@ tag if the parent is a
+      @<r:form:select>...</r:form:select>@ or @<r:form:radios>...</r:form:radios>@
+      
+      **Required**
+      * *value* the value you want to be sent if selected
+    }
+    tag 'form:option' do |tag|
+      value = tag.attr['value'] || tag.expand
+
+      if tag.locals.parent_tag_type == 'select'
+        text = tag.expand.length == 0 ? value : tag.expand
+        %(<option #{form_attrs(tag, { 'value' => value})}>#{text}</option>)
+      elsif tag.locals.parent_tag_type == 'radios'
+        name = tag.locals.parent_tag_type == 'radios' ? tag.locals.parent_tag_name : tag.attr['name']
+        id = name.gsub('[','_').gsub(']','') + '_' + value
+        %(<input #{form_attrs(tag, { 'id' => id, 'value' => value, 'name' => name, 'type' => 'radio' })} />)
+      end
+    end
+
+    desc %{
+      Renders an @<input type="submit" />@ tag for a form.
+      
+      **Optional**
+      * *value* the text on the submit
+    }
+    tag 'form:submit' do |tag|
+      value = tag.attr['value'] || 'submit'
+      
+      %(<input #{form_attrs(tag, { 'value' => value, 'type' => 'submit', 'class' => 'submit', 'name' => 'submit' })} />)
+    end
+  
+    desc %{ 
+      Allows access to the response of a submitted form
+      @<r:form:response>...<r:get /><r:clear />...</r:form:response>@
+      
+      _Will not expand if a form has not been submitted or has been cleared_
+    }
+    tag 'form:response' do |tag|
+      tag.locals.form_response = find_form_response(tag)
+
+      tag.expand unless tag.locals.form_response.nil? or tag.locals.form_response.response.nil?
+    end
+  
+    desc %{
+      Access the attributes of a submitted form.
+      
+      @<r:form:get name=object[value]
+    }
+    tag 'form:response:clear' do |tag|
+      clear_form_response(tag)
+      
+      return nil
+    end
+
+    desc %{ 
+      Access the attributes of a submitted form.
+      
+      @<r:form:get name="object[value]" />@ an object which was submitted with the form
+      @<r:form:get name="mail_ext[value]" />@ a response to an extension which hooked the submission
+      
+      _Refer to the readme on extensions to find out what they return_
+    }
+    tag 'form:response:get' do |tag|
+      raise_error_if_missing 'form:response:get', tag.attr, 'name'
+      
+      results = hash_retrieve(tag.locals.form_response.result, tag.attr['name'])
+    end
+  
+    # accessing data when processing a form
+    desc %{
+      Query the data from a submitted form
+      
+      @<r:form:read name="object[value]" />@ access the object which was submitted
+      
+      _This can only be used in the content section of a form, use @<r:form:get />@ in pages_
+    }
+    tag 'form:read' do |tag|
+      raise_error_if_missing 'form:read', tag.attr, 'name'
+
+      data = hash_retrieve(tag.locals.page.data, tag.attr['name']).to_s      
+    end
+  
+  protected
+  
+    def form_attrs(tag, extras={})
+      @id = tag.attr['name'] || extras['name']
+      @id = @id || tag.attr['for'] + '_label' if tag.attr['for']
+      @id = @id.gsub('[','_').gsub(']','') unless @id.nil?
+    
+      attrs = {
+        'id'            => @id,  
+        'class'         => tag.attr['type'],
+        'name'          => nil,
+        'for'           => nil,
+        'method'        => nil,
+        'action'        => nil,
+        'placeholder'   => nil,
+        'value'         => nil,
+        'maxlength'     => nil
+      }.merge(extras)
+      
+      result = attrs.collect do |k,v|
+        v = (tag.attr[k] || v)
+        next if v.blank?
+        %(#{k}="#{v}")
+      end.reject{|e| e.blank?}
+      
+      result.join(' ')
+    end
+
+    def prior_value(tag, tag_name=tag.attr['name'])
+      #TODO make work with hash_retrieve
+    end
+
+    def render_form(form, tag)
+      string =  %(<form enctype="multipart/form-data" #{form_attrs(tag)}>\n)
+      string << %(<input type="hidden" name="page_id" value="#{tag.locals.page.id}" />\n)
+      string << %(<input type="hidden" name="form_id" value="#{tag.locals.form.id.to_s}" />\n)
+      string << "<r:form>"
+      string << form.body
+      string << "</r:form>"
+      string << %(</form>)
+      
+      text = parse(string)
+    end
+
+    def raise_error_if_missing(tag_name, tag_attr, name)
+      raise "'#{tag_name}' tag requires a '#{name}' attribute" if tag_attr[name].blank?
+    end
+
+    def find_form_response(tag)
+      if tag.locals.form_response
+        tag.locals.form_response
+      elsif request.session[:form_response]
+        Response.find(request.session[:form_response])
+      else
+        nil
+      end
+    end
+  
+    def clear_form_response(tag)
+      tag.locals.form_response.update_attribute('result', nil)
+    end
+  
+    # takes object[key] or value 
+    # Accesses the hash as hash[object][value]
+    # Accesses the value as hash[value]
+    def hash_retrieve(hash, array)
+      result = nil
+      
+      unless hash.nil? or hash.empty?
+        data = array.gsub("[","|").gsub("]","").split("|") rescue nil
+      
+        result = hash.fetch(data[0]) unless data.nil?
+        result = result.fetch(data[1]) unless data.nil? or data[1].nil?
+      end
+      
+      result
+    end
+  
+  end
+end

data/lib/tasks/forms_extension_tasks.rake

@@ -0,0 +1,55 @@
+namespace :radiant do
+  namespace :extensions do
+    namespace :forms do
+      
+      desc "Runs the migration of the Forms extension"
+      task :migrate => :environment do
+        require 'radiant/extension_migrator'
+        if ENV["VERSION"]
+          FormsExtension.migrator.migrate(ENV["VERSION"].to_i)
+          Rake::Task['db:schema:dump'].invoke
+        else
+          FormsExtension.migrator.migrate
+          Rake::Task['db:schema:dump'].invoke
+        end
+      end
+      
+      desc "Copies public assets of the Forms to the instance public/ directory."
+      task :update => :environment do
+        is_svn_or_dir = proc {|path| path =~ /\.svn/ || File.directory?(path) }
+        puts "Copying assets from FormsExtension"
+        Dir[FormsExtension.root + "/public/**/*"].reject(&is_svn_or_dir).each do |file|
+          path = file.sub(FormsExtension.root, '')
+          directory = File.dirname(path)
+          mkdir_p RAILS_ROOT + directory, :verbose => false
+          cp file, RAILS_ROOT + path, :verbose => false
+        end
+        unless FormsExtension.root.starts_with? RAILS_ROOT # don't need to copy vendored tasks
+          puts "Copying rake tasks from FormsExtension"
+          local_tasks_path = File.join(RAILS_ROOT, %w(lib tasks))
+          mkdir_p local_tasks_path, :verbose => false
+          Dir[File.join FormsExtension.root, %w(lib tasks *.rake)].each do |file|
+            cp file, local_tasks_path, :verbose => false
+          end
+        end
+      end  
+      
+      desc "Syncs all available translations for this ext to the English ext master"
+      task :sync => :environment do
+        # The main translation root, basically where English is kept
+        language_root = FormsExtension.root + "/config/locales"
+        words = TranslationSupport.get_translation_keys(language_root)
+        
+        Dir["#{language_root}/*.yml"].each do |filename|
+          next if filename.match('_available_tags')
+          basename = File.basename(filename, '.yml')
+          puts "Syncing #{basename}"
+          (comments, other) = TranslationSupport.read_file(filename, basename)
+          words.each { |k,v| other[k] ||= words[k] }  # Initializing hash variable as empty if it does not exist
+          other.delete_if { |k,v| !words[k] }         # Remove if not defined in en.yml
+          TranslationSupport.write_file(filename, basename, comments, other)
+        end
+      end
+    end
+  end
+end

data/radiant-forms-extension.gemspec

@@ -0,0 +1,87 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{radiant-forms-extension}
+  s.version = "2.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["dirkkelly"]
+  s.date = %q{2010-08-02}
+  s.description = %q{Send data from a page to a form handler, extendable with addons}
+  s.email = %q{dirk.kelly@squaretalent.com}
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    ".gitignore",
+     "README.md",
+     "Rakefile",
+     "VERSION",
+     "app/controllers/admin/forms_controller.rb",
+     "app/controllers/forms_controller.rb",
+     "app/models/form.rb",
+     "app/models/form_page.rb",
+     "app/models/response.rb",
+     "app/views/admin/forms/_fields.html.haml",
+     "app/views/admin/forms/_filters.html.haml",
+     "app/views/admin/forms/_form.html.haml",
+     "app/views/admin/forms/_header.html.haml",
+     "app/views/admin/forms/edit.html.haml",
+     "app/views/admin/forms/index.html.haml",
+     "app/views/admin/forms/new.html.haml",
+     "app/views/admin/forms/remove.html.haml",
+     "config/locales/en.yml",
+     "config/routes.rb",
+     "cucumber.yml",
+     "db/migrate/001_create_forms.rb",
+     "db/migrate/002_create_user_observer.rb",
+     "db/migrate/003_rename_output_to_content.rb",
+     "db/migrate/004_create_responses.rb",
+     "forms_extension.rb",
+     "lib/forms/admin_ui.rb",
+     "lib/forms/application_controller_extensions.rb",
+     "lib/forms/extension_methods.rb",
+     "lib/forms/page_extensions.rb",
+     "lib/forms/site_controller_extensions.rb",
+     "lib/forms/tags.rb",
+     "lib/tasks/forms_extension_tasks.rake",
+     "public/images/admin/extensions/form/form.png",
+     "radiant-forms-extension.gemspec",
+     "spec/controllers/forms_controller_spec.rb",
+     "spec/datasets/forms.rb",
+     "spec/lib/forms/extension_methods_spec.rb",
+     "spec/lib/forms/tags_spec.rb",
+     "spec/models/form_spec.rb",
+     "spec/models/response_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/squaretalent/radiant-forms-extension}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Forms Extension for Radiant CMS}
+  s.test_files = [
+    "spec/controllers/forms_controller_spec.rb",
+     "spec/datasets/forms.rb",
+     "spec/lib/forms/extension_methods_spec.rb",
+     "spec/lib/forms/tags_spec.rb",
+     "spec/models/form_spec.rb",
+     "spec/models/response_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/spec/controllers/forms_controller_spec.rb

@@ -0,0 +1,150 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe FormsController do
+  dataset :pages, :forms
+  
+  context '#create' do
+    
+    before :all do
+      @params = {
+        'request' => 'test'
+      }
+    end
+    
+    before :each do
+      @page = pages(:home)
+      @form = forms(:test)
+      mock(Page).find(anything) { @page }
+      mock(Form).find(anything) { @form }
+    end
+    
+    context 'initialize' do
+      
+      before :each do
+        post :create, @params
+      end
+        
+      it 'should assign the page' do
+        assigns(:page).should == @page
+      end
+  
+      it 'should assign the form' do
+        assigns(:form).should == @form
+      end
+  
+      it 'should put the params into the page data' do
+        assigns(:page).data['request'].should == @params['request']
+      end
+  
+      it 'should find/create a response object' do
+        assigns(:response).should be_an_instance_of(Response)
+      end
+  
+      it 'should add the params to the response result' do
+        assigns(:response).result['request'].should == @params['request']
+      end
+      
+    end
+    
+    context 'configuration' do
+
+      before :each do
+        post :create, @params
+      end
+      
+      context 'configuration exists' do
+        
+        it 'should assign the configuration settings' do
+          assigns(:form)[:config][:test]['config'].should == 'test'
+        end
+        
+      end
+      
+      context 'configuration doesn\'t exist' do
+        
+        before :each do 
+          @form.config = nil
+        end
+        
+        it 'should raise a form not configured exception' do
+          response.should raise_error
+        end
+        
+      end
+      
+    end
+  
+    context 'extensions' do
+      
+      before :each do
+        post :create, @params
+      end
+          
+      context 'extension configured' do
+      
+        it 'should call that test extension' do
+          assigns(:response).result['test_ext'].should == { 'response' => 'test' }
+        end
+        
+        it 'should not call the alt extension' do
+          assigns(:response).result['test_alt'].should be_nil
+        end
+      
+      end
+    
+    end
+    
+    context 'response' do
+      
+      context 'successfully save response' do
+        
+        before :each do
+          stub(@response).save { true }
+        end
+        
+        context 'form has a redirect url' do
+          
+          before :each do
+            @form.redirect_to = '/redirect/url'
+            post :create, @params
+          end
+          
+          it 'should redirect to the form redirect url' do
+            response.should redirect_to('/redirect/url')
+          end
+          
+        end
+        
+        context 'form does not have a redirect url' do
+          
+          before :each do
+            @page.slug = '/page/url'
+            post :create, @params
+          end
+          
+          it 'should render page url' do
+            response.should redirect_to(@page.url)
+          end
+          
+        end
+        
+      end
+      
+      context 'cant save response' do
+        
+        before :each do
+          stub(@response).save { false }
+          post :create, @params
+        end
+        
+        it 'should raise a form not submitted exception' do
+          response.should raise_error
+        end
+        
+      end
+      
+    end
+    
+  end
+  
+end

data/spec/datasets/forms.rb

@@ -0,0 +1,30 @@
+class FormsTestController
+  include Forms::ExtensionMethods
+  def create
+    result = { :response => 'test' }
+  end
+end
+
+class FormsAltController
+  include Forms::ExtensionMethods
+  def create
+    result = { :response => 'alt' }
+  end
+end
+
+class FormsDataset < Dataset::Base
+  
+  def load
+    attributes = {
+      :title        => "test_form",
+      :body         => "<r:text name='request[test]' />",
+      :content      => "<r:form:read name='request[test]' />",
+      :config       => <<-CONFIG
+test:
+  config: test
+CONFIG
+    }
+    create_record :form, :test, attributes
+  end
+  
+end

data/spec/lib/forms/extension_methods_spec.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Forms::ExtensionMethods do
+  dataset :forms, :pages
+  
+  before :each do
+    @page = pages(:home)
+    @form = forms(:test)
+  end
+  
+  context 'initializer' do
+        
+    it 'should expect a form and page object' do
+      lambda { FormsTestController.new(@form, @page) }.should_not raise_error
+    end
+    
+  end
+    
+  context 'instance variables' do
+    
+    before :each do
+      @forms_test = FormsTestController.new(@form, @page)
+    end
+    
+    it 'should have a forms attribute' do
+      @forms_test.form.should be_an_instance_of(Form)
+      @forms_test.form.should == @form
+    end
+    
+    it 'should have a page attribute' do
+      @forms_test.page.should be_an_instance_of(Page)
+      @forms_test.page.should == @page
+    end
+    
+    it 'should have a data attribute' do
+      @forms_test.data.should == @page.data
+    end
+    
+  end
+  
+end