smql 0.0.4.1 → 0.0.4.2

data/VERSION

@@ -1 +1 @@
-0.0.4.1
+0.0.2

data/lib/smql_to_ar/condition_types.rb

@@ -25,44 +25,28 @@ class SmqlToAR
 	# Nimmt eine Klasse ein Objekt an,  so soll diese Klasse instanziert werden.
 	# Alles weitere siehe Condition.
 	module ConditionTypes
-		extend SmqlToAR::Assertion
-
 		class <<self
 			# Ex: 'givenname|surname|nick' => [:givenname, :surname, :nick]
 			def split_keys k
 				k.split( '|').collect &:to_sym
 			end
 
-			def conditions &e
-				unless block_given?
-					r = Enumerator.new( self, :conditions)
-					s = self
-					r.define_singleton_method :[] do |k|
-						s.conditions.select {|c| c::Operator === k }
-					end
-					return r
-				end
-				constants.each do |c|
-					next  if :Condition == c
-					c = const_get c
-					next  if Condition === c
-					yield c
-				end
-			end
-
 			# Eine Regel parsen.
 			# Ex: Person, "givenname=", "Peter"
 			def try_parse_it model, colop, val
 				r = nil
 				#p :try_parse => { :model => model, :colop => colop, :value => val }
-				conditions.each do |c|
-					raise_unless colop =~ /^(?:\d*:)?(.*?)(\W*)$/, UnexpectedColOpError.new( model, colop, val)
+				constants.each do |c|
+					next  if :Condition == c
+					c = const_get c
+					next  if Condition === c
+					raise UnexpectedColOpError.new( model, colop, val)  unless colop =~ /^(?:\d*:)?(.*?)(\W*)$/
 					col, op = $1, $2
 					col = split_keys( col).collect {|c| Column.new model, c }
 					r = c.try_parse model, col, op, val
 					break  if r
 				end
-				raise_unless r, UnexpectedError.new( model, colop, val)
+				raise UnexpectedError.new( model, colop, val)  unless r
 				r
 			end
 
@@ -88,24 +72,16 @@ class SmqlToAR
 		end
 
 		class Condition
-			include SmqlToAR::Assertion
-			extend SmqlToAR::Assertion
 			attr_reader :value, :cols
 			Operator = nil
 			Expected = []
 			Where = nil
 
-			class <<self
-				# Versuche das Objekt zu erkennen.  Operator und Expected muessen passen.
-				# Passt das Object,  die Klasse instanzieren.
-				def try_parse model, cols, op, val
-					#p :self => name, :try_parse => op, :cols => cols, :with => self::Operator, :value => val, :expected => self::Expected, :model => model.name
-					new model, cols, val  if self::Operator === op and self::Expected.any?( &it === val)
-				end
-
-				def inspect
-					"#{self.name}(:operator=>#{self::Operator.inspect}, :expected=>#{self::Expected.inspect}, :where=>#{self::Where.inspect})"
-				end
+			# Versuche das Objekt zu erkennen.  Operator und Expected muessen passen.
+			# Passt das Object,  die Klasse instanzieren.
+			def self.try_parse model, cols, op, val
+				#p :self => name, :try_parse => op, :cols => cols, :with => self::Operator, :value => val, :expected => self::Expected, :model => model.name
+				new model, cols, val  if self::Operator === op and self::Expected.any? {|i| i === val }
 			end
 
 			def initialize model, cols, val
@@ -117,10 +93,6 @@ class SmqlToAR
 				verify
 			end
 
-			def inspect
-				"#<#{self.class.name}:0x#{(self.object_id<<1).to_s 16} model: #{self.class.name}, cols: #{@cols.inspect}, value: #{@value.inspect}>"
-			end
-
 			def verify
 				@cols.each do |col|
 					verify_column col
@@ -131,19 +103,19 @@ class SmqlToAR
 			# Gibt es eine Spalte diesen Namens?
 			# Oder:  Gibt es eine Relation diesen Namens?  (Hier nicht der Fall)
 			def verify_column col
-				raise_unless col.exist_in?, NonExistingColumnError.new( %w[Column], col)
+				raise NonExistingColumnError.new( %w[Column], col)  unless col.exist_in?
 			end
 
 			# Modelle koennen Spalten/Relationen verbieten mit Model#smql_protected.
 			# Dieses muss ein Object mit #include?( name_als_string) zurueckliefern,
 			# welches true fuer verboten und false fuer, erlaubt steht.
 			def verify_allowed col
-				raise_if col.protected?, ProtectedColumnError.new( col)
+				raise ProtectedColumnError.new( col)  if col.protected?
 			end
 
 			# Erstelle alle noetigen Klauseln. builder nimmt diese entgegen,
-			# wobei builder.joins, builder.select, builder.where und builder.wobs von interesse sind.
-			# mehrere Schluessel bedeuten, dass die Values _alle_ zutreffen muessen, wobei die Schluessel geODERt werden.
+			# wobei builder.join, builder.select, builder.where und builder.wobs von interesse sind.
+			# mehrere Schluessel bedeuten, dass die Values _alle_ zutreffen muessen, wobei die Schluessel geodert werden.
 			# Ex:
 			# 1) {"givenname=", "Peter"} #=> givenname = 'Peter'
 			# 2) {"givenname=", ["Peter", "Hans"]} #=> ( givenname = 'Peter' OR givenname = 'Hans' )
@@ -156,16 +128,15 @@ class SmqlToAR
 					@cols.each do |col|
 						col.joins builder, table
 						col = builder.column table+col.path, col.col
-						builder.where values.keys.collect {|vid| self.class::Where % [ col, vid.to_s ] }
+						builder.where *values.keys.collect {|vid| self.class::Where % [ col, vid.to_s ] }
 					end
 				else
-					b2 = SmqlToAR::And.new builder
 					values.keys.each do |vid|
-						b2.where SmqlToAR::Or[ *@cols.collect {|col|
+						builder.where *@cols.collect {|col|
 								col.joins builder, table
 								col = builder.column table+col.path, col.col
 								self.class::Where % [ col, vid.to_s ]
-							}]
+							}
 					end
 				end
 				self
@@ -214,92 +185,50 @@ class SmqlToAR
 
 		In = simple_condition NotIn, '|=', '%s IN (%s)', [Array]
 		In2 = simple_condition In, '', nil, [Array]
-		NotEqual = simple_condition Condition, '!=', "%s <> %s", [Array, String, Numeric]
-		NotEqual2 = simple_condition Condition, '<>', "%s <> %s", [Array, String, Numeric]
+		NotEqual = simple_condition Condition, /\!=|<>/, "%s <> %s", [Array, String, Numeric]
 		GreaterThanOrEqual = simple_condition Condition, '>=', "%s >= %s", [Array, Numeric]
 		LesserThanOrEqual = simple_condition Condition, '<=', "%s <= %s", [Array, Numeric]
-
-		# Examples:
-		# { 'articles=>' => { id: 1 } }
-		# { 'articles=>' => [ { id: 1 }, { id: 2 } ] }
 		class EqualJoin <Condition
-			Operator = '=>'
-			Expected = [Hash, lambda {|x| x.kind_of?( Array) and x.all?( &it.kind_of?( Hash))}]
+			Operator = '='
+			Expected = [Hash]
 
 			def initialize *pars
 				super( *pars)
-				@value = Array.wrap @value
 				cols = {}
 				@cols.each do |col|
-					col_model = col.relation
-					cols[col] = [col_model] + @value.collect {|val| ConditionTypes.try_parse( col_model, val) }
+					col_model = SmqlToAR.model_of col.last_model, col.col
+					#p col_model: col_model.to_s, value: @value
+					cols[col] = [col_model] + ConditionTypes.try_parse( col_model, @value)
 				end
 				@cols = cols
 			end
 
 			def verify_column col
-				raise_unless col.relation, NonExistingRelationError.new( %w[Relation], col)
+				refl = SmqlToAR.model_of col.last_model, col.col
+				#p refl: refl, model: @model.name, col: col, :reflections => @model.reflections.keys
+				raise NonExistingRelationError.new( %w[Relation], col)  unless refl
 			end
 
 			def build builder, table
 				@cols.each do |col, sub|
-					model, *sub = sub
 					t = table + col.path + [col.col]
-					col.joins.each {|j, m| builder.joins table+j, m }
-					builder.joins t, model
-					b2 = 1 == sub.length ? builder : Or.new( builder)
-					sub.each {|i| i.collect( &it.build( And.new( b2), t)); p 'or' => b2 }
-				end
-				self
-			end
-		end
-
-		# Takes to Queries.
-		# First Query will be a Subquery, second a regular query.
-		# Example:
-		#   Person.smql 'sub.articles:' => [{'limit:' => 1, 'order:': 'updated_at desc'}, {'content~' => 'some text'}]
-		# Person must have as last Article (compared by updated_at) owned by Person a Artive which has 'some text' in content.
-		# The last Article needn't to have 'some text' has content,  the subquery takes it anyway.
-		# But the second query compares to it and never to any other Article,  because these are filtered by first query.
-		# The difference to
-		#   Person.smql :articles => {'content~' => 'some text', 'limit:' => 1, 'order:': 'updated_at desc'}
-		# is,  second is not allowed (limit and order must be in root) and this means something like
-		#   "Person must have the Article owned by Person which has 'some text' in content.
-		#   limit and order has no function in this query and this article needn't to be the last."
-		class SubEqualJoin < EqualJoin
-			Operator = '()'
-			Expected = [lambda {|x| x.kind_of?( Array) and (1..2).include?( x.length) and x.all?( &it.kind_of?( Hash))}]
-
-			def initialize model, cols, val
-				super model, cols, val[1]
-				# sub: model, subquery, sub(condition)
-				@cols.each {|col, sub| sub[ 1..-1] = SmqlToAR.new( col.relation, val[0]).parse, *sub[-1] }
-			end
-
-			def verify_column col
-				raise_unless col.child?, ConColumnError.new( [:Column], col)
-			end
-
-			def build builder, table
-				@cols.each do |col, sub|
-					t = table+col.to_a
-					builder.sub_joins t, col, *sub[0..1]
-					#ap sub: sub[2..-1]
-					sub[2..-1].each &it.build( builder, t)
+					#p sub: sub
+					p col: col, joins: col.joins
+					col.joins.each {|j, m| builder.join table+j, m }
+					builder.join t, SmqlToAR.model_of( col.last_model, col.col)
+					sub[1..-1].each {|one| one.build builder, t }
 				end
 				self
 			end
 		end
-
 		Equal = simple_condition Condition, '=', "%s = %s", [Array, String, Numeric]
 		Equal2 = simple_condition Equal, '', "%s = %s", [String, Numeric]
 		GreaterThan = simple_condition Condition, '>', "%s > %s", [Array, Numeric]
 		LesserThan = simple_condition Condition, '<', "%s < %s", [Array, Numeric]
 		NotIlike = simple_condition Condition, '!~', "%s NOT ILIKE %s", [Array, String]
 		Ilike = simple_condition Condition, '~', "%s ILIKE %s", [Array, String]
-		Exists = simple_condition Condition, '', '%s IS NOT NULL', [true]
-		NotExists = simple_condition Condition, '', '%s IS NULL', [false]
 
+		####### No Operator #######
 		Join = simple_condition EqualJoin, '', nil, [Hash]
 		InRange2 = simple_condition InRange, '', nil, [Range]
 		class Select < Condition
@@ -307,7 +236,7 @@ class SmqlToAR
 			Expected = [nil]
 
 			def verify_column col
-				raise_unless col.exist_in? || SmqlToAR.model_of( col.last_model, col.col), NonExistingSelectableError.new( col)
+				raise NonExistingSelectableError.new( col)  unless col.exist_in? or SmqlToAR.model_of( col.last_model, col.col)
 			end
 
 			def build builder, table
@@ -329,19 +258,13 @@ class SmqlToAR
 			Expected = [String, Array, Hash, Numeric, nil]
 
 			class Function
-				include SmqlToAR::Assertion
 				Name = nil
 				Expected = []
 				attr_reader :model, :func, :args
 
-				class <<self
-					def try_parse model, func, args
-						self.new model, func, args  if self::Name === func and self::Expected.any?( &it === args)
-					end
-
-					def inspect
-						"#{self.name}(:name=>#{self::Name}, :expected=>#{self::Expected})"
-					end
+				def self.try_parse model, func, args
+					SmqlToAR.logger.info( { try_parse: [func,args]}.inspect)
+					self.new model, func, args  if self::Name === func and self::Expected.any? {|e| e === args }
 				end
 
 				def initialize model, func, args
@@ -354,19 +277,22 @@ class SmqlToAR
 				Expected = [String, Array, Hash, nil]
 
 				def initialize model, func, args
+					SmqlToAR.logger.info( {args: args}.inspect)
 					args = case args
 						when String then [args]
 						when Array, Hash then args.to_a
 						when nil then nil
 						else raise 'Oops'
 						end
+					SmqlToAR.logger.info( {args: args}.inspect)
 					args.andand.collect! do |o|
 						o = Array.wrap o
 						col = Column.new model, o.first
 						o = 'desc' == o.last.to_s.downcase ? :DESC : :ASC
-						raise_unless col.exist_in?, NonExistingColumnError.new( [:Column], col)
+						raise NonExistingColumnError.new( [:Column], col)  unless col.exist_in?
 						[col, o]
 					end
+					SmqlToAR.logger.info( {args: args}.inspect)
 					super model, func, args
 				end
 
@@ -376,39 +302,22 @@ class SmqlToAR
 						col, o = o
 						col.joins builder, table
 						t = table + col.path
-						raise_unless 1 == t.length, RootOnlyFunctionError.new( t)
+						#raise OnlyOrderOnBaseError.new( t)  unless 1 == t.length
 						builder.order t, col.col, o
 					end
 				end
 			end
 
-			class Limit < Function
-				Name = :limit
-				Expected = [Fixnum]
-
-				def build builder, table
-					raise_unless 1 == table.length, RootOnlyFunctionError.new( table)
-					builder.limit = Array.wrap(@args).first.to_i
-				end
-			end
-
-			class Offset < Function
-				Name = :offset
-				Expected = [Fixnum]
-
-				def build builder, table
-					raise_unless 1 == table.length, RootOnlyFunctionError.new( table)
-					builder.offset = Array.wrap(@args).first.to_i
-				end
-			end
-
 			def self.new model, col, val
+				SmqlToAR.logger.info( { function: col.first.to_sym }.inspect)
 				r = nil
 				constants.each do |c|
 					next  if [:Function, :Where, :Expected, :Operator].include? c
 					c = const_get c
 					next  if Function === c or not c.respond_to?( :try_parse)
+					SmqlToAR.logger.info( {f: c}.inspect)
 					r = c.try_parse model, col.first.to_sym, val
+					SmqlToAR.logger.info( {r: r}.inspect)
 					break  if r
 				end
 				r

data/lib/smql_to_ar/query_builder.rb

@@ -22,41 +22,36 @@ class SmqlToAR
 		class Vid
 			attr_reader :vid
 			def initialize( vid)  @vid = vid  end
-			def to_s() ":smql_c#{@vid}" end
-			def to_sym() "smql_c#{@vid}".to_sym end
+			def to_s() ":c#{@vid}" end
+			def to_sym() "c#{@vid}".to_sym end
 			alias sym to_sym
 			def to_i()  @vid  end
 		end
 
-		attr_reader :table_alias, :model, :table_model, :base_table, :_where, :_select, :_wobs, :_joins, :prefix, :_vid
-		attr_accessor :logger, :limit, :offset
+		attr_reader :table_alias, :model, :table_model, :base_table, :_where, :_select, :_wobs, :_joins
+		attr_accessor :logger
 
-		def initialize model, prefix = nil
-			@prefix = "smql"
+		def initialize model
 			@logger = SmqlToAR.logger
 			@table_alias = Hash.new do |h, k|
-				j = Array.wrap( k).compact
-				h[k] = h.key?(j) ? h[j] : "#{@prefix},#{j.join(',')}"
+				k = Array.wrap k
+				h[k] = "smql,#{k.join(',')}"
 			end
-			@_vid, @_where, @_wobs, @model, @quoter = 0, SmqlToAR::And[], {}, model, model.connection
+			@_vid, @_where, @_wobs, @model, @quoter = 0, [], {}, model, model.connection
 			@base_table = [model.table_name.to_sym]
 			@table_alias[ @base_table] = @base_table.first
 			t = quote_table_name @table_alias[ @base_table]
-			@_select, @_joins, @_joined, @_includes, @_order = ["DISTINCT #{t}.*"], "", [@base_table], [], []
+			@_select, @_joins, @_joined, @_includes, @_order = ["DISTINCT #{t}.*"], "", [], [], []
 			@table_model = {@base_table => @model}
 		end
 
 		def vid()  Vid.new( @_vid+=1)  end
 
-		def inspect
-			"#<#{self.class.name}:#{"0x%x"% (self.object_id<<1)}|#{@prefix}:#{@base_table}:#{@model} vid=#{@_vid} where=#{@_where} wobs=#{@_wobs} select=#{@_select} aliases=#{@_table_alias}>"
-		end
-
 		# Jede via where uebergebene Condition wird geodert und alle zusammen werden geundet.
 		# "Konjunktive Normalform".  Allerdings duerfen Conditions auch Komplexe Abfragen enthalten.
-		# Ex: builder.where( ['a = a', 'b = c']).where( ['c = d', 'e = e']).where( 'x = y').where( ['( m = n AND o = p )', 'f = g'])
+		# Ex: builder.where( 'a = a', 'b = c').where( 'c = d', 'e = e').where( 'x = y').where( '( m = n AND o = p )', 'f = g')
 		#        #=> WHERE ( a = a OR b = c ) AND ( c = d OR e = e ) AND x = y ( ( m = n AND o = p ) OR f = g )
-		def where cond
+		def where *cond
 			@_where.push cond
 			self
 		end
@@ -79,52 +74,30 @@ class SmqlToAR
 		end
 
 		def build_join orig, pretable, table, prekey, key
-			" LEFT JOIN #{orig} AS #{quote_table_name table} ON #{column pretable, prekey} = #{column table, key} "
+			" JOIN #{quote_table_name orig.to_sym} AS #{quote_table_name table} ON #{column pretable, prekey} = #{column table, key} "
 		end
 
-		def sub_joins table, col, model, query
-			prefix, base_table = "#{@prefix}_sub", col.relation.table_name
-			join_ table, model, "(#{query.build( prefix).ar.to_sql})"
-		end
-
-		def join_ table, model, query, pretable = nil
-			pretable ||= table[0...-1]
+		def join table, model
+			return self  if @_joined.include? table # Already joined
+			pretable = table[0...-1]
 			@table_model[ table] = model
 			premodel = @table_model[ pretable]
 			t = @table_alias[ table]
 			pt = quote_table_name @table_alias[ table[ 0...-1]]
 			refl = premodel.reflections[table.last]
-			case refl
-			when ActiveRecord::Reflection::ThroughReflection
-				through = refl.through_reflection
-				throughtable = table[0...-1]+[through.name.to_sym]
-				srctable = throughtable+[refl.source_reflection.name]
-				@table_model[ srctable] = model
-				@table_alias[ table] = @table_alias[ srctable]
-				join_ throughtable, through.klass, quote_table_name( through.table_name)
-				join_ srctable, refl.klass, query, throughtable
-			when ActiveRecord::Reflection::AssociationReflection
-				case refl.macro
-				when :has_many
-					@_joins += build_join query, pretable, t, premodel.primary_key, refl.primary_key_name
-				when :belongs_to
-					@_joins += build_join query, pretable, t, refl.primary_key_name, premodel.primary_key
-				when :has_and_belongs_to_many
-					jointable = [','] + table
-					@_joins += build_join refl.options[:join_table], pretable, @table_alias[jointable], premodel.primary_key, refl.primary_key_name
-					@_joins += build_join query, jointable, t, refl.association_foreign_key, refl.association_primary_key
-				else raise BuilderError, "Unkown reflection macro: #{refl.macro.inspect}"
-				end
-			else raise BuilderError, "Unkown reflection type: #{refl.class.name}"
+			case refl.macro
+			when :has_many
+				@_joins += build_join model.table_name, pretable, t, premodel.primary_key, refl.primary_key_name
+			when :belongs_to
+				@_joins += build_join model.table_name, pretable, t, refl.primary_key_name, premodel.primary_key
+			when :has_and_belongs_to_many
+				jointable = [','] + table
+				@_joins += build_join refl.options[:join_table], pretable, @table_alias[jointable], premodel.primary_key, refl.primary_key_name
+				@_joins += build_join model.table_name, jointable, t, refl.association_foreign_key, refl.association_primary_key
+			else raise BuilderError, "Unkown reflection macro: #{refl.macro.inspect}"
 			end
-			self
-		end
-
-		def joins table, model
-			table = table.flatten.compact
-			return self  if @_joined.include? table # Already joined
-			join_ table, model, quote_table_name( model.table_name)
 			@_joined.push table
+			self
 		end
 
 		def includes table
@@ -138,25 +111,36 @@ class SmqlToAR
 		end
 
 		def order table, col, o
-			@_order.push "#{column table, col} #{:DESC == o ? :DESC : :ASC}"
+			tc = column table, col
+			@_select.push ct
+			@_order.push "#{ct} #{:DESC == o ? :DESC : :ASC}"
+			self
+		end
+
+		class Dummy
+			def method_missing m, *a, &e
+				#p :dummy => m, :pars => a, :block => e
+				self
+			end
 		end
 
 		def build_ar
-			where_str = @_where.type_correction!.optimize!.build_where
+			where_str = @_where.collect do |w|
+				w = Array.wrap w
+				1 == w.length ? w.first : "( #{w.join( ' OR ')} )"
+			end.join ' AND '
 			incls = {}
 			@_includes.each do |inc|
 				b = incls
 				inc[1..-1].collect {|rel| b = b[rel] ||= {} }
 			end
+			@logger.debug incls: incls, joins: @_joins
 			@model = @model.
 				select( @_select.join( ', ')).
 				joins( @_joins).
 				where( where_str, @_wobs).
 				order( @_order.join( ', ')).
 				includes( incls)
-			@model = @model.limit @limit  if @limit
-			@model = @model.offset @offset  if @offset
-			@model
 		end
 
 		def fix_calculate
@@ -175,72 +159,4 @@ class SmqlToAR
 			@model
 		end
 	end
-
-	class SubBuilder < Array
-		attr_reader :parent, :_where
-		delegate :wobs, :joins, :includes, :sub_joins, :vid, :quote_column_name, :quoter, :quote_table_name, :column, :to => :parent
-
-		def initialize parent, tmp = false
-			@parent = parent
-			@parent.where self  unless @parend.nil? && tmp
-		end
-
-		def new parent, tmp = false
-			super parent, tmp
-			#return parent  if self.class == parent.class
-			#super parent
-		end
-
-		alias where push
-
-		def type_correction!
-			collect! do |sub|
-				if sub.kind_of? Array
-					sub = default[ *sub]  unless sub.respond_to?( :type_correction!)
-					sub.type_correction!
-				end
-				sub
-			end
-			self
-		end
-
-		def optimize!
-			ext = []
-			collect! do |sub|
-				sub = sub.optimize!  if sub.kind_of? Array
-				if self.class == sub.class
-					ext.push *sub
-					nil
-				elsif sub.blank?
-					nil
-				else
-					sub
-				end
-			end.compact!
-			push *ext
-			self
-		end
-
-		def inspect
-			"#{self.class.name.sub( /.*::/, '')}[ #{collect(&:inspect).join ', '}]"
-		end
-		def default()  SmqlToAR::And  end
-		def default_new( parent)  default.new self, parent, false  end
-		def collect_build_where
-			collect {|x| x.respond_to?( :build_where) ? x.build_where : x.to_s }
-		end
-	end
-
-	class And < SubBuilder
-		def default; SmqlToAR::Or; end
-		def build_where
-			collect_build_where.join ' AND '
-		end
-	end
-
-	class Or < SubBuilder
-		def build_where
-			collect_build_where.join ' OR '
-		end
-	end
 end

data/lib/smql_to_ar.rb

@@ -15,18 +15,6 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 class SmqlToAR
-	module Assertion
-		def raise_unless cond, exception = nil, *args
-			cond, exception, *args = yield. cond, exception, *args  if block_given?
-			raise exception || Exception, *args  unless cond
-		end
-
-		def raise_if cond, exception = nil, *args
-			cond, exception, *args = yield. cond, exception, *args  if block_given?
-			raise exception || Exception, *args  if cond
-		end
-	end
-
 	include ActiveSupport::Benchmarkable
 	############################################################################r
 	# Exceptions
@@ -89,27 +77,19 @@ class SmqlToAR
 		end
  	end
 
-	class RootOnlyFunctionError < SMQLError
+	class OnlyOrderOnBaseError < SMQLError
 		def initialize path
 			super :path => path
 		end
 	end
 
-	class ConColumnError < SMQLError
-		def initialize expected, got
-			super :expected => expected, :got => got
-		end
-	end
-
 	class BuilderError < Exception; end
 
 	#############################################################################
 
 	# Model der Relation `rel` von `model`
 	def self.model_of model, rel
-		rel = rel.to_sym
-		r = model.reflections[ rel].andand.klass
-		r.nil? && :self == rel ? model : r
+		model.reflections[ rel.to_sym].andand.klass
 	end
 
 	# Eine Spalte in einer Tabelle, relativ zu `Column#model`.
@@ -123,7 +103,7 @@ class SmqlToAR
 		def initialize model, *col
 			@model = model
 			@last_model = nil
-			*@path, @col = *Array.wrap( col).collect( &it.to_s.split( /[.\/]/)).flatten.collect( &:to_sym).reject( &it==:self)
+			*@path, @col = Array.wrap( col).collect {|s| s.to_s.split /[.\/]/ }.flatten.collect &:to_sym
 		end
 
 		def last_model
@@ -133,12 +113,9 @@ class SmqlToAR
 		def each
 			model = @model
 			@path.each do |rel|
-				rel = rel.to_sym
-				unless :self == rel
-					model = SmqlToAR.model_of model, rel
-					return false  unless model
-					yield rel, model
-				end
+				model = SmqlToAR.model_of model, rel
+				return false  unless model
+				yield rel, model
 			end
 			model
 		end
@@ -163,23 +140,19 @@ class SmqlToAR
 		def joins builder = nil, table = nil, &exe
 			pp = []
 			table = Array.wrap table
-			exe ||= builder ? lambda {|j, m| builder.joins table+j, m} : Array.method( :[])
+			exe ||= builder ? lambda {|j, m| builder.join table+j, m} : Array.method( :[])
 			collect do |rel, model|
 				pp.push rel
 				exe.call pp, model
 			end
 	 	end
-		def self?()  !@col  end
-		def length() @path.length+(self.self? ? 0 : 1)  end
-		def size()   @path.size+(self.self? ? 0 : 1)  end
-		def to_a()   @path+(self.self? ? [] : [@col])  end
+		def to_a()   @path+[@col]  end
 		def to_s()   to_a.join '.'  end
 		def to_sym() to_s.to_sym  end
 		def to_json()  to_s  end
 		def inspect()  "#<Column: #{model} #{to_s}>"  end
-		def relation()  self.self? ? model : SmqlToAR.model_of( last_model, @col)  end
+		def relation()  SmqlToAR.model_of last_model, @col  end
 		def allowed?()  ! self.protected?  end
-		def child?()  @path.empty? and !!relation  end
 	end
 
 	attr_reader :model, :query, :conditions, :builder, :order
@@ -206,23 +179,6 @@ class SmqlToAR
 		#p model: @model, query: @query
 	end
 
-	def self.models models
-		models = Array.wrap models
-		r = Hash.new {|h,k| h[k] = {} }
-		while model = models.tap( &:uniq!).pop
-			refls = model.respond_to?( :reflections) && model.reflections
-			refls && refls.each do |name, refl|
-				r[model.name][name] = case refl
-					when ActiveRecord::Reflection::ThroughReflection then {:macro => refl.macro, :model => refl.klass.name, :through => refl.through_reflection.name}
-					when ActiveRecord::Reflection::AssociationReflection then {:macro => refl.macro, :model => refl.klass.name}
-					else raise "Ups: #{refl.class}"
-					end
-				models.push refl.klass  unless r.keys.include? refl.klass.name
-			end
-		end
-		r
-	end
-
 	def parse
 		benchmark 'SMQL parse' do
 			@conditions = ConditionTypes.try_parse @model, @query
@@ -231,11 +187,11 @@ class SmqlToAR
 		self
 	end
 
-	def build prefix = nil
+	def build
 		benchmark 'SMQL build query' do
-			@builder = QueryBuilder.new @model, prefix
+			@builder = QueryBuilder.new @model
 			table = @builder.base_table
-			@conditions.each &it.build( builder, table)
+			@conditions.each {|condition| condition.build builder, table }
 		end
 		#p builder: @builder
 		self
@@ -258,12 +214,4 @@ class SmqlToAR
 	def self.to_ar *params
 		new( *params).to_ar
 	end
-
-	def self.reload_library
-		lib_dir = File.dirname __FILE__
-		fj = lambda {|*a| File.join lib_dir, *a }
-		load fj.call( 'smql_to_ar.rb')
-		load fj.call( 'smql_to_ar', 'condition_types.rb')
-		load fj.call( 'smql_to_ar', 'query_builder.rb')
-	end
 end

metadata

@@ -6,8 +6,8 @@ version: !ruby/object:Gem::Version
   - 0
   - 0
   - 4
-  - 1
-  version: 0.0.4.1
+  - 2
+  version: 0.0.4.2
 platform: ruby
 authors: 
 - Denis Knauf
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-06 00:00:00 +02:00
+date: 2011-10-27 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency