instructions 0.1.0

data/spec/error_message_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe ErrorMessage do
+	before do
+		@model = Object.new
+		@model_errors = []
+		@model.stub :errors => @model_errors
+		@error_message_object = Object.new.extend ErrorMessage
+		set_model_errors
+		@error_message = @error_message_object.compose_error_message :some_attribute, @model
+	end
+
+	context "composing an error message for a field with many errors" do
+		def set_model_errors
+			@model_errors.stub :[] => ["some error message", "some other error message"]
+		end
+		
+		observe "combines the many error messages into a single message" do
+			@error_message.should == "some error message, some other error message"
+		end
+	end
+
+	context "composing an error message for a field with one error" do
+		def set_model_errors
+			@model_errors.stub :[] => ["some error message"]
+		end
+
+		observe "reports the single error" do
+			@error_message.should == "some error message"
+		end
+	end
+
+	context "composing an error message for a field with no errors" do
+		def set_model_errors
+			@model_errors.stub :[] => []
+		end
+
+		observe "doesn't compose an error message" do
+			@error_message.should == ""
+		end
+	end
+end

data/spec/error_message_tag_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe ErrorMessageTag do
+	context "building" do
+		because { ErrorMessageTag.build :some_attribute, @model, "some_model"	}
+	
+		observe "composes instructions from error messages" do
+			ErrorMessageTag.should_have_received :compose_error_message
+		end
+	end
+
+	context "rendering errors for a field that has no errors" do
+		before do
+			@model = Object.new
+
+			@human_attribute_name = "Some Attribute"
+			@model.class.stub :human_attribute_name => @human_attribute_name
+
+			@model_errors = []
+			@model.stub :errors => @model_errors
+			@model_errors.stub :[] => []
+
+			@tag = ErrorMessageTag.build :some_attribute, @model, "some_model"
+		end
+	
+		observe "renders an empty error message" do
+			@tag.render.should include(">Some Attribute</")
+		end
+	end
+end

data/spec/fake_model.rb

@@ -0,0 +1,17 @@
+module FakeModel
+	def self.included(base)
+		base.class_eval do
+			before :each do
+				@model = Object.new
+				@model.stub :new_record? => false
+				@model.stub :some_attribute => "some attribute"
+		
+				@human_attribute_name = "Some Attribute"
+				@model.class.stub :human_attribute_name => @human_attribute_name
+	
+				@model_errors = []
+				@model.stub :errors => @model_errors
+			end
+		end
+	end
+end

data/spec/field_error_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe FieldError do
+	before do
+		@html_tag = "some html"
+
+		@model = "some model"
+		@model_errors = []
+		@attribute_errors = "some error message"
+
+		@model.stub :errors => @model_errors
+		@model_errors.stub :[] => @attribute_errors
+
+		@error_data = "some error data"
+		@error_data.stub :object => @model
+		@error_data.stub :object_name => "Model"
+
+		@attribute_name = "attribute"
+		@human_attribute_name = "Attribute"
+		@model.class.stub :human_attribute_name => @human_attribute_name
+
+		@error_data.stub :method_name => @attribute_name
+
+		@field_error = FieldError.new
+	end
+
+	context "rendering" do
+		before do
+			@html = FieldError.field_error_proc.call @html_tag, @error_data
+		end
+	
+		observe "should render the field with the error wrapping" do
+			@html.should == '<div class="field_with_errors">some html</div>'
+		end
+	end
+
+	context "rendering" do
+		because { FieldError.render_field_with_error @html_tag, @error_data }
+	
+		observe "wrap the html tag with a field with errors div" do
+			FieldError.should_have_received(:wrap_html_tag_with_field_with_errors_div)
+		end
+	
+		observe "humanize the attribute name" do
+			@model.class.should_have_received(:human_attribute_name)
+		end
+	end
+
+	context "when rendering a div tag" do
+		before do
+			@html_tag = "<label>#{@html_tag}</label>"
+		end
+		
+		because { FieldError.render_field_with_error @html_tag, @error_data }
+	
+		observe "wrap the label tag with a model data with with errors div" do
+			FieldError.should_have_received(:wrap_label_tag_with_field_with_errors_label_div)
+		end
+
+		observe "doesn't render the error message" do
+			FieldError.should_not_have_received(:model_error_div)
+		end
+	end
+
+	context "when rendering the html tag with an error" do
+		before do
+			@html = FieldError.wrap_html_tag_with_field_with_errors_div @html_tag
+		end
+	
+		observe "wrap the field with a field_with_errors div" do
+			@html.gsub(/some html/, '').should == '<div class="field_with_errors"></div>'
+		end
+	end
+ 
+	context "when rendering a label tag for a field with an error" do
+		before do
+			@html_tag = '<label>some model label</label>'
+			@html = FieldError.wrap_label_tag_with_field_with_errors_label_div @html_tag
+		end	
+
+		observe "wrap the div with a model label with errors div" do
+			@html.gsub(/<label>some model label<\/label>/, '').should == '<div class="field_with_errors_label"></div>'
+		end
+	end
+end

data/spec/form_helper_spec.rb

@@ -0,0 +1,123 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require File.join(File.expand_path(File.dirname(__FILE__)), 'fake_model')
+
+describe FormHelper do
+	include FakeModel
+	
+	before do
+		@helper = Object.new.extend FormHelper
+		model = @model			
+		@helper.instance_eval { @object = model }
+	end
+
+	context "rendering instructions" do
+		before do
+			@tag = Object.new.extend Tag
+			@tag.stub :render => nil
+
+			@helper.stub :renderer => @tag
+		end
+
+		because {	@helper.instructions :some_attribute, "some_instructions" }
+
+		observe "determines the tag renderer to use" do
+			@helper.should_have_received(:renderer)
+		end
+
+		observe "renders instructions" do
+			@tag.should_have_received(:render)
+		end
+	end
+	
+	context "rendering instructions" do
+		before do
+			@tag = Object.new.extend Tag
+			@tag.stub :render
+			@helper.stub :renderer => @tag
+		end
+
+		because {	@helper.instructions :some_attribute, "some_instructions" }
+
+		observe "determines the tag renderer to use" do
+			@helper.should_have_received(:renderer)
+		end
+
+		observe "renders instructions" do
+			@tag.should_have_received(:render)
+		end
+	end
+	
+	context "determining the renderer" do
+		before do
+			@helper.stub :determine
+			@helper.stub :merge
+		end
+
+		because { @tag = @helper.renderer :some_attribute, "can't be blank" }
+
+		it "determines the attribute state" do
+			@helper.should_have_received(:determine)
+		end
+
+		it "gets the formatters" do
+			@helper.should_have_received(:merge)
+		end
+	end
+
+	context FormHelper, "renderer" do
+		before do
+			@formatters = {:some_key => :some_value}
+			@helper.stub :merge => @formatters
+		end
+
+		context "for a new attribute" do
+			before do
+				@helper.stub :determine => :new
+				@tag = @helper.renderer :some_attribute, "can't be blank"
+			end
+
+			observe "uses the instructions tag" do
+				@tag.class.should == InstructionsTag
+			end
+
+			observe "configures tag with formatters" do
+				@tag.formatters.should == @formatters
+			end
+		end
+
+		context "for a valid attribute" do
+			before do
+				@helper.stub :determine => :valid
+				@tag = @helper.renderer :some_attribute, "can't be blank"
+			end
+
+			observe "uses the valid instructions tag" do
+				@tag.class.should == ValidInstructionsTag
+			end
+
+			observe "configures tag with formatters" do
+				@tag.formatters.should == @formatters
+			end
+		end
+
+		context "for an ininvalid attribute" do
+			before do
+				@model_errors.stub :[] => ["some error message"]
+
+				@helper.stub :determine => :invalid
+				@tag = @helper.renderer :some_attribute, "can't be blank"
+			end
+
+			observe "uses the error message tag" do
+				@tag.class.should == ErrorMessageTag
+			end
+
+			observe "configures tag with formatters" do
+				@tag.formatters.should == @formatters
+			end
+		end
+		
+	end
+end
+

data/spec/formatters_spec.rb

@@ -0,0 +1,76 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+module FormattersSetup
+	def self.included(base)
+		base.class_eval do
+		end
+	end
+end
+
+describe Formatters do
+	before do
+		@configured_formatters = {}
+		Configuration.stub :formatters => @configured_formatters
+		@formatters_object = Object.new.extend Formatters
+	end
+	
+	context "merging local formatters over configured formatters" do	
+		before do
+			@configured_formatters[:some_formattable] = :some_configured_formatter		
+			@options = { :formatters => { :some_attribute_state => { :some_formattable => :tag_formatter }}}
+			@formatters = @formatters_object.merge :some_attribute_state, @options
+		end
+	
+		observe "local formatters take precedence" do
+			@formatters[:some_formattable].should == :tag_formatter
+		end
+	end
+
+	context "merging when no configured formatters" do
+		before do
+			@configured_formatters[:some_formattable] = nil
+			@options = { :formatters => { :some_attribute_state => { :some_formattable => :tag_formatter }}}
+			@formatters = @formatters_object.merge :some_attribute_state, @options
+		end
+	
+		observe "local formatters take precedence" do
+			@formatters[:some_formattable].should == :tag_formatter
+		end
+	end
+
+	context "merging when no configured formatter for the attribute state" do
+		before do
+			@configured_formatters[:some_other_formattable] = :some_configured_formatter
+			@options = { :formatters => { :some_attribute_state => { :some_formattable => :tag_formatter }}}
+			@formatters = @formatters_object.merge :some_attribute_state, @options
+		end
+	
+		observe "local formatters take precedence" do
+			@formatters[:some_formattable].should == :tag_formatter
+		end
+	end
+
+	context "merging when there are no local formatters but there are configured formatters" do
+		before do
+			@configured_formatters[:some_formattable] = :some_configured_formatter
+			@options = {}
+			@formatters = @formatters_object.merge :some_attribute_state, @options
+		end
+	
+		observe "configured formatters take precedence" do
+			@formatters[:some_formattable].should == :some_configured_formatter
+		end
+	end
+
+	context "merging when there are no local formatters for the attribute state but there are configured formatters" do
+		before do
+			@configured_formatters[:some_formattable] = :some_configured_formatter
+			@options = { :formatters => { :some_other_attribute_state => { :some_formattable => :tag_formatter }}}
+			@formatters = @formatters_object.merge :some_attribute_state, @options
+		end
+	
+		observe "configured formatters take precedence" do
+			@formatters[:some_formattable].should == :some_configured_formatter
+		end
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}

data/spec/support/field_instructions_namespace.rb

@@ -0,0 +1,2 @@
+require 'core_files'
+include Instructions

data/spec/support/html_safe_string.rb

@@ -0,0 +1,7 @@
+module HtmlSafeString
+	String.class_eval do
+		def html_safe
+			self
+		end
+	end
+end

data/spec/support/rspec_patches.rb

@@ -0,0 +1,22 @@
+module RSpec
+  module Core
+    module Hooks
+			def because(*args, &block)
+				scope, options = scope_and_options_from(*args)
+				hooks[:after][scope] << AfterHook.new(options, &block)
+			end
+		end
+	end
+	module Mocks
+		module Methods
+			alias_method :should_have_received, :should_receive
+			alias_method :should_not_have_received, :should_not_receive
+		end
+	end
+end
+
+alias :context :describe
+
+RSpec.configure do |config|
+	config.alias_example_to :observe
+end

data/spec/tag_spec.rb

@@ -0,0 +1,136 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'spec_helper')
+
+class TagClass
+	include Tag
+	
+	def descriptor
+		"tag"
+	end
+	
+	def css_class
+		"tag_class"
+	end
+end
+
+describe Tag do
+	include FakeModel
+
+	before do
+		@tag = TagClass.new :some_attribute, @model, "some_model", "some instructions"
+	end
+
+	context "rendering" do
+		before do
+			@tag.stub :open_tag => "some_tag_opening"
+			@tag.stub :instructions => "some_instructions"
+			@tag.stub :close_tag => "some_tag_closing"
+		end
+	
+		because { @tag.render }
+	
+		observe "opens the tag" do
+			@tag.should_have_received :open_tag
+		end
+	
+		observe "composes the instructions" do
+			@tag.should_have_received :instructions
+		end
+	
+		observe "closes the tag" do
+			@tag.should_have_received :close_tag
+		end	
+	end
+
+	context "instructions are not provided" do
+		before do
+			@tag.instance_eval { @instructions = nil }
+			@tag.stub :formatted_attribute_name => nil
+			@tag.stub :formatted_instructions => nil
+				
+			@tag.render
+		end
+	
+		observe "doesn't compose the instructions" do
+			@tag.should_not_have_received :formatted_instructions
+		end
+
+		observe 'CSS class includes "empty"' do
+			@tag.formatted_css_class.should include "empty"
+		end
+	end
+
+	context "rendering the open tag" do
+		before do
+			@tag.stub :identifier => "some_html_id"
+			@tag.stub :css_class => "some_class"
+		end
+		
+		because { @tag.render }
+	
+		observe "composes the HTML ID" do
+			@tag.should_have_received(:identifier)
+		end
+
+		observe "composes the CSS class" do
+			@tag.should_have_received(:css_class)
+		end
+	end
+
+	context "composing the id for a model attribute" do
+		before do
+			@id = @tag.field_identifier
+		end
+	
+		observe "is formatted as {model name}_{attribute_name}" do
+			@id.should == "some_model_some_attribute"
+		end
+	end
+
+	context "rendered content" do
+		before do
+			@rendered = @tag.render
+		end
+	
+		observe "includes the attribute name" do
+			@rendered.should include(">Some Attribute")
+		end
+	
+		observe "includes the instructions" do
+			@rendered.should include("some instructions<")
+		end
+	
+		observe "includes the CSS class" do
+			@rendered.should include("class=\"tag_class\"")
+		end
+	
+		observe "includes the HTML ID" do
+			@rendered.should include("id=\"some_model_some_attribute_tag\"")
+		end
+	end
+
+	context "rendering using an attribute name formatter" do
+		before do
+			@formatter = Proc.new { "some formatted name" }
+			formatters = {:attribute_name => @formatter}
+			tag = TagClass.new :some_attribute, @model, "some_model", "some instructions", formatters
+			@rendered = tag.render
+		end
+	
+		observe "formats the attribute name" do
+			@rendered.should include(">some formatted name")
+		end
+	end
+
+	context "rendering using an instructions formatter" do
+		before do
+			@formatter = Proc.new {"some formatted instructions" }
+			formatters = {:instructions => @formatter}
+			tag = TagClass.new :some_attribute, @model, "some_model", "some instructions", formatters
+			@rendered = tag.render
+		end
+	
+		observe "formats the instructions" do
+			@rendered.should include("some formatted instructions<")
+		end
+	end
+end