transit 0.0.1 → 0.0.2

data/app/views/transit/pages/index.html.erb

@@ -0,0 +1,17 @@
+<%= page_id('transit_index') %>
+<%= page_title("Transit: Manage Pages") %>
+<h1>Manage Pages</h1>
+<%= paginate(@pages, :remote => true) %>
+<table border="0" id="listing">
+	<thead>
+		<tr>
+			<th>Name</th>
+			<th>URL</th>
+			<th>Edit</th>
+		</tr>
+	</thead>
+	<tbody>
+		<%= render :partial => 'table' %>
+	</tbody>
+</table>
+<%= paginate(@pages, :remote => true) %>

data/app/views/transit/pages/update.js.erb

@@ -0,0 +1 @@
+success

data/app/views/transit/posts/_form.html.erb

@@ -0,0 +1,49 @@
+<%= form_for resource, as: :post, validate: true do |f| %>
+<%= transit_toolbar(resource) do %>
+	<ol>
+		<% unless resource.new_record %>
+		<li class="menu">
+			<span class='ui-icon ui-icon-circle-plus'></span>
+			Add a New Item
+			<ol class="ui-state-hover">
+				<% Transit.contexts.map(&:to_s).each do |type| %>
+				<li class="icon_<%= type.underscore %>">
+					<%= link_to type, new_polymorphic_path([resource, Transit::Context], type: type, form_name: 'post'), :remote => true %>
+				</li>
+				<% end %>
+			</ol>
+		</li>
+		<% end %>
+		<li class="multifield post_date menu" id="datepicker_target">
+			<span class='ui-icon ui-icon-calendar'></span>
+			Post Date
+			<span id="post_date_selects"><%= f.date_select :post_date, { order: [:month, :day, :year], use_short_month: true } %></span>
+		</li>
+		<% unless resource.new_record? %>
+		<li>
+			<%= f.check_box :published, class: 'toggle_button', data: { 'ui-icon' => 'ui-icon-star' } %>
+			<%= f.label :published %>
+		</li>		
+		<li>
+			<%= toolbar_button('Delete This Post', polymorphic_path(resource), method: :delete, class: 'ui-icon-red', icon: 'closethick') %>
+		</li>
+		<% end %>
+	</ol>
+	<%= f.hidden_field(:user, value: current_user.id) if resource.delivers?(:owner) %>	
+<% end %>
+
+<div id="post">
+	<%= render partial: 'transit/posts/fields/title', locals: { form: f } %>
+	<%= render template: 'transit/contexts/index', locals: { form: f } %>
+</div>
+<div id='edit_post_sidebar'>
+	<% if resource.delivers?(:topics) %>
+	<%= render(partial: 'transit/topics/model', locals: { form: f }) %>
+	<% end %>
+	<% if resource.delivers?(:assets) %>
+	<%= render(partial: 'transit/assets/model', locals: { form: f }) %>
+	<% end %>
+
+<%= f.button %>
+<% end %>
+<%= text_field_tag :datepicker_holder, resource.post_date.strftime('%Y-%m-%d'), rel: 'post_post_date', data: { 'calendar-link' => "#post_date_menu" } %>

data/app/views/transit/posts/edit.html.erb

@@ -0,0 +1,14 @@
+<%= page_id("#{resource_collection_name}_show") %>
+<%= page_title("Edit Post #{resource.title}") %>
+<h2 class='main_heading'>Edit Post</h2>	
+<%= form_for(resource, as: :post, html: { remote: true }) do |f| %>
+<div id='edit_post_form'>
+	<div class="post">
+		<h1 class='transit-editable' rel="post_title"><%= resource.title %></h1>
+		<p class='timestamp'>Posted <%= resource.timestamp %></p>
+		<%= render(template: 'transit/contexts/index', locals: { form: f }) %>
+	</div>
+</div>
+<%= render(template: 'transit/interface/post_panel', locals: { form: f }) %>
+<%= f.hidden_field :title %>
+<% end %>

data/app/views/transit/posts/new.html.erb

@@ -0,0 +1,21 @@
+<%= page_id("#{resource_collection_name}_show") %>
+<%= page_title("Create a New Post") %>
+<h2 class='main_heading'>New Post</h2>	
+<%= form_for(resource, as: :post, html: { remote: true }) do |f| %>
+<div id='edit_post_form'>
+	<div class="post">
+		<h1 class='transit-editable' rel="post_title">Add your title here</h1>
+		<%= f.label :teaser, 'Teaser (optional)', style: 'padding-top:1em; display:block;' %>
+		<%= f.text_area :teaser, id: 'new_post_teaser' %>
+		<p id='new_post_help_note'>
+			Once you click Create Post! below you will be able to edit things like files/images and the overall content 
+			that will be displayed in your post.
+		</p>
+	</div>
+</div>
+<%= render(template: 'transit/interface/post_panel', locals: { form: f }) %>
+<%= f.hidden_field :title %>
+<p style="clear:both">
+	<%= f.button 'Create Post!', class: 'green' %>
+</p>
+<% end %>

data/app/views/transit/table.html.erb

@@ -0,0 +1,13 @@
+<% collection.each do |item| %>
+<tr<%= cycle(""," class='even'") %>>
+<% resource_class.admin_options.column_hash.each do |name, value| %>
+	<% if value.is_a?(Array) %>
+	<td><%= value.last.call(item) %></td>
+	<% else %>
+	<td><%= item.send(:"#{name.to_s}") %></td>
+	<% end %>
+<% end %>
+	<td><%= link_to 'Edit', transit.edit_polymorphic_path(item) %></td>
+	<td><%= link_to 'Delete', transit.polymorphic_path(item), method: :delete, confirm: 'Are you sure?' %></td>
+</tr>
+<% end %>

data/app/views/transit/table.js.erb

@@ -0,0 +1,8 @@
+$("#listing tbody").slideUp('fast',
+	function(){
+		$(this)
+			.empty()
+			.html("<%= escape_javascript(render(template: "transit/table.html.erb")) %>")
+			.slideDown('fast');
+			$('p.pagination').replaceWith("<%= escape_javascript(paginate(collection, :remote => true)) %>");	
+	});

data/app/views/transit/topics/manage.html.erb

@@ -0,0 +1,28 @@
+<div id="post_topics">
+	<h4>Topics</h4>
+	<ol>
+		<li class='select_list'>
+			<%= select_tag :topics, options_for_select(Topic.for_editing(resource_class, resource).collect{ |t| [t.title, t.id.to_s] }), id: 'all_topics_list' %>
+			<%= link_to 'Add', '#', class: 'add_to_list icon_add ui-button', id:'add_topic_link', data: { ui_icon: 'plus' } %>
+		</li>
+		<li id="topic_selections" rel="<%= "post[topics][]" %>">
+			<ul>
+				<% form.object.topics.each do |topic| %>
+				<li rel="<%= topic.id.to_s %>">
+					<%= topic.title %>
+					<%= hidden_field_tag "post[topics][]", topic.id.to_s %>
+					<%= link_to 'Remove', '#', class: 'icon_delete remove_from_list' %>
+				</li>
+				<% end %>
+			</ul>
+		</li>
+	</ol>
+	<script type="text/javascript" charset="utf-8">
+	//<![CDATA[
+		jQuery('#all_topics_list').selectToList({ 
+			target:'#topic_selections ul', 
+			name:  jQuery('#topic_selections').attr('rel'), 
+			add:   jQuery('#add_topic_link') });
+	//]]>
+	</script>
+</div>

data/config/locales/en.yml

@@ -0,0 +1,22 @@
+en:
+  flash:
+    actions:
+      create:
+        success: '%{resource_name} was successfully created.'
+        error: 'Looks like there was a problem with your submission!'
+      update:
+        success: '%{resource_name} was successfully updated.'
+        error: 'Looks like there was a problem with your submission!'
+      destroy:
+        success: '%{resource_name} was successfully destroyed.'
+        error: '%{resource_name} could not be destroyed.'
+  transit:
+    post_collection: 'Posts'
+    blog_collection: 'Blog Posts'
+    article_collection: 'Articles'
+    post: 'Post'
+    blog: 'Blog Post'
+    article: 'Article'
+    
+    legends:
+      topics: "Topics"

data/config/routes.rb

@@ -1,5 +1,5 @@
 Transit::Engine.routes.draw do
-  match "packages/:scope_name/:scope_id/contexts/new" => 'contexts#new', :as => :new_package_context, :via => [:get]
-  match "packages/:scope_name/:scope_id/contexts/:id" => 'contexts#destroy', :as => :package_context, :via => [:delete]
-  root :to => 'index#index'
+  resources :posts
+  resources :pages
+  resources :package_assets, :controller => 'assets'
 end

data/lib/transit.rb

@@ -1,30 +1,60 @@
-require 'rails'
 require 'active_support'
-require 'mongoid'
+require 'transit/core_ext'
 
 module Transit
   
-  autoload :Package, 'transit/package'
-  autoload :Context, 'transit/context'
+  autoload :Admin, 'transit/admin'
+  autoload :Config, 'transit/config'
   
-  module Helpers
-    autoload :ControllerHelpers,  'transit/helpers/controller_helpers'
-    autoload :ModelHelpers,       'transit/helpers/model_helpers'
+  module Package
+    autoload :Post, 'transit/package/post'
+    autoload :Page, 'transit/package/page'
+  end
+  
+  module Model
+    autoload :Assets,        'transit/model/assets'
+    autoload :Attachments,   'transit/model/attachments'
+    autoload :AutoIncrement, 'transit/model/auto_increment'
+    autoload :Comments,      'transit/model/comments'
+    autoload :Topics,        'transit/model/topics'
+    autoload :Base,          'transit/model/base'
+    autoload :Hooks,         'transit/model/hooks'
+    autoload :Owners,        'transit/model/owners'
+    autoload :Paginator,     'transit/model/paginator'
+  end
+  
+  module Controller
+    autoload :Generator,  'transit/controller/generator'
+    autoload :Responder,  'transit/controller/responder'
   end
   
   module Errors
-    autoload :InvalidContext, 'transit/errors/invalid_context'
+    autoload :InvalidContext,   'transit/errors/invalid_context'
+    autoload :ResourceNotFound, 'transit/errors/resource_not_found'
   end
   
+  module Builders
+    autoload :JstBuilder,      'transit/builders/jst_builder'
+    autoload :FormBuilder,     'transit/builders/form_builder'
+    autoload :PackageBuilder,  'transit/builders/package_builder'
+  end
+    
   DESCRIPTIONS = {}
-  CONTROLLERS  = []
   
-  def self.add_controller(klass)
-    CONTROLLERS << klass.to_s.classify.pluralize
+  # Store an array of controller mappings
+  mattr_accessor :mappings
+  @@mappings = []
+
+  def self.add_mapping(obj)
+    @@mappings << obj
   end
-  
+
+  def self.configure(&block)
+    yield Transit::Config
+  end
+
   def self.contexts
-    Transit::Context.subclasses.map(&:to_s).uniq
+    ["Text","Video", "Audio"]
   end
   
   def self.track(klass, template)
@@ -36,8 +66,12 @@ module Transit
     DESCRIPTIONS[template] ||= []
   end
   
+  def self.superclass_for(template)
+    DESCRIPTIONS[template].detect do |klass|
+      klass.constantize.superclass === Object
+    end
+  end
+  
 end
-
-require 'transit/package'
-require 'transit/rails/engine'
-require 'transit/rails/routing'
+require 'transit/model/hooks'
+require 'transit/rails/engine'

data/lib/transit/admin.rb

@@ -0,0 +1,85 @@
+module Transit
+  ##
+  # Manages configuration options for models.
+  # When a model is managed via the admin, register it by Transit::Admin.register and 
+  # passing a configuration block.
+  # 
+  # @example Assign the columns to be displayed on "index"
+  #   Transit::Admin.register :model_name do |config|
+  #     config.columns = [:name, :title]
+  #   end
+  # 
+  module Admin
+    
+    def self.register(klass, &block)
+      klass = klass.to_s.classify.constantize
+      unless klass.respond_to?(:admin_options)
+        klass.send(:class_attribute, :admin_options, instance_writer: false)
+      end
+      dsl = klass.admin_options ||= DSL.new
+      block.call(dsl)
+      klass.admin_options = dsl
+    end
+    
+    class DSL
+      
+      attr_accessor :columns, :column_hash, :fields
+      
+      ##
+      # Specify the columns to be displayed in the admin. At minimum the name of a 
+      # method is required. For additional options, use hash syntax.
+      # 
+      # @example List a title and post_date column
+      #   config.columns :title, :post_date
+      # 
+      # @example List a title field, and a post_date field, where post_date uses a proc to describe its value. When called
+      # the proc will be passed a reference to the current object.
+      # 
+      #   config.columns :title, post_date: lambda{ |obj| obj.created_at.to_formatted_s }
+      # 
+      # @example Overriding the displayed name
+      #   
+      #   config.columns :title, timestamp: { as: 'Post Date' }
+      # 
+      def columns(*cols)
+        options = cols.extract_options!
+        @column_hash = ActiveSupport::OrderedHash.new
+        cols.each.each do |col|
+          @column_hash[col] = col.to_s.titleize
+        end
+        options.each do |name, value|
+          @column_hash[name] = case value
+          when Proc then [name.to_s.titleize, value]
+          when Hash
+            colname = (value[:as].present? ? value[:as].to_s.titleize : name.to_s.titleize)
+            (value[:proc].present? ? [colname, value[:proc]] : colname)
+          end
+        end
+      end
+      
+      ##
+      # Specify the form fields used for each attribute. When inheriting posts or pages 
+      # defaults are already pre-defined and normally only need to be overridden.
+      # 
+      # @example Specify a text_area for the title and teaser of a post
+      #   config.fields title: :text_area, teaser: :text_area
+      #
+      def fields(field_hash = {})
+        @fields.merge!(field_hash) unless field_hash.empty?
+        @fields
+      end
+      
+      def initialize
+        @fields = ActiveSupport::HashWithIndifferentAccess.new({
+          title:      :text_field,
+          teaser:     :text_area,
+          post_date:  { date_select: { order: [:month, :day, :year], use_short_month: true } },
+          image:      :file_field,
+          photo:      :file_field
+        })
+      end
+      
+    end
+    
+  end
+end

data/lib/transit/builders/form_builder.rb

@@ -0,0 +1,319 @@
+module Transit  
+  module Builders
+    
+    ##
+    # Base class for creating form builders
+    # 
+    class FormBuilder < ActionView::Helpers::FormBuilder #:nodoc:
+      
+      # Access the template object
+      attr_accessor :template
+      # Tracks the order in which fields are used in the form, this allows the easy rebuilding of the submitted form
+      # data when submitted since normally the hash isn't ordered.
+      attr_accessor :field_order
+      # Tracks the field currently being "processed"
+      attr_accessor :current_field_type
+
+      # create overrides for custom rendering
+      [:email_field, :password_field, :text_field, :text_area, :url_field].each do |method|      
+        class_eval <<-FUNC, __FILE__, __LINE__ + 1
+
+          alias :_super_#{method} :#{method}
+
+          def #{method}(method_name, *args)
+            render_field_as_custom(:#{method}, method_name, *args)
+          end
+        FUNC
+      end
+
+      ##
+      # Modified label tag to support adding a 'required' asterisk to the end of the label.
+      # Same params as the original implementation
+      # 
+      def label(method, text = nil, options = {}, &block) #:nodoc:
+
+        options, text = text, nil if text.is_a?(Hash)
+        text ||= method.to_s.humanize
+
+        options.stringify_keys!
+        klasses = (options.delete(['class']) || "").split(" ")
+        klasses << 'field_with_errors' if errors_on_attribute?(method)
+        options['class'] = klasses.join(" ") unless klasses.compact.empty?
+
+        text = "#{text} <abbr title='Required'>*</abbr>".html_safe  if attribute_required?(method) || required_by_option?(options.delete('required'))        
+        super(method, text, options, &block)
+
+      end
+
+      ##
+      # 
+      # Creates a button tag to be used in a form instead of the default input[type=submit]
+      # to help make CSS styling easier
+      # 
+      # @param [String] value The text for the button
+      # @param [Hash] options HTML options to be passed to the button
+      # @option [String] icon If included, adds an image to the button to be used as an icon
+      # 
+      def button(value = nil, options = {})
+
+        value, options = nil, value if value.is_a?(Hash)
+        value ||= submit_default_value
+
+        value    = [image_tag(icon, :class => 'icon'), value].join(' ') if icon = options.delete(:icon)
+        klasses = (options.delete(:class) || "").split(" ")
+        klasses << "button"
+        options['class'] = klasses.join(" ")
+        content_tag(:button, value.to_s.html_safe, options.reverse_merge!({ "type" => "submit", "name" => "commit" }))
+
+      end
+      
+      # Overrides fields_for to make sure the form builder is set properly
+      # 
+      def fields_for(record_or_name_or_array, *args, &block) #:nodoc:
+        opts = args.extract_options!
+        opts.merge!(:builder => Transit::Builders::FormBuilder)
+        args.push(opts)
+        super(record_or_name_or_array, *args, &block)
+      end
+      
+
+      ##
+      # 
+      # Generate a select tag with the 50 US states as options
+      # 
+      # @param [Symbol] method The object method/attribute to be used
+      # @param [Hash] options Same as Rails' select options hash
+      # @option options [Symbol] :international Include an international option
+      # @option options [Symbol] :abbreviate Use an abbreviated version of the state name for the value
+      # @param [Hash] html_options Same as Rails' html_options hash
+      # 
+      # @return [String] HTML select tag
+      # 
+      def state_select(method, options = {}, html_options = {})
+        abbr = options.delete(:abbreviate)
+        abbr = !(abbr.nil? || abbr === false)
+        select(method, @template.options_for_select(options_for_state_select(abbr, options.delete(:international)), @object.try(:state)), options, html_options)        
+      end
+
+      protected
+
+      ##
+      # 
+      # Returns a list of US states as an array
+      # 
+      # @param [Boolean] abbreviate Abbreviate the value
+      # @param [Boolean, String] incl_international Include an additional state for "International"
+      # 
+      # @return [Array] An array of states
+      # 
+      def options_for_state_select(abbreviate = false, incl_international = false)
+        incl_international ||= false
+        state_list = [
+            ['Alabama', "AL"],['Alaska', "AK"],['Arizona', "AZ"],['Arkansas', "AR"],['California', "CA"],['Colorado', "CO"],
+          	['Connecticut', "CT"],['District of Columbia', "DC"],['Delaware', "DE"],['Florida', "FL"],['Georgia', "GA"],
+          	['Hawaii', "HI"],['Idaho', "ID"],['Illinois', "IL"],['Indiana', "IN"],['Iowa', "IA"],['Kansas', "KS"],['Kentucky', "KY"],
+          	['Louisiana', "LA"],['Maine', "ME"],['Maryland', "MD"],['Massachusetts', "MA"],['Michigan', "MI"],['Minnesota', "MN"],
+          	['Mississippi', "MS"],['Missouri', "MO"],['Montana', "MT"],['Nebraska', "NE"],['Nevada', "NV"],['New Hampshire', "NH"],
+          	['New Jersey', "NJ"],['New Mexico', "NM"],['New York', "NY"],['North Carolina', "NC"],['North Dakota', "ND"],
+          	['Ohio', "OH"],['Oklahoma', "OK"],['Oregon', "OR"],['Pennsylvania', "PA"],['Rhode Island', "RI"],['South Carolina', "SC"],
+          	['South Dakota', "SD"],['Tennessee', "TN"],['Texas', "TX"],['Utah', "UT"],['Vermont', "VT"],['Virginia', "VA"],['Washington', "WA"],
+          	['West Virginia', "WV"],['Wisconsin', "WI"],['Wyoming', "WY"]
+
+        ].map do |state|
+          (abbreviate ? state : [state.first, state.first])
+        end
+        state_list << ['International', incl_international] unless incl_international === false
+        state_list
+      end
+            
+      ##
+      # 
+      # Checks to see if a particular attribute is required, if so, a "required" attribute is added to the field.
+      # 
+      # @param [Symbol] attribute The attribute to check against validators
+      # @return [Boolean]
+      # 
+      def attribute_required?(attribute)
+        validates_presence?(attribute) || validates_inclusion?(attribute)
+      end
+      
+      # Convenience method to use the +content_tag+ method from our template
+      # 
+      def content_tag(tag, content, options = {}, escape = true, &block) #:nodoc:
+        @template.content_tag(tag, content, options, escape, &block)
+      end
+      
+      ##
+      # Checks to see if there are errors for the particular method or attribute
+      # 
+      # @param [Symbol] method The method/attribute to check
+      # 
+      # @return [Boolean]
+      #
+      def errors_on_attribute?(method)
+        return false if @object.nil?
+        !(@object.errors.empty? || !@object.errors[method.to_sym].present? || [@object.errors[method.to_sym]].flatten.empty?)
+      end
+      
+      ##
+      # 
+      # Checks a passed validator to see if it is required
+      # 'borrowed' from Formtastic by Justin French (see https://github.com/justinfrench/formtastic)
+      # 
+      # @param [Hash] options Validator options
+      # 
+      def options_require_validation?(options)
+        
+        allow_blank = options[:allow_blank]
+        return !allow_blank unless allow_blank.nil?
+        if_condition = !options[:if].nil?
+        condition = if_condition ? options[:if] : options[:unless]
+
+        condition = if condition.respond_to?(:call)
+          condition.call(@object)
+        elsif condition.is_a?(::Symbol) && @object.respond_to?(condition)
+          @object.send(condition)
+        else
+          condition
+        end
+        if_condition ? !!condition : !condition
+      end
+      
+      ##
+      # 
+      # Checks an options hash to determine if a required method/attribute was overridden manually
+      # @param [Hash] options The options hash to check
+      #
+      #
+      def required_by_option?(options)
+        req = (options.is_a?(Hash) ? options.stringify_keys[:required] : options)
+        !(req.to_s === 'false' || req.nil?)
+      end
+      
+      ##
+      # 
+      # Wrapper method used by all form fields to customize the output
+      # 
+      # @param [Symbol] helper_method Original Rails helper method name
+      # @param [Symbol] method Object method / symbol used for the element
+      # @param [Array] args Array of original arguments passed to the helper
+      # 
+      # @return [String] Rendered HTML tag for the element
+      # 
+      def render_field_as_custom(helper_method, method, *args)
+
+        @current_field_type = helper_method
+        
+        options = args.extract_options!
+        (@field_order ||= []) << method
+        
+        # Add an error class to the field if it has errors
+        #
+        if errors_on_attribute?(method)
+          klasses = (options.delete(:class) || "").split(" ")
+          klasses << "field_with_errors"
+          options[:class] = klasses.join(" ")
+        end
+        
+        # Add a required attribute to the field if it is required
+        # Skip if false was passed as the required option
+        # 
+        options[:required] = "required" if attribute_required?(method) && options.delete(:required).to_s !=  'false'
+        options['data-validates-uniqueness'] = "true" if validates_uniqueness?(method)
+        
+        result   = send(:"_super_#{helper_method}", method, *(args << options))
+        messages = @object.nil? ? [] : @object.errors[method]
+        render_field_with_errors(method, result, messages)
+        
+      end
+      
+      ##
+      # 
+      # Renders the passed +html_tag+ with the custom error_template
+      # 
+      # @param [Symbol] method The method/attribute to check for errors
+      # @param [Object, String] html_tag Instance of an input tag or a string
+      # @param [Array] messages An array of all error messages to be added to the template
+      # 
+      def render_field_with_errors(method, html_tag, messages)
+        
+        return html_tag unless errors_on_attribute?(method)
+        
+        error_class         = 'field_with_errors'
+        message_error_class = 'errors_for_field'
+        render_binding      = binding
+        error_template      = %{
+              <span class="<%= error_class %>">
+                   <%= html_tag %>
+                   <span class="<%= message_error_class %>"><%= [messages].flatten.join(",") %></span>
+              </span>}
+              
+        renderer = ERB.new(error_template)
+        renderer.result(render_binding).to_s.html_safe        
+      end
+      
+      ##
+      # 
+      # Compiles an array of all validators for a particular attribute
+      # @param [Symbol] attribtue The attribute to check
+      # 
+      def validators_for(attribute)
+        
+        return [] if @object.nil?
+        return [] unless @object.class.respond_to?(:validators_on)
+        
+        attribute  = attribute.to_s.sub(/_id$/, '').to_sym
+        @object.class.validators_on(attribute).uniq
+        
+      end
+      
+      ##
+      # 
+      # Convenience method to see if a particular attribute has validators
+      # @param [Symbol] attribute The attribute to check
+      # 
+      def validators_for?(attribute)
+        !validators_for(attribute).empty?
+      end
+      
+      ##
+      # 
+      # Checks for a presence validation on a particular attribute
+      # @param [Symbol] attribute The attribute to check
+      # 
+      def validates_presence?(attribute)
+        validator_of_type_exists?(validators_for(attribute), :presence)
+      end
+      
+      ##
+      # 
+      # Checks for a uniqueness validation on a particular attribute
+      # @param [Symbol] attribute The attribute to check
+      # 
+      def validates_uniqueness?(attribute)
+        validator_of_type_exists?(validators_for(attribute), :uniqueness, false)
+      end
+      
+      ##
+      # 
+      # Checks for inclusion validation on a particular attribute
+      # @param [Symbol] attribute The attribute to check
+      # 
+      def validates_inclusion?(attribute)
+        validator_of_type_exists?(validators_for(attribute), :inclusion)
+      end
+      
+      private
+      
+      def validator_of_type_exists?(validators, kind, check_options = true) #:nodoc: @private
+        validators.detect do |validator| 
+          exists = (validator.kind.to_s == kind.to_s)
+          next exists unless (check_options && exists) && validator.options.present?
+          options_require_validation?(validator.options)
+        end
+      end
+      
+    end
+    
+  end
+end