wice_grid_mongoid 0.5.6

data/lib/wice_grid_serialized_query.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+class WiceGridSerializedQuery < ActiveRecord::Base  #:nodoc:
+  serialize :query
+
+  validates_uniqueness_of :name, :scope => :grid_name, :on => :create, 
+    :message => ::Wice::WiceGridNlMessageProvider.get_message(:VALIDATES_UNIQUENESS_ERROR)
+  validates_presence_of :name, :message => ::Wice::WiceGridNlMessageProvider.get_message(:VALIDATES_PRESENCE_ERROR)
+
+  def self.list(name, controller)
+    conditions = {:grid_name => name}
+    self.find(:all, :conditions => conditions)
+  end
+
+end

data/lib/wice_grid_spreadsheet.rb

@@ -0,0 +1,33 @@
+# encoding: UTF-8
+require 'csv'
+
+module Wice
+  class Spreadsheet  #:nodoc:
+
+    attr_reader :tempfile
+    # CSV in 1.9.1 is a version of FasterCSV
+    if RUBY_VERSION == '1.9.1' || RUBY_VERSION == '1.9.2'
+
+      def initialize(name, field_separator)  #:nodoc:
+        @tempfile = Tempfile.new(name)
+        @csv = CSV.new(@tempfile, :col_sep => field_separator)
+      end
+
+      def << (row)  #:nodoc:
+        @csv << row
+      end
+      
+    else
+      def initialize(name, field_separator)  #:nodoc:
+        @tempfile = Tempfile.new(name)
+        @field_separator = field_separator
+      end
+
+      def << (row)  #:nodoc:
+        CSV::Writer.generate(@tempfile, @field_separator) do |csv|
+           csv << row.map(&:to_s)
+        end
+      end
+    end
+  end
+end

data/tasks/wice_grid_tasks.rake

@@ -0,0 +1,28 @@
+namespace "wice_grid" do
+  
+  desc "Create a table to store saved queries"
+  task :create_queries_table => :environment do
+    
+    class CreateWiceGridSerializedQueriesTable < ::ActiveRecord::Migration
+      def self.up
+        create_table :wice_grid_serialized_queries do |t|
+          t.column :name,      :string
+          t.column :grid_name, :string
+          t.column :query,     :text
+
+          t.timestamps
+        end
+        add_index :wice_grid_serialized_queries, :grid_name
+        add_index :wice_grid_serialized_queries, [:grid_name, :id]
+      end
+
+      def self.down
+        drop_table :wice_grid_serialized_queries
+      end
+    end
+    
+    CreateWiceGridSerializedQueriesTable.up
+  end
+  
+  
+end

data/test/.gitignore

@@ -0,0 +1,2 @@
+*.log
+*.db

data/test/database.yml

@@ -0,0 +1,21 @@
+sqlite:
+  :adapter: sqlite
+  :dbfile: vendor/plugins/wice_grid/test/wice_grid_plugin.sqlite.db
+
+sqlite3:
+  :adapter: sqlite3
+  :dbfile: vendor/plugins/wice_grid/test/wice_grid_plugin.sqlite3.db
+
+postgresql:
+  :adapter: postgresql
+  :username: postgres
+  :password: postgres
+  :database: wice_grid_plugin_test
+  :min_messages: ERROR
+
+mysql:
+  :adapter: mysql
+  :host: localhost
+  :username: root
+  :password: 
+  :database: wice_grid_plugin_test

data/test/schema.rb

@@ -0,0 +1,33 @@
+ActiveRecord::Schema.define(:version => 0) do
+  
+  create_table :people, :force => true do |t|
+    t.string :firstname
+    t.string :lastname
+    t.string :email
+    t.timestamps
+  end
+  
+  create_table :projects, :force => true do |t|
+    t.string  :name
+    t.integer :person_id
+    t.timestamps
+  end
+  
+  create_table :tasks, :force => true do |t|
+    t.integer :project_id
+    t.integer :person_id
+    t.string  :name
+    t.text    :description
+    t.boolean :done
+    t.timestamps
+  end
+  
+  create_table :saved_queries, :force => true  do |t|
+    t.column :name,      :string
+    t.column :grid_name, :string
+    t.column :query,     :text
+    t.column :grid_hash, :string
+
+    t.timestamps
+  end  
+end

data/test/test_helper.rb

@@ -0,0 +1,89 @@
+ENV['RAILS_ENV'] = 'test'
+ENV['RAILS_ROOT'] ||= File.dirname(__FILE__) + '/../../../..'
+
+ENV['DB'] =  'mysql'
+
+require 'test/unit'
+require File.expand_path(File.join(ENV['RAILS_ROOT'], 'config/environment.rb'))
+
+def load_schema
+
+  config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+  ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+
+  db_adapter = ENV['DB']
+
+  # no db passed, try one of these fine config-free DBs before bombing.
+  db_adapter ||=
+    begin
+      require 'rubygems'
+      require 'sqlite'
+      'sqlite'
+    rescue MissingSourceFile
+      begin
+        require 'sqlite3'
+        'sqlite3'
+      rescue MissingSourceFile
+      end
+    end
+
+  if db_adapter.nil?
+    raise "No DB Adapter selected. Pass the DB= option to pick one, or install Sqlite or Sqlite3."
+  end
+
+  ActiveRecord::Base.establish_connection(config[db_adapter])
+  load(File.dirname(__FILE__) + "/schema.rb")
+  require File.dirname(__FILE__) + '/../init.rb'
+  
+end
+
+#
+#
+#
+
+require File.join(File.dirname(__FILE__), '../generators/wice_grid_assets/templates/initializers/wice_grid_config.rb')
+
+load_schema
+
+class Person < ActiveRecord::Base
+  has_many :projects
+  has_many :tasks
+end
+
+class Project < ActiveRecord::Base
+  belongs_to :person
+  validates_presence_of :person_id
+end
+
+class Task < ActiveRecord::Base
+  belongs_to :project
+  belongs_to :person
+  validates_presence_of :project_id
+  validates_presence_of :person_id
+end
+
+class SavedQuery < ActiveRecord::Base
+  def self.list(a, b)
+  end
+end
+
+NUM_PEOPLE   = 10
+NUM_PROJECTS = 5
+NUM_TASKS    = 1000
+
+NUM_PEOPLE.times do |i|
+  Person.create!(:firstname => "Firstname%02d" % i, :lastname => "Lastname%02d" % i, :email => "user%02d@example.com" % i)
+end
+
+NUM_PROJECTS.times do |i|
+  Project.create!(:name => "Project%02d" % i, :person => Person.all[i % NUM_PEOPLE])
+end
+
+NUM_TASKS.times do |i|
+  project = Project.find(:first, :order => 'RAND()')
+  owner = Person.find(:first, :order => 'RAND()')
+  Task.create!(:name => "Task%03d" % i, 
+               :description => "Description%03d" % i, 
+               :person => Person.all[i % NUM_PEOPLE], 
+               :project => Project.all[i % NUM_PROJECTS])
+end

data/test/views/projects_and_people_grid.html.erb

@@ -0,0 +1,12 @@
+<%= grid(@grid) do |g|
+
+	g.column(:attribute_name => 'name')
+
+	g.column(:attribute_name => 'firstname', :model_class => 'Person')
+	g.column(:attribute_name => 'lastname',  :model_class => 'Person')
+
+	g.column(:attribute_name => 'updated_at') do |project|
+		project.updated_at.strftime("%d/%m/%Y %H:%M")
+	end
+	
+end -%>

data/test/views/projects_and_people_grid_invalid.html.erb

@@ -0,0 +1,12 @@
+<%= grid(@grid) do |g|
+
+	g.column(:attribute_name => 'name')
+
+	g.column(:attribute_name => 'firstname', :model_class => 'Person')
+	g.column(:attribute_name => 'lastname',  :model_class => 'Person') 
+
+	g.column(:attribute_name => 'updated_at') do |project|
+		project.updated_at.strftime("%d/%m/%Y %H:%M")
+	end
+	
+end -%>

data/test/views/simple_projects_grid.html.erb

@@ -0,0 +1,9 @@
+<%= grid(@grid) do |g|
+
+	g.column(:attribute_name => 'name')
+
+	g.column(:attribute_name => 'updated_at') do |project|
+		project.updated_at.strftime("%d/%m/%Y %H:%M")
+	end
+	
+end -%>

data/test/wice_grid_core_ext_test.rb

@@ -0,0 +1,183 @@
+# More or less complete
+
+require 'test/unit'
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class WiceGridCoreExtTest < Test::Unit::TestCase
+  
+  #
+  # Hash
+  #
+
+  def test_rec_merge
+    
+    # required for will_paginate
+    # read this - http://err.lighthouseapp.com/projects/466/tickets/197-using-param_name-something-page-leads-to-invalid-behavior
+    
+    a_hash = {34 => 12,  :key1 => 87,  :key2 => {:f => 67} }
+    b_hash = {34 => 'x', :key3 => 987, :key2 => {:key4 => {:key5 => 0} } }
+    
+    assert_equal({:key3 => 987, 34 => "x", :key1 => 87, :key2 => {:key4 => {:key5 => 0}, :f => 67}} , a_hash.rec_merge(b_hash))
+
+    a_hash = {34 => 12,  :key1 => 87}
+    b_hash = {34 => 12}
+    
+    assert_equal({34 => 12,  :key1 => 87} , a_hash.rec_merge(b_hash))
+
+    a_hash = {34 => { :f => :moo},  :key1 => 87}
+    b_hash = {34 => { :k => [1,2, { :z => :baz }]},  :key1 => 87}
+    
+    assert_equal({34 => {  :f => :moo,  :k => [1,2, { :z => :baz}]},  :key1 => 87} , a_hash.rec_merge(b_hash))
+
+  end
+  
+  def test_hash_make_hash
+    
+    assert_equal({}, Hash.make_hash(:key, nil))
+    assert_equal({}, Hash.make_hash(:key, ''))
+
+    assert_equal({:key => "value"}, Hash.make_hash(:key, "value"))
+    
+  end
+  
+  def test_hash_deep_clone_yl
+    
+    a = {}
+    b = a.deep_clone_yl
+    assert_equal    a, b 
+    assert_not_same a, b
+    
+    a = {'a' => 'b'}
+    b = a.deep_clone_yl
+    assert_equal    a, b 
+    assert_not_same a, b
+
+    a = {'a' => 'b', 'c' => {'d' => 'e'}}
+    b = a.deep_clone_yl
+    assert_equal    a, b
+    assert_equal    a['c'], b['c']
+    assert_not_same a, b
+    assert_not_same a['c'], b['c']
+    
+  end
+  
+  def test_hash_add_or_append_class_value_on_empty_hash
+    
+    h = {}
+    
+    h.add_or_append_class_value!('foo')
+    assert_equal({:class => 'foo'}, h)
+
+    res = h.add_or_append_class_value!('bar')
+    assert_equal({:class => 'foo bar'}, h)
+    
+    assert_equal(res, h)
+        
+  end
+  
+  def test_hash_add_or_append_class_value_key_normalization
+    
+    h = {'class' => 'foo'}
+
+    h.add_or_append_class_value!('bar')
+    assert_equal({:class => 'foo bar'}, h)
+  
+  end
+  
+  def test_hash_parameter_names_and_values
+    
+    assert_equal([], {}.parameter_names_and_values)
+    assert_equal([], {}.parameter_names_and_values(%w(foo)))
+
+
+    assert_equal([['a', 'b']], {'a' => 'b'}.parameter_names_and_values)
+    assert_equal([['a', 'b'], ['c[d]', 'e']], {'a' => 'b', 'c' => {'d' => 'e'}}.parameter_names_and_values)
+    
+    assert_equal([['foo[a]', 'b']], {'a' => 'b'}.parameter_names_and_values(%w(foo)))
+    assert_equal([['foo[a]', 'b'], ['foo[c][d]', 'e']], {'a' => 'b', 'c' => {'d' => 'e'}}.parameter_names_and_values(%w(foo)))
+    
+    assert_equal(
+      [["a[d][e]", 5], ["a[b]", 3], ["a[c]", 4]].sort, 
+      { :a => { :b => 3, :c => 4, :d => { :e => 5 }} }.parameter_names_and_values.sort
+    )
+
+    assert_equal(
+      [["foo[baz][a][d][e]", 5], ["foo[baz][a][b]", 3], ["foo[baz][a][c]", 4]].sort, 
+      { :a => { :b => 3, :c => 4, :d => { :e => 5 }} }.parameter_names_and_values(['foo', 'baz']).sort
+    )
+
+  end
+
+  #
+  # Enumerable
+  # 
+
+  def test_enumerable_all_items_are_of_class
+    
+    assert([].respond_to?(:all_items_are_of_class))
+    assert({}.respond_to?(:all_items_are_of_class))
+    
+    assert_equal false, [].all_items_are_of_class(Object)
+    
+    assert_equal true, [1, 2, 3].all_items_are_of_class(Numeric)
+    assert_equal true, %(one two three).all_items_are_of_class(String)
+
+    assert_equal false, [1, 2, "apple"].all_items_are_of_class(String)
+    assert_equal false, [1, 2, nil].all_items_are_of_class(String)
+    assert_equal false, [1, 2.5].all_items_are_of_class(String)
+
+    assert_equal true, [1, 2, "apple"].all_items_are_of_class(Object)
+    
+  end
+  
+  #
+  # Object
+  #
+  
+  def test_object_deep_send
+    
+    wrapper = Struct.new(:hop)
+    
+    z = wrapper.new(123)
+    y = wrapper.new(z)
+    x = wrapper.new(y)
+    
+    assert_equal x, x.deep_send
+    assert_equal y, x.deep_send(:hop)
+    assert_equal z, x.deep_send(:hop, :hop)
+    assert_equal 123, x.deep_send(:hop, :hop, :hop)
+    
+    assert_nil x.deep_send(:non_existing_method)
+    assert_nil x.deep_send(:hop, :non_existing_method)
+    
+  end
+  
+  
+  #
+  # Array
+  #
+  
+  def test_array_to_parameter_name
+    
+    assert_equal '', [].to_parameter_name
+    assert_equal 'foo', %w(foo).to_parameter_name
+    assert_equal 'foo[bar]', %w(foo bar).to_parameter_name
+    assert_equal 'foo[bar][baz]', %w(foo bar baz).to_parameter_name
+    
+  end
+  
+  #
+  # ActionView
+  #
+  
+  include ActionView::Helpers::TagHelper
+  
+  def test_action_view_tag_options_visibility
+    assert_nothing_raised {
+      tag_options({})
+    }
+    assert_equal(%! class="foo" style="baz"!, tag_options({:class => 'foo', :style => 'baz'}))
+  end
+  
+
+end