yodel 0.0.1

data/lib/yodel/models/migrations/05_user_model.rb

@@ -0,0 +1,24 @@
+class UserModelMigration < Migration
+  def self.up(site)
+    site.records.create_model :users do |users|
+      add_field :first_name, :string
+      add_field :last_name, :string
+      add_field :email, :email, validations: {required: {}, unique: {}}, searchable: false
+      add_field :oauth_id, :string, index: true, searchable: false
+      add_field :username, :string, index: true, validations: {required: {}, unique: {}}, searchable: false
+      add_field :password, :password, validations: {required: {}}, searchable: false
+      add_field :password_salt, :string, display: false, searchable: false
+      add_field :created_at, :time, display: false
+      add_many  :groups, default: [site.groups['Users'].id]
+      add_field :owner, :self
+      
+      add_field :name, :function, fn: 'format("{{first_name}} {{last_name}}").strip()'
+      users.icon = '/admin/images/user_icon.png'
+      users.record_class_name = 'User'
+    end
+  end
+  
+  def self.down(site)
+    site.users.destroy
+  end
+end

data/lib/yodel/models/migrations/06_snippet_model.rb

@@ -0,0 +1,13 @@
+class SnippetModelMigration < Migration
+  def self.up(site)
+    site.records.create_model :snippets do |snippets|
+      add_field :name, :string, validations: {required: {}}, index: true
+      add_field :content, :text
+      snippets.searchable = false
+    end
+  end
+  
+  def self.down(site)
+    site.snippets.destroy
+  end
+end

data/lib/yodel/models/migrations/07_search_page_model.rb

@@ -0,0 +1,32 @@
+class SearchPageModelMigration < Migration
+  def self.up(site)
+    operators = [ 'Equals', 'Not Equal', 'Greater Than',
+                  'Less Than', 'Greater Than or Equal To',
+                  'Less Than or Equal To', 'In']
+                  
+    site.pages.create_model :search_pages do |search_pages|
+      add_field :sort, :string, searchable: false
+      add_field :limit, :integer
+      add_field :skip, :integer
+      add_one   :type, model: :model
+      
+      add_embed_many :conditions do
+        add_field :name, :string
+        add_field :value, :string
+        add_field :operator, :enum, options: operators
+      end
+      
+      add_embed_many :user_conditions, default: [{name: 'search_keywords', as: 'query', operator: 'In'}] do
+        add_field :name, :string
+        add_field :as, :string
+        add_field :operator, :enum, options: operators
+      end
+      
+      search_pages.record_class_name = 'SearchPage'
+    end
+  end
+  
+  def self.down(site)
+    site.search_pages.destroy
+  end
+end

data/lib/yodel/models/migrations/08_default_site_options.rb

@@ -0,0 +1,21 @@
+class DefaultSiteOptionsMigration < Migration
+  def self.up(site)
+    site.options = {
+      pages: {
+        permalink_character: {
+          description: 'When Yodel creates a URL for a page by using the title of the page, there are sometimes characters (such as spaces) that need to be replaced. This character will be used in their place. e.g "About Us" would become "about-us".',
+          type: 'String',
+          default: '-',
+          value: '-'
+        }
+      },
+      icon: nil
+    }
+    site.save
+  end
+  
+  def self.down(site)
+    site.options = {}
+    site.save
+  end
+end

data/lib/yodel/models/migrations/09_security_page_models.rb

@@ -0,0 +1,36 @@
+class SecurityPageModelsMigration < Migration
+  def self.up(site)
+    site.pages.create_model :login_pages do |login_pages|
+      add_field :username_field, :string, validations: {required: {}}, default: 'username'
+      add_field :password_field, :string, validations: {required: {}}, default: 'password'
+      add_one   :redirect_to, model: :page
+      login_pages.record_class_name = 'LoginPage'
+    end
+    
+    site.pages.create_model :logout_pages do |logout_pages|
+      add_one :redirect_to, model: :page
+      logout_pages.record_class_name = 'LogoutPage'
+    end
+    
+    site.pages.create_model :password_reset_pages do |password_reset_pages|
+      add_field :success, :html, default: 'Thank you, your password has been emailed to your email address.'
+      add_field :email_field, :string, validations: {required: {}}, default: 'email'
+      password_reset_pages.record_class_name = 'PasswordResetPage'
+    end
+    
+    site.pages.create_model :facebook_login_pages do |facebook_login_pages|
+      add_field :callback_uri, :string
+      add_field :app_id, :string
+      add_field :app_secret, :string
+      add_one   :join_page, model: :page
+      add_one   :after_login_page, model: :page
+      facebook_login_pages.record_class_name = 'FacebookLoginPage'
+    end
+  end
+  
+  def self.down(site)
+    site.login_pages.destroy
+    site.logout_pages.destroy
+    site.password_reset_pages.destroy
+  end
+end

data/lib/yodel/models/migrations/10_record_proxy_page_model.rb

@@ -0,0 +1,17 @@
+class RecordProxyPageModelMigration < Migration
+  def self.up(site)
+    site.pages.create_model :record_proxy_pages do |record_proxy_pages|
+      add_one   :record_model, model: :model
+      add_one   :after_create_page, model: :page
+      add_one   :after_delete_page, model: :page
+      add_one   :after_update_page, model: :page
+      add_field :show_record_layout, :string
+      add_one   :show_record_layout_record, model: :layout, display: false
+      record_proxy_pages.record_class_name = 'RecordProxyPage'
+    end
+  end
+  
+  def self.down(site)
+    site.record_proxy_pages.destroy
+  end
+end

data/lib/yodel/models/migrations/11_email_model.rb

@@ -0,0 +1,28 @@
+class EmailModelMigration < Migration
+  def self.up(site)
+    site.records.create_model :emails do |emails|
+      add_field :name, :string
+      add_field :from, :string
+      add_field :to, :string
+      add_field :cc, :string
+      add_field :bcc, :string
+      add_field :subject, :string
+      add_field :text_body, :text
+      add_field :html_body, :html
+      add_field :html_layout, :string
+      emails.record_class_name = 'Email'
+    end
+    
+    # template password reset email
+    password_reset_email = site.emails.new
+    password_reset_email.name = 'password_reset'
+    password_reset_email.from = 'admin@site.com'
+    password_reset_email.subject = 'Password Reset'
+    password_reset_email.text_body = 'Hi <%= options["first_name"] %>, your password has been reset and is now: <%= options["new_password"] %>.'
+    password_reset_email.save
+  end
+  
+  def self.down(site)
+    site.emails.destroy
+  end
+end

data/lib/yodel/models/migrations/12_api_call_model.rb

@@ -0,0 +1,23 @@
+class APICallModelMigration < Migration
+  def self.up(site)
+    site.records.create_model :api_calls do |api_calls|
+      add_field :name, :string
+      add_field :http_method, :string
+      add_field :domain, :string
+      add_field :port, :integer, default: 80
+      add_field :path, :string
+      add_field :username, :string
+      add_field :password, :string
+      add_field :authentication, :enum, options: %w{basic digest}
+      add_field :mime_type, :string, default: 'json'
+      add_field :body, :text
+      add_field :body_layout, :string
+      add_field :function, :string
+      api_calls.record_class_name = 'APICall'
+    end
+  end
+  
+  def self.down(site)
+    site.api_calls.destroy
+  end
+end

data/lib/yodel/models/migrations/13_redirect_page_model.rb

@@ -0,0 +1,13 @@
+class RedirectPageModelMigration < Migration
+  def self.up(site)
+    site.pages.create_model :redirect_page do |redirect_pages|
+      add_field :url, :string, searchable: false
+      add_one   :page, show_blank: true, blank_text: 'None'
+      redirect_pages.record_class_name = 'RedirectPage'
+    end
+  end
+  
+  def self.down(site)
+    site.redirect_pages.destroy
+  end
+end

data/lib/yodel/models/migrations/14_menu_model.rb

@@ -0,0 +1,20 @@
+class MenuModelMigration < Migration
+  def self.up(site)
+    site.records.create_model :menu do |menus|
+      add_one   :root, model: :page, validations: {required: {}}
+      add_field :include_root, :boolean, default: false
+      add_field :include_all_children, :boolean, default: true
+      add_field :depth, :integer, default: 0, validations: {required: {}}
+      add_embed_many :exceptions do
+        add_one   :page
+        add_field :show, :boolean, default: false
+        add_field :depth, :integer, default: 0, validations: {required: {}}
+      end
+      menus.record_class_name = 'Menu'
+    end
+  end
+  
+  def self.down(site)
+    site.menus.destroy
+  end
+end

data/lib/yodel/models/models.rb

@@ -0,0 +1,8 @@
+Dir.chdir(File.dirname(__FILE__)) do
+  require './core/core'
+  require './api/api'
+  require './email/email'
+  require './pages/pages'
+  require './search/search'
+  require './security/security'
+end

data/lib/yodel/models/pages/form_builder.rb

@@ -0,0 +1,379 @@
+class FormBuilder
+  MONTHS = [
+    [1, "January"],
+    [2, "February"],
+    [3, "March"],
+    [4, "April"],
+    [5, "May"],
+    [6, "June"],
+    [7, "July"],
+    [8, "August"],
+    [9, "September"],
+    [10, "October"],
+    [11, "November"],
+    [12, "December"]
+  ]
+  
+  
+  def initialize(record, action, options={}, &block)
+    @record = record
+    @options = options
+    @block = block
+    @action = action
+    
+    @remote = options.delete(:remote)
+    @method = options.delete(:method) || 'post'
+    @params = options.delete(:params) || {}
+    @embedded_record = options.delete(:embedded_record)
+    @blank_record = options.delete(:blank_record)
+    @prefix = options.delete(:prefix)
+    @id = options.delete(:id) || "form_for_#{record.id}"
+    
+    # js functions
+    @success_function = options.delete(:success)
+    @errors_function  = options.delete(:errors)
+    @failure_function = options.delete(:failure)
+  end
+  
+  def form_for_section(section)
+    buffer = Ember::Template.buffer_from_block(@block)
+    section.displayed_fields.each do |field|
+      buffer << field_row(field.name, field)
+    end
+    ''
+  end
+  
+  def field_row(name, field=nil)
+    field = @record.fields[name.to_s] if field.nil?
+    "<div class='contains-field-type-#{field.options['type']}'>" << label(name).to_s << "<div>" << field(name).to_s << status(name).to_s << "</div></div>"
+  end
+  
+  
+  def field(name, options={}, &block)
+    invalid = @record.errors.key?(name.to_s)
+    field_name = name.to_s
+    field = @record.field(field_name)
+    input_name = (options.delete(:name) || field_name).to_s
+    input_name = "#{@prefix}[][#{input_name}]" if @prefix
+    value = options.delete(:value) || @record.get(field_name)
+    type = options.delete(:as) || field.default_input_type
+    
+    case type
+    when :text, :password, :hidden
+      value = nil if type == :password
+      value = value.id if value.is_a?(AbstractRecord)
+      value = value.to_s("F") if value.is_a?(BigDecimal)
+      element = build_element(:input, {type: type.to_s, value: value.to_s})
+    when :textarea
+      element = build_element(:textarea, {}, value.to_s)
+    when :html
+      element = build_element(:textarea, {class: 'html'}, value.to_s)
+    when :file, :image
+      elements = []
+      elements << build_element(:input, {type: 'hidden', name: input_name + '[_action]', value: 'set'})
+      if type == :file
+        elements << build_element(:p, {}, "File: <span>#{value && value.name || 'none'}</span>")
+      else
+        if !value.nil? && value.exist?
+          src = value.url(:admin_thumb).to_s
+          display = 'block'
+        else
+          src = ''
+          display = 'none'
+        end
+        elements << build_element(:div, {class: 'image_preview'}, [build_element(:img, {src: src, style: "display: #{display}"})])
+        elements << build_element(:p, {}, "Image: <span>#{(value && value.name) || 'none'}</span>")
+      end
+      elements << build_element(:input, {type: 'checkbox', name: input_name + '[_action]', value: 'clear'})
+      elements << build_element(:span, {}, "Delete")
+      elements << build_element(:input, {type: 'file', value: value.name, name: input_name + '[_value]'})
+      element = build_element(:span, {}, elements)
+    when :radio
+      base = {type: 'radio', name: input_name}
+      true_button   = build_element(:input, base.merge(condition('checked', value, ['true', true])))
+      false_button  = build_element(:input, base.merge(condition('checked', value, ['false', false])))
+      true_text     = options.delete(:true) || 'Yes'
+      false_text    = options.delete(:false) || 'No'
+      element = build_element(:span, {}, [true_text, true_button, false_text, false_button])
+    when :enum
+      element = build_select(value, field.options['options'], show_blank: field.show_blank, blank_text: field.blank_text)
+    when :store_one
+      element = build_select(value, field.record_options(@record), show_blank: field.show_blank, blank_text: field.blank_text, group_by: field.group_by, name_field: 'name', value_field: 'id')
+    when :store_many
+      element = build_select(value.collect(&:id), field.record_options(@record), show_blank: false, name_field: 'name', value_field: 'id', multiple: true)
+      input_name += '[]'
+    when :date, :datetime
+      # day
+      day_select = build_select(value.try(:day).to_s, (1..31), show_blank: true, blank_text: '', name_field: 'to_s', value_field: 'to_s')
+      day_select.set_attribute(:name, input_name + '[day]')
+      day_select.set_attribute(:id, input_name + '_day_')
+      
+      # month
+      month_select = build_select(value.try(:month).to_s, MONTHS, show_blank: true, blank_text: '', name_field: 'last', value_field: 'first')
+      month_select.set_attribute(:name, input_name + '[month]')
+      month_select.set_attribute(:id, input_name + '_month_')
+      
+      # year
+      year_select = build_select(value.try(:year).to_s, ((Time.now.year - 100)..(Time.now.year + 10)), show_blank: true, blank_text: '', name_field: 'to_s', value_field: 'to_s')
+      year_select.set_attribute(:name, input_name + '[year]')
+      year_select.set_attribute(:id, input_name + '_year_')
+      
+      elements = [day_select, month_select, year_select]
+      if type == :datetime
+        # hour
+        hour_select = build_select(value.try(:hour).to_s, (0..23), show_blank: true, blank_text: '', name_field: 'to_s', value_field: 'to_s')
+        hour_select.set_attribute(:name, input_name + '[hour]')
+        hour_select.set_attribute(:id, input_name + '_hour_')
+        
+        # minute
+        min_select = build_select(value.try(:min).to_s, (0..59), show_blank: true, blank_text: '', name_field: 'to_s', value_field: 'to_s')
+        min_select.set_attribute(:name, input_name + '[min]')
+        min_select.set_attribute(:id, input_name + '_min_')
+        
+        elements += [hour_select, min_select]
+      end
+      
+      element = build_element(:span, {}, elements)
+    when :embedded
+      if block_given?
+        if value.respond_to?(:each)
+          value.each do |document|
+            self.class.new(document, @action, {embedded_record: field, prefix: name, id: @id}, &block).render
+          end
+        else
+          self.class.new(value, @action, {embedded_record: field, prefix: name, id: @id}, &block).render
+        end
+      
+        if options.delete(:blank_record)
+          self.class.new(value.new, @action, {embedded_record: field, blank_record: true, prefix: name, id: @id}, &block).render
+        end
+      end
+      
+      buffer = Ember::Template.buffer_from_block(@block)
+      buffer << build_element(:input, {'type' => 'hidden', 'data-field' => input_name}).to_s
+    end
+    
+    element.tap do |element|
+      class_name = invalid ? 'invalid' : (@record.new? ? 'new' : 'valid')
+      class_name += " field-type-#{field.options['type']}"
+      element.set_attribute(:id, input_name.gsub(/\W/, '_'))
+      element.set_attribute(:name, input_name)
+      element.set_attribute(:class, class_name)
+      element.set_attribute(:placeholder, field.placeholder || '')
+      element.set_attribute('data-field', input_name)
+      options.each do |name, value|
+        element.set_attribute(name.to_s, value)
+      end
+    end if element
+  end
+  
+  def record
+    @record
+  end
+  
+  
+  def label(name, text=nil, options={})
+    text ||= name.to_s.humanize
+    build_element(:label, {:for => name.to_s}, text)
+  end
+
+  
+  def status(*params)
+    if params.last.is_a?(Hash)
+      handles = params[0...-1]
+      options = params.last
+    else
+      handles = params
+      options = {}
+    end
+    
+    handles       = handles.collect(&:to_s)
+    name          = options.delete(:as) || handles.first
+    new_text      = options.delete(:new).to_s
+    valid_text    = options.delete(:valid).to_s
+    invalid_text  = options.delete(:invalid).to_s
+    
+    if @record.errors.empty?
+      state = 'new'
+      message = new_text
+    elsif handles.any? {|name| @record.errors.key?(name)}
+      state = 'invalid'
+      unless invalid_text.blank?
+        message = invalid_text
+      else
+        message = handles.collect {|name| @record.errors.summarise[name]}.compact.join(', ')
+      end
+    else
+      state = 'valid'
+      message = valid_text
+    end
+    
+    render_status(name, handles.join(' '), message, state, new_text, valid_text, invalid_text)
+  end
+  
+  def progress(&block)
+    Ember::Template.wrap_content_block(block) do |content|
+      Hpricot::Elem.new('span', {
+        :class => 'yodel-form-activity',
+        :style => 'visibility: hidden'
+      }, [Hpricot::Text.new(content.join)])
+    end
+  end
+  
+  def success(&block)
+    @success_function = Ember::Template.content_from_block(block).join
+    ''
+  end
+  
+  def errors(&block)
+    @errors_function = Ember::Template.content_from_block(block).join
+    ''
+  end
+  
+  def failure(&block)
+    @failure_function = Ember::Template.content_from_block(block).join
+    ''
+  end
+  
+  def statuses(&block)
+    @status_template = block
+  end
+  
+  def blank_record?
+    @blank_record
+  end
+  
+  def render
+    if @embedded_record
+      buffer = Ember::Template.buffer_from_block(@block)
+      buffer << Ember::Template.content_from_block(@block, self)
+    else
+      Ember::Template.wrap_content_block(@block, self) do |content|
+        params = {
+          'action' => @action,
+          'method' => 'post',
+          'enctype' => 'multipart/form-data',
+          'data-remote' => (!!@remote).to_s,
+          'id' => @id
+        }.merge(@params)
+        
+        elements = [
+          Hpricot::Text.new(content.join),
+          Hpricot::Elem.new('input', {type: 'hidden', name: '_method', value: @method})
+        ]
+        
+        if @success_function
+          params['data-success-function'] = "#{@id}_success"
+          elements << Hpricot::Text.new(define_callback_function('success', 'record', @success_function))
+        end
+        
+        if @errors_function
+          params['data-errors-function'] = "#{@id}_errors"
+          elements << Hpricot::Text.new(define_callback_function('errors', 'errors', @errors_function))
+        end
+        
+        if @failure_function
+          params['data-failure-function'] = "#{@id}_failure"
+          elements << Hpricot::Text.new(define_callback_function('failure', 'xhr', @failure_function))
+        end
+        
+        Hpricot::Elem.new('form', params, elements)
+      end
+    end
+  end
+  
+  
+  private
+    def render_status(name, handles, message, state, new_text, valid_text, invalid_text)
+      if @status_template
+        element = Ember::Template.content_from_block(@status_template, name, message, state).join
+      else
+        element = Hpricot::Elem.new('span', {'class' => state}, [Hpricot::Text.new(message)])
+      end
+      
+      Hpricot::Elem.new('span', {
+        'data-new-text' => new_text,
+        'data-valid-text' => valid_text,
+        'data-invalid-text' => invalid_text,
+        'data-handles' => handles,
+        'class' => 'yodel-field-status'
+      }, [Hpricot::Text.new(element)])
+    end
+    
+    def define_callback_function(name, parameter, source)
+      function_name = "#{@id}_#{name}"
+      instance_variable_set("@#{name}_function_name", function_name)
+      Hpricot::Elem.new('script', {}, [
+        Hpricot::Text.new("var #{function_name} = function(#{parameter}, json){"),
+        Hpricot::Text.new(source.to_s),
+        Hpricot::Text.new("}"),
+      ])
+    end
+    
+    def build_element(tag, params, content=[])
+      content = [content] unless content.respond_to?(:to_a)
+      content = content.to_a.collect {|item| item.is_a?(String) ? Hpricot::Text.new(item): item}
+      Hpricot::Elem.new(tag.to_s, params, content)
+    end
+    
+    def condition(name, value, options, multiple=false)
+      options = [options] unless options.respond_to?(:to_a) && !options.is_a?(BSON::ObjectId)
+      {value: options.first}.tap do |attributes|
+        if multiple
+          attributes[name] = name if value.to_a.include?(options.first)
+        else
+          attributes[name] = name if options.to_a.include?(value)
+        end
+      end
+    end
+    
+    def build_select(current_value, values, options={})
+      show_blank = options[:show_blank]
+      blank_text = options[:blank_text]
+      group_by = options[:group_by]
+      name_field = options[:name_field]
+      value_field = options[:value_field]
+      
+      group_by_field = group_by.is_a?(Hash) ? group_by.keys.first : group_by
+      current_value = current_value.map(&:to_s) if options[:multiple]
+            
+      if group_by_field
+        select_options = Hash.new {|hash, key| hash[key] = []}
+      else
+        select_options = []
+      end
+      
+      values.each do |value|
+        if name_field && value_field
+          option_name = value.send(name_field).to_s
+          option_value = value.send(value_field).to_s
+        else
+          option_name = option_value = value.to_s
+        end
+        
+        element = build_element(:option, condition('selected', current_value, option_value, options[:multiple]), option_name)
+        
+        if group_by_field
+          key = value.send(group_by_field).to_s
+          select_options[key] << element
+        else
+          select_options << element
+        end
+      end
+      
+      if group_by_field
+        select_options = group_by[group_by_field].collect do |group_value, group_name|
+          build_element(:optgroup, {label: group_name}, select_options[group_value])
+        end
+      end
+      
+      if show_blank
+        blank_text = blank_text || 'Other'
+        select_options.unshift(build_element(:option, condition('selected', current_value.to_s, ''), blank_text))
+      end
+      
+      attributes = {}
+      attributes[:multiple] = 'multiple' if options[:multiple]
+      build_element(:select, attributes, select_options)
+    end
+end