reporter 0.0.1

data/lib/reporter/data_source/scoping.rb

@@ -0,0 +1,153 @@
+# The scoping class manages the active scopes applied on all datasources.
+# It takes care of serialization of the scopes when they are switched between iterations of the data.
+#
+class Reporter::DataSource::Scoping
+
+	SUPPORTED_SCOPES = {
+					:date => Reporter::Scope::DateScope,
+					:reference => Reporter::Scope::ReferenceScope
+	}
+
+	def initialize data_source
+		@data_source = data_source
+		@defined_scopes = {}
+		@scope_serialization = {}
+		@scope_hash = nil
+	end
+
+	public
+
+	# returns an array with all possible scopes between all datasources
+	def possible
+		return @possible_scopes if @possible_scopes
+		results = SUPPORTED_SCOPES.collect { |type_name, scope_type| scope_type.possible_scopes data_source.sources }.flatten
+		#[{ :funeral => "work_area", :cbs_statistic => "work_area" }, { :funeral => "notification_date", :cbs_statistic => "month" }]
+		@possible_scopes = results.uniq
+	end
+
+	def << scope_type, name, *args
+		raise "Invalid scope #{scope_type}" unless SUPPORTED_SCOPES.keys.include? scope_type
+		@defined_scopes[name] = SUPPORTED_SCOPES[scope_type].new(self, name, data_source, *args)
+		#Rails.logger.info "Added scope #{name}: #{scope_type}"
+		self
+	end
+	alias :add :<<
+
+	def limit_scope scope, *args
+		get(scope).limit = *args
+	end
+
+	def change changes
+		changes.each do |scope, change|
+			get(scope).change change
+		end
+		self
+	end
+
+	def get scope
+		raise "Scope does not exist" unless @defined_scopes.has_key? scope
+		@defined_scopes[scope]
+	end
+
+	# internal
+
+	def apply_on source, options
+		ignored_scopes = options[:ignore_scopes] || []
+		c = @cached_scopes[source][ignored_scopes.hash][@scope_hash]
+		raise "create" if c.nil?
+#		Rails.logger.info "cache!"
+		c
+	rescue
+#		Rails.logger.info "scope creation!"
+		c_source = source
+		@cached_scopes ||= {}
+		@cached_scopes[c_source] ||= {}
+		@cached_scopes[c_source][ignored_scopes.hash] ||= {}
+		@defined_scopes.each do |name, scope|
+			source = scope.apply_on(source) unless ignored_scopes.include? name
+		end
+		@cached_scopes[c_source][ignored_scopes.hash][@scope_hash] = source
+	end
+
+	def normalize_mapping mapping
+		normalized = {}
+		mapping.each do |key, value|
+			key_s = key.to_s
+			source = data_source.sources.find { |source| source.model_name.underscore == key_s.underscore }
+			normalized_value = \
+				case value
+					when Array :
+					 value.collect(&:to_s)
+					when Hash :
+					 value
+					else
+					 value.to_s
+				end
+			normalized[source.model_name] = normalized_value
+		end
+		normalized.freeze
+	end
+
+	def valid_scope? mapping
+		!(get_scope_type mapping == false)
+	end
+
+	def get_scope_type mapping
+		if mapping.is_a? Hash
+			mapping = normalize_mapping mapping
+			#Rails.logger.info mapping.inspect
+			valid = false
+			possible.each do |fields|
+				if (mapping.keys & fields.keys) == mapping.keys
+					combination_valid = true
+					mapping.each do |source, column|
+						columns = fields[source].is_a?(Array) ? fields[source] : [fields[source]]
+						#Rails.logger.info "#{columns.inspect} <=> #{column.inspect}"
+						combination_valid = false unless columns.include? column
+					end
+					return fields[:type] if combination_valid
+				end
+			end
+		elsif mapping.ancestors.include? ActiveRecord::Base
+			return :reference
+		end
+		false
+	end
+
+	# internal serialization
+
+	def current_scope
+		scope_serialization
+	end
+
+	def apply_scope scope_serialization
+		@scope_serialization = scope_serialization
+		@scope_hash = scope_serialization.hash
+	end
+
+	def serialize_scope(scope_name, value)
+		scope_serialization[scope_name] = value
+		@scope_hash = scope_serialization.hash
+	end
+
+	def unserialize_scope(scope_name)
+		scope_serialization[scope_name]
+	end
+
+	def method_missing(method_name, *args, &block)
+		if method_name.to_s =~ /^add_(.*)_scope$/
+			return send :add, $1.to_sym, *args, &block
+		end
+		super
+	end
+
+	def respond_to?(method_name)
+		return true if method_name.to_s =~ /^add_(.*)_scope$/
+		super
+	end
+
+	private
+
+	attr_reader :data_source, :scope_serialization
+
+end

data/lib/reporter/data_source.rb

@@ -0,0 +1,30 @@
+
+class Reporter::DataSource
+
+	def initialize *args, &block
+		@sources = []
+		@scopes = Reporter::DataSource::Scoping.new self
+		yield self if block_given?
+	end
+
+	def << source
+		@sources << wrap_source(source)
+		self
+	end
+	alias :add :<<
+
+	def get name
+		sources.detect { |source| source.name == name } or raise "Source #{name} not found"
+	end
+
+	attr_reader :scopes, :sources
+
+	private
+
+	def wrap_source source
+		if source.ancestors.include? ActiveRecord::Base
+			Reporter::DataSource::ActiveRecordSource.new(self, source)
+		end
+	end
+
+end

data/lib/reporter/data_structure.rb

@@ -0,0 +1,41 @@
+class Reporter::DataStructure
+
+	def initialize data_set, *args
+		@data_set = data_set
+		@fields = {}
+	end
+
+	attr_reader :fields
+
+	def << column_type, column_alias, *args, &block
+		klass = "reporter/field/#{column_type}".classify.constantize
+		column = klass.new self, column_alias, *args, &block
+		#TODO: Validate column
+
+		@fields[column_alias] = column
+		column
+	end
+	alias :add :<<
+
+	def field_value_of field, options
+		raise "No such field defined: #{field}" unless @fields.has_key? field
+		@fields[field].calculate_value(data_set.data_source, options)
+	end
+
+	def method_missing(method_name, *args, &block)
+		if method_name.to_s =~ /^add_(.*)_field$/
+			return send :add, "#{$1}_field", *args, &block
+		end
+		return send :add, :field, *args, &block if method_name.to_s == "add_field"
+		super
+	end
+
+	def respond_to?(method_name)
+		return true if method_name.to_s.starts_with? "add_" and method_name.to_s.ends_with? "_field"
+		super
+	end
+
+	private
+
+	attr_reader :data_set
+end

data/lib/reporter/field/average_field.rb

@@ -0,0 +1,7 @@
+class Reporter::Field::AverageField < Reporter::Field::CalculationField
+
+	def initialize structure, alias_name, data_source, column, options = {}, &block
+		super structure, alias_name, data_source, :average, column, options, &block
+	end
+
+end

data/lib/reporter/field/base.rb

@@ -0,0 +1,21 @@
+class Reporter::Field::Base
+
+	def initialize structure, alias_name
+		@structure = structure
+		@name = alias_name
+	end
+
+	def validate
+		raise NotImplementedError
+	end
+
+	def calculate_value data_source, options
+		raise NotImplementedError
+	end
+
+	attr_reader :name
+
+	protected
+	attr_reader :structure
+
+end

data/lib/reporter/field/calculation_field.rb

@@ -0,0 +1,32 @@
+class Reporter::Field::CalculationField < Reporter::Field::Base
+
+	def initialize structure, alias_name, data_source, calculation, column, options = {}, &block
+		super structure, alias_name
+		@source = data_source
+		@column = column
+		@options = options
+		@calculation = calculation
+		@calculation_block = block if block_given?
+	end
+
+	def calculate_value data_source, calculation_options
+		source = data_source.get(@source)
+		value = source.calculate @calculation, @column, options, &calculation_block
+		Reporter::Value.new(name, options[:name], value, nil, options[:description], options[:source_link])
+	end
+
+	def preload_for_period data_source, calculation_options, period, filter, scope
+		source = data_source.get(@source)
+		values = source.calculate_for_period @calculation, period, filter, scope, @column, options, &calculation_block
+		results = {}
+		values.each do |r|
+			val = r.delete :value
+			results[r] = Reporter::Value.new(name, options[:name], val, nil, options[:description], options[:source_link])
+		end
+		results
+	end
+
+	private
+
+	attr_reader :options, :calculation_block
+end

data/lib/reporter/field/count_field.rb

@@ -0,0 +1,9 @@
+class Reporter::Field::CountField < Reporter::Field::CalculationField
+
+	def initialize structure, alias_name, data_source, *args, &block
+		options = args.extract_options!
+		column = args.first
+		super structure, alias_name, data_source, :count, column, options, &block
+	end
+
+end

data/lib/reporter/field/field.rb

@@ -0,0 +1,25 @@
+class Reporter::Field::Field < Reporter::Field::Base
+
+	def initialize structure, alias_name, *args, &block
+		super structure, alias_name
+		@options = args.extract_options!
+		@value = args.first
+		@calculation_block = block if block_given?
+	end
+
+	def calculate_value data_source, calculation_options
+		if calculation_block
+			row = Reporter::Value.new(name, options[:name], nil, nil, options[:description], options[:source_link])
+			calculation_block.call(data_source, options, row)
+			return row
+		end
+		return Reporter::Value.new(name, options[:name], value, nil, options[:description], options[:source_link]) unless value.is_a? Symbol
+		Reporter::Value.new(name, options[:name], data_source.scopes.get(value).value,
+												data_source.scopes.get(value).human_name, options[:description], options[:source_link])
+	end
+
+	private
+
+	attr_reader :options, :value, :calculation_block
+
+end

data/lib/reporter/field/formula_field.rb

@@ -0,0 +1,24 @@
+class Reporter::Field::FormulaField < Reporter::Field::Base
+
+	def initialize structure, alias_name, formula, options = {}
+		super structure, alias_name
+		@formula = Reporter::Formula.new formula
+		@options = options
+	end
+
+	def calculate_value data_source, calculation_options
+		required_terms = {}
+		formula.term_list.each do |term|
+			required_terms[term] = nil
+			required_terms[term] = calculation_options[:row][term].value if calculation_options[:row] and term != name
+		end
+		value = formula.call(required_terms)
+
+		Reporter::Value.new(name, options[:name], value, nil, options[:description], options[:source_link])
+	end
+
+	private
+
+	attr_reader :options, :formula
+
+end

data/lib/reporter/field/sum_field.rb

@@ -0,0 +1,7 @@
+class Reporter::Field::SumField < Reporter::Field::CalculationField
+
+	def initialize structure, alias_name, data_source, column, options = {}, &block
+		super structure, alias_name, data_source, :sum, column, options, &block
+	end
+
+end