dataview 0.1.0

data/README

@@ -0,0 +1,58 @@
+Data View is copyrighted free software by Brian Takita <brian.takita@gmail.com>.
+You can redistribute it and/or modify it under either the terms of the GPL, or the conditions below:
+
+  1. You may make and give away verbatim copies of the source form of the
+     software without restriction, provided that you duplicate all of the
+     original copyright notices and associated disclaimers.
+
+  2. You may modify your copy of the software in any way, provided that
+     you do at least ONE of the following:
+
+       a) place your modifications in the Public Domain or otherwise
+          make them Freely Available, such as by posting said
+	  modifications to Usenet or an equivalent medium, or by allowing
+	  the author to include your modifications in the software.
+
+       b) use the modified software only within your corporation or
+          organization.
+
+       c) rename any non-standard executables so the names do not conflict
+	  with standard executables, which must also be provided.
+
+       d) make other distribution arrangements with the author.
+
+  3. You may distribute the software in object code or executable
+     form, provided that you do at least ONE of the following:
+
+       a) distribute the executables and library files of the software,
+	  together with instructions (in the manual page or equivalent)
+	  on where to get the original distribution.
+
+       b) accompany the distribution with the machine-readable source of
+	  the software.
+
+       c) give non-standard executables non-standard names, with
+          instructions on where to get the original software distribution.
+
+       d) make other distribution arrangements with the author.
+
+  4. You may modify and include the part of the software into any other
+     software (possibly commercial).  But some files in the distribution
+     are not written by the author, so that they are not under this terms.
+
+     They are gc.c(partly), utils.c(partly), regex.[ch], st.[ch] and some
+     files under the ./missing directory.  See each file for the copying
+     condition.
+
+  5. The scripts and library files supplied as input to or produced as 
+     output from the software do not automatically fall under the
+     copyright of the software, but belong to whomever generated them, 
+     and may be sold commercially, and may be aggregated with this
+     software.
+
+  6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+     IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+     WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+     PURPOSE.
+
+

data/lib/data_view.rb

@@ -0,0 +1,158 @@
+module DataView
+
+# DataView is intended to reduce coupling between the Controller and View layers in a MVC application. The Controller can send a DataView to the View layer. The View layer does not need to have access to the Model.
+class DataView
+	class Row
+		public
+			include Enumerable
+			attr_accessor :data_view
+			def initialize(data_view, values = [])
+				@data_view = data_view
+				@values = values
+			end
+			def [](key)
+				 return @values[get_index(key)]
+			end
+			def []=(key, value)
+				@values[get_index(key)] = value
+			end
+			def each
+				@values.each_with_index do |v, i|
+					yield(data_view.fields[i], v)
+				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
+			end
+	end
+	public
+		include Enumerable
+		attr_reader :fields, :titles, :delegates
+		# 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:
+		# * :sender - The DataView sending the call
+		# * :row_index - The Index of the current row.
+		# * :column_index - The Index of the current column.
+		# * :field - The field of the current value.
+		# ====:value_transforms
+		# A Hash of the delegates 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:
+		# * :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 = {})
+			@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)
+		end
+		# Gets a particular row of the view.
+		def [](index)
+			get_view_row(index)
+		end
+		# The number of rows in the result.
+		def length
+			@model.length
+		end
+		# Iterates through each row of the view.
+		def each
+			@model.each_index do |row_index|
+				yield(get_view_row(row_index))
+			end
+		end
+		# Iterates through each title of the fields.
+		def each_title
+			@fields.each do |field|
+				if @titles.include?(field)
+					yield(field, @titles[field])
+				else
+					yield(field, nil)
+				end
+			end
+		end
+		# Iterates through each title of the fields with the index.
+		def each_title_with_index
+			i = 0
+			each_title do |f, t|
+				yield(f, t, i)
+				i = i + 1
+			end
+		end
+	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(@model, row_index, field)
+				else
+					actual_value = model_row[field]
+				end
+				view_value = actual_value
+				
+				if @value_transforms.include?(field)
+					delegate_value = actual_value
+					@value_transforms[field].each do |delegate|
+						delegate_params = {
+							:sender => self,
+							:row_index => row_index,
+							:column_index => field_index,
+							:value => delegate_value,
+							:field => field
+						}
+						delegate_value = delegate.call(delegate_params)
+					end
+					view_value = delegate_value
+				end
+				view_row_values << view_value
+			end
+			Row.new(self, view_row_values)
+		end
+		def get_param_value(param, key)
+			return nil if param == nil
+			return param[key]
+		end
+		def format_value_transforms(delegates)
+			delegates.each do |k, *items|
+				delegates[k] = items.flatten
+				delegates[k].each do |d|
+					raise ":delegate must respond to call" unless d.respond_to?(:call)
+				end
+			end
+			delegates
+		end
+end
+
+end

data/lib/dataview.rb

@@ -0,0 +1 @@
+require 'data_view'

data/test/tc_data_view.rb

@@ -0,0 +1,138 @@
+this_dir = File.dirname(__FILE__)
+require this_dir << '/../lib/data_view'
+require 'test/unit'
+
+class DataViewTest < Test::Unit::TestCase
+	include DataView
+	public
+		def test_brackets
+			do_test_brackets(mock_model)
+			do_test_brackets(singular_mock_model)
+		end
+		def test_each
+			do_test_each(mock_model)
+			do_test_each(singular_mock_model)
+		end
+		def test_each_title
+			do_test_each_title(mock_model)
+			do_test_each_title(singular_mock_model)
+		end
+		def test_each_title_with_index
+			do_test_each_title_with_index(mock_model)
+			do_test_each_title_with_index(singular_mock_model)
+		end
+		def test_length
+			assert_equal(mock_model.length, get_data_view(mock_model).length)
+			assert_equal(1, get_data_view(singular_mock_model).length)
+		end
+	private
+		def do_test_brackets(model)
+			data_view = get_data_view(model)
+
+			test_model = model.respond_to?(:each_index) ? model : [model]
+			test_model.each_with_index do |r, i|
+				fields.each_with_index do |f, j|
+					v = (f == :model_value_field) ? get_model_value(model, i, f) : r[f]
+					assert_equal(expected_altered_value(v), data_view[i][f])
+				end
+			end
+		end
+		def do_test_each(model)
+			data_view = get_data_view(model)
+			data_view.each_with_index do |row, i|
+				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|
+					expected_value = get_model_value(model, i, k) if k == :model_value_field
+					assert_equal(expected_altered_value(expected_value), row[k])
+				end
+			end
+		end
+		def do_test_each_title(model)
+			data_view = get_data_view(model)
+			i = 0
+			data_view.each_title do |f, t|
+				assert_equal(titles[f], t)
+				i = i + 1
+			end
+		end
+		def do_test_each_title_with_index(model)
+			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(ei, i)
+				ei = ei + 1
+			end
+		end
+		def expected_altered_value(v)
+			"altered " << v
+		end
+		def get_data_view(model)
+			DataView.new(
+				model,
+				:fields => fields,
+				:titles => titles,
+				:values => values,
+				:value_transforms => value_transforms
+			)
+		end
+		def get_model_value_method
+			return @get_model_value_method if defined?(@get_model_value_method)
+			@get_model_value_method = method(:get_model_value)
+		end
+		def get_model_value(model, row_index, field)
+			row_index.to_s << ' : Custom ' << 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'
+			end
+			@titles = t
+		end
+		def singular_mock_model
+			return @singular_mock_model if defined?(@singular_mock_model)
+			@singular_mock_model = get_mock_model_row(0)
+		end
+		def mock_model
+			return @mock_model if defined?(@mock_model)
+			m = Array.new
+			(0..2).each do |i|
+				row = get_mock_model_row(i)
+				m << row
+			end
+			@mock_model = m
+		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
+			end
+			row
+		end
+		def values
+			return @values if defined?(@values)
+			v = Hash.new
+			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
+				}
+			end
+			@value_transforms = t
+		end
+end
+

data/test/ts_data_view.rb

@@ -0,0 +1,2 @@
+this_dir = File.dirname(__FILE__)
+require this_dir << '/tc_data_view'

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: dataview
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2005-07-25 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
+email: brian.takita@gmail.com
+homepage: http://DataView.rubyforge.org
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+  - Brian Takita
+files: 
+  - test/tc_data_view.rb
+  - test/ts_data_view.rb
+  - lib/dataview.rb
+  - lib/data_view.rb
+  - README
+test_files: 
+  - test/ts_data_view.rb
+rdoc_options: []
+extra_rdoc_files: 
+  - README
+executables: []
+extensions: []
+requirements: []
+dependencies: []