ccls-common_lib 1.4.0

data/lib/common_lib/action_controller_extension/routing.rb

@@ -0,0 +1,20 @@
+module CommonLib::ActionControllerExtension::Routing
+
+	def self.included(base)
+		base.extend ClassMethods
+	end
+
+	module ClassMethods
+
+		def assert_no_route(verb,action,args={})
+			test "#{brand}no route to #{verb} #{action} #{args.inspect}" do
+				assert_raise(ActionController::RoutingError){
+					send(verb,action,args)
+				}
+			end
+		end
+
+	end	# module ClassMethods
+end	#	module CommonLib::ActionControllerExtension::Routing
+ActionController::TestCase.send(:include, 
+	CommonLib::ActionControllerExtension::Routing)

data/lib/common_lib/action_controller_extension/test_case.rb

@@ -0,0 +1,22 @@
+module CommonLib::ActionControllerExtension::TestCase
+
+#	def turn_https_on
+#		@request.env['HTTPS'] = 'on'
+##		@request.env['HTTP_X_FORWARDED_PROTO'] == 'https'
+#	end
+#
+#	def turn_https_off
+#		@request.env['HTTPS'] = nil
+#	end
+
+#
+#	Apparently, I don't use this?
+#
+#	def assert_layout(layout)
+#		layout = "layouts/#{layout}" unless layout.match(/^layouts/)
+#		assert_equal layout, @response.layout
+#	end
+
+end	#	module CommonLib::ActionControllerExtension::TestCase
+ActionController::TestCase.send(:include,
+	CommonLib::ActionControllerExtension::TestCase)

data/lib/common_lib/action_view_extension.rb

@@ -0,0 +1,3 @@
+module CommonLib::ActionViewExtension; end
+require 'common_lib/action_view_extension/base'
+require 'common_lib/action_view_extension/form_builder'

data/lib/common_lib/action_view_extension/base.rb

@@ -0,0 +1,310 @@
+module CommonLib::ActionViewExtension::Base
+
+	def self.included(base)
+		base.class_eval do
+			#	This NEEDS to be HERE or gets stuck at method_missing_without_wrapping call????
+			alias_method_chain( :method_missing, :wrapping )
+		end
+	end
+
+	# Just a simple method to wrap the passed text in a span
+	# with class='required'
+	def required(text)
+		"<span class='required'>#{text}</span>".html_safe
+	end
+	alias_method :req, :required
+
+	def nbsp
+		"&nbsp;".html_safe
+	end
+
+	def mdy(date)
+		( date.blank? or !date.respond_to?(:strftime) ) ? nbsp : date.strftime("%m/%d/%Y")
+	end
+
+	#	For use in CSV output as don't want the &nbsp;
+	def mdy_or_nil(date)
+		( date.blank? or !date.respond_to?(:strftime) ) ? nil : date.strftime("%m/%d/%Y")
+	end
+
+	def mdyhm(datetime)
+		( datetime.blank? or !datetime.respond_to?(:strftime) ) ? nbsp : 
+				datetime.strftime("%m/%d/%Y %H:%M (%Z)")
+	end
+
+	#	For use in CSV output as don't want the &nbsp;
+	def mdyhm_or_nil(datetime)
+		( datetime.blank? or !datetime.respond_to?(:strftime) ) ? nil : 
+				datetime.strftime("%m/%d/%Y %H:%M (%Z)")
+	end
+	
+	def time_mdy(time)
+		( time.blank? or !time.respond_to?(:strftime) ) ? nbsp : 
+				time.strftime("%I:%M %p %m/%d/%Y")
+	end
+
+	def field_wrapper(method,options={},&block)
+		classes = [method,options[:class]].compact.join(' ')
+		s =  "<div class='#{classes} field_wrapper'>\n"
+		s << yield 
+		s << "\n</div><!-- class='#{classes}' -->"
+		s.html_safe
+	end
+
+# t is RedCloth.textualize NOT I18n.translate
+
+	#	This is NOT a form field
+	def _wrapped_spans(object_name,method,options={})
+			object = instance_variable_get("@#{object_name}")
+#		s =  "<span class='label'>#{options[:label_text]||method}</span>\n"
+
+#	could also "object.class.human_attribute_name method" ?
+
+#		s =  "<span class='label'>#{options[:label_text]||I18n.translate(
+#			"#{object.class.to_s.underscore}.#{method}",
+#			:scope => "activerecord.attributes",
+#			:default => method.to_s)}</span>\n"	#	if method is a symbol, tries to translate it too.
+
+
+
+
+#
+#		label = if options[:label_text].present?
+#			options[:label_text]
+#		else
+#			l = ( I18n.translate("#{object.class.to_s.underscore}.#{method}",
+#				:scope => "activerecord.attributes", :raise => true ) rescue false ) ||
+#				method.to_s
+#			l.send( :humanize or :titleize or :gsub('_', ' ') or ......
+#		end
+#
+#	titleize - capitalizes all words
+#	humanize - capitalizes only the first word ( same as other rails helpers, but I don't like )
+#	
+#
+
+		s =  "<span class='label'>#{options[:label_text] ||
+			( I18n.translate("#{object.class.to_s.underscore}.#{method}",
+				:scope => "activerecord.attributes", :raise => true ) rescue false ) ||
+			method.to_s.humanize }</span>\n"	#	if method is a symbol, tries to translate it too.
+
+		value = if options[:value]
+			options[:value]
+		else
+#	moved to top
+#			object = instance_variable_get("@#{object_name}")
+			value = object.send(method)
+			value = (value.to_s.blank?)?'&nbsp;':value
+		end
+		s << "<span class='value'>#{value}</span>"
+		s << (( options.has_key?(:post_text) ) ? "<span class='post_text'>#{options[:post_text]}</span>" : "")
+		s.html_safe
+	end
+
+	def _wrapped_date_spans(object_name,method,options={})
+		object = instance_variable_get("@#{object_name}")
+		_wrapped_spans(object_name,method,options.update(
+			:value => mdy(object.send(method)) ) )
+	end
+
+	def _wrapped_datetime_spans(object_name,method,options={})
+		object = instance_variable_get("@#{object_name}")
+		_wrapped_spans(object_name,method,options.update(
+			:value => mdyhm(object.send(method)) ) )
+	end
+
+	#	This is NOT a form field
+	def _wrapped_yes_or_no_spans(object_name,method,options={})
+		object = instance_variable_get("@#{object_name}")
+		_wrapped_spans(object_name,method,options.update(
+			:value => (object.send("#{method}?"))?'Yes':'No') )
+#		s =  "<span class='label'>#{options[:label_text]||method}</span>\n"
+#		value = (object.send("#{method}?"))?'Yes':'No'
+#		s << "<span class='value'>#{value}</span>"
+	end
+
+	def method_missing_with_wrapping(symb,*args, &block)
+		method_name = symb.to_s
+		if method_name =~ /^wrapped_(.+)$/
+			unwrapped_method_name = $1
+#
+#	It'd be nice to be able to genericize all of the
+#	wrapped_* methods since they are all basically
+#	the same.
+#		Strip of the "wrapped_"
+#		Label
+#		Call "unwrapped" method
+#
+
+			object_name = args[0]
+			method      = args[1]
+
+			content = field_wrapper(method,:class => unwrapped_method_name) do
+				s = if respond_to?(unwrapped_method_name)
+					options    = args.detect{|i| i.is_a?(Hash) }
+					label_text = options.delete(:label_text) unless options.nil?
+					if unwrapped_method_name == 'check_box'
+						send("#{unwrapped_method_name}",*args,&block) <<
+						label( object_name, method, label_text )
+					else
+						label( object_name, method, label_text ) <<
+						send("#{unwrapped_method_name}",*args,&block)
+					end
+				else
+					send("_#{method_name}",*args,&block)
+				end
+
+				s << (( block_given? )? capture(&block) : '')
+#				send("_#{method_name}",*args) << 
+#					(( block_given? )? capture(&block) : '')
+			end
+#			if block_called_from_erb?(block)
+#				concat(content)
+#			else
+				content
+#			end
+		else
+			method_missing_without_wrapping(symb,*args, &block)
+		end
+	end
+
+	def form_link_to( title, url, options={}, &block )
+		extra_tags = extra_tags_for_form(options)
+		s =  "\n" <<
+			"<form " <<
+			"class='#{options.delete(:class)||'form_link_to'}' " <<
+			"action='#{url_for(url)}' " <<
+			"method='#{options.delete('method')}'>\n" <<
+			extra_tags << "\n"
+		s << (( block_given? )? capture(&block) : '')
+		s << submit_tag(title, :name => nil ) << "\n" <<
+			"</form>\n"
+		s.html_safe
+	end
+
+	def destroy_link_to( title, url, options={}, &block )
+		s = form_link_to( title, url, options.merge(
+			'method' => 'delete',
+			:class => 'destroy_link_to'
+		),&block )
+	end
+
+	def aws_image_tag(image,options={})
+		#	in console @controller is nil
+		protocol = @controller.try(:request).try(:protocol) || 'http://'
+		host = 's3.amazonaws.com/'
+#		bucket = ( defined?(RAILS_APP_NAME) && RAILS_APP_NAME ) || 'ccls'
+		bucket = ( defined?(RAILS_APP_NAME) && RAILS_APP_NAME ) || 
+			Rails.application.class.parent.to_s.downcase || 'ccls'
+		src = "#{protocol}#{host}#{bucket}/images/#{image}"
+		alt = options.delete(:alt) || options.delete('alt') || image
+		tag('img',options.merge({:src => src, :alt => alt}))
+	end
+
+	def flasher
+		s = ''
+		flash.each do |key, msg|
+			s << content_tag( :p, msg, :id => key, :class => "flash #{key}" )
+			s << "\n"
+		end
+		s << "<noscript><p id='noscript' class='flash'>\n"
+		s << "Javascript is required for this site to be fully functional.\n"
+		s << "</p></noscript>\n"
+		s.html_safe
+	end
+
+	#	Created to stop multiple entries of same stylesheet
+	def stylesheets(*args)
+		@stylesheets ||= []
+		args.each do |stylesheet|
+			unless @stylesheets.include?(stylesheet.to_s)
+				@stylesheets.push(stylesheet.to_s)
+				content_for(:head,stylesheet_link_tag(stylesheet.to_s))
+			end
+		end
+	end
+
+	def javascripts(*args)
+		@javascripts ||= []
+		args.each do |javascript|
+			unless @javascripts.include?(javascript.to_s)
+				@javascripts.push(javascript.to_s)
+				content_for(:head,javascript_include_tag(javascript).to_s)
+			end
+		end
+	end
+
+	def yndk(value=nil)
+		(YNDK[value]||'&nbsp;').html_safe
+	end
+
+	def ynodk(value=nil)
+		(YNODK[value]||'&nbsp;').html_safe
+	end
+
+	def ynrdk(value=nil)
+		(YNRDK[value]||'&nbsp;').html_safe
+	end
+
+	def ynordk(value=nil)
+		(YNORDK[value]||'&nbsp;').html_safe
+	end
+
+	def padk(value=nil)
+		(PADK[value]||'&nbsp;').html_safe
+	end
+
+	def adna(value=nil)
+		(ADNA[value]||'&nbsp;').html_safe
+	end
+
+	def pos_neg(value=nil)
+		(POSNEG[value]||'&nbsp;').html_safe
+	end
+	alias_method :posneg, :pos_neg
+
+	def _wrapped_yndk_spans(object_name,method,options={})
+		object = instance_variable_get("@#{object_name}")
+		_wrapped_spans(object_name,method,options.update(
+			:value => (YNDK[object.send(method)]||'&nbsp;') ) )
+	end
+
+	def _wrapped_ynodk_spans(object_name,method,options={})
+		object = instance_variable_get("@#{object_name}")
+		_wrapped_spans(object_name,method,options.update(
+			:value => (YNODK[object.send(method)]||'&nbsp;') ) )
+	end
+
+	def _wrapped_ynrdk_spans(object_name,method,options={})
+		object = instance_variable_get("@#{object_name}")
+		_wrapped_spans(object_name,method,options.update(
+			:value => (YNRDK[object.send(method)]||'&nbsp;') ) )
+	end
+
+	def _wrapped_ynordk_spans(object_name,method,options={})
+		object = instance_variable_get("@#{object_name}")
+		_wrapped_spans(object_name,method,options.update(
+			:value => (YNORDK[object.send(method)]||'&nbsp;') ) )
+	end
+
+	def _wrapped_padk_spans(object_name,method,options={})
+		object = instance_variable_get("@#{object_name}")
+		_wrapped_spans(object_name,method,options.update(
+			:value => (PADK[object.send(method)]||'&nbsp;') ) )
+	end
+
+	def _wrapped_adna_spans(object_name,method,options={})
+		object = instance_variable_get("@#{object_name}")
+		_wrapped_spans(object_name,method,options.update(
+			:value => (ADNA[object.send(method)]||'&nbsp;') ) )
+	end
+
+	def _wrapped_pos_neg_spans(object_name,method,options={})
+		object = instance_variable_get("@#{object_name}")
+		_wrapped_spans(object_name,method,options.update(
+			:value => (POSNEG[object.send(method)]||'&nbsp;') ) )
+	end
+
+end	#	module CommonLib::ActionViewExtension::Base
+ActionView::Base.send(:include, 
+	CommonLib::ActionViewExtension::Base )

data/lib/common_lib/action_view_extension/form_builder.rb

@@ -0,0 +1,197 @@
+module CommonLib::ActionViewExtension::FormBuilder
+
+	def error_messages
+		if self.object.errors.count > 0
+			s  = '<div id="errorExplanation" class="errorExplanation">'
+			s << "<h2>#{self.object.errors.count} #{"error".pluralize(self.object.errors.count)} prohibited this #{self.object.class} from being saved:</h2>"
+			s << '<p>There were problems with the following fields:</p>'
+			s << '<ul>'
+			self.object.errors.full_messages.each do |msg|
+				s << "<li>#{msg}</li>"
+			end
+			s << '</ul></div>'
+			s.html_safe
+		end
+	end
+
+	def hour_select(method,options={},html_options={})
+		@template.select(object_name, method,
+			(1..12),
+			{:include_blank => 'Hour'}.merge(options), html_options)
+	end
+
+	def minute_select(method,options={},html_options={})
+		minutes = (0..59).to_a.collect{|m|[sprintf("%02d",m),m]}
+		@template.select(object_name, method,
+			minutes,
+			{:include_blank => 'Minute'}.merge(options), html_options)
+	end
+
+	def meridiem_select(method,options={},html_options={})
+		@template.select(object_name, method,
+			['AM','PM'], 
+			{:include_blank => 'Meridiem'}.merge(options), html_options)
+	end
+
+	def sex_select(method,options={},html_options={})
+		@template.select(object_name, method,
+			[['-select-',''],['male','M'],['female','F'],["don't know",'DK']],
+			options, html_options)
+	end
+	alias_method :gender_select, :sex_select
+
+	def date_text_field(method, options = {})
+		format = options.delete(:format) || '%m/%d/%Y'
+		tmp_value = if options[:value].blank? #and !options[:object].nil?
+#			object = options[:object]
+			tmp = self.object.send("#{method}") ||
+			      self.object.send("#{method}_before_type_cast")
+		else
+			options[:value]
+		end
+		begin
+			options[:value] = tmp_value.to_date.try(:strftime,format)
+		rescue NoMethodError, ArgumentError
+			options[:value] = tmp_value
+		end
+		options.update(:class => [options[:class],'datepicker'].compact.join(' '))
+		@template.text_field( object_name, method, options )
+	end
+
+	def datetime_text_field(method, options = {})
+		format = options.delete(:format) || '%m/%d/%Y %H:%M'
+		tmp_value = if options[:value].blank?
+			tmp = self.object.send("#{method}") ||
+			      self.object.send("#{method}_before_type_cast")
+		else
+			options[:value]
+		end
+		begin
+			options[:value] = tmp_value.to_datetime.try(:strftime,format)
+		rescue NoMethodError, ArgumentError
+			options[:value] = tmp_value
+		end
+		options.update(:class => [options[:class],'datetimepicker'].compact.join(' '))
+		@template.text_field( object_name, method, options )
+	end
+
+	def yndk_select(method,options={},html_options={})
+		@template.select(object_name, method, YNDK.selector_options,
+			{:include_blank => true}.merge(objectify_options(options)), html_options)
+	end
+
+	def ynrdk_select(method,options={},html_options={})
+		@template.select(object_name, method, YNRDK.selector_options,
+			{:include_blank => true}.merge(objectify_options(options)), html_options)
+	end
+
+	def ynodk_select(method,options={},html_options={})
+		@template.select(object_name, method, YNODK.selector_options,
+			{:include_blank => true}.merge(objectify_options(options)), html_options)
+	end
+
+	def ynordk_select(method,options={},html_options={})
+		@template.select(object_name, method, YNORDK.selector_options,
+			{:include_blank => true}.merge(objectify_options(options)), html_options)
+	end
+
+	def padk_select(method,options={},html_options={})
+		@template.select(object_name, method, PADK.selector_options,
+			{:include_blank => true}.merge(objectify_options(options)), html_options)
+	end
+
+	def adna_select(method,options={},html_options={})
+		@template.select(object_name, method, ADNA.selector_options,
+			{:include_blank => true}.merge(objectify_options(options)), html_options)
+	end
+
+	def pos_neg_select(method, options={}, html_options={})
+		@template.select(object_name, method, POSNEG.selector_options,
+			{:include_blank => true}.merge(objectify_options(options)), html_options)
+	end
+
+	def wrapped_check_box(*args,&block)
+		method      = args[0]
+		content = @template.field_wrapper(method,:class => 'check_box') do
+			options    = args.detect{|i| i.is_a?(Hash) }
+			label_text = options.delete(:label_text) unless options.nil?
+			post_text  = options.delete(:post_text) unless options.nil?
+#	INVERTED ORDER SO NOT INCLUDED BELOW
+			s  = check_box(*args,&block) <<
+				self.label( method, label_text )
+			s << (( block_given? )? @template.capture(&block) : '')
+			s << (( post_text.blank? ) ? '' : "<span>#{post_text}</span>".html_safe )
+		end
+		content.html_safe
+	end
+
+#	special
+#		def wrapped_check_box(*args,&block)
+
+#
+#	This isn't pretty, but does appear to work.
+#	Dynamically defined using a class_eval rather than
+#	define_method. And no method_missing.
+#
+#	Actually, now that we're using ruby 1.9, can't I use
+#	define_method with a block?
+#
+#	Add "field_error" class if errors.include?(method)
+#
+	%w( adna_select collection_select country_select 
+			datetime_select date_text_field datetime_text_field 
+			file_field password_field
+			hour_select minute_select meridiem_select gender_select
+			grouped_collection_select padk_select
+			pos_neg_select select sex_select text_area
+			text_field yndk_select ynodk_select ynrdk_select ynordk_select
+		).each do |unwrapped_method_name|
+	define_method "wrapped_#{unwrapped_method_name}" do |*args,&block|
+#class_eval %Q"
+#	def wrapped_#{unwrapped_method_name}(*args,&block)
+		method      = args[0]
+#		content = @template.field_wrapper(method,:class => '#{unwrapped_method_name}') do
+		content = @template.field_wrapper(method,:class => unwrapped_method_name) do
+			options    = args.detect{|i| i.is_a?(Hash) }
+			label_text = options.delete(:label_text) unless options.nil?
+			post_text  = options.delete(:post_text) unless options.nil?
+			#	removing these from the options hash will stop them from being 
+			#	passed on to the unwrapped_method
+
+#			s  = self.label( method, label_text ) <<
+#				#{unwrapped_method_name}(*args)
+##				#{unwrapped_method_name}(*args,&block)
+##	why pass the block along? usually a good idea, but these methods don't use it. (at least I don't see any)
+##	if they did, then why capture it again too?
+#			s << (( block_given? )? @template.capture(&block) : '')
+#			s << (( post_text.blank? ) ? '' : \"<span>\#{post_text}</span>\".html_safe )
+
+#	I would prefer to do this the newer way, but
+#	when a wrapped method has a block with a wrapped method
+#	it ends up being rendered a couple times ??
+
+			s  = self.label( method, label_text ) 
+			s << send(unwrapped_method_name,*args,&block)
+#			s << (( block )? block.call : '')	
+#			s << (( block_given? )? @template.capture(&block) : '')
+#	the new way won't work with block_given?, but template.capture still does.
+			s << (( block )? @template.capture(&block) : '')
+#if block	#block_given? 
+#	puts "BLOCK GIVEN"
+##puts @template.concat(&block)
+#puts @template.capture(&block)
+#else
+#	puts "NO BLOCK GIVEN"
+#end
+			s << (( post_text.blank? ) ? '' : "<span>#{post_text}</span>".html_safe )
+
+
+		end
+		content.html_safe
+	end
+#"
+end
+
+end
+ActionView::Helpers::FormBuilder.send(:include, 
+	CommonLib::ActionViewExtension::FormBuilder )