the_grid 1.0.7

data/lib/the_grid/api/command.rb

@@ -0,0 +1,48 @@
+module TheGrid
+  class Api::Command
+
+    def self.find(cmd)
+      @@commands ||= {}
+      @@commands[cmd] ||= build(cmd)
+    end
+
+    def self.register_lookup_scope(scope)
+      scopes.unshift(scope).uniq!
+    end
+
+    def self.scopes
+      @@scopes ||= ["the_grid/api/command"]
+    end
+
+    def self.build(cmd)
+      scope = scopes.detect do |scope|
+        "#{scope}/#{cmd}".camelize.constantize rescue nil
+      end
+      raise ArgumentError, %{ Command "#{cmd}" is unknown } if scope.nil?
+      "#{scope}/#{cmd}".camelize.constantize.new
+    end
+
+    def execute_on(relation, params)
+      run_on(relation, configure(relation, params))
+    end
+
+    def batch?
+      @is_batch ||= self.class.name.demodulize.starts_with?('Batch')
+    end
+
+    def contextualize(relation, params)
+      {}
+    end
+
+  protected
+
+    def run_on(relation, params)
+      raise "Method \"#{inspect}::run_on\" should be implemented by child class"
+    end
+
+    def configure(relation, params)
+      params
+    end
+
+  end
+end

data/lib/the_grid/api.rb

@@ -0,0 +1,52 @@
+module TheGrid
+  class Api
+    attr_reader :relation, :options
+
+    def initialize(relation)
+      @relation = relation
+      @options = { :delegated_commands => {} }
+    end
+
+    def delegate(commands)
+      options[:delegated_commands].merge! commands.stringify_keys
+    end
+
+    def compose!(params)
+      configure(params).fetch(:cmd).each do |cmd|
+        @relation = run_command!(cmd, params) unless command(cmd).batch?
+      end
+    end
+
+    def run_command!(name, params)
+      @options.merge! command(name).contextualize(@relation, params)
+
+      if command_delegated?(name)
+        assoc_name = options[:delegated_commands][name.to_s]
+        assoc = @relation.reflections[assoc_name].klass.scoped
+        @relation.merge command(name).execute_on(assoc, params)
+      else
+        command(name).execute_on(@relation, params)
+      end
+    end
+
+  protected
+
+    def command(type)
+      ::TheGrid::Api::Command.find(type)
+    end
+
+    def command_delegated?(cmd)
+      options[:delegated_commands].has_key?(cmd.to_s)
+    end
+
+    def configure(params)
+      self.delegate(params[:delegate]) if params[:delegate]
+      params.tap do |o|
+        o[:cmd] = Array.wrap(o[:cmd])
+        o[:cmd].unshift(:paginate) unless params[:per_page] === false
+        o[:cmd].uniq!
+      end
+    end
+
+  end
+end

data/lib/the_grid/builder/context.rb

@@ -0,0 +1,96 @@
+module TheGrid
+  class Builder::Context
+    attr_reader :columns, :options, :scope, :name
+
+    def initialize(options = {}, &dsl)
+      @scope   = options.delete(:scope)
+      @options = options
+      @columns = { :id => {:hidden => true} }
+
+      self.instance_eval(&dsl)
+    end
+
+    def column(name, attributes = {}, &block)
+      find_or_build_column(name).tap do |column|
+        column.merge! attributes
+        column[:as] = block if block_given?
+      end
+    end
+
+    def method_missing(method_name, *args, &block)
+      if @scope.respond_to?(method_name)
+        @scope.send(method_name, *args, &block)
+      elsif method_name.to_s.ends_with?("ble_columns")
+        feature = method_name.to_s.chomp("_columns")
+        mark_columns_with(feature.to_sym, args)
+        @options[method_name.to_sym] = args
+      else
+        @options[method_name] = args.size == 1 ? args.first : args
+      end
+    end
+
+    def scope_for(scope_name, attributes = {}, &block)
+      name = attributes.delete(:as) || scope_name
+      column name, attributes.merge(:as => Builder::Context.new(:scope => scope, &block), :scope_name => scope_name)
+    end
+
+    def visible_columns
+      columns.each_with_object({}) do |column, vc|
+        name, options = column
+        vc[name] = options.except(:as, :if, :unless) unless options[:hidden]
+        vc[name] = options[:as].visible_columns if options[:as].respond_to?(:visible_columns)
+      end
+    end
+
+    def assemble(records)
+      records.map{ |record| assemble_row_for(record) }
+    end
+
+  protected
+
+    def find_or_build_column(name)
+      @columns[name.to_sym] ||= {}
+    end
+
+    def mark_columns_with(feature, column_names)
+      column_names.each do |name|
+        find_or_build_column(name).store(feature, true)
+      end
+    end
+
+    def assemble_row_for(record)
+      columns.each_with_object({}) do |column, row|
+        name, options = column
+        row[name] = assemble_column_for(record, name, options)
+      end
+    end
+
+    def assemble_column_for(record, name, options)
+      formatter = options[:as]
+
+      if formatter.respond_to?(:call)
+        formatter.call(record)
+      elsif formatter.is_a? Symbol
+        record.send(formatter)
+      elsif formatter.respond_to?(:assemble)
+        formatter.assemble(record.send(options[:scope_name])) if may_assemble?(record, options)
+      else
+        record.send(name)
+      end
+    end
+
+    def may_assemble?(record, options)
+      condition = options[:if] || options[:unless]
+
+      if condition.is_a? Symbol
+        result = assemble_column_for(record, condition, columns[condition])
+      elsif condition.respond_to?(:call)
+        result = condition.call(record)
+      else
+        result = true
+      end
+      options[:unless].present? ? !result : result
+    end
+
+  end
+end

data/lib/the_grid/builder/json.rb

@@ -0,0 +1,37 @@
+module TheGrid
+  class Builder::Json
+    cattr_accessor :prettify_json
+    attr_reader :api, :context
+
+    def initialize(relation, context)
+      @api = TheGrid::Api.new(relation)
+      @context = context
+    end
+
+    def assemble_with(params)
+      options = params.merge context.options
+      api.compose!(options)
+      stringify as_json_with(options)
+    rescue ArgumentError => error
+      stringify as_json_message('error', error.message)
+    end
+
+  private
+
+    def stringify(json_hash)
+      self.class.prettify_json ? JSON.pretty_generate(json_hash) : json_hash.to_json
+    end
+
+    def as_json_with(options)
+      {}.tap do |json|
+        json[:meta], json[:columns] = context.options.except(:delegate, :search_over), context.visible_columns if options[:with_meta]
+        json[:max_page] = api.options[:max_page]
+        json[:items] = context.assemble(api.relation)
+      end
+    end
+
+    def as_json_message(status, message)
+      {:status => status, :message => message}
+    end
+  end
+end

data/lib/the_grid/builder.rb

@@ -0,0 +1,61 @@
+module TheGrid
+  class Builder
+    private_class_method :new
+
+    def self.call(template)
+      source = if template.source.empty?
+        File.read(template.identifier)
+      else
+        template.source
+      end
+
+      %{
+        ::TheGrid::Builder.assemble(:view_type => ::TheGrid::Builder::Json, :scope => self) {
+          #{source}
+        }
+      }
+    end
+
+    def self.assemble(options, &block)
+      new(options, &block)
+    end
+
+    def initialize(options, &block)
+      options.assert_valid_keys(:scope, :view_type)
+
+      @_scope = options.delete(:scope)
+      @_view_type = options.delete(:view_type)
+
+      copy_instance_variables_from(@_scope) if @_scope
+      self.instance_eval(&block)
+    end
+
+    def grid_for(relation, options = {}, &block)
+      context = Context.new(options.merge(:scope => @_scope), &block)
+      @_view_handler = @_view_type.new(relation, context)
+    end
+
+    def assemble(&block)
+      @_view_handler.assemble_with(@_scope.params, &block)
+    end
+
+    def method_missing(name, *args, &block)
+      if @_scope.respond_to?(name)
+        @_scope.send(name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def to_s; assemble;end
+    def to_str; assemble;end
+
+  private
+
+    def copy_instance_variables_from(object)
+      vars = object.instance_variables.map(&:to_s)
+      vars.each { |name| instance_variable_set(name.to_sym, object.instance_variable_get(name)) }
+    end
+
+  end
+end

data/lib/the_grid/config.rb

@@ -0,0 +1,18 @@
+module TheGrid
+  class Config
+    attr_accessor :default_max_per_page, :prettify_json, :commands_lookup_scopes
+
+    def initialize
+      self.commands_lookup_scopes = []
+      self.prettify_json  = false
+    end
+
+    def apply
+      self.commands_lookup_scopes.flatten.each{ |s| Api::Command.register_lookup_scope(s) }
+      Api::Command.find(:paginate).default_per_page = self.default_max_per_page
+      Builder::Json.prettify_json = self.prettify_json
+    end
+  end
+
+  ActionView::Template.register_template_handler :grid_builder, ::TheGrid::Builder if defined?(ActionView::Template)
+end

data/lib/the_grid/version.rb

@@ -0,0 +1,3 @@
+module TheGrid
+  VERSION = "1.0.7"
+end

data/lib/the_grid.rb

@@ -0,0 +1,18 @@
+require 'the_grid/version'
+require 'the_grid/api'
+require 'the_grid/api/command'
+require 'the_grid/builder'
+require 'the_grid/config'
+Dir.chdir(File.dirname(__FILE__)) do
+  Dir['the_grid/builder/**/*.rb', 'the_grid/api/command/**/*.rb'].each{ |f| require f }
+end
+
+module TheGrid
+  def self.configure
+    Config.new.tap{ |c| yield c }.apply
+  end
+
+  def self.build_for(relation)
+    Api.new(relation)
+  end
+end

data/spec/api/command/batch_remove_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe TheGrid::Api::Command::BatchRemove do
+  let(:table)    { double(:primary_key => double.as_null_object) }
+  let(:relation) { double(:table => table).tap{ |r| r.stub(:scoped => r, :where => r) } }
+
+  it "raise exception when item_ids is blank" do
+    expect{
+      subject.execute_on(relation, :item_ids => [])
+    }.to raise_error ArgumentError
+  end
+
+  it "is a batch command" do
+    subject.batch?.should be_true
+  end
+
+  context "when item_ids is present" do
+    let(:item_ids) { [1, 2, 'non-int', 3, 4, '5'] }
+    let(:int_ids)  { item_ids.reject{ |id| id.to_i <= 0 } }
+
+    before(:each) { relation.stub(:destroy_all => int_ids) }
+    after(:each)  { subject.execute_on(relation, :item_ids => item_ids) }
+
+    it "remove items based on by primary key" do
+      relation.table.primary_key.should_receive(:in)
+    end
+
+    it "reject non-integer ids" do
+      relation.table.primary_key.should_receive(:in).with(int_ids)
+    end
+
+    it "remove only records with specified ids" do
+      relation.should_receive(:where).with(table.primary_key.in(int_ids))
+    end
+
+    it "destroy records" do
+      relation.should_receive(:destroy_all)
+    end
+  end
+
+end

data/spec/api/command/batch_update_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe TheGrid::Api::Command::BatchUpdate do
+  let(:table)    { double(:primary_key => double(:name => 'id').as_null_object) }
+  let(:relation) { double(:table => table).tap{ |r| r.stub(:scoped => r, :where => r) } }
+
+  it "raise exception when items is blank" do
+    expect{
+      subject.execute_on(relation, :items => [])
+    }.to raise_error ArgumentError
+  end
+
+  it "is a batch command" do
+    subject.batch?.should be_true
+  end
+
+  context "when items is present" do
+    let(:non_valid_items) { 2.times.map{ |i| {'id' => "string_#{i}", 'name' => "test_#{i}"} } }
+    let(:valid_items)     { 4.times.map{ |i| {'id' => i +1 , 'name' => "test_#{i}"} } }
+    let(:valid_ids) { valid_items.map{ |r| r['id'] } }
+    let(:records)   { valid_items.map{ |r| double(r.merge :update_attributes => true) } }
+
+    before(:each) { relation.stub(:where => records) }
+    after(:each)  { subject.execute_on(relation, :items => valid_items + non_valid_items) }
+
+    it "remove items based on by primary key" do
+      relation.table.primary_key.should_receive(:in)
+    end
+
+    it "reject items with non-integer ids" do
+      relation.table.primary_key.should_receive(:in).with(valid_ids)
+    end
+
+    it "remove only records with specified ids" do
+      relation.should_receive(:where).with(table.primary_key.in(valid_ids))
+    end
+
+    it "update attributes with given data" do
+      rows = records.index_by(&:id)
+      valid_items.each{ |data| rows.fetch(data['id']).should_receive(:update_attributes).with(data.except('id'))  }
+    end
+  end
+
+end

data/spec/api/command/filter_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+shared_examples "for a range filter" do
+  let(:filters){ { :field => filter } }
+
+  context "when both boundaries are specified" do
+    it "adds 'from' filter" do
+      relation.table[:field].should_receive(:gteq).with(value[:from])
+    end
+
+    it "adds 'to' filter" do
+      relation.table[:field].should_receive(:lteq).with(value[:to])
+    end
+  end
+
+  context "when left boundary is missed" do
+    before(:each){ filters[:field] = filter.except(:from) }
+
+    it "adds 'to' filter" do
+      relation.table[:field].should_receive(:lteq).with(value[:to])
+    end
+
+    it "does not add 'from' filter" do
+      relation.table[:field].should_not_receive(:gteq)
+    end
+  end
+
+  context "when right boundary is missed" do
+    before(:each){ filters[:field] = filter.except(:to) }
+
+    it "adds 'from' filter " do
+      relation.table[:field].should_receive(:gteq).with(value[:from])
+    end
+
+    it "does not add 'to' filter" do
+      relation.table[:field].should_not_receive(:lteq)
+    end
+  end
+end
+
+describe TheGrid::Api::Command::Filter do
+  let(:table)    { double(:blank? => false).as_null_object }
+  let(:relation) { double(:table => table).tap{ |r| r.stub(:where => r) } }
+
+  after(:each) { subject.execute_on(relation, :filters => filters) }
+
+  context "when filters are missed" do
+    let(:filters){ Hash.new }
+
+    it "returns the same relation object" do
+      relation.should_not_receive(:where)
+    end
+  end
+
+  context "when filters with primary values" do
+    let(:filters){ { :id => [1, 2], :state => "test" } }
+
+    it "changes relation conditions" do
+      relation.should_receive(:where)
+    end
+
+    it "filters by array of values" do
+      relation.table[:id].should_receive(:in).with(filters[:id])
+    end
+
+    it "filters by value" do
+      relation.table[:state].should_receive(:eq).with(filters[:state])
+    end
+  end
+
+  context "when filters with date range" do
+    let(:filter) { {:from => '2013-02-12 12:20:21', :to => '2013-05-12 13:20:01', :type => :date } }
+    let(:value)  { Hash[filter.except(:type).map{ |k, v| [k, v.to_time] }] }
+    include_examples "for a range filter"
+  end
+
+  context "when filters with time range" do
+    let(:filter) { {:from => 2.days.ago.to_f, :to => Time.now.to_f, :type => :time } }
+    let(:value)  { Hash[filter.except(:type).map{ |k, v| [k, Time.at(v)] }] }
+    include_examples "for a range filter"
+  end
+
+  context "when filters with non-date range" do
+    let(:filter) { {:from => 10, :to => 20} }
+    let(:value)  { filter }
+    include_examples "for a range filter"
+  end
+
+end

data/spec/api/command/paginate_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe TheGrid::Api::Command::Paginate do
+  let(:relation){ double("ActiveRecord::Relation", :count => 25).as_null_object }
+
+  context "when options are missed" do
+    after(:each){ subject.execute_on(relation, {}) }
+
+    it "returns first page" do
+      relation.should_receive(:offset).with(0)
+    end
+
+    it "returns default amount of items" do
+      relation.should_receive(:limit).with(subject.class.default_per_page)
+    end
+  end
+
+  context "when options are specified" do
+    after(:each){ subject.execute_on(relation, :page => 3, :per_page => 5) }
+
+    it "returns specified page" do
+      relation.should_receive(:offset).with(10)
+    end
+
+    it "returns specified amount of items" do
+      relation.should_receive(:limit).with(5)
+    end
+  end
+
+  context "when calculates max page" do
+    it "should use default per_page option" do
+      subject.calculate_max_page_for(relation, {}).should eql (25.0 / subject.class.default_per_page).ceil
+    end
+
+    it "should respect specified per_page option" do
+      subject.calculate_max_page_for(relation, :per_page => 15).should eql 2
+    end
+  end
+
+  it "calculates max page when prepares context" do
+    subject.contextualize(relation, :page => 1, :per_page => 15).fetch(:max_page).should eql 2
+  end
+
+end

data/spec/api/command/search_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe TheGrid::Api::Command::Search do
+  let(:columns)  {{ :name => string_column, :status => string_column, :id => double(:type => :int) }}
+  let(:relation) { double(:columns_hash => columns, :column_names => columns.keys, :table => columns).as_null_object }
+
+  after(:each) { subject.execute_on(relation, options) }
+
+  context "when query or search_over is missed" do
+    let(:options) { Hash.new }
+
+    it "does not search if query is missed" do
+      relation.should_not_receive(:where)
+    end
+
+    it "does not search over nested relations if search_over is missed" do
+      relation.should_not_receive(:reflections)
+    end
+  end
+
+  context "when searchable_columns is missed" do
+    let(:options) {{ :query => "test" }}
+
+    it "search over own columns" do
+      relation.should_receive(:columns_hash)
+    end
+
+    it "does not search over non-string columns" do
+      relation.table[:id].should_not_receive(:matches)
+    end
+
+    it "combine searchable conditions by or" do
+      relation.table[:name].should_receive(:or).with(relation.table[:status])
+    end
+  end
+
+  context "when options are valid" do
+    let(:options) {{ :query => "test", :searchable_columns => [:name] }}
+
+    it "search by query" do
+      relation.should_receive(:where)
+    end
+
+    it "search only by specified columns" do
+      relation.table[:status].should_not_receive(:matches)
+      relation.table[:id].should_not_receive(:matches)
+    end
+
+    it "search using SQL LIKE" do
+      relation.table[:name].should_receive(:matches).with("%#{options[:query]}%")
+    end
+  end
+
+  context "when search over nested relations" do
+    pending "logic is too complicated; maybe will be rewritten"
+  end
+
+  def string_column
+    double(:type => :string).tap do |c|
+      c.stub(:matches => c, :or => c)
+    end
+  end
+
+end

data/spec/api/command/sort_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe TheGrid::Api::Command::Sort do
+  let(:table)    { double(:name => "table_for_sort", :present? => true).as_null_object }
+  let(:relation) { double(:table_name => table.name, :table => table) }
+  let(:options)  { {:field => "name", :order => "desc" } }
+
+  after(:each){ subject.execute_on(relation, options) }
+
+  it "sort by asc if order invalid" do
+    options[:order] = 'wrong order'
+    relation.should_receive(:order).with("#{table.name}.#{options[:field]} asc")
+  end
+
+  it "sort by specified order" do
+    relation.should_receive(:order).with("#{table.name}.#{options[:field]} #{options[:order]}")
+  end
+
+  it "does not prepend field with table name if field is an alias" do
+    table.stub(:present? => false)
+    relation.should_receive(:order).with("#{options[:field]} #{options[:order]}")
+  end
+end

data/spec/api/command_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+module GridCommands
+  class Sort < TheGrid::Api::Command::Sort; end
+end
+
+describe TheGrid::Api::Command do
+  subject{ TheGrid::Api::Command }
+  let(:commands_scope) { GridCommands }
+
+  it "can be executed on relation" do
+    subject.find(:paginate).should respond_to(:execute_on)
+  end
+
+  it "build command instance" do
+    subject.find(:paginate).should be_kind_of subject.const_get('Paginate')
+  end
+
+  it "build flyweight instances" do
+    subject.find(:paginate).object_id.should eql subject.find(:paginate).object_id
+  end
+
+  it "raise error if command not found" do
+    expect{ subject.find(:unknown_cmd) }.to raise_error ArgumentError
+  end
+
+  it "has only one scope for commands by default" do
+    subject.scopes.should eql [ subject.to_s.underscore ]
+  end
+
+  context "when register new scope" do
+    before(:each) { subject.register_lookup_scope commands_scope.to_s.underscore }
+    after(:each) { subject.scopes.shift() }
+
+    it "put scope at the top" do
+      subject.scopes.first.should eql commands_scope.to_s.underscore
+    end
+
+    it "build the first found command" do
+      subject.find(:sort).should be_kind_of commands_scope.const_get('Sort')
+    end
+  end
+
+end