instructions 0.1.0

data/lib/instructions/configuration.rb

@@ -0,0 +1,49 @@
+module Instructions
+	class Configuration
+		attr_reader :attribute_name_formatters
+		attr_reader :instructions_formatters
+		
+		def initialize
+			@attribute_name_formatters = {}
+			@instructions_formatters = {}
+		end
+		
+		def self.default_message_joiner
+			Proc.new { |messages| messages.join ', ' }
+		end
+		
+		def self.instance
+			@@instance ||= new
+		end
+	
+		def format_attribute_name(attribute_state, &block)
+			@attribute_name_formatters[attribute_state] = block
+		end
+		
+		def format_instructions(attribute_state, &block)
+			@instructions_formatters[attribute_state] = block
+		end
+				
+		def formatters(attribute_state)
+			{:attribute_name => @attribute_name_formatters[attribute_state],
+				:instructions => @instructions_formatters[attribute_state]}
+		end
+		
+		def self.formatters(attribute_state)
+			instance.formatters attribute_state
+		end
+		
+		def message_joiner(&block)
+			if block_given?
+				@message_joiner = block
+			else
+				@message_joiner ||= self.class.default_message_joiner
+			end
+			@message_joiner
+		end
+
+		def self.message_joiner
+			instance.message_joiner
+		end
+	end
+end

data/lib/instructions/core_ext/action_view_ext.rb

@@ -0,0 +1,9 @@
+ActionView::Base.field_error_proc = Instructions::FieldError.field_error_proc
+
+ActionView::Base.default_form_builder.class_eval do
+	include Instructions::FormHelper
+end
+
+ActionView::Base.instance_eval do
+	include Instructions::FormHelper
+end

data/lib/instructions/error_message.rb

@@ -0,0 +1,9 @@
+module Instructions
+	module ErrorMessage
+		def compose_error_message(method, model)
+			errors = model.errors[method]
+			return Configuration.message_joiner.call errors if errors.kind_of? Array
+			return errors if errors.kind_of? String
+		end
+	end
+end

data/lib/instructions/error_message_tag.rb

@@ -0,0 +1,21 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'tag')
+
+module Instructions
+	class ErrorMessageTag
+		include Tag
+		extend ErrorMessage
+		
+		def self.build(method, model, model_name, formatters={}, *options)
+			error_message = compose_error_message(method, model)
+			new method, model, model_name, error_message, formatters, *options
+		end
+		
+		def descriptor
+			"error_message"
+		end
+		
+		def css_class
+			"instructions invalid"
+		end
+	end
+end

data/lib/instructions/field_error.rb

@@ -0,0 +1,33 @@
+module Instructions
+	class FieldError
+		def self.field_error_proc
+			Proc.new do |html_tag, error_data|
+				render_field_with_error(html_tag, error_data).html_safe
+			end
+		end
+
+		def self.render_field_with_error(html_tag, error_data)
+			if html_tag =~ /^<label/
+				return wrap_label_tag_with_field_with_errors_label_div(html_tag)
+			end
+
+			model = error_data.object
+
+			model_name = error_data.object_name
+			attribute_name = error_data.method_name
+			human_attribute_name = model.class.human_attribute_name(attribute_name)
+			attribute_errors = model.errors[attribute_name.to_sym]
+
+			field_with_errors_div = wrap_html_tag_with_field_with_errors_div(html_tag)
+			"#{field_with_errors_div}"
+		end
+	
+		def self.wrap_html_tag_with_field_with_errors_div(html_tag)
+			"<div class=\"field_with_errors\">#{html_tag}</div>"
+		end
+
+		def self.wrap_label_tag_with_field_with_errors_label_div(div_tag)
+			"<div class=\"field_with_errors_label\">#{div_tag}</div>"
+		end
+	end
+end

data/lib/instructions/field_instructions.rb

@@ -0,0 +1,6 @@
+module Instructions
+	def self.configure(&block)
+		configuration = Configuration.instance
+		block.call configuration
+	end
+end

data/lib/instructions/form_helper.rb

@@ -0,0 +1,65 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'attribute_state')
+require File.join(File.expand_path(File.dirname(__FILE__)), 'formatters')
+
+module Instructions
+	module FormHelper
+		include AttributeState
+		include Formatters
+		
+		def instructions(method, message=nil, options={})
+			text = message_text method, message
+			renderer(method, text, options).render
+		end
+		
+		def message_text(method, message)
+			return message if message.is_a? String
+			return active_model_message(method, message) if [Symbol, Hash].include? message.class
+			return active_model_messages(method, message) if message.is_a? Array
+		end
+		
+		def active_model_messages(method, message)
+			messages = []
+			generator = generator(@object)
+			message.each do |m|
+				messages << active_model_message(method, m, generator)
+			end
+			Configuration.message_joiner.call messages
+		end
+		
+		def active_model_message(method, message, generator=nil)
+			generator ||= generator(@object)
+			if message.is_a? Hash
+				return generator.generate_message(method, message.keys[0], :count => message.values[0])
+			else
+				return generator.generate_message(method, message)
+			end
+		end
+		
+		def generator(object)
+			ActiveModel::Errors.new object
+		end
+
+		def test
+			def method_missing(method_name, *args) 
+				"<div class=\"method_missing\" style=\"font-weight: bold; color: red;\">No helper found to respond to \"#{method_name}\"</div>"
+			end
+		end
+	
+		def renderer(method, text, options={})
+			attribute_state = determine method
+			formatters = merge attribute_state, options
+			
+			if attribute_state == :new
+				return InstructionsTag.new method, @object, @object_name, text, formatters
+			end
+			
+			if attribute_state == :valid
+				return ValidInstructionsTag.new method, @object, @object_name, text, formatters
+			end
+			
+			if attribute_state == :invalid
+				return ErrorMessageTag.build method, @object, @object_name, formatters
+			end
+		end
+	end
+end

data/lib/instructions/formatters.rb

@@ -0,0 +1,10 @@
+module Instructions
+	module Formatters
+		def merge(attribute_state, options)
+			configured_formatters = Configuration.formatters(attribute_state)
+			tag_formatters = (options[:formatters] || {}) [attribute_state] || {}
+			
+			configured_formatters.merge tag_formatters
+		end
+	end
+end

data/lib/instructions/instructions_tag.rb

@@ -0,0 +1,15 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'tag')
+
+module Instructions
+	class InstructionsTag
+		include Tag
+	
+		def descriptor
+			"instructions"
+		end
+		
+		def css_class
+			"#{descriptor}"
+		end
+	end
+end

data/lib/instructions/tag.rb

@@ -0,0 +1,71 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'abstract')
+
+module Instructions
+	module Tag
+		include Abstract
+		abstract_method :descriptor
+		abstract_method :css_class
+		
+		attr_reader :formatters
+		
+		def initialize(method, model, model_name, instructions, formatters={})
+			@method = method
+			@model = model
+			@instructions = instructions
+			@model_name = model_name
+			@formatters = formatters
+		end
+
+		def render
+			"#{open_tag}#{instructions}#{close_tag}".html_safe
+		end
+	
+		def instructions
+			return "#{formatted_attribute_name}" if @instructions.nil? or @instructions.empty?
+			"#{formatted_attribute_name} #{formatted_instructions}".strip
+		end
+		
+		def formatted_attribute_name
+			return attribute_name_formatter.call(attribute_name) if attribute_name_formatter
+			attribute_name
+		end
+	
+		def attribute_name
+			@model.class.human_attribute_name(@method)
+		end
+
+		def attribute_name_formatter
+			@formatters[:attribute_name]
+		end
+	
+		def formatted_instructions
+			return instructions_formatter.call(@instructions) if instructions_formatter
+			@instructions
+		end
+	
+		def instructions_formatter
+			@formatters[:instructions]
+		end
+		
+		def identifier
+			"#{field_identifier}_#{descriptor}"
+		end
+		
+		def field_identifier
+			"#{@model_name}_#{@method}"
+		end
+		
+		def formatted_css_class
+			return "#{css_class} empty" if instructions.empty?
+			"#{css_class}"
+		end
+		
+		def open_tag
+			"<div id=\"#{identifier}\" data-for=\"#{field_identifier}\" class=\"#{formatted_css_class}\">"
+		end
+		
+		def close_tag
+			"</div>"
+		end
+	end
+end

data/lib/instructions/valid_instructions_tag.rb

@@ -0,0 +1,9 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), 'tag')
+
+module Instructions
+	class ValidInstructionsTag < InstructionsTag
+		def css_class
+			"instructions valid"
+		end
+	end
+end

data/spec/attribute_state_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe AttributeState do
+	before do
+		@model = Object.new
+
+		@model_errors = []
+		@model.stub :errors => @model_errors
+
+		@attribute_state_object = Object.new.extend AttributeState
+		model = @model			
+		@attribute_state_object.instance_eval { @object = model }
+		
+		setup_model_errors
+		setup_model_state
+
+		@state = @attribute_state_object.determine :some_attribute
+	end
+
+	context "unsaved model" do
+		def setup_model_state
+			@model.stub :new_record? => true
+		end
+		
+		context "attribute without a value for an unsaved model" do
+			def setup_model_errors
+				@model.stub :some_attribute => nil
+				@model_errors.stub :[] => []
+			end
+
+			observe "is: new" do
+				@state.should == :new
+			end
+		end
+	end	
+
+	context "saved model" do
+		def setup_model_state
+			@model.stub :new_record? => false
+		end
+		
+		context "attribute does not have errors" do
+			def setup_model_errors
+				@model_errors.stub :[] => []
+			end
+		
+			observe "is: valid" do
+				@state.should == :valid
+			end
+		end
+
+		context "attribute has errors" do
+			def setup_model_errors
+				@model_errors.stub :[] => ["some error message"]
+			end
+
+			observe "is: invalid" do
+				@state.should == :invalid
+			end
+		end
+	end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+context Instructions, "configuring" do
+	before do
+		Configuration.stub :instance => @configuration
+
+		@config_block_arg = Object.new
+		Instructions.configure do |config| 
+			@config_block_arg = config
+		end
+	end
+	
+	observe "invokes the configuration block" do
+		@config_block_arg.should == @configuration
+	end
+end
+
+describe Configuration do
+	before do		
+		@proc = Proc.new {}
+	end
+
+	context "configuring an attribute name formatter" do
+		before do
+			subject.format_attribute_name :some_attribute_state, &@proc
+		end
+
+		observe "adds attribute name formatter block to the configured formatters" do
+			subject.attribute_name_formatters[:some_attribute_state].should == @proc
+		end
+	end
+
+	context "configuring an instruction formatter" do
+		before do
+			subject.format_instructions :some_attribute_state, &@proc
+		end
+
+		observe "adds attribute name formatter block to the configured formatters" do
+			subject.instructions_formatters[:some_attribute_state].should == @proc
+		end
+	end
+
+	context "getting formatters for a specific kind" do
+		before do
+			subject.format_attribute_name :some_attribute_state, &@proc
+			subject.format_instructions :some_attribute_state, &@proc
+		end
+
+		observe "gets the attribute name formatter registered for the kind" do
+			subject.formatters(:attribute_name).should_not be_nil
+		end
+
+		observe "gets the instructions formatter registered for the kind" do
+			subject.formatters(:instructions).should_not be_nil
+		end
+	end
+
+	context "short hand for retrieving formatters (using class methods)" do
+		before do
+			Configuration.stub :instance => subject
+			subject.stub :formatters => nil
+		end
+	
+		because { Configuration.formatters :some_attribute_state }
+	
+		observe "uses the configuration singleton" do
+			Configuration.should_have_received :instance
+		end
+
+		observe "uses gets the formatters from the configuration singleton" do
+			subject.should_have_received :formatters
+		end
+	end
+end