search.rb

require 'set'
require 'json'

class QueryHandler
	def initialize (indexPath, tagPath)
		index_get indexPath
		tags_get tagPath
	end

	def parse_json (path)
		f = File.open path
		index_raw = JSON.parse f.read
		f.close
		return index_raw
	end

	def index_get (path)
		# TODO: implement synonyms/thesaurus
		@index = Hash.new
		parse_json(path).each { |key, docs|
			@index[key] = Set.new()
			docs.each_key { |docID|
				@index[key] << docID
			}
		}
	end

	def tags_get (path)
		@tags = Hash.new
		parse_json(path).each { |key, value|
			@tags[key] = value.to_set
		}
	end

	def retrieve_index (set, key)
		key = key.downcase
		if set.include?(key)
			return set[key]
		else
			return Set.new()
		end
	end

	def intersect (set1, set2)
		# key1 = key1.downcase
		# key2 = key2.downcase
		# if @index.include?(key1)
		# 	if @index.include?(key2)
		# 		return @index[key1].intersect(@index[key2])
		# 	else
		# 		return @index[key1]
		# 	end
		# else
		# 	if @index.include?(key2)
		# 		return @index[key2]
		# 	else
		# 		return Set.new()
		# 	end
		# end
		set1.intersect(set2);
	end

	def union (set1, set2)
		# key1 = key1.downcase
		# key2 = key2.downcase
		# if @index.include?(key1)
		# 	if @index.include?(key2)
		# 		return @index[key1].union(@index[key2])
		# 	else
		# 		return @index[key1]
		# 	end
		# else
		# 	if @index.include?(key2)
		# 		return @index[key2]
		# 	else
		# 		return Set.new()
		# 	end
		# end
		set1.union(set2)
	end

	def exclude (set1, set2)
		# key1 = key1.downcase
		# key2 = key2.downcase
		# if not @index.include?(key1)
		# 	return Set.new()
		# end

		# if @index.include?(key2)
		# 	return @index[key1].difference(@index[key2])
		# else
		# 	return @index[key1]
		# end
		set1.difference(set2)
	end

	def operate (operator, set1, set2)
		case operator
		when '+'
			# return self.union(set1, set2)
			return set1.union(set2)
		when '&'
			# return self.intersect(set1, set2)
			return set1.intersect(set2)
		when '-'
			# return self.difference(set1, set2)
			return set1.difference(set2)
		end
	end

	def handle (query)
		# (exclude (intersect (union stripes black) cat) tiger)
		# Polish-like Notation:
		# +&-:stripes:black:cat:tiger
		# :dog
		if query.length > 0
			query = query.split(':')
			ops = query.shift

			puts "Query dump: " << query.inspect
			# puts "index: " << @index.inspect
			# puts "tags: " << @tags.inspect

			if ops.length > 0
				ops = ops.split(//)
				puts "Operator dump: " << ops.inspect
				first_key = query.shift
				tags = self.retrieve_index(@tags, first_key)
				index = self.retrieve_index(@index, first_key)
				last_result = tags.union(index)

				while ops.length > 0
					key2 = query.shift;
					op = ops.shift
					tag_set = self.retrieve_index(@tags, key2)
					index_set = self.retrieve_index(@index, key2)
					# puts "Operation: " << op << " " << last_result.to_a.inspect << " " << s2.to_a.inspect
					last_result = self.operate(op, last_result, tag_set).union(index_set)

					puts "Result: " << last_result.to_a.inspect
				end

				return last_result
			end
		end

		# begin
		# 	arg1 = query.shift
		# 	arg2 = query.shift
		# end until ops.length == 0
	end
end


qh = QueryHandler.new('search/index.json', 'search/tags.json')

# print "Input Query:"
# q = gets.chomp
puts "ARGV: " << ARGV.inspect
q = ARGV[0]
puts "Query Length: " << q.length.to_s
qh.handle(q)
# puts "Result: " << qh.handle(q).inspect
# qh.handle('+&-:stripes:black:cat:tiger')

# require('index');
# index = Index.new('public/search/index.json');