reporter 0.0.1

data/lib/reporter/formula.rb

@@ -0,0 +1,371 @@
+# Formula parser and calculator
+# Author:: Matthijs Groen
+#
+# This class has two main functions:
+# 1. to parse formula into ready-to-use-arrays
+# 2. use those arrays to perform calculations
+#
+#
+# = Parsing formula
+# my_formula = Formula.new("100% – (MAX(score – 5, 0) * 10%)") => Formula
+# my_formula_data = Formula.make("100% – (MAX(score – 5, 0) * 10%)") => Array
+#
+# The array format used for formula data is [:operator, [parameter, parameter]]
+# the parameters can also be arrays: e.g. sub-calculations
+#
+# The text formula can be build with the following elements:
+# == operators:
+# -:: subtract. subtracts the right side from the left side argument.
+# *:: multiply. multiplies the left side with the right side argument.
+# /:: divide. divides the left side with the ride side argument.
+# +:: add. adds the right side to the left side argument.
+# ^:: power. multiplies the left side by the power of the right side.
+#
+# == functions:
+# functions have the format of name(parameters)
+# the parameters of the function will be pre calculated before the code of the function is executed.
+# supported functions:
+#
+# max:: selects the biggest value from the provided values
+#	min:: selects the smallest value from the provided values
+#	sum:: creates a sum of all the provided values
+#	avg:: creates an average of all the provided values
+#	select:: selects the value with the index of the first parameter
+#	empty:: returns 1 if the given string is empty, 0 otherwise
+#
+# == parenthesis:
+# parentesis can be used to group calculation parts
+#
+# == variables:
+# terms that start with a alfabetic character and contain only alfanumeric characters and underscores
+# can be used as variables. A hash with variables should be supplied when the calculation is performed
+#
+# == numeric values:
+# numeric values like integers, floats and percentages are also allowed. Percentages will be converted to floats.
+#	3% and 66% will be converted to resp. 100% / 3 and 200% / 3
+#
+# = Performing calculations
+# my_formula.call(:score => 7.0) => 0.8 (using the above formula example)
+# Formula.calculate(my_formula_data, :score => 3.0) => 1.0 (using the above formula example)
+#
+class Reporter::Formula
+
+	# Known operators
+	OPERATORS = "-*/+^"
+
+	# parse the given code formula in an array using the format
+	# calculation = [operation, [parameter, parameter]]
+	# a parameter can ofcourse be in turn another calculation
+	def initialize(code)
+		@calculation = Reporter::Formula.make code
+		#puts "#{@calculation.inspect}"
+	end
+
+	attr_reader :calculation
+	
+	# Parses the given formula as text and returns the formula in nested array form.
+	def self.make(code)
+		#puts "parsing: #{code}"
+		begin
+			parse_operation(code)
+		rescue StandardError => e
+			puts "Error in formula: #{code}: #{e}"
+			raise
+		end
+	end
+
+	# executes the formula with a hash of given calculation terms
+	def call(input)
+		begin
+			Reporter::Formula.calculate(@calculation, input)
+		rescue StandardError => e
+			Rails.logger.error "Error executing formula: #{Reporter::Formula.calculation_to_s(@calculation, input)} : #{e.message}"
+			raise
+		end
+	end
+
+	def term_list
+		terms = {}
+		Reporter::Formula.term_list @calculation, terms
+		terms.keys
+	end
+
+	def to_string(input)
+		Reporter::Formula.calculation_to_s(@calculation, input)
+	end
+
+	def solve(input)
+		Reporter::Formula.calculation_to_s(@calculation, input, true)
+	end
+
+	def self.calculation_to_s(calculation, input, solve = false)
+		operation, parameters = * calculation
+
+		string_parameters = parameters.collect do |parameter|
+			parameter.is_a?(Array) ? "#{calculation_to_s(parameter, input, solve)}" : parameter
+		end
+		case operation
+			when :add,
+				:subtract,
+				:times,
+				:divide,
+				:power then
+				"(#{string_parameters[0]} #{{:add => "+",
+																		 :subtract => "-",
+																		 :times => "*",
+																		 :divide => "/",
+																		 :power => "^"}[operation]} #{string_parameters[1]})"
+			# functions:
+			when :max,
+				:min,
+				:sum,
+				:select,
+				:avg,
+				:empty then
+				if solve
+					result = calculate(calculation, input)
+					"#{operation}(#{string_parameters * ","})[#{result}]"
+				else
+					"#{operation}(#{string_parameters * ","})"
+				end
+			# variables
+			when :text then
+				"\"#{string_parameters[0]}\""
+			when :term then
+				"#{string_parameters[0]}[#{input[string_parameters[0]] ? input[string_parameters[0]] : "nil"}]"
+			when :negative_term then
+				"-#{string_parameters[0]}[#{input[string_parameters[0]] ? input[string_parameters[0]] : "nil"}]"
+			when :literal then
+				begin
+					"nil" if string_parameters[0].nil?
+				end
+			# no-op
+			when nil then
+				string_parameters[0].to_s
+			when :percentage then
+				"#{string_parameters[0] * 100.0}%"
+			else
+				"!unsupported(#{operation}}"
+		end
+	end
+
+	def self.term_list(calculation, input = {})
+		operation, parameters = *calculation
+
+		parameters = parameters.collect do |parameter|
+			parameter.is_a?(Array) ? term_list(parameter, input) : parameter
+		end
+
+		case operation
+			# variables
+			when :term then
+					input[parameters[0]] = :term
+			when :negative_term then
+					input[parameters[0]] = :term
+		end
+	end
+
+	def self.calculate(calculation, input)
+		operation, parameters = *calculation
+
+		parameters = parameters.collect do |parameter|
+			parameter.is_a?(Array) ? calculate(parameter, input) : parameter
+		end
+
+		return nil if (parameters[0].nil? or parameters[1].nil?) and [:add, :subtract, :times, :divide, :power].include? operation
+
+		case operation
+			when :add then
+				parameters[0] + parameters[1]
+			when :subtract then
+				parameters[0] - parameters[1]
+			when :times then
+				parameters[0] * parameters[1]
+			when :divide then
+				parameters[1] == 0 ? nil : parameters[0].to_f / parameters[1].to_f
+			when :power then
+				parameters[0] ** parameters[1]
+			# functions:
+			when :max then
+				parameters.compact.max
+			when :min then
+				parameters.compact.min
+			when :sum then
+				begin
+					result = 0.0
+					parameters.each { |value| result += value || 0.0 }
+					result
+				end
+			when :select then
+				begin
+					index = parameters.shift
+					index.is_a?(Numeric) ? parameters[index - 1] : nil
+				end
+			when :avg then
+				begin
+					items = parameters.compact
+					result = 0.0
+					items.each { |value| result += value }
+					result / items.length
+				end
+			when :empty then
+				begin
+					result = parameters.collect { |item| item.to_s.strip == "" ? 1 : 0 }
+					result.include?(0) ? 0 : 1 					
+				end
+			# variables
+			when :term then
+				begin
+					raise "Can't find  term: #{parameters[0]}. Has keys: #{input.keys.collect(&:to_s).sort.inspect}" unless input.has_key? parameters[0]
+					input[parameters[0]]
+				end
+			when :negative_term then
+				begin
+					raise "Can't find  term: #{parameters[0]}. Has keys: #{input.keys.sort.inspect}" unless input.has_key? parameters[0]
+					val = input[parameters[0]]
+					return nil unless val
+					- val
+				end
+			when :literal
+				parameters[0]
+			when :text
+				parameters[0]
+			# no-op
+			when nil, :percentage then
+				parameters[0].to_f
+		end
+	end
+
+	private
+
+	def self.parse_operation(code)
+		#puts "parsing: #{code}"
+
+		# check if the code is totally surrounded by parenthesis that can be removed. remove them if possible
+		code = ungroup code
+
+		left, right, operator, operator_char = "", "", nil, ""
+		char_index, group_level, in_text = 0, 0, false
+		while char_index < code.length
+			char = code[char_index, 1]
+			if operator.nil? and OPERATORS.include? char and group_level == 0 and not in_text
+				operator = case char
+					when "-" then :subtract
+					when "+" then	:add
+					when "*" then	:times
+					when "/" then	:divide
+					when "^" then :power	
+				end
+				operator_char = char
+			else
+				in_text = !in_text if char == "\""
+				group_level += (char == "(") ? 1 : -1 if "()".include? char and not in_text
+				operator ? right += char : left += char
+			end
+			char_index += 1
+		end
+		begin
+			#puts "parse-result: #{operator}, #{left}, #{right}"
+
+			return parse_definition(left.strip) unless operator
+			return parse_definition(operator_char + right) if operator and left.strip == ""
+			return operator, [parse_operation(left.strip), parse_operation(right.strip)]
+		rescue StandardError => e
+			puts "can't parse code: \"#{code}\""
+			raise
+		end
+	end
+
+	def self.parse_definition(code)
+		code = code.strip
+
+		# text "some text"
+		if result = code.match(/\A"([^"]*)"\z/)
+			return :text, result[1]
+			
+			# parse percentages 100%, 10%
+		elsif result = code.match(/\A([\d\.]+)%\z/)
+			return :percentage, [1.0 / 3.0] if result[1].to_f == 33.0
+			return :percentage, [2.0 / 3.0] if result[1].to_f == 66.0
+			return :percentage, [result[1].to_f / 100.0]
+
+			# parse function calls in the format FUNCTION(parameters)
+		elsif result = code.upcase.match(/\A([A-Z_]+)\((.+)\)\z/m)
+			return result[1].downcase.to_sym, self.parameterize(result[2][0 .. -1]).collect { |parameter| parse_operation(parameter) }
+
+			# parse numeric value
+		elsif code.to_i.to_s == code
+			return nil, [code.to_i]
+
+			# parse numeric value
+		elsif code.to_f.to_s == code
+			return nil, [code.to_f]
+
+			# parse literal
+		elsif result = code.upcase.match(/\ANIL\z/)
+			return :literal, [nil]
+
+			# parse variable term
+		elsif result = code.upcase.match(/\A([A-Z][A-Z0-9_]*)\z/)
+			return :term, [result[1].downcase.to_sym]
+		elsif result = code.upcase.match(/\A-([A-Z][A-Z0-9_]*)\z/)
+			return :negative_term, [result[1].downcase.to_sym]
+		else
+			raise "can't parse code: \"#{code}\""
+		end
+	end
+
+	# check if the code is totally surrounded by parenthesis that can be removed. remove them if possible
+	# examples:
+	# ungroup("(my code ()") => "(my code ()"
+	# ungroup("(my code ())") => "my code ()"
+	# ungroup("(my code) ()") => "(my code) ()"
+	# ungroup("m(my code)") => "m(my code)"
+	def self.ungroup(code)
+		# exit if the code does not start with an opening parentesis
+		return code unless code[0, 1] == "("
+		return code unless code[-1, 1] == ")"
+		# since we know the first character is an opening parenthesis,
+		# start parsing at the second character, and assume grouping level 1
+		group_level, char_index, in_text = 1, 1, false
+		while char_index < code.length
+			char = code[char_index, 1]
+			in_text = !in_text if char == "\""
+			group_level += 1 if char == "(" and not in_text
+			group_level -= 1 if char == ")" and not in_text
+
+			# only strip the first and last parenthesis if we exit the grouping AND we reached the last character
+			return code[1 .. -2] if group_level == 0 and char_index == code.length - 1
+			char_index += 1
+		end
+		code
+	end
+
+	#
+	# SUM(1, 2), SELECT(1, 2, 3)
+	def self.parameterize(code)
+		result = []
+		# since we know the first character is an opening parenthesis,
+		# start parsing at the second character, and assume grouping level 1
+		current_param, char = "", ""
+		group_level, char_index, in_text = 0, 0, false
+		while char_index <= code.length
+			char = code[char_index, 1]
+			in_text = !in_text if char == "\""
+			group_level += 1 if char == "(" and not in_text
+			group_level -= 1 if char == ")" and not in_text
+
+			if char == "," and group_level == 0 and not in_text
+				result << current_param
+				current_param = ""
+			else
+				current_param << char
+			end
+
+			char_index += 1
+		end
+		result << current_param unless current_param == ""
+		result
+	end
+
+end

data/lib/reporter/result_row.rb

@@ -0,0 +1,37 @@
+class Reporter::ResultRow
+
+	def initialize(data_set, scope_serialization)
+		@data_set = data_set
+		@scope_serialization = scope_serialization
+		@field_cache = { }
+	end
+
+	def [] field
+		field_cache[field] ||= load_field_values(field)[field]
+	end
+
+	protected
+
+	attr_reader :data_set, :scope_serialization
+	attr_accessor :field_cache
+
+	def load_field_values(*fields)
+		execute_fields *(fields + [{ :scope => scope_serialization, :row => self }])
+	end
+
+	def execute_fields *fields
+		options = fields.extract_options!
+		temp_scope = data_set.data_source.scopes.current_scope
+		field_options = {}
+		data_set.data_source.scopes.apply_scope options[:scope] if options[:scope]
+		field_options[:row] = options[:row] if options[:row]
+		results = {}
+		fields.each do |field|
+			results[field] = data_set.data_structure.field_value_of field, field_options
+		end
+		data_set.data_source.scopes.apply_scope temp_scope
+		results
+	end
+
+
+end

data/lib/reporter/scope/base.rb

@@ -0,0 +1,37 @@
+class Reporter::Scope::Base
+
+	def initialize scoping, name, data_source, mappings
+		@data_source = data_source
+		@scoping = scoping
+		@name = name
+		@mappings = scoping.normalize_mapping mappings
+		@limit = nil
+	end
+
+	def limit= *args
+		raise NotImplementedError
+	end
+
+	def change value
+		raise NotImplementedError
+	end
+
+	def value
+		raise NotImplementedError
+	end
+
+	def apply_on source
+		raise NotImplementedError
+	end
+
+	def iterate &block
+		raise NotImplementedError
+	end
+
+	attr_reader :name, :mappings, :limit
+
+	protected
+
+	attr_reader :scoping, :data_source
+
+end

data/lib/reporter/scope/date_scope.rb

@@ -0,0 +1,109 @@
+class Reporter::Scope::DateScope < Reporter::Scope::Base
+
+	def initialize scoping, name, data_source, mappings
+		super scoping, name, data_source, mappings
+		@period = nil
+	end
+
+	def limit= period
+		@limit = period_as_range(period)
+	end
+
+	def value
+		active_period
+	end
+
+	def human_name
+		active_period.human_name
+	end
+
+	def active_period
+		get_period || @limit
+	end
+
+	def change period
+		scoping.serialize_scope name, period_as_range(period)
+	end
+
+	def apply_on source, period = nil
+		raise "No mapped column for source #{source}" unless mappings.has_key? source.name
+		column = mappings[source.name]
+		# The time period range is inclusive in all aspects of the report to detemine correctly if it runs to the end of a year
+		# or the beginning of another year.
+		# In SQL, the period is used as a BETWEEN statement, with the end exclusive.
+		# In code when we want the whole of Januari, we use 1-1 00:00 till 1-31 23:59
+		# in SQL, we need to use BETWEEN 1-1 00:00 AND 2-1 00:00
+		# when a date includes time, we need to add 1 second. If a date has no time, we need to include 1 day.
+
+		period ||= active_period.dup
+		period = if period.end.is_a? Date
+			period.begin .. period.end.advance(:days => 1)
+	  else
+			period.begin .. period.end.advance(:seconds => 1)
+		end
+
+		case column
+			when String :
+				source.where(column.to_sym => period)
+  		when Hash : begin
+				column.each do |key, value|
+					source = source.joins(key).where(key => { value => period })
+				end
+				source
+			end
+		end
+	end
+
+	def group_on source, period_type
+		column = mappings[source.name]
+		case column
+			when String :
+				"#{period_type.to_s.upcase}(#{column})"
+			when Hash : begin
+				column.each do |key, value|
+					table_name = table_name_of_association source, key
+					return "#{period_type.to_s.upcase}(#{table_name}.#{value})"
+				end
+			end
+		end
+	end
+
+	def self.possible_scopes sources
+		results = []
+		global_dates = nil
+		specific_dates = { :type => :date, :match => :loose }
+		sources.each do |source|
+			global_dates = global_dates ? (global_dates & source.date_columns) : source.date_columns
+			specific_dates[source.model_name] = source.date_columns
+		end
+		results << specific_dates
+		global_dates.each do |reference|
+			result_hash = {:type => :date, :match => :exact}
+			sources.each { |source| result_hash[source.model_name] = reference }
+			results << result_hash
+		end if global_dates
+		results
+	end
+
+	private
+
+	def get_period
+		scoping.unserialize_scope name
+	end
+
+	def period_as_range period
+		case period
+			when Range :
+				period.dup
+			when Fixnum :
+				Date.civil(period).beginning_of_year .. Date.civil(period).end_of_year
+			when :year_cumulative :
+				active_period.begin.beginning_of_year .. active_period.end
+		end
+	end
+
+	def table_name_of_association source, name
+		source.reflect_on_association(name.to_sym).klass.table_name
+	end
+
+end

data/lib/reporter/scope/reference_scope.rb

@@ -0,0 +1,154 @@
+class Reporter::Scope::ReferenceScope < Reporter::Scope::Base
+
+	def initialize scoping, name, data_source, *args
+		mappings = args.extract_options!
+		mappings = create_mappings_for_object_type(data_source, args.first, mappings) if args.first
+		super scoping, data_source, name, mappings
+		@limiter = nil
+		@id_collection = nil
+	end
+
+	def limit= object_or_array
+		@limiter = object_or_array
+	end
+
+	def group_object
+		scoping.unserialize_scope(name)
+	end
+
+	def value
+		group_object || @limiter
+	end
+
+	def change object
+		scoping.serialize_scope name, item
+	end
+
+	def human_name
+		limiter = group_object || @limiter
+		return limiter.collect { |item| human_name_for item }.to_sentence if limiter.is_a? Enumerable
+		human_name_for limiter
+	end
+
+	def apply_on source
+		raise "No mapped column for source #{source}" unless mappings.has_key? source.name
+		reference = mappings[source.name]
+
+		limiter = group_object || @limiter
+		if limiter
+			q, values = limit_through_association source, reference, limiter
+			source.where(q, values)
+		else
+			source
+		end
+	end
+
+	def iterate items, data_set, &block
+		items ||= @limiter
+		if items.is_a? Enumerable
+			items.each do |item|
+				scoping.serialize_scope name, item
+				yield data_set.get_row
+			end
+			scoping.serialize_scope name, nil
+		else
+			scoping.serialize_scope name, items
+			yield data_set.get_row
+			scoping.serialize_scope name, nil
+		end
+	end
+
+	def self.possible_scopes sources
+		results = []
+		# check reflections
+		reflection_references = nil
+		sources.each do |source|
+			relations = source.relations_to_objects
+			relation_pool = relations.keys + [source.active_record]
+			reflection_references = reflection_references ? (reflection_references & relation_pool) : relation_pool
+		end
+		(reflection_references || []).each do |reflection_object|
+			result_hash = { :type => :reference, :match => :loose, :object => reflection_object }
+			sources.each do |source|
+				fields = []
+				fields << "id" if (source.active_record == reflection_object)
+				fields += source.relations_to_objects[reflection_object] || []
+				result_hash[source.model_name] = fields
+			end
+			results << result_hash
+		end
+		#Rails.logger.info reflection_references.inspect
+
+		results
+	end
+
+	private
+
+	def limit_through_association source, reference, limiter
+		if reference.is_a? Array
+			query = [[], {}]
+			reference.each do |ref|
+				q, values = limit_through_association source, ref, limiter
+				query[0] << q
+				query[1].merge! values
+			end
+			return "(#{query[0].join ") OR ("})", query[1]
+		end
+		association = source.reflect_on_association(reference.to_sym)
+		if association.macro == :belongs_to
+			id_collection = get_ids_from limiter, reference, association
+			#Rails.logger.info "Belongs to association #{reference} limited by #{limiter}: #{id_collection.inspect}"
+			return "#{reference}_id IN(:#{reference}_ids)", { "#{reference}_ids".to_sym => id_collection }
+		elsif association.macro == :has_one and association.options[:through]
+			#Rails.logger.info "Has one through association #{reference} limited by #{limiter}"
+			through_association = association.options[:through]
+			limit_through_association source, through_association, limiter
+		end
+	end
+
+	def get_ids_from item, reference, association
+		return [] if item.nil?
+		return item.collect { |sub_item| get_ids_from sub_item, reference, association }.flatten if item.is_a? Enumerable
+		if item.class.ancestors.include? ActiveRecord::Base
+
+			return [item.id] if item.class == association.klass
+			return item.send("#{reference.to_s}_ids".to_sym) if item.respond_to? "#{reference.to_s}_ids"
+			return [item.send("#{reference.to_s}_id".to_sym)] if item.respond_to? "#{reference.to_s}_id"
+		end
+		[]
+	end
+
+	def human_name_for item
+		item.name
+	end
+
+	def create_mappings_for_object_type data_source, object, mappings
+		possible = self.class.possible_scopes data_source.sources
+		#Rails.logger.info possible.inspect
+		possible.each do |reference_mapping|
+			return create_mapping_from(reference_mapping, mappings, data_source.sources) if reference_mapping[:object] == object
+		end
+		raise "No valid data-source mapping could be made with #{object.name}"
+	end
+
+	def create_mapping_from reference_mapping, mapping_specifics, sources
+		mapping = {}
+		sources.each do |source|
+			key = source.model_name.underscore.to_sym
+			columns = reference_mapping[source.model_name]
+			if columns.size == 1
+				mapping[key] = columns.first
+			else
+				specifics = [mapping_specifics[key]].flatten
+				specifics.each do |specific|
+					raise "No available reference to satisfy one of these columns (#{columns.to_sentence}) for datasource #{source.model_name}" unless specific and columns.include? specific
+				end
+				mapping[key] = mapping_specifics[key]
+			end
+		end
+		#{ :funeral => "work_area", :cbs_statistic => "work_area" }
+		#Rails.logger.info mapping.inspect
+		mapping
+	end
+
+end