datagrid 1.5.9 → 1.6.3

data/.document

@@ -1,5 +0,0 @@
-lib/**/*.rb
-bin/*
-- 
-features/**/*.feature
-LICENSE.txt

data/.rspec

@@ -1 +0,0 @@
---color

data/.travis.yml

@@ -1,21 +0,0 @@
-language: ruby
-#bundler_args: --without development
-rvm:
-  - 2.2.2
-  - 2.3.0
-  - 2.4.1
-  - 2.5.1
-  #- jruby
-  #- jruby-head
-#env: JRUBY_OPTS="--server -J-Xms512m -J-Xmx1024m"
-#matrix:
-  #allow_failures:
-    #- rvm: jruby-head
-    #- gemfile: gemfiles/rails41.gemfile
-notifications:
-  email: false
-services:
-  - mongodb
-gemfile:
-  - Gemfile
-  #- gemfiles/rails41.gemfile

data/Gemfile

@@ -1,29 +0,0 @@
-source "https://rubygems.org"
-
-gem "rails", ">= 4.0"
-
-group :development do
-
-  gem "bundler"
-  if RUBY_VERSION >= "2.3"
-    gem "jeweler", ">= 2.1.2", platform: [:ruby_23, :ruby_24, :ruby_25]
-  end
-
-
-  #gem "json", ">= 1.9"
-  gem "pry-byebug", :platform => [:ruby_24, :ruby_25, :ruby_22, :ruby_23] & Bundler::Dsl::VALID_PLATFORMS
-
-  gem "rspec", ">= 3"
-  gem "nokogiri" # used to test html output
-
-  gem "sqlite3", "~> 1.3.6"
-  gem "sequel"
-
-  group :mongo do
-    gem "mongoid"
-    #gem "mongo_mapper", "~> 0.13.0"
-    gem "bson"
-    gem "bson_ext"
-  end
-
-end

data/Rakefile

@@ -1,43 +0,0 @@
-# encoding: utf-8
-
-require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'rake'
-
-if RUBY_VERSION >= "2.3"
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
-    gem.name = "datagrid"
-    gem.homepage = "http://github.com/bogdan/datagrid"
-    gem.license = "MIT"
-    gem.summary = %Q{Ruby gem to create datagrids}
-    gem.description = %Q{This allows you to easily build datagrid aka data tables with sortable columns and filters}
-    gem.email = "agresso@gmail.com"
-    gem.authors = ["Bogdan Gusiev"]
-    gem.required_ruby_version = '>= 2.0'
-    # dependencies defined in Gemfile
-  end
-  Jeweler::RubygemsDotOrgTasks.new
-end
-
-require 'rspec/core'
-require 'rspec/core/rake_task'
-RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = FileList['spec/**/*_spec.rb']
-end
-
-RSpec::Core::RakeTask.new(:rcov) do |spec|
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
-end
-
-task :default => :spec
-

data/VERSION

@@ -1 +0,0 @@
-1.5.9

data/spec/datagrid/active_model_spec.rb

@@ -1,33 +0,0 @@
-require 'spec_helper'
-
-describe Datagrid::ActiveModel do
-
-  class ActiveReport
-    include Datagrid::ActiveModel
-  end
-
-  module Grid
-    class ActiveReport
-      include Datagrid::ActiveModel
-    end
-  end
-
-  describe ".model_name" do
-    it "should be generate from class name " do
-      expect(ActiveReport.model_name).to eq("ActiveReport")
-    end
-    it "should have ActiveModel naming conventions" do
-      expect(ActiveReport.model_name.i18n_key).to eq(:active_report)
-    end
-  end
-
-  describe ".param_name" do
-    it "should make right param key from simple class name" do
-      expect(ActiveReport.param_name).to eq('active_report')
-    end
-    it "should make right param key from class of module" do
-      expect(Grid::ActiveReport.param_name).to eq('grid_active_report')
-    end
-  end
-
-end

data/spec/datagrid/column_names_attribute_spec.rb

@@ -1,86 +0,0 @@
-require "spec_helper"
-
-describe Datagrid::ColumnNamesAttribute do
-
-  let(:column_names_filter_options) do
-    {}
-  end
-
-  let(:report) do
-    options = column_names_filter_options
-    test_report do
-      scope { Entry }
-      column_names_filter(options)
-      column(:id)
-      column(:name, :mandatory => true)
-      column(:category)
-    end
-  end
-  subject { report }
-
-
-  let!(:entry) do
-    Entry.create!(:name => 'hello', :category => 'greeting')
-  end
-
-  it "should work" do
-    subject.column_names = [:id]
-    expect(subject.mandatory_columns.map(&:name)).to eq([:name])
-    expect(subject.optional_columns.map(&:name)).to eq([:id, :category])
-    expect(subject.data).to eq([["Id", "Name"], [entry.id, "hello"]])
-    columns_filter = subject.filter_by_name(:column_names)
-    expect(columns_filter).not_to be_nil
-    expect(columns_filter.select(subject)).to eq([["Id", :id], ["Category", :category]])
-  end
-
-  it "should show only mandatory columns by default" do
-    expect(subject.row_for(entry)).to eq([ "hello" ])
-    subject.column_names = ["name", "category"]
-    expect(subject.row_for(entry)).to eq(["hello", "greeting"])
-  end
-
-  it "should show mandatory columns even if they are unselected" do
-    subject.column_names = ["category"]
-    expect(subject.row_for(entry)).to eq(["hello", "greeting"])
-    expect(subject.data).to eq([["Name", "Category"], ["hello", "greeting"]])
-  end
-
-  it "should find any column by name" do
-    expect(subject.column_by_name(:id)).not_to be_nil
-    expect(subject.column_by_name(:name)).not_to be_nil
-    expect(subject.column_by_name(:category)).not_to be_nil
-  end
-
-
-  context "when default option is passed to column_names_filter" do
-    let(:column_names_filter_options) do
-      { :default => [:id] }
-    end
-
-    describe '#data' do
-      subject { super().data }
-      it { should == [["Id", "Name"], [entry.id, 'hello']] }
-    end
-
-  end
-
-  context "when some columns are disabled" do
-    subject do
-      test_report do
-        scope {Entry}
-        column(:id, :mandatory => true)
-        column(:name)
-        column(:category, if: proc { false })
-        column(:group, :mandatory => true, if: proc { false })
-      end
-    end
-
-    it "excludes them from mandatory_columns" do
-      expect(subject.mandatory_columns.map(&:name)).to eq([:id])
-    end
-
-    it "excludes them from optional_columns" do
-      expect(subject.optional_columns.map(&:name)).to eq([:name])
-    end
-  end
-end

data/spec/datagrid/columns/column_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe Datagrid::Columns::Column do
-  
-  describe ".inspect" do
-    subject do
-      class ColumnInspectTest
-        include Datagrid
-        scope {Entry}
-        column(:id, header: "ID")
-      end
-      ColumnInspectTest.column_by_name(:id)
-    end
-
-    it "shows inspect information" do
-      expect(subject.inspect).to eq("#<Datagrid::Columns::Column ColumnInspectTest#id {:header=>\"ID\"}>")
-    end
-  end
-end

data/spec/datagrid/columns_spec.rb

@@ -1,592 +0,0 @@
-require 'spec_helper'
-
-describe Datagrid::Columns do
-
-  let(:group) { Group.create!(:name => "Pop") }
-
-  subject do
-    SimpleReport.new
-  end
-
-  describe "basic methods" do
-
-    let!(:entry) {  Entry.create!(
-      :group => group,
-      :name => "Star",
-      :disabled => false,
-      :confirmed => false,
-      :category => "first",
-      :access_level => 'admin',
-      :pet => 'rottweiler',
-      :shipping_date => Date.new(2013, 8, 1)
-    ) }
-    let(:date) { Date.new(2013, 8, 1) }
-
-    it "should have data columns without html columns" do
-      grid = test_report do
-        scope {Entry}
-        column(:name)
-        column(:action, :html => true) do
-          'dummy'
-        end
-      end
-      expect(grid.data_columns.map(&:name)).to eq([:name])
-      expect(grid.html_columns.map(&:name)).to eq([:name, :action])
-    end
-    it "should build rows of data" do
-      grid = test_report do
-        scope {Entry}
-        column(:name)
-        column(:action, :html => true) do
-          'dummy'
-        end
-      end
-      expect(grid.rows).to eq([["Star"]])
-    end
-    it  "should generate header without html columns" do
-      grid = test_report do
-        scope {Entry}
-        column(:name)
-        column(:action, :html => true) do
-          'dummy'
-        end
-      end
-      expect(grid.header).to eq(["Name"])
-    end
-
-    describe "translations" do
-
-      module ::Ns45
-        class TranslatedReport
-          include Datagrid
-          scope { Entry }
-          column(:name)
-        end
-      end
-      it "translates column-header with namespace" do
-        store_translations(:en, datagrid: {:"ns45/translated_report" => {columns: {name: "Navn"}}}) do
-          expect(Ns45::TranslatedReport.new.header.first).to eq("Navn")
-        end
-      end
-
-      it "translates column-header without namespace" do
-        class Report27
-          include Datagrid
-          scope {Entry}
-          column(:name)
-        end
-
-        store_translations(:en, datagrid: {:"report27" => {columns: {name: "Nombre"}}}) do
-          expect(Report27.new.header.first).to eq("Nombre")
-        end
-      end
-
-      it "translates column-header in using defaults namespace" do
-        class Report27
-          include Datagrid
-          scope {Entry}
-          column(:name)
-        end
-
-        store_translations(:en, datagrid: {defaults: {columns: {name: "Nombre"}}}) do
-          expect(Report27.new.header.first).to eq("Nombre")
-        end
-      end
-
-    end
-
-    it "should return html_columns" do
-      report = test_report do
-        scope {Entry}
-        column(:id)
-        column(:name, :html => false)
-      end
-      expect(report.html_columns.map(&:name)).to eq([:id])
-    end
-
-    it "should return html_columns when column definition has 2 arguments" do
-      report = test_report(:name => "Hello") do
-        scope {Entry}
-        filter(:name)
-        column(:id)
-        column(:name, :html => false) do |model, grid|
-          "'#{model.name}' filtered by '#{grid.name}'"
-        end
-      end
-      entry = Entry.create!(:name => "Hello World")
-      expect(report.row_for(entry)).to eq([entry.id, "'Hello World' filtered by 'Hello'"])
-    end
-
-    it "should generate table data" do
-      expect(subject.data).to eq([
-        subject.header,
-        subject.row_for(entry)
-      ])
-    end
-
-    it "supports dynamic header" do
-      grid = test_report do
-        scope {Entry}
-        column(:id, header: proc { rand(10**9) })
-      end
-
-      expect(grid.header).to_not eq(grid.header)
-    end
-
-    it "should generate hash for given asset" do
-      expect(subject.hash_for(entry)).to eq({
-        :group => "Pop",
-        :name => "Star",
-        :access_level => 'admin',
-        :pet => 'ROTTWEILER',
-        :shipping_date => date
-      })
-    end
-
-    it "should support csv export" do
-      expect(subject.to_csv).to eq("Shipping date,Group,Name,Access level,Pet\n#{date},Pop,Star,admin,ROTTWEILER\n")
-    end
-
-    it "should support csv export of particular columns" do
-      expect(subject.to_csv(:name)).to eq("Name\nStar\n")
-    end
-
-    it "should support csv export options" do
-      expect(subject.to_csv(:col_sep => ";")).to eq("Shipping date;Group;Name;Access level;Pet\n#{date};Pop;Star;admin;ROTTWEILER\n")
-    end
-
-  end
-
-  it "should support columns with model and report arguments" do
-    report = test_report(:category => "foo") do
-      scope {Entry.order(:category)}
-      filter(:category) do |value|
-        where("category LIKE '%#{value}%'")
-      end
-
-      column(:exact_category) do |entry, grid|
-        entry.category == grid.category
-      end
-    end
-    Entry.create!(:category => "foo")
-    Entry.create!(:category => "foobar")
-    expect(report.rows.first.first).to eq(true)
-    expect(report.rows.last.first).to eq(false)
-  end
-
-  it "should inherit columns correctly" do
-    parent = Class.new do
-      include Datagrid
-      scope { Entry }
-      column(:name)
-    end
-
-    child = Class.new(parent) do
-      column(:group_id)
-    end
-    expect(parent.column_by_name(:name)).not_to be_nil
-    expect(parent.column_by_name(:group_id)).to be_nil
-    expect(child.column_by_name(:name)).not_to be_nil
-    expect(child.column_by_name(:group_id)).not_to be_nil
-  end
-  it "should support defining a query for a column" do
-    report = test_report do
-      scope {Entry}
-      filter(:name)
-      column(:id)
-      column(:sum_group_id, 'sum(group_id)')
-    end
-    Entry.create!(:group => group)
-    expect(report.assets.first.sum_group_id).to eq(group.id)
-  end
-
-    it "should support post formatting for column defined with query" do
-      report = test_report do
-        scope {Group.joins(:entries).group("groups.id")}
-        filter(:name)
-        column(:entries_count, 'count(entries.id)') do |model|
-          format("(#{model.entries_count})") do |value|
-            content_tag(:span, value)
-          end
-        end
-      end
-      3.times { Entry.create!(group: group) }
-      expect(report.rows).to eq([["(3)"]])
-    end
-    it "should support hidding columns through if and unless" do
-      report = test_report do
-        scope {Entry}
-        column(:id, :if => :show?)
-        column(:name, :unless => proc {|grid| !grid.show? })
-        column(:category)
-
-        def show?
-          false
-        end
-      end
-      expect(report.columns(:id)).to eq([])
-      expect(report.columns(:name)).to eq([])
-      expect(report.available_columns.map(&:name)).to eq([:category])
-    end
-
-    it "raises when incorrect unless option is given" do
-      expect do
-        test_report do
-          column(:id, if: Object.new)
-        end
-      end.to raise_error(Datagrid::ConfigurationError)
-    end
-
-    it "raises when :before and :after used together" do
-      expect do
-        test_report do
-          column(:id)
-          column(:name, :before => :id, :after => :name)
-        end
-      end.to raise_error(Datagrid::ConfigurationError)
-    end
-
-  describe ".column_names attributes" do
-    let(:grid) do
-      test_report(:column_names => ["id", "name"]) do
-        scope { Entry }
-        column(:id)
-        column(:name)
-        column(:category)
-      end
-    end
-    let!(:entry) do
-      Entry.create!(:name => 'hello')
-    end
-    it "should be suppored in header" do
-      expect(grid.header).to eq(["Id", "Name"])
-    end
-    it "should be suppored in rows" do
-      expect(grid.rows).to eq([[entry.id, "hello"]])
-    end
-
-    it "should be suppored in csv" do
-      expect(grid.to_csv).to eq("Id,Name\n#{entry.id},hello\n")
-    end
-
-    it "should support explicit overwrite" do
-      expect(grid.header(:id, :name, :category)).to eq(%w(Id Name Category))
-    end
-
-  end
-
-
-  context "when grid has formatted column" do
-    it "should output correct data" do
-      report = test_report do
-        scope {Entry}
-        column(:name) do |entry|
-          format(entry.name) do |value|
-            "<strong>#{value}</strong"
-          end
-        end
-      end
-      Entry.create!(:name => "Hello World")
-      expect(report.rows).to eq([["Hello World"]])
-    end
-  end
-
-  describe ".default_column_options" do
-    it "should pass default options to each column definition" do
-      report = test_report do
-        scope {Entry}
-        self.default_column_options = {:order => false}
-        column(:id)
-        column(:name, :order => "name")
-      end
-      first = Entry.create(:name => '1st')
-      second = Entry.create(:name => '2nd')
-      expect do
-        report.attributes = {:order => :id}
-        report.assets
-      end.to raise_error(Datagrid::OrderUnsupported)
-      report.attributes = {:order => :name, :descending => true}
-      expect(report.assets).to eq([second, first])
-    end
-  end
-
-  describe "fetching data in batches" do
-    it "should pass the batch size to the find_each method" do
-      report = test_report do
-        scope { Entry }
-        column :id
-        self.batch_size = 25
-      end
-
-      fake_assets = double(:assets)
-      expect(report).to receive(:assets) { fake_assets }
-      expect(fake_assets).to receive(:find_each).with(batch_size: 25)
-      expect(fake_assets).to receive(:limit_value).and_return(nil)
-      report.rows
-    end
-    it "should be able to disable batches" do
-      report = test_report do
-        scope { Entry }
-        column :id
-        self.batch_size = 0
-      end
-
-      fake_assets = double(:assets)
-
-      expect(report).to receive(:assets) { fake_assets }
-      expect(fake_assets).to receive(:each)
-      expect(fake_assets).not_to receive(:find_each)
-      report.rows
-    end
-
-    it "should support instance level batch size" do
-      grid = test_report do
-        scope {Entry}
-        column :id
-        self.batch_size = 25
-      end
-      grid.batch_size = 0
-      fake_assets = double(:assets)
-
-      expect(grid).to receive(:assets) { fake_assets }
-      expect(fake_assets).to receive(:each)
-      expect(fake_assets).not_to receive(:find_each)
-      grid.rows
-    end
-  end
-
-  describe ".data_row" do
-    it "should give access to column values via an object" do
-      grid = test_report do
-        scope  { Entry }
-        column(:id)
-        column(:name) do
-          name.capitalize
-        end
-        column(:actions, html: true) do
-          "some link here"
-        end
-      end
-      entry = Entry.create!(name: 'hello')
-      row = grid.data_row(entry)
-      expect(row.id).to eq(entry.id)
-      expect(row.name).to eq("Hello")
-      expect {
-        row.actions
-      }.to raise_error(RuntimeError)
-    end
-  end
-
-  describe "column value" do
-    it "should support conversion" do
-      group = Group.create!
-      Entry.create(:group => group)
-      Entry.create(:group => group)
-      grid = test_report do
-        scope { Group }
-        column(:entries_count) do |g|
-          g.entries.count
-        end
-        column(:odd_entries) do |_, _, row|
-          row.entries_count.odd?
-        end
-      end
-
-      expect(grid.row_for(group)).to eq([2, false])
-    end
-  end
-
-  describe "instance level column definition" do
-    let(:modified_grid) do
-      grid = test_report do
-        scope { Entry }
-        column(:id)
-      end
-      grid.column(:name)
-      grid
-    end
-
-    let(:basic_grid) { modified_grid.class.new }
-    let!(:entry) { Entry.create!(:name => "Hello", :category => 'first') }
-
-    it "should have correct columns" do
-      expect(modified_grid.columns.size).to eq(2)
-      expect(basic_grid.class.columns.size).to eq(1)
-      expect(basic_grid.columns.size).to eq(1)
-    end
-
-    it "should give correct header" do
-      expect(modified_grid.header).to eq(["Id", "Name"])
-      expect(basic_grid.header).to eq(["Id"])
-    end
-
-    it "should give correct rows" do
-      expect(modified_grid.rows).to eq([[entry.id, 'Hello']])
-      expect(basic_grid.rows).to eq([[entry.id]])
-    end
-
-    it "should support :before column name" do
-      modified_grid.column(:category, :before => :name)
-      expect(modified_grid.header).to eq(["Id", "Category", "Name"])
-    end
-
-    it "should support :before all" do
-      modified_grid.column(:category, :before => true)
-      expect(modified_grid.header).to eq(["Category", "Id", "Name"])
-    end
-
-    it "should support columns block" do
-      modified_grid.column(:category) do
-        category.capitalize
-      end
-      expect(modified_grid.rows).to eq([[entry.id, "Hello", 'First']])
-    end
-
-    it "should support column_names accessor" do
-      modified_grid.column_names = [:name]
-      expect(modified_grid.rows).to eq([['Hello']])
-      modified_grid.column_names = [:id]
-      expect(modified_grid.rows).to eq([[entry.id]])
-    end
-    it "should support column_names accessor with mandatory columns" do
-      modified_grid.column(:category, :mandatory => true)
-      modified_grid.column_names = [:name]
-      expect(modified_grid.rows).to eq([['Hello', 'first']])
-      basic_grid.column_names = [:id]
-      expect(basic_grid.rows).to eq([[entry.id]])
-    end
-
-    it "should support available columns" do
-      modified_grid.column(:category, :mandatory => true)
-      expect(modified_grid.available_columns.map(&:name)).to eq([:id, :name, :category])
-    end
-
-    it "should respect column availability criteria" do
-      modified_grid.column(:category, :if => proc { false })
-      expect(modified_grid.columns.map(&:name)).to eq([:id, :name])
-    end
-  end
-
-  describe ".data_value" do
-    it "should return value" do
-      grid = test_report do
-        scope {Entry }
-        column(:name)
-      end
-      expect(grid.data_value(:name, Entry.create!(:name => 'Hello'))).to eq('Hello')
-    end
-    it "should raise for disabled columns" do
-      grid = test_report do
-        scope {Entry }
-        column(:name, :if => proc { false })
-      end
-      expect  {
-        grid.data_value(:name, Entry.create!(:name => 'Hello'))
-      }.to raise_error(Datagrid::ColumnUnavailableError)
-    end
-  end
-
-  describe "caching" do
-    it "should work when enabled in class" do
-      grid = test_report do
-        scope {Entry}
-        self.cached = true
-        column(:random1) {rand(10**9)}
-        column(:random2) {rand(10**9)}
-      end
-
-      row = grid.data_row(Entry.create!)
-      expect(row.random1).to eq(row.random1)
-      expect(row.random2).to_not eq(row.random1)
-      grid.cached = false
-      expect(row.random2).to_not eq(row.random2)
-      expect(row.random2).to_not eq(row.random1)
-    end
-  end
-
-  describe "decoration" do
-    class EntryDecorator
-      attr_reader :model
-      def initialize(model)
-        @model = model
-      end
-      def capitalized_name
-        model.name.capitalize
-      end
-    end
-
-    let!(:entry) do
-      Entry.create!(name: 'hello', category: 'first')
-    end
-
-    it "delegates column values to decorator" do
-      grid = test_report do
-        scope { Entry }
-        decorate { |model| EntryDecorator.new(model) }
-        column(:capitalized_name)
-        column(:category) do |presenter|
-          presenter.model.category
-        end
-        column(:capitalized_name_dup) do |_, _, row|
-          row.capitalized_name
-        end
-      end
-
-      expect(grid.rows).to eq([['Hello', 'first', 'Hello']])
-    end
-
-    it "allows class decorator" do
-      grid = test_report do
-        scope { Entry }
-        decorate { EntryDecorator }
-        column(:capitalized_name)
-      end
-      expect(grid.rows).to eq([['Hello']])
-    end
-  end
-
-  describe "column scope" do
-    it "appends preload as non block" do
-      grid = test_report do
-        scope { Entry }
-        column(:id, preload: [:group])
-      end
-      expect(grid.assets.preload_values).to_not be_blank
-    end
-
-    it "appends preload with no args" do
-      grid = test_report do
-        scope { Entry }
-        column(:id, preload: -> { order(:id) })
-      end
-      expect(grid.assets.order_values).to_not be_blank
-    end
-
-    it "appends preload with arg" do
-      grid = test_report do
-        scope { Entry }
-        column(:id, preload: ->(a) { a.order(:id) })
-      end
-      expect(grid.assets.order_values).to_not be_blank
-    end
-
-    it "appends preload as true value" do
-      grid = test_report do
-        scope { Entry }
-        column(:group, preload: true)
-      end
-      expect(grid.assets.preload_values).to eq([:group])
-    end
-
-    it "doesn't append preload when column is invisible" do
-      grid = test_report do
-        scope { Entry }
-        column(:id1, preload: ->(a) { a.order(:id) })
-        column(:id2, preload: ->(a) { a.order(:id) }, if: ->(a) { false })
-        column(:name)
-      end
-      grid.column_names = [:name]
-      expect(grid.assets.order_values).to be_blank
-    end
-  end
-end