dataview 0.2.0 → 0.3.0

data/lib/data_view.rb

@@ -1,150 +1,181 @@
+require 'ducktypechecker'
+
 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_key(key)]
-			end
-			def []=(key, value)
-				@values[get_key(key)] = value
-			end
-			def each
-				data_view.columns.each_with_index do |c, i|
-					yield(c, @values[c])
-				end
-			end
-			def length
-				@values.length
-			end
-		private
-			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 :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.
-		# ===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.
-		# * :column - The column of the current value.
-		# ====:value_transforms
-		# 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.
-		# * :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]
-
-			# @columns is an ordered array of the columns that will be shown
-			@columns = columns
-		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 columns.
-		def each_title
-			@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 columns 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 = {}
-			@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_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}
+class << self
+  # Creates a column definition struct.
+  def create_column(field=nil, title=nil, value=nil, *value_transforms)
+    @@Column_Struct_Class = Struct.new(
+      :field,
+      :title,
+      :value,
+      :value_transforms
+    ) unless defined?(@@Column_Struct_Class)
+    
+    @@Column_Struct_Class.new(field, title, value, value_transforms.flatten)
+  end
+end
+   
+  public
+  
+  include Enumerable
+  attr_reader :columns, :rows
+  # Initializes the DataView.
+  # ===Model
+  # The DataView supports a model that contains an array of structs or hashes.
+  # The keys in these hashes much be symbols of the field names.
+  # ===Columns
+  # An Array of Structs (see :create_column) 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 Struct 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 Struct of parameters and return
+  # the transformed value. The Struct contains the following keys:
+  # * :model - The Model of the DataView
+  # * :row_index - The Index of the current row.
+  # * :column_index - The Index of the current column.
+  # * :column - The column of the current value.
+  # ====:value_transforms
+  # 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 Struct of parameters
+  # and return the transformed value.
+  # The Struct contains the following keys:
+  # * :value - The current value.
+  # * :model - The Model of the DataView
+  # * :row_index - The Index of the current row.
+  # * :column_index - The Index of the current column.
+  # * :column - The column of the current value.
+  def initialize(model, *columns)
+    columns = columns.flatten
+    @model = if model.respond_to?(:each_index) then model else [model] end
 
-			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 get_transformed_value(value, column, row_index, column_index)
-			transforms = column[:value_transforms]
-			return value if transforms == nil
+    # @columns is an ordered array of the columns that will be shown
+    @columns = columns
+  end
+  
+  # Creates a column definition struct.
+  def create_column(field=nil, title=nil, value=nil, *value_transforms)
+    DataView.create_column(field, title, value, *value_transforms)
+  end
+  
+  # Gets a particular row of the view.
+  def [](index)
+    v_r_s = create_view_row_struct
+    get_view_row(index, v_r_s)
+  end
+  
+  # The number of rows in the result.
+  def length
+    @model.length
+  end
+  
+  # Iterates through each row of the view.
+  def each
+    v_r_s = create_view_row_struct
+    @model.each_index do |row_index|
+      yield(get_view_row(row_index, v_r_s))
+    end
+  end
+  
+  private
+  
+  def create_view_row_struct
+    fields = @columns.collect{|c| c.field}
+    Struct.new(*fields)
+  end
+    
+  def get_view_row(row_index, view_row_struct)
+    model_row = @model[row_index]
+    
+    view_row_values = view_row_struct.new
+    @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.field] = value
+    end
+    view_row_values
+  end
+    
+  def get_raw_value(model_row, col, row_index, column_index)
+    return model_row[col.field] if col.value.nil?
+    
+    return col.value.call(
+      create_value_proc_struct(row_index, column_index, col)
+    ) if col.value.respond_to?(:call)
+      
+    return col.value
+  end
+  
+  def create_value_proc_struct(row_index, column_index, column)
+    @@Value_Proc_Struct_Class = Struct.new(
+      :model,
+      :row_index,
+      :column_index,
+      :column
+    ) unless defined?(@@Value_Proc_Struct_Class)
+    
+    @@Value_Proc_Struct_Class.new(
+      @model,
+      row_index,
+      column_index,
+      column
+    )
+  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
-		end
+    DuckType.check(transforms, :each, 'column.value_transforms')
+    
+    transforms.each do |t|
+      next unless t
+      
+      params = create_value_transforms_struct(
+        value,
+        row_index,
+        column_index,
+        column
+      )
+      
+      value = t.call(params)
+    end
+    value
+  end
+  
+  def create_value_transforms_struct(value, row_index, column_index, column)
+    @@Value_Transforms_Struct_Class = Struct.new(
+      :value,
+      :model,
+      :row_index,
+      :column_index,
+      :column
+    ) unless defined?(@@Value_Transforms_Struct_Class)
+    
+    @@Value_Transforms_Struct_Class.new(
+      value,
+      @model,
+      row_index,
+      column_index,
+      column
+    )
+  end
 end
 
 end

data/test/tc_data_view.rb

@@ -3,171 +3,158 @@ 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
-		def test_value_transforms_accessor
-			data_view = get_data_view(mock_model)
-			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])
+  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_length
+    assert_equal(mock_model.length, get_data_view(mock_model).length)
+    assert_equal(1, get_data_view(singular_mock_model).length)
+  end
+  
+  def test_value_transforms_accessor
+    data_view = get_data_view(mock_model)
+    col = data_view.columns.find {|col| col.field == :field1}
+    col.value_transforms.clear
+    field = col.field
+    assert_equal(mock_model[0][field], data_view[0].field1)
 
-			test_transform = lambda { |h|
-				'test ' << h[:value].to_s
-			}
-			col[:value_transforms] = test_transform
+    test_transform = lambda { |h|
+      'test ' << h.value.to_s
+    }
+    col.value_transforms << test_transform
 
-			expected_transform_value = test_transform.call({:value => mock_model[0][field]})
-			assert_equal(expected_transform_value, data_view[0][:field1])
-		end
-	private
-		def do_test_brackets(model)
-			data_view = get_data_view(model)
+    arg = data_view.send(:create_value_transforms_struct, mock_model[0][field], 0, 0, col)
+    expected_transform_value = test_transform.call(arg)
+    assert_equal(expected_transform_value, data_view[0].field1)
+  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|
-				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, :column => col})
-					end
-					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)
+    test_model = model.respond_to?(:each_index) ? model : [model]
+    test_model.each_with_index do |r, i|
+      columns.each_with_index do |col, j|
+        f = col.field
+        if f == :model_value_field
+          value_struct = create_value_proc_struct(data_view, i, j, col)
+          v = get_model_value(value_struct)
+        else
+          v = r[f]
+        end
+        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 |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[f])
-				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(f[:title], 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(f[:title], 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, columns)
-		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(params)
-			test_sender = params[:sender]
-			test_model = params[:model]
-			test_row_index = params[:row_index]
-			test_column_index = params[:column_index]
-			test_column = params[:column]
-			
-			unless test_sender == self
-				assert_equal(DataView, test_sender.class)
-				unless mock_model == test_model
-					assert_equal(singular_mock_model, test_model[0])
-				end
-				assert((0..2).include?(test_row_index))
-				assert(columns.include?(test_column))
-				fi = columns.index(test_column)
-				assert_equal(fi, test_column_index)
-			end
-			test_row_index.to_s << ' : Custom ' << test_column[:field].to_s
-		end
-		def columns
-			return @columns if defined?(@columns)
+      expected_row.each do |f, expected_value|
+        col_index = data_view.columns.each_with_index do |col, i|
+          break i if col.field == f
+        end
+        
+        col = data_view.columns[col_index]
+        
+        if f == :model_value_field
+          value_struct = create_value_proc_struct(data_view, i, col_index, col)
+          expected_value = get_model_value(value_struct)
+        end
+        assert_equal(expected_altered_value(expected_value), row[f])
+      end
+    end
+  end
+  
+  def create_value_proc_struct(dv, row_index, column_index, column)
+    dv.send(:create_value_proc_struct, row_index, column_index, column)
+  end
+    
+  def expected_altered_value(v)
+    "altered " << v
+  end
+  
+  def get_data_view(model)
+    DataView.new(model, columns)
+  end
+  
+  def get_model_value_method
+    method(:get_model_value)
+  end
+  
+  def get_model_value(params)
+    test_model = params.model
+    test_row_index = params.row_index
+    test_column_index = params.column_index
+    test_column = params.column
+      
+    unless mock_model == test_model
+      assert_equal(singular_mock_model, test_model[0])
+    end
+    assert((0..2).include?(test_row_index))
+    assert(columns.collect{|c| c.field}.include?(test_column.field))
+      
+    fi = columns.collect{|c| c.field}.index(test_column.field)
+    assert_equal(fi, test_column_index)
+    
+    test_row_index.to_s << ' : Custom ' << test_column[:field].to_s
+  end
+  
+  def columns
+    columns = []
+    [:model_value_field, :field1, :field2, :field3].each do |f|
+      col = DataView.create_column
+      col.field = f
+      col.title = get_title(f)
+      col.value = get_model_value_method if f == :model_value_field
+      col.value_transforms << value_transform
+      columns << col
+    end
 
-			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
-
-			@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)
-			@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
-			columns.each do |f|
-				field = f[:field]
-				row[field] = i.to_s << ' : ' << field.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_transform
-			return @value_transform if defined?(@value_transform)
-			@value_transform = lambda do |h|
-				'altered ' << h[:value].to_s
-			end
-		end
+    columns
+  end
+  
+  def get_title(field)
+    "#{field.to_s} Title"
+  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
+    [0..2].collect {|i| get_mock_model_row(i)}
+  end
+  
+  def get_mock_model_row(i)
+    row = Hash.new
+    columns.each do |f|
+      field = f[:field]
+      row[field] = i.to_s << ' : ' << field.to_s
+    end
+    row
+  end
+  
+  def values
+    {:model_value_field => get_model_value_method}
+  end
+  
+  def value_transform
+    lambda { |h| 'altered ' << h[:value].to_s }
+  end
 end
-

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: dataview
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
-date: 2005-07-26 00:00:00 -07:00
+  version: 0.3.0
+date: 2005-09-02 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
@@ -42,4 +42,14 @@ extra_rdoc_files:
 executables: []
 extensions: []
 requirements: []
-dependencies: []
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: ducktypechecker
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Version::Requirement 
+      requirements: 
+        - 
+          - ">="
+          - !ruby/object:Gem::Version 
+            version: 0.1.0
+      version: