listings 0.0.3 → 0.1.0

data/spec/dummy/app/listings/tracks_listing.rb

@@ -0,0 +1,18 @@
+class TracksListing < Listings::Base
+
+  model Track
+
+  filter album: :name
+  filter album: :id, title: 'The Album Id' do |value|
+    "#{value}!"
+  end
+
+  column :order
+  column :title, searchable: true
+  column album: :name, searchable: true do |track, album_name|
+    "#{album_name} (Buy!)"
+  end
+
+  column album: :id, title: 'The Album Id'
+
+end

data/spec/dummy/app/models/album.rb

@@ -0,0 +1,4 @@
+class Album < ActiveRecord::Base
+  attr_accessible :name if Rails::VERSION::MAJOR == 3
+  has_many :tracks
+end

data/spec/dummy/app/models/object_album.rb

@@ -0,0 +1,8 @@
+class ObjectAlbum
+  attr_accessor :name
+  attr_accessor :tracks
+
+  def to_h
+    { name: name }
+  end
+end

data/spec/dummy/app/models/object_track.rb

@@ -0,0 +1,8 @@
+class ObjectTrack
+  attr_accessor :album
+  attr_accessor :order, :title
+
+  def to_h
+    { title: title, album: album.try(&:to_h) }
+  end
+end

data/spec/dummy/app/models/track.rb

@@ -0,0 +1,7 @@
+class Track < ActiveRecord::Base
+  belongs_to :album
+  attr_accessible :order, :title if Rails::VERSION::MAJOR == 3
+
+  scope :even, -> { where("#{table_name}.id % 2 = 0") }
+
+end

data/spec/dummy/app/views/welcome/index.html.haml

@@ -1,5 +1,11 @@
 %h1 Welcome#index
 
+%dl
+  %dt
+    = link_to 'Tracks', tracks_path
+  %dd
+    ActiveRecord based listing with association handling
+
 %dl
   %dt
     = link_to 'Posts', posts_path
@@ -20,6 +26,6 @@
 
 %dl
   %dt
-    = link_to 'Array', hash_path
+    = link_to 'Array', array_path
   %dd
     Array based listing

data/spec/dummy/app/views/welcome/tracks.html.haml

@@ -0,0 +1,3 @@
+%h1 Welcome#tracks
+
+= render_listing :tracks

data/spec/dummy/config/routes.rb

@@ -8,6 +8,7 @@ Rails.application.routes.draw do
 
   get 'array', to: 'welcome#array'
   get 'hash', to: 'welcome#hash'
+  get 'tracks', to: 'welcome#tracks'
 
   root to: 'welcome#index'
 

data/spec/dummy/db/migrate/20150611185824_create_albums.rb

@@ -0,0 +1,9 @@
+class CreateAlbums < ActiveRecord::Migration
+  def change
+    create_table :albums do |t|
+      t.string :name
+
+      t.timestamps
+    end
+  end
+end

data/spec/dummy/db/migrate/20150611185922_create_tracks.rb

@@ -0,0 +1,12 @@
+class CreateTracks < ActiveRecord::Migration
+  def change
+    create_table :tracks do |t|
+      t.string :title
+      t.integer :order
+      t.references :album
+
+      t.timestamps
+    end
+    add_index :tracks, :album_id
+  end
+end

data/spec/dummy/db/schema.rb

@@ -11,7 +11,13 @@
 #
 # It's strongly recommended to check this file into your version control system.
 
-ActiveRecord::Schema.define(:version => 20140728151246) do
+ActiveRecord::Schema.define(:version => 20150611185922) do
+
+  create_table "albums", :force => true do |t|
+    t.string   "name"
+    t.datetime "created_at", :null => false
+    t.datetime "updated_at", :null => false
+  end
 
   create_table "posts", :force => true do |t|
     t.string   "title"
@@ -21,4 +27,14 @@ ActiveRecord::Schema.define(:version => 20140728151246) do
     t.string   "category"
   end
 
+  create_table "tracks", :force => true do |t|
+    t.string   "title"
+    t.integer  "order"
+    t.integer  "album_id"
+    t.datetime "created_at", :null => false
+    t.datetime "updated_at", :null => false
+  end
+
+  add_index "tracks", ["album_id"], :name => "index_tracks_on_album_id"
+
 end

data/spec/dummy/db/seeds.rb

@@ -1,5 +1,11 @@
+require 'factory_girl'
+# Dir[Rails.root.join("spec/factories/*.rb")].each {|f| require f}
 
 (1..100).each do |sn|
   Post.create! title: "post n-#{sn}", author: "john-#{(sn % 4) + 1}", category: "category-#{(sn % 3) + 1}"
 end
 
+
+(1..10).each do |sn|
+  FactoryGirl.create :album
+end

data/spec/factories/albums.rb

@@ -0,0 +1,25 @@
+FactoryGirl.define do
+  factory :album do
+    name
+
+    transient do
+      tracks_count 5
+    end
+
+    after(:create) do |album, evaluator|
+      create_list(:track, evaluator.tracks_count, album: album)
+    end
+  end
+
+  factory :object_album do
+    name
+
+    transient do
+      tracks_count 5
+    end
+
+    after(:build) do |album, evaluator|
+      album.tracks = build_list(:object_track, evaluator.tracks_count, album: album)
+    end
+  end
+end

data/spec/factories/post.rb

@@ -1,4 +1,5 @@
 FactoryGirl.define do
   factory :post do
+    title
   end
 end

data/spec/factories/tracks.rb

@@ -0,0 +1,14 @@
+FactoryGirl.define do
+  factory :track do
+    title
+    order 1
+    album nil
+  end
+
+  factory :object_track do
+    title
+    order 1
+    album nil
+  end
+
+end

data/spec/factories/traits.rb

@@ -0,0 +1,9 @@
+FactoryGirl.define do
+  sequence :title do |n|
+    "title #{rand(1000)} #{n}"
+  end
+
+  sequence :name do |n|
+    "name #{rand(1000)} #{n}"
+  end
+end

data/spec/lib/filter_parser_spec.rb

@@ -5,6 +5,8 @@ describe Listings do
     assert_parse_filter "author:me", {author: "me"}, ""
     assert_parse_filter "Author:me", {author: "me"}, ""
 
+    assert_parse_filter "101", {}, "101"
+
     assert_parse_filter "author:me category:foo", {author: "me", category: "foo"}, ""
     assert_parse_filter "   author:  me    category:  foo", {author: "me", category: "foo"}, ""
     assert_parse_filter "   author:  'me'    category:  foo", {author: "me", category: "foo"}, ""
@@ -21,6 +23,9 @@ describe Listings do
     assert_parse_filter "author:'John Doe:s'", {author: "John Doe:s"}, ""
 
     assert_parse_filter "bar author:'me:s' baz category:\"foo foo\"", {author: "me:s", category: "foo foo"}, "bar baz"
+
+    assert_parse_filter "album_name:me", {album_name: "me"}, ""
+    assert_parse_filter "album_name:'me 2' ", {album_name: "me 2"}, ""
   end
 
   def assert_parse_filter(text, hash, left_text)

data/spec/lib/sources/active_record_data_source_spec.rb

@@ -0,0 +1,359 @@
+include Listings::Sources
+
+RSpec.describe ActiveRecordDataSource do
+
+  def show_query(ds)
+    # with_active_record_logging do
+      ds.items.to_a
+    # end
+  end
+
+  def with_active_record_logging
+    ActiveRecord::Base.logger = Logger.new(STDOUT)
+    puts
+    yield
+    ActiveRecord::Base.logger = nil
+  end
+
+  context "simple active record model" do
+    let(:total_count) { 40 }
+
+    let!(:posts) { create_list(:post, total_count) }
+    let(:title) { ds.build_field :title }
+    let(:author) { ds.build_field :author }
+
+    shared_examples "project all authors" do
+      it "should matching values" do
+        expect(ds.values_for_filter(author)).to eq(['author1', 'author2', 'author3'])
+      end
+    end
+
+    shared_examples "activerecord datasource with all item" do
+      describe "DataSource factory" do
+        it "should create from with class name" do
+          expect(ds).to be_a ActiveRecordDataSource
+        end
+      end
+
+      describe "items" do
+        it "should return all items" do
+          expect(ds.items.count).to be(total_count)
+        end
+
+        it "should enumerate all items" do
+          expect(begin
+            c = 0
+            ds.items.each do
+              c = c + 1
+            end
+            c
+          end).to be(total_count)
+        end
+      end
+
+      describe "paginate" do
+        let(:page_size) { 5 }
+
+        before(:each) { ds.paginate(2, page_size) }
+
+        it "should get only paged items" do
+          expect(ds.items.count).to be(page_size)
+        end
+
+        it "should keep total_count" do
+          expect(ds.items.total_count).to be(total_count)
+        end
+      end
+
+      describe "field" do
+        it "should project attribute value" do
+          expect(title.value_for(ds.items.first)).to eq(posts.first.title)
+        end
+
+        it "should have key" do
+          expect(title.key).to eq('title')
+        end
+      end
+
+      describe "scope" do
+        before(:each) do
+          ds.scope do |items|
+            items.even
+          end
+        end
+
+        it "should return scoped items" do
+          expect(ds.items.count).to be(total_count / 2)
+        end
+      end
+
+      describe "search" do
+        before(:each) do
+          create_list(:post, 10, title: 'title-magic-string')
+          create_list(:post, 10, author: 'author-magic-string')
+
+          ds.search([title, author], 'magic')
+        end
+
+        it "should return matching items" do
+          expect(ds.items.count).to be(20)
+        end
+      end
+
+      describe "sort" do
+        before(:each) do
+          expect(posts.map(&:title)).to_not eq(posts.map(&:title).sort)
+          ds.sort(title)
+        end
+
+        it "should return matching items" do
+          expect(ds.items.map { |e| title.value_for(e) }).to eq(posts.map(&:title).sort)
+        end
+      end
+
+      describe "sort desc" do
+        before(:each) do
+          expect(posts.map(&:title)).to_not eq(posts.map(&:title).sort.reverse)
+          ds.sort(title, DataSource::DESC)
+        end
+
+        it "should return matching items" do
+          expect(ds.items.map { |e| title.value_for(e) }).to eq(posts.map(&:title).sort.reverse)
+        end
+      end
+
+      describe "filter" do
+        before(:each) do
+          create_list(:post, 10, author: 'author1')
+          create_list(:post, 10, author: 'author2')
+
+          ds.filter(author, 'author1')
+        end
+
+        it "should return matching items" do
+          expect(ds.items.count).to be(10)
+        end
+      end
+
+      describe "values_for_filter" do
+        let(:total_count) { 0 } # skip default test posts
+
+        before(:each) do
+          create_list(:post, 10, author: 'author3')
+          create_list(:post, 10, author: 'author1')
+          create_list(:post, 10, author: 'author2')
+          create_list(:post, 10, author: nil)
+        end
+
+        context "without search" do
+          it_behaves_like "project all authors"
+        end
+
+        context "with scope" do
+          before(:each) do
+            ds.scope do |items|
+              items.where(author: ['author1', 'author2'])
+            end
+          end
+
+          it "should matching values" do
+            expect(ds.values_for_filter(author)).to eq(['author1', 'author2'])
+          end
+        end
+
+        context "with search" do
+          before(:each) do
+            ds.search([author], 'author2')
+          end
+
+          it_behaves_like "project all authors"
+        end
+
+        context "with filter" do
+          before(:each) do
+            ds.filter(author, 'author2')
+          end
+
+          it_behaves_like "project all authors"
+        end
+
+        context "with paging" do
+          before(:each) do
+            ds.paginate(1, 1)
+          end
+
+          it_behaves_like "project all authors"
+        end
+
+        context "with sort" do
+          before(:each) do
+            ds.sort(title)
+          end
+
+          it_behaves_like "project all authors"
+        end
+      end
+    end
+
+    context "using class" do
+      let(:ds) { DataSource.for(Post) }
+      it_behaves_like "activerecord datasource with all item"
+    end
+
+    context "using relation" do
+      let(:ds) { DataSource.for(Post.where('1 = 1')) }
+      it_behaves_like "activerecord datasource with all item"
+    end
+  end
+
+  context "active record model with belongs_to" do
+    let(:total_count) { 6 } # skip default test posts
+    let!(:albums) { create_list(:album, total_count) }
+    let!(:ds) { DataSource.for(Track) }
+    let!(:track_title) { ds.build_field :title }
+
+    shared_examples "listing with projected values" do
+      describe "projected field" do
+        it "should project attribute value" do
+          expect(album_name.value_for(ds.items.first)).to eq(Track.first.album.name)
+        end
+
+        it "should have key" do
+          expect(album_name.key).to eq('album_name')
+        end
+      end
+
+      it "should deal with intermediate nils" do
+        track_without_album = create(:track, album: nil)
+        expect(album_name.value_for(track_without_album)).to be_nil
+      end
+
+      it "should perform a eager_load" do
+        show_query ds
+      end
+
+      it "should perform a single query" do
+        expect(ActiveRecord::Base.count_queries do
+          album_name.value_for(ds.items.first)
+          album_id.value_for(ds.items.first)
+        end).to eq(1)
+      end
+
+      describe "scope" do
+        before(:each) do
+          ds.scope do |items|
+            items.even
+          end
+        end
+
+        it "should return scoped items" do
+          expect(ds.items.count).to be(Track.count / 2)
+        end
+      end
+
+      describe "search" do
+        before(:each) do
+          create(:album, tracks_count: 5, name: 'album-name-magic-string-1')
+          create(:album, tracks_count: 5, name: 'album-name-magic-string-2')
+          create_list(:album, 2).each do |album_with_tracks_to_match|
+            create_list(:track, 5, title: 'title-magic-string', album: album_with_tracks_to_match)
+          end
+
+          ds.search([track_title, album_name], 'magic')
+        end
+
+        it "should return matching items" do
+          show_query ds
+          expect(ds.items.count).to be(20)
+        end
+      end
+
+      describe "filter" do
+        before(:each) do
+          create(:album, tracks_count: 5, name: 'album-name-magic-string-1')
+          create(:album, tracks_count: 5, name: 'album-name-magic-string-2')
+
+          ds.filter(album_name, 'album-name-magic-string-1')
+        end
+
+        it "should return matching items" do
+          expect(ds.items.count).to be(5)
+        end
+      end
+
+      describe "sort" do
+        def all_track_albumns_name
+          Track.all.map { |t| t.album.name }
+        end
+
+        before(:each) do
+          expect(all_track_albumns_name).to_not eq(all_track_albumns_name.sort)
+          ds.sort(album_name)
+        end
+
+        it "should return matching items" do
+          expect(ds.items.map { |e| album_name.value_for(e) }).to eq(all_track_albumns_name.sort)
+        end
+      end
+
+      describe "sort desc" do
+        def all_track_albumns_name
+          Track.all.map { |t| t.album.name }
+        end
+
+        before(:each) do
+          expect(all_track_albumns_name).to_not eq(all_track_albumns_name.sort.reverse)
+          ds.sort(album_name, DataSource::DESC)
+        end
+
+        it "should return matching items" do
+          expect(ds.items.map { |e| album_name.value_for(e) }).to eq(all_track_albumns_name.sort.reverse)
+        end
+      end
+
+      describe "values_for_filter" do
+        let(:total_count) { 0 } # skip default test albums
+
+        before(:each) do
+          create(:album, tracks_count: 5, name: 'album-name-1')
+          create(:album, tracks_count: 5, name: 'album-name-3')
+          create(:album, tracks_count: 5, name: 'album-name-2')
+          create(:album, tracks_count: 5, name: nil)
+        end
+
+        context "without search" do
+          it "should matching values" do
+            expect(ds.values_for_filter(album_name)).to eq(['album-name-1', 'album-name-2', 'album-name-3'])
+          end
+        end
+
+        context "with scope" do
+          before(:each) do
+            ds.scope do |items|
+              items.where("tracks.id % 2 = 0")
+            end
+          end
+
+          it "should matching values" do
+            expect(ds.values_for_filter(album_name)).to eq(['album-name-1', 'album-name-2', 'album-name-3'])
+          end
+        end
+
+      end
+    end
+
+    context "using array as path" do
+      let!(:album_name) { ds.build_field [:album, :name] }
+      let!(:album_id) { ds.build_field [:album, :id] }
+
+      it_behaves_like "listing with projected values"
+    end
+
+    context "hash as path" do
+      let!(:album_name) { ds.build_field album: :name }
+      let!(:album_id) { ds.build_field album: :id }
+
+      it_behaves_like "listing with projected values"
+    end
+  end
+end