ccls-common_lib 1.4.0

data/lib/common_lib/ruby/fixnum.rb

@@ -0,0 +1,5 @@
+#Fixnum.class_eval do
+#	def html_friendly
+#		self.to_s.html_friendly	#downcase.gsub(/\W/,'_').gsub(/_+/,'_')
+#	end
+#end

data/lib/common_lib/ruby/hash.rb

@@ -0,0 +1,51 @@
+module CommonLib::Hash	#	:nodoc:
+
+	#	delete all keys matching the given regex
+	#	and return the new hash
+	def delete_keys_matching!(regex)
+		self.keys.each do |k| 
+			if k.to_s =~ Regexp.new(regex)
+				self.delete(k)
+			end 
+		end 
+		self
+	end 
+
+	#	delete all keys in the given array
+	#	and return the new hash
+	def delete_keys!(*keys)
+		keys.each do |k| 
+			self.delete(k)
+		end 
+		self
+	end 
+
+	#	params.dig('study_events',se.id.to_s,'eligible')
+	def dig(*args)
+		if args.length > 0 && self.keys.include?(args.first)
+			key = args.shift
+			if args.length > 0 
+				if self[key].is_a?(Hash)
+					self[key].dig(*args)
+				else
+					nil		#	This shouldn't ever happen
+				end
+			else
+				self[key]
+			end
+		else
+			nil
+		end
+	end
+
+	#	from http://iain.nl/writing-yaml-files
+	def deep_stringify_keys
+		new_hash = {}
+		self.each do |key, value|
+			new_hash.merge!(key.to_s => ( value.is_a?(Hash) ? value.deep_stringify_keys : value ))
+		end
+		new_hash	#	originally didn't return new_hash, which didn't work for me.  returned self apparently.
+	end
+
+end
+Hash.send( :include, CommonLib::Hash )

data/lib/common_lib/ruby/integer.rb

@@ -0,0 +1,11 @@
+module CommonLib::Integer	#	:nodoc:
+
+	#	Return n!
+	def factorial
+		f = n = self
+		f *= n -= 1 while( n > 1 )
+		return f
+	end
+
+end
+Integer.send( :include, CommonLib::Integer )

data/lib/common_lib/ruby/nil_class.rb

@@ -0,0 +1,13 @@
+module CommonLib::NilClass	#	:nodoc:
+
+	#	Return an empty array when attempting to split nil
+	def split(*args)
+		[]
+	end
+
+	def include?(*args)
+		false
+	end
+
+end
+NilClass.send( :include, CommonLib::NilClass )

data/lib/common_lib/ruby/object.rb

@@ -0,0 +1,53 @@
+module CommonLib::Object	#	:nodoc:
+#
+#		#	originally from ActiveSupport::Callbacks::Callback
+##	needs modified to actually work the way I'd like
+##	needs tests
+##	x(:some_method)
+##	x(Proc.new(....))
+##	x(lambda{...})
+#		#	def evaluate_method(method, *args, &block)
+#		def evaluate_method(method, *args, &block)
+#			case method
+#				when Symbol
+##		I don't quite understand the shift (it fails)
+##					object = args.shift
+##					object.send(method, *args, &block)
+#					send(method, *args, &block)
+#				when String
+#					eval(method, args.first.instance_eval { binding })
+#				when Proc, Method
+##	fails
+#					method.call(*args, &block)
+#				else
+#					if method.respond_to?(kind)
+#						method.send(kind, *args, &block)
+#					else
+#						raise ArgumentError,
+#							"Callbacks must be a symbol denoting the method to call, a string to be evaluated, " +
+#							"a block to be invoked, or an object responding to the callback method."
+#					end
+#				end
+#		end
+#		alias_method :x, :evaluate_method
+#
+	def to_boolean
+#		return [true, 'true', 1, '1', 't'].include?(
+		return ![nil, false, 'false', 0, '0', 'f'].include?(
+			( self.is_a?(String) ) ? self.downcase : self )
+	end
+
+	#	looking for an explicit true
+	def true?
+		return [true, 'true', 1, '1', 't'].include?(
+			( self.is_a?(String) ) ? self.downcase : self )
+	end
+
+	#	looking for an explicit false (not nil)
+	def false?
+		return [false, 'false', 0, '0', 'f'].include?(
+			( self.is_a?(String) ) ? self.downcase : self )
+	end
+
+end
+Object.send(:include, CommonLib::Object )

data/lib/common_lib/ruby/string.rb

@@ -0,0 +1,20 @@
+module CommonLib::String	#	:nodoc:
+
+	#	Convert a query string like that in a URL
+	#	to a Hash
+	def to_params_hash
+		h = HashWithIndifferentAccess.new
+		self.split('&').each do |p|
+			(k,v) = p.split('=',2)
+			h[k] = URI.decode(v)
+		end
+		return h
+	end
+
+	#	Return self
+	def uniq
+		self
+	end
+
+end
+String.send( :include, CommonLib::String )

data/lib/common_lib/translation_table.rb

@@ -0,0 +1,129 @@
+class CommonLib::TranslationTable
+
+	def self.[](key=nil)
+		short(key) || short(key.to_s.downcase) || value(key) || nil
+	end
+
+#	DO NOT MEMORIZE HERE.  IT ENDS UP IN ALL SUBCLASSES
+#	Doesn't really seem necessary.  It isn't that complicated.
+
+	#	[1,2,999]
+	def self.valid_values
+#		@@valid_values ||= table.collect{ |x| x[:value] }
+		table.collect{ |x| x[:value] }
+	end
+
+	#	[['Yes',1],['No',2],["Don't Know",999]]
+	def self.selector_options
+#		@@selector_options ||= table.collect{|x| [x[:long],x[:value]] }
+		table.collect{|x| [x[:long],x[:value]] }
+	end
+
+protected
+
+	def self.short(key)
+		index = table.find_index{|x| x[:short] == key.to_s }
+		( index.nil? ) ? nil : table[index][:value]
+	end
+
+	def self.value(key)
+#	used in testing and breaks in ruby 1.9.3 so next line is NEEDED!
+return nil if key == :nil
+		index = table.find_index{|x| x[:value] == key.to_i }
+		( index.nil? ) ? nil : table[index][:long] 
+	end
+
+	def self.table
+		[]
+	end
+end
+
+
+class YNDK < CommonLib::TranslationTable
+	#	unique translation table
+	def self.table
+		@@table ||= [
+			{ :value => 1,   :short => 'yes', :long => "Yes" },
+			{ :value => 2,   :short => 'no',  :long => "No" },
+			{ :value => 999, :short => 'dk',  :long => "Don't Know" }
+		]
+	end
+end
+#
+#	YNDK[1]     => 'Yes'
+#	YNDK['1']   => 'Yes'
+#	YNDK['yes'] => 1
+#	YNDK[:yes]  => 1
+#	YNDK[:asdf] => nil
+#
+#	YNDK[:Yes] => 1
+#	YNDK[:YES] => 1
+#
+#	YNDK[:nil] => ????	# worked in ruby 1.8.7, errors in 1.9.3
+#		:nil.to_i => NoMethodError: undefined method `to_i' for :nil:Symbol
+#		what did it do?  was that correct?
+#
+#	in jruby 
+#	jruby-1.5.1 :003 > :nil.to_i
+#	 => 610 
+#	which, in hind site, makes some sort of sense, but is NOT what is wanted
+#	same in ruby 1.8.7 (basically object id)
+#
+class YNODK < CommonLib::TranslationTable
+	def self.table
+		@@table ||= [
+			{ :value => 1,   :short => 'yes',   :long => "Yes" },
+			{ :value => 2,   :short => 'no',    :long => "No" },
+			{ :value => 3,   :short => 'other', :long => "Other" },
+			{ :value => 999, :short => 'dk',    :long => "Don't Know" }
+		]
+	end
+end
+class YNRDK < CommonLib::TranslationTable
+	def self.table
+		@@table ||= [
+			{ :value => 1,   :short => 'yes',     :long => "Yes" },
+			{ :value => 2,   :short => 'no',      :long => "No" },
+			{ :value => 999, :short => 'dk',      :long => "Don't Know" },
+			{ :value => 888, :short => 'refused', :long => "Refused" }
+		]
+	end
+end
+class YNORDK < CommonLib::TranslationTable
+	def self.table
+		@@table ||= [
+			{ :value => 1,   :short => 'yes',     :long => "Yes" },
+			{ :value => 2,   :short => 'no',      :long => "No" },
+			{ :value => 3,   :short => 'other',   :long => "Other" },
+			{ :value => 999, :short => 'dk',      :long => "Don't Know" },
+			{ :value => 888, :short => 'refused', :long => "Refused" }
+		]
+	end
+end
+class ADNA < CommonLib::TranslationTable
+	def self.table
+		@@table ||= [
+			{ :value => 1,   :short => 'agree',    :long => "Agree" },
+			{ :value => 2,   :short => 'disagree', :long => "Do Not Agree" },
+			{ :value => 555, :short => 'na',       :long => "N/A" },
+			{ :value => 999, :short => 'dk',       :long => "Don't Know" }
+		]
+	end
+end
+class PADK < CommonLib::TranslationTable
+	def self.table
+		@@table ||= [
+			{ :value => 1,   :short => 'present', :long => "Present" },
+			{ :value => 2,   :short => 'absent',  :long => "Absent" },
+			{ :value => 999, :short => 'dk',      :long => "Don't Know" }
+		]
+	end
+end
+class POSNEG < CommonLib::TranslationTable
+	def self.table
+		@@table ||= [
+			{ :value => 1,   :short => 'pos', :long => "Positive" },
+			{ :value => 2,   :short => 'neg', :long => "Negative" }
+		]
+	end
+end

data/lib/tasks/common_lib.rake

@@ -0,0 +1,10 @@
+#puts "Just loaded common_lib rake file.  Woohoo!"
+
+namespace :common_lib do
+	desc "don't do anything"
+	task :nothing => :environment do
+
+		puts "Not doing anything"
+
+	end
+end

data/lib/tasks/database.rake

@@ -0,0 +1,229 @@
+class Hash
+	#	From http://snippets.dzone.com/posts/show/5811
+  # Renaming and replacing the to_yaml function so it'll serialize hashes sorted (by their keys)
+  # Original function is in /usr/lib/ruby/1.8/yaml/rubytypes.rb
+  def to_ordered_yaml( opts = {} )
+    YAML::quick_emit( object_id, opts ) do |out|
+      out.map( taguri, to_yaml_style ) do |map|
+        sort.each do |k, v|   # <-- here's my addition (the 'sort')
+#	The above sort, sorts the main yaml 'keys' or fixture labels.
+#	k is a fixture label here, eg. "pages_001"
+#	v is the attributes hash
+#	The hash attributes are NOT sorted, unfortunately.
+#	Still working on that one.
+          map.add( k, v )
+
+
+#pages_001:
+#  position: 1
+#  menu_en: CCLS
+#  body_es:
+        end
+      end
+    end
+  end
+end
+
+namespace :app do
+namespace :db do
+
+	desc "Create yml fixtures for given model in database\n" <<
+	     "rake app:db:extract_fixtures_from pages"
+	task :extract_fixtures_from => :environment do
+		me = $*.shift
+		while( table_name = $*.shift )
+#			File.open("#{RAILS_ROOT}/db/#{table_name}.yml", 'w') do |file|
+			File.open("#{Rails.root}/db/#{table_name}.yml", 'w') do |file|
+#				data = table_name.singularize.capitalize.constantize.find(
+#				data = table_name.singularize.classify.constantize.find(
+#					:all).collect(&:attributes)
+#	Added unscoped to break any default scope and sort by id to add some order.
+#	Doesn't seem to actually work though.  Still not sorted properly.
+#	Cause the result is an unordered hash. Bummer
+#	Still use unscoped, just in case there is a default scope with a limit.
+#	
+				data = table_name.singularize.classify.constantize.unscoped.order(
+					'id asc').collect(&:attributes)
+
+#				file.write data.inject({}) { |hash, record|
+#					record.delete('created_at')
+#					record.delete('updated_at')
+#					#	so that it is really string sortable, add leading zeros
+#					hash["#{table_name}_#{sprintf('%03d',record['id'])}"] = record
+#					hash
+#				}.to_ordered_yaml
+
+
+				file.write recursive_hash_to_yml_string(
+					data.inject({}) { |hash, record|
+						record.delete('created_at')
+						record.delete('updated_at')
+						#	so that it is really string sortable, add leading zeros
+						hash["#{table_name}_#{sprintf('%03d',record['id'])}"] = record
+						hash
+					}
+				)
+
+			end
+		end
+		exit	#	REQUIRED OR WILL ATTEMPT TO PROCESS ARGUMENTS AS RAKE TASK
+	end
+
+	desc "Dump MYSQL table descriptions."
+	task :describe => :environment do
+		puts
+		puts "FYI: This task ONLY works on MYSQL databases."
+		puts
+		config = ActiveRecord::Base.connection.instance_variable_get(:@config)
+#=> {:adapter=>"mysql", :host=>"localhost", :password=>nil, :username=>"root", :database=>"my_development", :encoding=>"utf8"}
+
+#		tables = ActiveRecord::Base.connection.execute('show tables;')
+#		while( table = tables.fetch_row ) do
+#	changes for MySQL2
+		tables = ActiveRecord::Base.connection.execute('show tables;').to_a.flatten.sort
+		while( table = tables.shift ) do
+			puts "Table: #{table}"
+
+			#	may have to include host and port
+			system("mysql --table=true " <<
+				"--user=#{config[:username]} " <<
+				"--password='#{config[:password]}' " <<
+				"--execute='describe #{table}' " <<
+				config[:database]);
+
+			#
+			#	mysql formats the table well so doing it by hand is something that
+			#	will have to wait until I feel like wasting my time
+			#
+			#	columns = ActiveRecord::Base.connection.execute("describe #{table};")
+			#	while( column = columns.fetch_hash ) do
+			#		puts column.keys Extra Default Null Type Field Key
+			#	end
+		end
+	end
+
+
+
+	desc "Calculate row size"
+	task :row_sizes => :environment do
+		puts
+		puts "FYI: This task ONLY works on MYSQL databases."
+		puts
+		config = ActiveRecord::Base.connection.instance_variable_get(:@config)
+		#=> {:adapter=>"mysql", :host=>"localhost", :password=>nil, 
+		#		:username=>"root", :database=>"my_development", :encoding=>"utf8"}
+
+		tables = ActiveRecord::Base.connection.execute('show tables;').to_a.flatten.sort
+		require 'nokogiri'
+
+		while( table = tables.shift ) do
+#		begin
+#			table = tables.first
+			puts "Table: #{table}"
+
+			#	may have to include host and port
+			command = "mysql -X " <<
+				"--user=#{config[:username]} " <<
+				"--password='#{config[:password]}' " <<
+				"--execute='describe #{table}' " <<
+				config[:database]
+
+#			puts command
+			xml_doc = Nokogiri::XML(`#{command}`)
+
+			#  <row>
+			#	<field name="Field">id</field>
+			#	<field name="Type">int(11)</field>
+			#	<field name="Null">NO</field>
+			#	<field name="Key">PRI</field>
+			#	<field name="Default" xsi:nil="true" />
+			#	<field name="Extra">auto_increment</field>
+			#  </row>
+			table_size = 0
+			#	http://www.w3schools.com/xpath/xpath_syntax.asp
+			xml_doc.xpath("//row/field[@name='Type']").each do |field|
+				field_size = case field.text
+					when /tinyint/ then 1
+					when /smallint/ then 2
+					when /mediumint/ then 3
+					when /bigint/ then 8
+					when /int/ then 4			#	or integer (match last as would match above)
+					when /double/ then 4
+					when /float/ then 4
+					when /datetime/ then 8
+					when /timestamp/ then 4
+					when /year/ then 1
+					when /date/ then 3
+					when /time/ then 3
+					when /varchar\(\d+\)/ then field.text.scan(/varchar\((\d+)\)/).first.first.to_i
+					else 100	#	just a guess
+#						puts field
+				end
+#				puts "#{field.name} - #{field.text} - #{field_size}"
+				table_size += field_size
+			end
+			puts table_size
+		end
+
+	end
+
+end	#	namespace :db do
+end	#	namespace :app do
+
+
+
+
+
+#	Would have to be very careful here as to not break anything.
+#	I don't know when to quote, add a | or a |- (or what the diff is)
+
+
+#Possible yaml sort.  Doesn't use the yaml library 
+
+#http://stackoverflow.com/questions/7275952/how-can-i-sort-yaml-files
+#	(modified)
+
+
+#	This WILL NOT WORK when the hash contains values that contains multi-line
+#	strings (like a text area).  Somehow things need quoted or | or |- added.
+
+#	needed for escape
+require 'yaml'
+
+#	doesn't exist in ruby 1.9.3,
+#	but seems ok with it being commented out.
+#	probably included in yaml.rb
+#require 'yaml/encoding'	
+
+def recursive_hash_to_yml_string(hash, depth=0)
+	yml_string = ''
+	spacer = ""
+	depth.times { spacer += "  "}
+	hash.keys.sort.each do |sorted_key|
+		yml_string += spacer + sorted_key + ": "
+		if hash[sorted_key].is_a?(Hash)
+			yml_string += "\n"
+			yml_string += recursive_hash_to_yml_string(hash[sorted_key], depth+1)
+		else
+			s = hash[sorted_key].to_s
+			if s.match("\n")
+				yml_string += "|-\n"
+				s.split(/\n/).each do |line|
+					yml_string += "#{spacer}  #{line}\n"
+				end
+			else
+#	YAML.escape doesn't actually seem to escape as I would expect
+#				yml_string += "#{s.gsub(/([:>])/,"\\1")}\n"
+#				yml_string += "\"#{s}\"\n"
+
+				if s.match(/:/)
+					yml_string += "\"#{s}\"\n"
+				else
+					yml_string += "#{s}\n"
+				end
+			end
+		end
+	end
+	yml_string
+end
+