dataview 0.1.1 → 0.2.0

data/lib/data_view.rb

@@ -6,78 +6,67 @@ class DataView
 		public
 			include Enumerable
 			attr_accessor :data_view
-			def initialize(data_view, values = [])
+			def initialize(data_view, values = {})
 				@data_view = data_view
 				@values = values
 			end
 			def [](key)
-				 return @values[get_index(key)]
+				return @values[get_key(key)]
 			end
 			def []=(key, value)
-				@values[get_index(key)] = value
+				@values[get_key(key)] = value
 			end
 			def each
-				@values.each_with_index do |v, i|
-					yield(data_view.fields[i], v)
+				data_view.columns.each_with_index do |c, i|
+					yield(c, @values[c])
 				end
 			end
 			def length
 				@values.length
 			end
 		private
-			def get_index(key)
-				return data_view.fields.index(key) if data_view.fields.include?(key)
-				raise 'key must either be an array index integer or a field key' unless key.respond_to?(:to_i)
-				return key
+			def get_key(key)
+				return key if data_view.columns.include?(key)
+				col = data_view.columns.find {|c|	c[:field] == key}
+				return col unless col == nil
+				return data_view.columns[key.to_i] if key.respond_to?(:to_i)
+				raise "The column #{key} does not exist in this row"
 			end
 	end
 	public
 		include Enumerable
-		attr_reader :fields, :titles, :values, :value_transforms
+		attr_reader :columns, :rows
 		# Initializes the DataView.
 		# ===Model
 		# The DataView supports a model that contains an array of hashes. The keys in these hashes much be symbols of the field names. This is based off of the ActiveRecord interface.
-		# ===Params
-		# Params is a symbol keyed Hash of parameters to be passed.
-		# ====:fields
-		# An array of the fields, on order, that will be used from the model. A field value should be a Symbol or a Proc that accepts the @model and row_index and returns the value to access the value.
-		# ====:titles
-		# A Hash of the titles for the fields. The field symbol is the key, and the title is the value.
-		# ====:values
-		# A hash of Procs that get nondefault values of a field in a particular row. By default, the value is taken by looking at the field in the model. The Proc must accept a Hash of parameters and return the transformed value. The Hash contains the following keys:
+		# ===Columns
+		# An Array of Hashes that contain data about the columns and how the columns will be handled. The column order in the each method is the same as the array order.
+		# Each Hash contains the following keys:
+		# ====:field
+		# (Required) The database field should be a Symbol or String of the field that is called.
+		# ====:title
+		# The title of the column. If one is not given, the field value is used.
+		# ====:value
+		# The value of the particular cell. If a value is not given, the value of the database field in the model is used. If a Symbol or String is given and the model contains a field with that name, then the model value is returned. If the Symbol or string is not a field in the model, the value parameter is returned.
+		# If a Proc is given, the return value of the Proc is used. The Proc must accept a Hash of parameters and return the transformed value. The Hash contains the following keys:
 		# * :sender - The DataView sending the call
 		# * :model - The Model of the DataView
 		# * :row_index - The Index of the current row.
 		# * :column_index - The Index of the current column.
-		# * :field - The field of the current value.
+		# * :column - The column of the current value.
 		# ====:value_transforms
-		# A Hash of the value_transforms that will process the values. The field symbol is the key, and the Proc or array of Procs to transform the value. The Proc must accept a Hash of parameters and return the transformed value. The Hash contains the following keys:
+		# An Array of Procs that act as event sinks to transform the value into the desired view. The transforms occur in the order of the Array. Each Proc must accept a Hash of parameters and return the transformed value. The Hash contains the following keys:
 		# * :sender - The DataView sending the call
 		# * :row_index - The Index of the current row.
 		# * :column_index - The Index of the current column.
 		# * :value - The current value.
-		# * :field - The field of the current value.
-		def initialize(model, params = {})
+		# * :column - The column of the current value.
+		def initialize(model, columns = [])
+			raise 'columns cannot be nil' if columns == nil
 			@model = model.respond_to?(:each_index) ? model : [model]
 
-			# @fields is an ordered array of the fields that will be shown
-			@fields = get_param_value(params, :fields)
-			@fields = Array.new() if @fields == nil
-
-			# @titles is a hash with the field as the key and the title as the value
-			@titles = get_param_value(params, :titles)
-			@titles = Hash.new() if @titles == nil
-
-			# @values is a hash of Procs that get nondefault values of a field in a particular row. By default, the value is taken by looking at the field in the model.
-			@values = get_param_value(params, :values)
-			@values = Hash.new() if @values == nil
-
-			# @value_transforms is a hash with the field as the key and a Proc or array of procs that transforms the value into the proper format as the value
-			# The Proc that is the value must accept a hash that has the following keys:
-			# :sender, :row_index, :column_index, :value, :field
-			value_transforms = get_param_value(params, :value_transforms)
-			value_transforms = Hash.new() if value_transforms == nil
-			@value_transforms = format_value_transforms(value_transforms)
+			# @columns is an ordered array of the columns that will be shown
+			@columns = columns
 		end
 		# Gets a particular row of the view.
 		def [](index)
@@ -93,17 +82,15 @@ class DataView
 				yield(get_view_row(row_index))
 			end
 		end
-		# Iterates through each title of the fields.
+		# Iterates through each title of the columns.
 		def each_title
-			@fields.each do |field|
-				if @titles.include?(field)
-					yield(field, @titles[field])
-				else
-					yield(field, nil)
-				end
+			@columns.each do |column|
+				column_title = column[:title]
+				title = (column_title == nil) ? column[:field] : column[:title]
+				yield(column, title)
 			end
 		end
-		# Iterates through each title of the fields with the index.
+		# Iterates through each title of the columns with the index.
 		def each_title_with_index
 			i = 0
 			each_title do |f, t|
@@ -114,57 +101,49 @@ class DataView
 	private
 		def get_view_row(row_index)
 			model_row = @model[row_index]
-			view_row_values = []
-			@fields.each_with_index do |field, field_index|
-				if @values.include?(field)
-					actual_value = @values[field].call(
-						{
-							:sender => self,
-							:model => @model,
-							:row_index => row_index,
-							:column_index => field_index,
-							:field => field
-						}
-					)
-				else
-					actual_value = model_row[field]
-				end
-				view_value = actual_value
-				
-				if @value_transforms.include?(field)
-					transform_value = actual_value
-
-					transforms = @value_transforms[field]
-					transforms = [transforms] unless transforms.respond_to?(:each)
-					transforms.each do |transform|
-						next unless transform
-						transform_params = {
-							:sender => self,
-							:row_index => row_index,
-							:column_index => field_index,
-							:value => transform_value,
-							:field => field
-						}
-						transform_value = transform.call(transform_params)
-					end
-					view_value = transform_value
-				end
-				view_row_values << view_value
+			view_row_values = {}
+			@columns.each_with_index do |column, column_index|
+				value = get_raw_value(model_row, column, row_index, column_index)
+				value = get_transformed_value(value, column, row_index, column_index)
+				view_row_values[column] = value
 			end
 			Row.new(self, view_row_values)
 		end
-		def get_param_value(param, key)
-			return nil if param == nil
-			return param[key]
+		def get_raw_value(model_row, col, row_index, column_index)
+			value_param = col[:value]
+			return model_row[col[:field]] if value_param == nil
+			
+			return @columns[value_param] if @columns.any? {|f| f[:field] == value_param}
+
+			return value_param.call(
+				{
+					:sender => self,
+					:model => @model,
+					:row_index => row_index,
+					:column_index => column_index,
+					:column => col
+				}
+			) if value_param.respond_to?(:call)
+			
+			return value_param
 		end
-		def format_value_transforms(value_transforms)
-			value_transforms.each do |k, *items|
-				value_transforms[k] = items.flatten
-				value_transforms[k].each do |d|
-					raise ":delegate must respond to call" unless d.respond_to?(:call)
-				end
+		def get_transformed_value(value, column, row_index, column_index)
+			transforms = column[:value_transforms]
+			return value if transforms == nil
+
+			transforms = [transforms] unless transforms.respond_to?(:each)
+			transforms.each do |transform|
+				next unless transform
+				transform_params = {
+					:sender => self,
+					:row_index => row_index,
+					:column_index => column_index,
+					:value => value,
+					:column => column
+				}
+				value = transform.call(transform_params)
 			end
-			value_transforms
+			value
 		end
 end
 

data/test/tc_data_view.rb

@@ -27,15 +27,17 @@ class DataViewTest < Test::Unit::TestCase
 		end
 		def test_value_transforms_accessor
 			data_view = get_data_view(mock_model)
-			data_view.value_transforms[:field1] = nil
-			assert_equal(mock_model[0][:field1], data_view[0][:field1])
+			col = data_view.columns.find {|col| col[:field] == :field1}
+			col[:value_transforms] = nil
+			field = col[:field]
+			assert_equal(mock_model[0][field], data_view[0][:field1])
 
 			test_transform = lambda { |h|
 				'test ' << h[:value].to_s
 			}
-			data_view.value_transforms[:field1] = test_transform
+			col[:value_transforms] = test_transform
 
-			expected_transform_value = test_transform.call({:value => mock_model[0][:field1]})
+			expected_transform_value = test_transform.call({:value => mock_model[0][field]})
 			assert_equal(expected_transform_value, data_view[0][:field1])
 		end
 	private
@@ -44,11 +46,12 @@ class DataViewTest < Test::Unit::TestCase
 
 			test_model = model.respond_to?(:each_index) ? model : [model]
 			test_model.each_with_index do |r, i|
-				fields.each_with_index do |f, j|
+				columns.each_with_index do |col, j|
+					f = col[:field]
 					if f != :model_value_field
 						v = r[f]
 					else
-						v = get_model_value({:sender => self, :model => model, :row_index => i, :field => f})
+						v = get_model_value({:sender => self, :model => model, :row_index => i, :column => col})
 					end
 					assert_equal(expected_altered_value(v), data_view[i][f])
 				end
@@ -60,11 +63,12 @@ class DataViewTest < Test::Unit::TestCase
 				expected_row = model.respond_to?(:each_index) ? model[i] : model
 				assert_equal(expected_row.length, row.to_a.length)
 
-				expected_row.each do |k, expected_value|
-					if k == :model_value_field
-						expected_value = get_model_value({:sender => self, :model => model, :row_index => i, :field => k})
+				expected_row.each do |f, expected_value|
+					col = data_view.columns.find{|col| col[:field] == f}
+					if f == :model_value_field
+						expected_value = get_model_value({:sender => self, :model => model, :row_index => i, :column => col})
 					end
-					assert_equal(expected_altered_value(expected_value), row[k])
+					assert_equal(expected_altered_value(expected_value), row[f])
 				end
 			end
 		end
@@ -72,7 +76,7 @@ class DataViewTest < Test::Unit::TestCase
 			data_view = get_data_view(model)
 			i = 0
 			data_view.each_title do |f, t|
-				assert_equal(titles[f], t)
+				assert_equal(f[:title], t)
 				i = i + 1
 			end
 		end
@@ -80,7 +84,7 @@ class DataViewTest < Test::Unit::TestCase
 			data_view = get_data_view(model)
 			ei = 0
 			data_view.each_title_with_index do |f, t, i|
-				assert_equal(titles[fields[ei]], t)
+				assert_equal(f[:title], t)
 				assert_equal(ei, i)
 				ei = ei + 1
 			end
@@ -89,13 +93,7 @@ class DataViewTest < Test::Unit::TestCase
 			"altered " << v
 		end
 		def get_data_view(model)
-			DataView.new(
-				model,
-				:fields => fields,
-				:titles => titles,
-				:values => values,
-				:value_transforms => value_transforms
-			)
+			DataView.new(model, columns)
 		end
 		def get_model_value_method
 			return @get_model_value_method if defined?(@get_model_value_method)
@@ -106,7 +104,7 @@ class DataViewTest < Test::Unit::TestCase
 			test_model = params[:model]
 			test_row_index = params[:row_index]
 			test_column_index = params[:column_index]
-			test_field = params[:field]
+			test_column = params[:column]
 			
 			unless test_sender == self
 				assert_equal(DataView, test_sender.class)
@@ -114,23 +112,29 @@ class DataViewTest < Test::Unit::TestCase
 					assert_equal(singular_mock_model, test_model[0])
 				end
 				assert((0..2).include?(test_row_index))
-				assert(fields.include?(test_field))
-				fi = fields.index(test_field)
+				assert(columns.include?(test_column))
+				fi = columns.index(test_column)
 				assert_equal(fi, test_column_index)
 			end
-			test_row_index.to_s << ' : Custom ' << test_field.to_s
+			test_row_index.to_s << ' : Custom ' << test_column[:field].to_s
 		end
-		def fields
-			return @fields if defined?(@fields)
-			@fields = [:model_value_field , :field1, :field2, :field3] 
-		end
-		def titles
-			return @titles if defined?(@titles)
-			t = Hash.new()
-			fields.each do |f|
-				t[f] = f.to_s << ' Title'
+		def columns
+			return @columns if defined?(@columns)
+
+			columns = []
+			[:model_value_field, :field1, :field2, :field3].each do |f|
+				column = Hash.new
+				column[:field] = f
+				column[:title] = get_title(f)
+				column[:value] = get_model_value_method if f == :model_value_field
+				column[:value_transforms] = value_transform
+				columns.push(column)
 			end
-			@titles = t
+
+			@columns = columns
+		end
+		def get_title(field)
+			"#{field.to_s} Title"
 		end
 		def singular_mock_model
 			return @singular_mock_model if defined?(@singular_mock_model)
@@ -147,9 +151,9 @@ class DataViewTest < Test::Unit::TestCase
 		end
 		def get_mock_model_row(i)
 			row = Hash.new
-			fields.each do |f|
-				next if f.respond_to?(:call)
-				row[f] = i.to_s << ' : ' << f.to_s
+			columns.each do |f|
+				field = f[:field]
+				row[field] = i.to_s << ' : ' << field.to_s
 			end
 			row
 		end
@@ -159,15 +163,11 @@ class DataViewTest < Test::Unit::TestCase
 			v[:model_value_field] = get_model_value_method
 			@values = v
 		end
-		def value_transforms
-			return @value_transforms if defined?(@value_transforms)
-			t = Hash.new()
-			fields.each do |f|
-				t[f] = lambda { |h|
-					'altered ' << h[:value].to_s
-				}
+		def value_transform
+			return @value_transform if defined?(@value_transform)
+			@value_transform = lambda do |h|
+				'altered ' << h[:value].to_s
 			end
-			@value_transforms = t
 		end
 end
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: dataview
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
-date: 2005-07-25 00:00:00 -07:00
+  version: 0.2.0
+date: 2005-07-26 00:00:00 -07:00
 summary: Data View is a library that creates a view of a data model. The view can transform the data of the data model without changing the data. Supports ActiveRecord models and other data models that have a similar interface.
 require_paths: 
   - lib