kansas 0.9.0

data/lib/kansas/TableClass.rb

@@ -0,0 +1,179 @@
+class KSTable
+
+	def KSTable.is_a_kstable?
+		true
+	end
+
+	def KSTable.field(localName, remoteName=nil, conversion=nil)
+		remoteName = localName unless remoteName
+
+		conversionCall = conversion ? ".#{conversion}" : ''
+		addField(localName, remoteName)
+    
+		class_eval <<-EOS
+def #{localName}
+	@row['#{remoteName}']#{conversionCall}
+end
+
+def #{localName}=(val)
+	unless pending_deletion? or read_only?
+	  	@rollback_buffer.push ['#{remoteName}', @row['#{remoteName}']]
+	  	@rollback_hash['#{remoteName}'] ||= []
+	  	@rollback_hash['#{remoteName}'].push @row['#{remoteName}']
+		@row['#{remoteName}'] = val
+		changed
+	end
+end
+EOS
+	end
+  
+  	# A table can have more than one primary field?
+  	
+	def KSTable.primary(field)
+		if defined?(@primaries) && @primaries
+			@primaries << field unless @primaries.include?(field)
+		else
+			@primaries = [field]
+		end
+	end
+  
+	def KSTable.to_one(name, local_field, foreign_table, foreign_field = nil)
+		foreign_table = foreign_table.to_s if Symbol === foreign_table
+		if foreign_table.class.to_s == 'String'
+			if KSDatabase.partial_to_complete_map.has_key?(foreign_table)
+				foreign_table = KSDatabase.const_get KSDatabase.partial_to_complete_map[foreign_table]
+			else
+				foreign_table = nil
+			end
+		end
+		
+		# Need to throw an exception if foregin_table is bad.
+		
+		addRelation(name.to_s, KSToOne.new(self, local_field.to_s, foreign_table, foreign_field.to_s))
+		class_eval <<-EOS
+def #{name}
+	self.class.relations['#{name}'].get(self)
+end
+
+def #{name}=(val)
+	self.class.relations['#{name}'].set(self, val)
+end
+EOS
+	end
+
+	def KSTable.belongs_to(name, foreign_table, local_field, foreign_field = nil)
+		foreign_table = foreign_table.to_s if Symbol === foreign_table
+		if foreign_table.class.to_s == 'String'
+			if KSDatabase.partial_to_complete_map.has_key?(foreign_table)
+				foreign_table = KSDatabase.const_get KSDatabase.partial_to_complete_map[foreign_table]
+			else
+				foreign_table = nil
+			end
+		end
+		
+		# Need to throw an exception if foregin_table is bad.
+		
+		addRelation(name.to_s, KSBelongsTo.new(self, foreign_table, local_field.to_s, foreign_field.to_s))
+		class_eval <<-EOS
+def #{name}
+	self.class.relations['#{name}'].get(self)
+end
+
+def #{name}=(val)
+	self.class.relations['#{name}'].set(self, val)
+end
+EOS
+	end
+
+	def KSTable.to_many(name, foreign_table, foreign_field, local_field = nil)
+		foreign_table = foreign_table.to_s if Symbol === foreign_table
+		if foreign_table.class.to_s == 'String'
+			if KSDatabase.partial_to_complete_map.has_key?(foreign_table)
+				foreign_table = KSDatabase.const_get KSDatabase.partial_to_complete_map[foreign_table]
+			else
+				foreign_table = nil
+			end
+		end
+		
+		# Need to throw an exception if foregin_table is bad.
+		
+		addRelation(name.to_s, KSToMany.new(self, foreign_table, foreign_field.to_s, local_field.to_s))
+		class_eval <<-EOS
+def #{name}
+	self.class.relations['#{name}'].get(self)
+end
+
+def #{name}_count
+	self.class.relations['#{name}'].count(self)
+end
+EOS
+	end
+  
+	def KSTable.all_fields
+		database.query do |dbh|
+			dbh.columns(table_name).each do |descr|
+				fieldName = descr['name']
+				field(fieldName, fieldName, conversion(descr['type_name']))
+				if descr['primary']
+					primary fieldName
+				end
+			end
+		end
+	end
+  
+	def KSTable.primaries
+		@primaries
+	end
+  
+	def KSTable.table_name
+		class_eval 'Name'
+	end
+  
+	def KSTable.database
+		class_eval 'Database'
+	end
+  
+	def KSTable.fields
+		@fields
+	end
+  
+	def KSTable.relations
+		@relations
+	end
+
+	private
+  
+	def KSTable.addField(name, field)
+		if defined?(@fields) && @fields
+			@fields[name] = field
+		else
+			@fields = {name => field}
+		end
+	end
+
+	def KSTable.addRelation(name, relation)
+		if defined?(@relations)
+			@relations[name] = relation
+		else
+			@relations = {name => relation}
+		end
+	end
+  
+	def KSTable.conversion(type)
+		case type
+		when /int/
+			:to_i
+		when /float/, /double/
+			:to_f
+		else
+			nil
+		end
+	end
+  
+	def KSTable.canonical(fieldName)
+		newName = fieldName.mixcase
+		newName[0,1] = newName[0,1].downcase
+		newName
+	end
+
+end

data/lib/kansas/ToMany.rb

@@ -0,0 +1,13 @@
+class KSToMany
+	
+	def initialize(*args)
+		@localTable, @foreignTable, @foreignField, @localField = args
+		@localField = @localTable.primaries.first unless @localField != ''
+	end
+	
+	def get(parent)
+		sql = "SELECT * FROM #{@foreignTable.table_name} " +
+				"WHERE #{@foreignField} = '#{parent.row[@localField]}'" 
+		parent.context.select(@foreignTable, sql)
+	end
+end

data/lib/kansas/ToOne.rb

@@ -0,0 +1,29 @@
+class KSToOne
+
+	attr_reader :foreignTable, :foreignField, :localTable, :localField
+
+	def initialize(*args)
+		@localTable, @localField, @foreignTable, @foreignField = args
+		@foreignField = @foreignTable.primaries.first unless @foreignField != ''
+	end
+	
+	def get(parent)
+		if @foreignField != @foreignTable.primaries.first
+			sql = "SELECT * FROM #{@foreignTable.table_name} " +
+					"WHERE #{@foreignField} = '#{parent.row[@localField]}'" 
+			parent.context.select(@foreignTable, sql).first
+		else
+			parent.context.get_object(@foreignTable, [parent.row[@localField]])
+		end
+	end
+		
+	def set(parent, child)
+		parent.row[@localField] = child.row[@foreignField]
+		parent.changed
+	end
+	
+	def join
+		"#{@localTable.table_name}.#{@localField} = #{@foreignTable.table_name}.#{@foreignField}"
+	end
+	
+end

data/lib/kansas/adaptors/AdaptorRule.rb

@@ -0,0 +1,17 @@
+class KSAdaptorRule
+	def initialize(args, &block)
+		@name = args[:name] # name of adaptor
+		@description = args[:description] # short description of what adaptor provides
+		@file = args[:file] # adaptor file to require
+		@priority = args[:priority] # rules with a lower priority will be checked first
+		@klass = args[:klass] # adaptor class
+		@block = block # code to determine if this adaptor should be used
+	end
+
+	def name; @name; end
+	def description; @description; end
+	def file; @file; end
+	def priority; @priority; end
+	def klass; @klass; end
+	def check(*args); @block.call(args); end
+end

data/lib/kansas/adaptors/Adaptors.rb

@@ -0,0 +1,24 @@
+class KSAdaptors
+
+	@@list = Hash.new {|h,k| h[k] = []}
+
+	def KSAdaptors.<<(val)
+		@@list[val.priority] << val
+	end
+
+	def KSAdaptors[]=(key,val)
+		@@list[key] << val
+	end
+
+	def KSAdaptors[](key)
+		@@list[key]
+	end
+
+	def KSAdaptors.list
+		@@list
+	end
+
+	def KSAdaptors.to_s
+		@@list.inspect
+	end
+end

data/lib/kansas/adaptors/StandardSQLMixin.rb

@@ -0,0 +1,106 @@
+class Object
+	def expr_body
+		to_s
+	end
+end
+
+class Array
+	def expr_body
+		collect {|e| e.expr_body}.join(',')
+	end
+end
+
+class String
+	def expr_body
+		KSDatabase.sql_escape(self)
+	end
+end
+
+class KSStandardSQLMixin
+	def select_sql(context)
+		distinct_fields = []
+		fields = []
+		context.select_table.fields.each_value do |f|
+			if context.distinct[f]
+				distinct_fields.push "distinct(#{@context.select}.#{f})"
+			else
+				fields.push "#{@context.select}.#{f}"
+			end
+		end
+		
+		fields = distinct_fields.concat(fields)
+		
+		selectedTables = context.tables.compact.flatten.uniq.join(',')
+		joinConstraints = context.joins.compact.flatten.uniq.join(' AND ')
+		#selected_rows = context.select.compact.flatten.uniq.collect {|t| "#{t}.*"}.join(',')
+		
+		if joinConstraints != ""
+			joinConstraints << " AND "
+		end
+    
+		#statement = "SELECT #{context.select}.* FROM #{selectedTables} WHERE #{joinConstraints} #{expr_body}"
+		statement = "SELECT #{fields.join(',')} FROM #{selectedTables} WHERE #{joinConstraints} #{expr_body}"
+		statement << ' ORDER BY ' << context.sort_fields.collect {|f| "#{f[0].respond_to?(:expr_body) ? f[0].expr_body : f[0].to_s} #{f[1]}"}.join(',') if context.sort_fields.length > 0
+		statement << ' LIMIT ' << context.limits.join(',') if context.limits.length > 0
+		
+		statement
+	end
+
+	def count_sql(context)
+		selectedTables = context.tables.compact.flatten.uniq.join(',')
+		joinConstraints = context.joins.compact.flatten.uniq.join(' AND ')
+		#selected_rows = context.select.compact.flatten.uniq.collect {|t| "#{t}.*"}.join(',')
+		
+		if joinConstraints != ""
+			joinConstraints << " AND "
+		end
+    
+		statement = "SELECT count(*) FROM #{selectedTables} WHERE #{joinConstraints} #{expr_body}"
+		statement << ' ORDER BY ' << context.sort_fields.collect {|f| "#{f[0].respond_to?(:expr_body) ? f[0].expr_body : f[0].to_s} #{f[1]}"}.join(',') if context.sort_fields.length > 0
+		statement << ' LIMIT ' << context.limits.join(',') if @context.limits.length > 0
+
+		statement
+	end
+
+	def delete_sql(context)
+		selectedTables = context.tables.compact.flatten.uniq.join(",")
+		joinConstraints = context.joins.compact.flatten.uniq.join(" AND ")
+		if joinConstraints != ""
+			joinConstraints << " AND "
+		end
+    
+		statement = "DELETE FROM #{selectedTables} WHERE #{joinConstraints} #{expr_body}"
+		
+		statement
+	end
+
+	def build_where(object)
+		build_where_from_key(object, object.key)
+	end
+  
+	def build_where_from_key(object, key, tableflag = false)
+		table = tableflag ? object : object.class
+		where = " WHERE "
+		where_ary = []
+		fields = table.primaries
+    
+		fields.each_index do |i|
+			if !tableflag && object.rollback_hash[fields[i]]
+				val = object.rollback_hash[fields[i]].last
+			else
+				val = key[i]
+			end
+			
+			where_ary.push "#{fields[i]} = #{KSDatabase.sql_escape(val)}"
+		end
+		where + where_ary.join(' AND ')
+	end
+  
+	def build_update(object)
+		update = "UPDATE #{object.table_name} SET "
+		object.row.each do |field, val|
+			update << " #{field} = #{KSDatabase.sql_escape(val)},"
+		end
+		update.chop!		
+	end
+end

data/lib/kansas/adaptors/dbi_rule.rb

@@ -0,0 +1,8 @@
+KSAdaptors << KSAdaptorRule.new(
+	:name => 'General DBI Adaptor',
+	:description => 'Provides a generalized access to DBI; this is equivalent to the behavior of the legacy Kansas.',
+	:file => '',
+	:priority => 1000
+	) {|args|
+	# This code block determines if this adaptor might be able to handle the request.
+	}

data/lib/kansas/patch_dbi.rb

@@ -0,0 +1,54 @@
+module DBI
+
+  class Row
+    if RUBY_VERSION =~ /^1\.9/ || RUBY_VERSION =~ /^2/
+      def __getobj__
+        @arr
+      end
+
+      def __setobj__(obj)
+        @delegate_dc_obj = @arr = obj
+      end
+    else
+      def clone
+        Marshal.load(Marshal.dump(self))
+      end
+
+      def dup
+        row = self.class.allocate
+        row.instance_variable_set :@column_types,  @column_types
+        row.instance_variable_set :@convert_types, @convert_types
+        row.instance_variable_set :@column_map,    @column_map
+        row.instance_variable_set :@column_names,  @column_names
+        # this is the only one we actually dup...
+        row.instance_variable_set :@arr,           arr = @arr.dup
+        row.instance_variable_set :@_dc_obj,       arr
+        row
+      end
+    end
+
+  end
+
+  class ColumnInfo
+    def initialize(hash=nil)
+      @hash = hash.dup rescue nil
+       @hash ||= Hash.new
+
+       # coerce all strings to symbols
+       @hash.keys.each do |x|
+         if x.kind_of? String
+           sym = x.to_sym
+           if @hash.has_key? sym
+             raise ::TypeError, 
+               "#{self.class.name} may construct from a hash keyed with strings or symbols, but not both" 
+           end
+           @hash[sym] = @hash[x]
+           @hash.delete(x)
+         end
+       end
+
+       super(@hash)
+     end
+  end
+
+end

data/lib/kansas/version.rb

@@ -0,0 +1,3 @@
+module Kansas
+  VERSION = "0.9.0"
+end