fluffery 0.0.1

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.DS_Store
+.rvmrc

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in fluffery.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/fluffery.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "fluffery/version"
+
+Gem::Specification.new do |s|
+  
+  s.name        = "fluffery"
+  s.version     = Fluffery::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["kurb media"]
+  s.date        = %q{2011-03-10}  
+  s.email       = %q{info@kurbmedia.com}
+  s.homepage    = %q{http://github.com/kurbmedia/fluffery}
+  s.licenses    = ["MIT"]
+  s.summary     = %q{ummm.. Adds misc fluffery to yer apps.}
+  s.description = %q{Random fluffage for Rails applications.}
+
+  s.rubyforge_project = "fluffery"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_development_dependency(%q<rails>, ["~> 3.0.0"])
+  s.add_development_dependency(%q<actionpack>, ["~> 3.0.0"])
+  s.add_development_dependency(%q<rspec>, ["~> 2.3"])
+  s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+  
+  
+end

data/lib/fluffery.rb

@@ -0,0 +1,21 @@
+module Fluffery
+  
+  autoload :Config, 'fluffery/config'
+  
+  module Forms
+    autoload :Builder,   'fluffery/forms/builder'
+    autoload :Utilities, 'fluffery/forms/utilities'
+  end
+  
+  module Helpers
+    autoload :Navigation,    'fluffery/helpers/navigation'
+    autoload :PageVariables, 'fluffery/helpers/page_variables'
+    autoload :Elements,      'fluffery/helpers/elements'
+    autoload :Includes,      'fluffery/helpers/includes'
+  end
+  
+  module Utils
+    autoload :Internal, 'fluffery/utils/internal'
+  end
+  
+end

data/lib/fluffery/config.rb

@@ -0,0 +1,29 @@
+module Fluffery
+  
+  class Config
+    
+    def self.forms
+      @forms ||= {
+        :error_class         => 'field_with_errors',
+        :message_error_class => 'errors_for_field',
+        :error_template      => %{
+              <span class="<%= error_class %>">
+                   <%= html_tag %>
+                   <span class="<%= message_error_class %>"><%= [messages].flatten.join(",") %></span>
+              </span>
+            }
+          }
+    end
+    
+    def self.dom
+      @dom ||= {}
+    end
+    
+    def initialize
+      yield Fluffery::Config if block_given?
+    end
+    
+    
+  end
+  
+end

data/lib/fluffery/forms/builder.rb

@@ -0,0 +1,142 @@
+module Fluffery
+  module Forms
+    
+    class Builder < ActionView::Helpers::FormBuilder
+      
+      include Fluffery::Forms::Utilities
+      
+      # Access the template object
+      attr_accessor :template
+      
+      # Sets up options custom to our form builder.
+      # It also overrides the default error proc so we can use something more custom.
+      #
+      def initialize(object_name, object, template, options, proc)
+        without_error_proc do
+          super(object_name, object, template, options, proc)          
+        end        
+      end
+      
+      # Creates a html button tag for use in forms instead of the default input submit.
+      # Uses a span to wrap the content so it can be styled with css.
+      #
+      def button(value = nil, options = {})
+        value, options = nil, value if value.is_a?(Hash)
+        value ||= submit_default_value
+        
+        options = confirm_or_disable(options)        
+        options = Fluffery::Utils::Internal.merge_html_classes(options, 'button')
+
+        content_tag(:button, options.reverse_merge!({ "type" => "submit", "name" => "commit" })) do
+          content_tag(:span, value.to_s)
+        end
+
+      end
+      
+      # Custom label tag including an asterisk if the field is required.
+      #
+      def label(method, text = nil, options = {}, &block)
+
+        options, text = text, nil if text.is_a?(Hash)
+        text ||= method.to_s.humanize
+        options.stringify_keys!
+        
+        options.reverse_merge!('transform' => :titleize) unless option_exists?(options['transform'])
+        text.send(options['transform'].to_sym)
+        options.delete('transform')
+        
+        # Check to see if :required is set on a label, or if the attribute/method has a validator that require it exists. 
+        # If so, add a * to the label.
+        text = "#{text} <abbr title='Required'>*</abbr>".html_safe if validator.attribute_required?(method, options)
+        super(method, text, options, &block)
+
+      end
+      
+      def email_field(method, options = {})
+        render_with_fluff(method, options) do
+          super(method, options.merge!('type' => 'email'))
+        end
+      end
+      
+      # Renders the default date_select but with an error wrapping if 
+      # the method in question has errors
+      #
+      def date_select(method, options = {}, html_options = {})
+        render_with_fluff(method, options, html_options) do
+          super(method, options, html_options)
+        end        
+      end
+      
+      # HTML5 Number field, again, falls back to text in unsupportive browsers.
+      #
+      def number_field(method, range, options = {})
+        options, range = range, nil if range.is_a?(Hash)
+        options.stringify_keys!
+        unless range.nil?
+          range = (range.is_a?(Range)) ? range.to_a : range
+          options.merge!('min' => range.first, 'max' => range.last)
+        end
+        
+        render_with_fluff(method, options) do
+          super(method, options.merge!('type' => 'number'))
+        end
+        
+      end
+      
+      def password_field(method, options = {})
+        render_with_fluff(method, options) do
+          super(method, options)
+        end
+      end
+      
+      def select(method, choices, options = {}, html_options = {})
+        render_with_fluff(method, options, html_options) do
+          @template.select(@object_name, method, choices, options, html_options)
+        end
+      end
+      
+      def state_select(method, options = {}, html_options = {})
+        
+        state_options = [['Please Select',nil]]
+        state_options << ['International', (int || 'International')] if int = options.delete(:international)
+        [
+            ['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"]
+        ].each do |state|
+          should_abbr = options.delete(:abbreviate)
+          state_options << (should_abbr ? state : [state.first, state.first])
+        end
+        
+        select(method, @template.options_for_select(state_options, @object.try(:state)), options, html_options)
+        
+      end
+      
+      def text_field(method, options = {})
+        render_with_fluff(method, options) do
+          super(method, options)
+        end
+      end
+      
+      def text_area(method, options = {})
+        render_with_fluff(method, options) do
+          super(method, options)
+        end
+      end
+
+      def url_field(method, options = {})
+        render_with_fluff(method, options) do
+          super(method, options.merge!('type' => 'url'))
+        end
+      end  
+      
+    end
+    
+  end
+end

data/lib/fluffery/forms/utilities.rb

@@ -0,0 +1,89 @@
+require 'erb'
+require 'fluffery/forms/validation/base'
+
+module Fluffery
+  module Forms
+    
+    module Utilities
+      
+      # Simply shortening calls to content_tag since it is a method of @template
+      #
+      def content_tag(tag, content, options = {}, escape = true, &block)
+        @template.content_tag(tag, content, options, escape, &block)
+      end
+      
+      # Adds data-confirm, or data-disable-with if set.
+      #
+      def confirm_or_disable(options)
+        options.stringify_keys!
+        options.merge!("data-disable-with" => options["disable_with"]) if options.delete("disable_with")
+        options.merge!("data-confirm" => options["confirm"]) if options.delete("confirm")
+        options
+      end
+      
+      # Allows us to call something like f.error_console to log form errors
+      # to a javascript console such as firebug
+      #
+      def error_console
+        "<script type=\"text/javascript\" charset=\"utf-8\">
+        //<![CDATA[
+            try{ console.log(\"#{@template.escape_javascript(@object.errors.inspect)}\")}catch(e){}
+        //]]>
+        </script>".html_safe
+      end
+      
+      # Quick helper to see if an option is nil, blank, or false
+      #
+      def option_exists?(opt)
+        !(opt.nil? || opt.to_s.blank? || opt.to_s === "false")
+      end
+      
+      # Generate additional options on our fields.
+      # 1. If a field has errors, wrap it with the defined error template.
+      # 2. Also add our error class to the field itself.
+      #
+      def render_with_fluff(method, options, html_options = nil, &block)        
+        _options = html_options.nil? ? options : html_options
+        _options = validator.add_html_attributes(method, _options)
+        # If no errors, simply return.
+        unless validator.errors_for?(method)
+          return block.call
+        end
+        
+        configs     = Fluffery::Config.forms
+        template    = configs[:error_template]
+        error_class = configs[:error_class]
+        _options    = Fluffery::Utils::Internal.merge_html_classes(_options, error_class)
+        options     = _options if html_options.nil?
+        
+        # Capture the original html tag with any updated options.
+        html_tag = block.call
+        return html_tag if template.nil? or template.blank?
+        
+        renderer            = ERB.new(template)
+        messages            = @object.errors[method.to_sym]
+        message_error_class = configs[:message_error_class]
+        renderer.result(
+          OpenStruct.new(configs.merge!(:messages => messages)).send(:binding)
+          ).to_s.html_safe
+        
+      end
+      
+      def validator
+        @validator ||= Fluffery::Forms::Validation::Base.new(@object)
+      end
+      
+      # Override the default error proc for our forms, making sure to
+      # set it back when we are finished to avoid compatibility issues.
+      #
+      def without_error_proc
+        default_proc = ActionView::Base.field_error_proc
+        ActionView::Base.field_error_proc, proc = lambda{ |html_tag, instance| html_tag }
+        yield        
+        ActionView::Base.field_error_proc = default_proc
+      end
+      
+    end
+    
+  end
+end

data/lib/fluffery/forms/validation/base.rb

@@ -0,0 +1,178 @@
+module Fluffery
+  module Forms
+    module Validation
+      
+      class Base
+        
+        require 'fluffery/forms/validation/validators'
+        
+        attr_accessor :object
+        
+        def initialize(form_object)
+          @object = form_object
+        end
+        
+        def add_html_attributes(attribute, options)
+          options = Presence.create(attribute, options) if attribute_required?(attribute)
+          matcher = attribute_format_validator(attribute)
+          options = Pattern.create(attribute, options, matcher) unless matcher.nil?
+          options.reverse_merge!(default_messages_for(attribute))
+          options
+        end
+        
+        # Checks to see if the particular attribute is required, used primarily on labels.
+        #
+        def attribute_required?(attribute, options = nil)
+          options.stringify_keys! if options.is_a?(Hash)
+          unless options.nil?
+            return true if options.has_key?('required') and options['required'] === true
+          end
+          valid_items = validators_for(attribute).find do |validator| 
+            ([:presence, :inclusion].include?(validator.kind)) && 
+            (validator.options.present? ? options_require_validation?(validator.options) : true)
+          end        
+          !valid_items.nil?        
+        end
+        
+        # Checks to see if a particular attribute contains a Regex format validator
+        #
+        def attribute_format_validator(attribute)          
+          format_validator = validators_for(attribute).detect{ |v| v.kind == :format }
+          return nil unless !format_validator.nil?
+          return nil unless format_validator.options.has_key?(:with) && format_validator.options[:with].is_a?(Regexp)
+          matcher = format_validator.options[:with]
+        end
+        
+        # Looks up the default error message so it may be used in our data-message attribute
+        #
+        def default_messages_for(attribute)
+          validators   = validators_for(attribute)
+          return {} if validators.empty?
+          message_data = validators.inject({}) do |hash, validator|
+            message = validator.options.has_key?(:message) ? validator.options[:message] : MessageBuilder.message_for(@object, attribute, validator)
+            hash.merge!(validator.kind.to_s => message)
+          end
+          attr_hash = {'data-validation-messages' => CGI::escape(message_data.to_json) }
+          
+          # Create a list of data-validates-* attrs on the field so we can catch them with javascript
+          # Skip presence and format because they have their own valid HTML5 attrs.
+          #
+          validators.reject{ |v| v.kind.to_s.match(/(presence|format)/i) }.each{ |v| attr_hash.merge!("data-validates-#{v.kind.to_s}" => 'true') }
+          
+          attr_hash
+          
+        end
+
+        # Checks to see if the particular attribute has errors
+        #
+        def errors_for?(method)
+          !(@object.nil? || @object.errors.empty? || !@object.errors.key?(method.to_sym) || [@object.errors[method.to_sym]].flatten.empty?)
+        end
+
+        # Checks to see if the validation is required
+        # Courtesy Justin French and Formtastic
+        #
+        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
+
+        # Finds all existing validations for the current object and method
+        #
+        def validators_for(attribute)
+          return [] unless !@object.nil? and @object.class.respond_to?(:validators_on)
+          attribute  = attribute.to_s.sub(/_id$/, '').to_sym
+          validators = @object.class.validators_on(attribute).uniq
+        end
+        
+        def validators_for?(method)
+          !validators_for(method).empty?
+        end
+        
+      end
+      
+      class MessageBuilder
+        def self.message_for(object, attribute, validator)
+          message = self.get_validation_message(validator)
+          message = self.defaults(validator.kind) unless message.match(/translation missing/i).nil?
+          message
+        end
+        
+        private
+        
+        def self.defaults(validator)
+          {
+            :presence     => "required",
+            :format       => 'invalid',
+            :length       => "wrong length",
+            :numericality => "not a number",
+            :uniqueness   => 'taken',
+            :confirmation => 'required',
+            :acceptance   => 'required',
+            :inclusion    => 'invalid',
+            :exclusion    => 'invalid'
+          }[validator]
+        end
+        
+        def self.get_validation_message(validator)
+          key = {
+            :presence     => "blank",
+            :format       => 'invalid',
+            :length       => self.length_options(validator.options),
+            :numericality => self.numericality_options(validator.options),
+            :uniqueness   => 'taken',
+            :confirmation => 'confirmation',
+            :acceptance   => 'accepted',
+            :inclusion    => 'inclusion',
+            :exclusion    => 'exclusion'
+          }[validator.kind]
+          key.is_a?(Array) ? I18n.translate("errors.messages.#{key.first}").sub("%{#{:count}}", key.last.to_s) : I18n.translate("errors.messages.#{key}")
+        end
+
+        def self.length_options(opts)
+          if count = opts[:is]
+            ["wrong_length", count]
+          elsif count = opts[:minimum]
+            ["too_short", count]
+          elsif count = opts[:maximum]
+            ["too_long", count]
+          end
+        end
+
+        def self.numericality_options(opts)
+          if opts[:only_integer]
+            'not_a_number'
+          elsif count = opts[:greater_than]
+            ['greater_than', count]
+          elsif count = opts[:greater_than_or_equal_to]
+            ['greater_than_or_equal_to', count]
+          elsif count = opts[:less_than]
+            ['less_than', count]
+          elsif count = opts[:less_than_or_equal_to]
+            ['less_than_or_equal_to', count]
+          elsif opts[:odd]
+            'odd'
+          elsif opts[:even]
+            'even'
+          else
+            'not_a_number'
+          end
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/fluffery/forms/validation/validators.rb

@@ -0,0 +1,21 @@
+module Fluffery
+  module Forms
+    module Validation
+      
+      class Presence < Fluffery::Forms::Validation::Base        
+        def self.create(attribute ,options)
+          options.merge!('required' => 'required') unless options.has_key?('required') && options['required'] === false          
+          options
+        end        
+      end
+      
+      class Pattern < Fluffery::Forms::Validation::Base
+        def self.create(attribute, options, matcher)
+          options.reverse_merge!('pattern' => matcher.inspect) unless matcher.nil?
+          options
+        end        
+      end
+      
+    end
+  end
+end

data/lib/fluffery/helpers/elements.rb

@@ -0,0 +1,57 @@
+module Fluffery
+  module Helpers
+    
+    module Elements
+      
+      # Simply overriding the default form_for to add additional html options/attributes.      
+      def form_for(record_or_name_or_array, *args, &block)
+        
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        options[:html] ||= {}
+        
+        # Add support for the 'ajax' uploader.        
+        options[:html].merge!('data-remote-uploadable' => true) if options.delete(:remote_upload)        
+        # Add support for javascript validation.
+        options[:html].merge!('data-js-validatable' => true) if options.delete(:validate)
+        
+        args = (args << options)         
+        super(record_or_name_or_array, *args, &block)
+        
+      end
+      
+      # Creates a common format for CSS buttons
+      # Example: button_link('Blog', '/blog') yields <a href="/blog" class="button"><span>Blog</span></a>
+
+      def button_link(txt, path, attrs = {})
+        inline_classes = attrs.has_key?(:class) ? "#{attrs[:class]} " : ""
+        link_to "<span>#{txt}</span>".html_safe, path, attrs.merge({ :class => "#{inline_classes}button" })    
+      end
+      
+      # Outputs all flash messages. This allows you to call <%= flash_messages %> once in your
+      # application's layout file. The output is a div with the class flash_message, and the type used. It also renders
+      # a "close" tag, which can be overridden or set to "". By default this is a span containing 'X'
+      #
+      # <div class="flash_message error">
+      #      Your error message from flash[:error]
+      #      <span>X</span>
+      #  </div>
+      #
+      #
+      def flash_messages(attrs = {})
+        wrapper = attrs.delete(:wrapper) || :div
+        closer  = attrs.delete(:close) || "<span>X</span>"
+        classes = (attrs.key?(:class)) ? attrs[:class].split(' ') : []
+        classes << "flash_message"  
+        content = ""    
+        flash.each_key do |k|
+          classes << "flash_message_#{k.to_s.underscore}"
+          msg_attrs = attrs.merge(:class => [k.to_s, classes].flatten.join(' '))
+          content.concat content_tag(wrapper, "#{flash[k]} #{closer}".html_safe, msg_attrs).html_safe
+        end    
+        content.html_safe    
+      end
+      
+    end
+    
+  end
+end

data/lib/fluffery/helpers/includes.rb

@@ -0,0 +1,20 @@
+module Fluffery
+  module Helpers
+    
+    module Includes
+      
+      # Wraps output in IE conditional tags, the condition should be specified in the same
+      # format as it would in the conditional itself. For example:
+      # ie_conditional('lte IE 8') yields [if lte IE 8]
+      #
+      def ie_conditional(condition, &block)
+        output = ["<!--[if #{condition}]>"]
+        output << capture(&block)
+        output << "<![endif]-->"
+        output.join("\n").html_safe
+      end
+      
+    end
+    
+  end
+end

data/lib/fluffery/helpers/navigation.rb

@@ -0,0 +1,47 @@
+module Fluffery
+  module Helpers
+    module Navigation
+      
+      # Creates a navigation link (by default a list item) that has the class 'on' if we are on that particular page or a
+      # page beneath it.
+      # Example: nav_link_to('Blog', 'blog') will have the class of 'on' should we be on /blog or /blog/some_path 
+
+      def nav_link_to(txt, path, attrs = {}, wrapper = :li)
+
+        path_validation = false
+        path_validation = attrs.has_key?(:proc) ? attrs[:proc].call(path) : (request.path == path || request.path.match(/#{path}\/.*/i)) 
+        path_validation = request.path.match(/#{attrs[:matcher].gsub("_path", path)}/i)   if attrs.has_key?(:matcher)
+        attrs.delete(:proc)
+        attrs.delete(:matcher)
+        
+        wrapper_attrs = attrs.delete(:wrapper)
+        attrs, wrapper_attrs = merge_html_classes(attrs, path_validation), merge_html_classes(wrapper_attrs, path_validation)
+        
+        return_val = link_to_unless(path_validation, txt, path, attrs) do
+          link_to(txt, path, attrs)
+        end
+
+        (wrapper.eql? false) ? return_val : content_tag(wrapper, return_val, wrapper_attrs)
+
+      end
+      
+      # Creates a nested navigation block, generally used for lists/nested lists.
+      def navigation(txt, path, attrs = {}, options = {}, &block)
+        options.reverse_merge!(:container => :ol, :wrapper => :li)        
+        navigation_content = content_tag(options[:container], capture(&block))
+        wrapper_attrs = attrs.delete(:wrapper)
+        parent_link        = nav_link_to(txt, path, attrs, false)
+        content_tag(options[:wrapper], "#{parent_link}\n#{navigation_content}".html_safe, (wrapper_attrs || {}))        
+      end
+      
+      private
+      
+      def merge_html_classes(attrs, add_on = false)
+        attrs ||= {}
+        Fluffery::Utils::Internal.merge_html_classes(attrs, 'on') if add_on
+        attrs
+      end
+      
+    end
+  end
+end

data/lib/fluffery/helpers/page_variables.rb

@@ -0,0 +1,51 @@
+module Fluffery
+  module Helpers
+    
+    module PageVariables
+      
+      def page_default(param, data = nil)
+        create_variable("helpful_#{param}", data) unless data.nil? or data.blank?
+      end
+      
+      def page_id(content = nil)
+        create_internal_variable(:helpful_page_id, content) and return unless content.nil?
+        return retrieve_variable(:helpful_page_id) if content_for?(:helpful_page_id)
+        cname = controller.class.to_s.gsub(/controller$/i,'').underscore.split("/").join('_')
+        aname = controller.action_name
+        "#{cname}_#{aname}"
+      end
+            
+      def page_title(content = nil)
+        (content.nil?) ? retrieve_variable(:helpful_page_title) : create_internal_variable(:helpful_page_title, content)
+      end
+      
+      def keywords(content = nil)
+        (content.nil?) ? retrieve_variable(:helpful_keywords) : create_internal_variable(:helpful_keywords, content)
+      end
+      
+      def description(content = nil)
+        (content.nil?) ? retrieve_variable(:helpful_description) : create_internal_variable(:helpful_description, content)
+      end
+      
+      def create_variable(var, content, new_method = true)
+        content_for(var.to_sym) do
+          content
+        end                        
+        self.class_eval{ define_method("#{var.to_s}"){ retrieve_variable(var.to_sym) } } if new_method
+        return ""
+      end
+      
+      private
+      
+      def create_internal_variable(var, content)
+        create_variable(var, content, false)
+      end
+      
+      def retrieve_variable(var)
+        (content_for?(var.to_sym) ? content_for(var.to_sym) : "")
+      end
+      
+    end
+    
+  end
+end

data/lib/fluffery/railtie.rb

@@ -0,0 +1,14 @@
+module Fluffery
+  class Railtie < Rails::Railtie
+        
+    initializer :after_initialize do
+      # Configure ActionView with any addons.
+      ActionView::Base.send :include, Fluffery::Helpers::Navigation
+      ActionView::Base.send :include, Fluffery::Helpers::PageVariables
+      ActionView::Base.send :include, Fluffery::Helpers::Elements
+      ActionView::Base.send :include, Fluffery::Helpers::Includes
+      ActionView::Base.send :default_form_builder=, Fluffery::Forms::Builder
+    end
+    
+  end
+end

data/lib/fluffery/utils/configurator.rb

@@ -0,0 +1,9 @@
+module Fluffery
+  module Utils
+  
+    class Configurator
+      
+    end
+    
+  end
+end

data/lib/fluffery/utils/internal.rb

@@ -0,0 +1,19 @@
+module Fluffery
+  module Utils
+    
+    class Internal
+    
+      # Merge any new classes with existing html classes
+      #
+      def self.merge_html_classes(options, classes)
+        classes = [classes].flatten
+        options.stringify_keys!
+        return options.merge!('class' => classes.join(' ')) unless options.has_key?('class')
+        old_classes = options['class'].split(' ')
+        options.merge!('class' => [classes, old_classes].flatten.join(' '))
+      end
+    
+    end
+    
+  end  
+end

data/lib/fluffery/version.rb

@@ -0,0 +1,3 @@
+module Fluffery
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification 
+name: fluffery
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- kurb media
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-10 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 3.0.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: actionpack
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 3.0.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.3"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :development
+  version_requirements: *id004
+description: Random fluffage for Rails applications.
+email: info@kurbmedia.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Rakefile
+- fluffery.gemspec
+- lib/fluffery.rb
+- lib/fluffery/config.rb
+- lib/fluffery/forms/builder.rb
+- lib/fluffery/forms/utilities.rb
+- lib/fluffery/forms/validation/base.rb
+- lib/fluffery/forms/validation/validators.rb
+- lib/fluffery/helpers/elements.rb
+- lib/fluffery/helpers/includes.rb
+- lib/fluffery/helpers/navigation.rb
+- lib/fluffery/helpers/page_variables.rb
+- lib/fluffery/railtie.rb
+- lib/fluffery/utils/configurator.rb
+- lib/fluffery/utils/internal.rb
+- lib/fluffery/version.rb
+has_rdoc: true
+homepage: http://github.com/kurbmedia/fluffery
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: fluffery
+rubygems_version: 1.6.1
+signing_key: 
+specification_version: 3
+summary: ummm.. Adds misc fluffery to yer apps.
+test_files: []
+