the_grid 1.0.7

data/spec/api_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+describe TheGrid::Api do
+  subject{ TheGrid::Api.new(relation) }
+
+  let(:child_relation) { double("Child Relation").as_null_object }
+  let(:relation) { double("Relation", :reflections => { :child_relation => child_relation }).as_null_object }
+  let(:commands) { lambda{ |name| ::TheGrid::Api::Command.find(name) } }
+
+  context "when run single command" do
+    let(:options)  {{ :field => "title", :order => "desc" }}
+    let(:cmd_name) { :sort }
+
+    after(:each) { subject.run_command!(cmd_name, options) }
+
+    it "run specified command" do
+      commands[cmd_name].should_receive(:execute_on).with(subject.relation, options)
+    end
+
+    it "should be prepared by command instance" do
+      commands[cmd_name].should_receive(:contextualize).with(subject.relation, options).and_return({})
+    end
+
+    it "run delegated command on specified target" do
+      subject.delegate(cmd_name => :child_relation)
+      commands[cmd_name].should_receive(:execute_on).with(child_relation, options)
+    end
+  end
+
+  context "when run few commands" do
+    let(:params)  {{ :cmd => [:sort, :search, :batch_update], :field => "title", :query => "test" }}
+    before(:each) { subject.stub(:run_command!) }
+    after(:each)  { subject.compose!(params) }
+
+    it "skip batch commands" do
+      commands[:batch_update].should_not_receive(:execute_on)
+    end
+
+    it "run specified commands" do
+      subject.should_receive(:run_command!).with(:sort, params)
+      subject.should_receive(:run_command!).with(:search, params)
+    end
+
+    it "adds paginate command by default" do
+      subject.should_receive(:run_command!).with(:paginate, params)
+    end
+
+    it "doesn't add paginate command if per_page equals false" do
+      params[:per_page] = false
+      subject.should_not_receive(:run_command!).with(:paginate, params)
+    end
+
+    it "delegates specified commands" do
+      params[:delegate] = {:sort => child_relation}
+      subject.should_receive(:delegate).with(params[:delegate])
+    end
+  end
+end

data/spec/builder/context_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+
+describe TheGrid::Builder::Context do
+  subject{ TheGrid::Builder::Context }
+
+  let(:parent_scope) { double(:dsl => Proc.new{ column :title }) }
+  let(:options) {{ :per_page => 25, :scope => parent_scope }}
+
+  context "by default" do
+    it "has hidden id column" do
+      build_context.columns[:id].should have_key(:hidden)
+    end
+
+    it "stores specified options" do
+      build_context.options[:per_page].should eql options[:per_page]
+    end
+
+    it "requires block" do
+      expect{ subject.new(options) }.to raise_error ArgumentError
+    end
+
+    it "respects parent context" do
+      parent_scope.should_receive(:article_path)
+      build_context{ url article_path }
+    end
+
+    it "responds to assemble" do
+      build_context.should respond_to(:assemble).with(1).argument
+    end
+  end
+
+  context "DSL" do
+    it "defines columns" do
+      build_context{ column :name; column :url }.columns.keys.should include(:name, :url)
+    end
+
+    it "defines column specific options" do
+      columns = build_context{ column :name, :test => true, :value => 5 }.columns
+      columns[:name].values_at(:test, :value).should eql [true, 5]
+    end
+
+    it "marks columns as featurable" do
+      columns = build_context{ searchable_columns :name, :text }.columns
+      columns.slice(:name, :text).should be_all{ |k, v| v[:searchable] == true }
+    end
+
+    it "stores featureable columns in options" do
+      build_context{ searchable_columns :name, :text }.options[:searchable_columns].should eql [:name, :text]
+    end
+
+    it "accepts single option's values" do
+      options = build_context{ title "test"; email "test@example.com" }.options
+      options.values_at(:title, :email).should eql %w{ test test@example.com }
+    end
+
+    it "accepts multiple option's values" do
+      build_context{ my :name, :age, :pan }.options[:my].should eql [:name, :age, :pan]
+    end
+
+    it "accepts block as column generator" do
+      build_context{ column(:name){ "test" } }.columns[:name][:as].should respond_to(:call)
+    end
+
+    it "accepts method_name as column generator" do
+      build_context{ column :name, :as => :title}.columns[:name][:as].should eql :title
+    end
+
+    it "defines nested scope" do
+      context = build_context{ scope_for(:articles, &dsl) }
+      context.columns[:articles][:as].should be_kind_of subject
+    end
+
+    it "defines nested scope with specified name" do
+      context = build_context{ scope_for(:articles, :as => :children, &dsl) }
+      context.columns[:children][:as].should be_kind_of subject
+    end
+  end
+
+  context "when collects visible columns" do
+    let(:parent_scope){ double(:dsl => Proc.new{ column :title; column :name, :hidden => true }) }
+
+    it "returns only visible columns" do
+      build_context(&parent_scope.dsl).visible_columns.keys.should eql [:title]
+    end
+
+    it "respects visible columns of nested scopes" do
+      build_context{ scope_for(:children, &dsl) }.visible_columns[:children].keys.should eql [:title]
+    end
+  end
+
+  context "when assembles" do
+    let(:fields)  {{ :title => "item", :id => 5, :live? => false, :short_details => "details" }}
+    let(:records) {[ double(fields), double(fields.merge :live? => true) ]}
+
+    context "records" do
+      subject { context.assemble(records) }
+      let(:context) { build_plane_context }
+
+      it { should be_kind_of Array }
+      it { should have(records.size).items }
+      it { should be_all{ |r| r.kind_of? Hash } }
+      it { should be_all{ |r| r.keys == context.columns.keys }}
+    end
+
+    context "any structure" do
+      subject{ build_plane_context }
+      after(:each){ subject.assemble(records) }
+
+      it "builds records by name" do
+        records.each{ |r| r.should_receive(:title) }
+      end
+
+      it "builds records by alias" do
+        records.each{ |r| r.should_receive(:short_details) }
+      end
+
+      it "builds records by given block" do
+        records.each{ |r| r.should_receive(:live?) }
+      end
+    end
+
+    context "tree-like structure" do
+      let(:conditional_option) { :if }
+      let(:fields) {{ :id => 5, :live? => false, :permanent => [], :conditional => [], :conditional_block => [] }}
+      after(:each) { build_tree_like_context(conditional_option).assemble(records) }
+
+      it "creates nested scope for each record" do
+        records.each{ |r| r.should_receive(:permanent) }
+      end
+
+      context "when specified :if option" do
+        it "creates nested scope if record column is true" do
+          records.first.should_not_receive(:conditional)
+          records.last.should_receive(:conditional)
+        end
+
+        it "creates nested scope if block returns true" do
+          records.first.should_not_receive(:conditional_block)
+          records.last.should_receive(:conditional_block)
+        end
+      end
+
+      context "when specified :unless option" do
+        let(:conditional_option) { :unless }
+
+        it "creates nested :unless block returns true" do
+          records.first.should_receive(:conditional)
+          records.last.should_not_receive(:conditional)
+        end
+
+        it "creates nested :unless block returns true" do
+          records.first.should_receive(:conditional_block)
+          records.last.should_not_receive(:conditional_block)
+        end
+      end
+    end
+
+    def build_plane_context
+      build_context do
+        column :title
+        column :details, :as => :short_details
+        column(:is_active){ |r| r.live? }
+      end
+    end
+
+    def build_tree_like_context(conditional_option)
+      build_context do
+        column :is_active, :as => :live?
+        scope_for(:permanent, &dsl)
+        scope_for(:conditional, conditional_option => :is_active, &dsl)
+        scope_for(:conditional_block, conditional_option => proc{ |r| r.live? }, &dsl)
+      end
+    end
+
+  end
+
+  def build_context(&dsl)
+    dsl = Proc.new{} unless block_given?
+    TheGrid::Builder::Context.new(options, &dsl)
+  end
+
+end

data/spec/builder/json_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe TheGrid::Builder::Json do
+  subject { TheGrid::Builder::Json.new(relation, context) }
+
+  before(:each) { subject.api.stub(:compose!) { subject.api.options[:max_page] = 25 } }
+
+  let(:relation) { double('Relation').as_null_object }
+  let(:context) { create_context.tap { |c| c.stub(:assemble => [1,2,3,4]) } }
+  let(:params) {{  :cmd => [:sort], :field => :name, :order => :desc }}
+
+  let(:meta) {{ "meta" => {"api_key" => context.options[:api_key]}, "columns" => context.visible_columns.stringify_keys }}
+  let(:json_schema) {{ "max_page" => 25, "items" => context.assemble }}
+  let(:assembled_result) { JSON.parse(subject.assemble_with(params)) }
+
+  it "merges params with context options" do
+    subject.api.should_receive(:compose!).with(params.merge context.options)
+    subject.assemble_with params
+  end
+
+  it "generates json with meta information" do
+    params[:with_meta] = true
+    assembled_result.should eql json_schema.merge(meta)
+  end
+
+  it "generates json without meta" do
+    assembled_result.should eql json_schema
+  end
+
+  it "generates json notification when get wrong argument" do
+    subject.api.stub(:compose!) { raise ArgumentError, "123" }
+    assembled_result.should eql({"status" => "error", "message" => "123"})
+  end
+
+
+  def create_context
+    TheGrid::Builder::Context.new do
+      api_key "hello_world"
+      delegate  :sort => :articles, :filter => :articles
+
+      column :name
+      column :is_active
+    end
+  end
+
+end

data/spec/config_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe TheGrid::Config do
+  context "when initializes" do
+    its(:commands_lookup_scopes) { should eql [] }
+    its(:prettify_json) { should be_false }
+  end
+
+  context "when applying specified values" do
+    let(:command) { TheGrid::Api::Command }
+    let(:builder) { TheGrid::Builder::Json }
+    before(:each) { configure(subject) }
+
+    it "registers specified lookup scopes from configuration" do
+      command.scopes.should include(*subject.commands_lookup_scopes)
+    end
+
+    it "sets up default_per_page for Paginate command" do
+      command.find(:paginate).default_per_page.should eql subject.default_max_per_page
+    end
+
+    it "sets up prettify_json option for json builder" do
+      builder.prettify_json.should eql subject.prettify_json
+    end
+  end
+
+private
+
+  def configure(config)
+    config.commands_lookup_scopes += %w{ command_scope_1 command_scope_2 }
+    config.default_max_per_page = 10
+    config.prettify_json = true
+    config.apply
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'active_support/all'
+require 'the_grid'

data/the_grid.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "the_grid/version"
+
+Gem::Specification.new do |s|
+  s.name        = "the_grid"
+  s.version     = TheGrid::VERSION
+  s.authors     = ["Sergiy Stotskiy", "Yuriy Buchchenko"]
+  s.email       = "sergiy.stotskiy@gmail.com"
+  s.homepage    = "http://github.com/stalniy/grid"
+  s.license     = "MIT"
+  s.summary     = %q{Yet another grid api.}
+  s.platform    = Gem::Platform::RUBY
+
+  s.description = <<-EOF
+Provides json API for building ActiveRecord::Relation's.  It makes much easier to fetch information from database for displaying it using JavaScript MV* based frameworks such as Knockout, Backbone, Angular, etc.
+
+Tags: json, grid, api, grid builder, activerecord relation builder, relation
+EOF
+
+  s.rubyforge_project = "the_grid"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'activerecord', '>= 3.0'
+  s.add_dependency 'json'
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "rspec", "~> 2.13"
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: the_grid
+version: !ruby/object:Gem::Version
+  version: 1.0.7
+platform: ruby
+authors:
+- Sergiy Stotskiy
+- Yuriy Buchchenko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+description: ! 'Provides json API for building ActiveRecord::Relation''s.  It makes
+  much easier to fetch information from database for displaying it using JavaScript
+  MV* based frameworks such as Knockout, Backbone, Angular, etc.
+
+
+  Tags: json, grid, api, grid builder, activerecord relation builder, relation
+
+'
+email: sergiy.stotskiy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .rvmrc
+- Gemfile
+- README.md
+- Rakefile
+- lib/generators/the_grid/install/install_generator.rb
+- lib/generators/the_grid/install/templates/the_grid.rb
+- lib/the_grid.rb
+- lib/the_grid/api.rb
+- lib/the_grid/api/command.rb
+- lib/the_grid/api/command/batch_remove.rb
+- lib/the_grid/api/command/batch_update.rb
+- lib/the_grid/api/command/filter.rb
+- lib/the_grid/api/command/paginate.rb
+- lib/the_grid/api/command/search.rb
+- lib/the_grid/api/command/sort.rb
+- lib/the_grid/builder.rb
+- lib/the_grid/builder/context.rb
+- lib/the_grid/builder/json.rb
+- lib/the_grid/config.rb
+- lib/the_grid/version.rb
+- spec/api/command/batch_remove_spec.rb
+- spec/api/command/batch_update_spec.rb
+- spec/api/command/filter_spec.rb
+- spec/api/command/paginate_spec.rb
+- spec/api/command/search_spec.rb
+- spec/api/command/sort_spec.rb
+- spec/api/command_spec.rb
+- spec/api_spec.rb
+- spec/builder/context_spec.rb
+- spec/builder/json_spec.rb
+- spec/config_spec.rb
+- spec/spec_helper.rb
+- the_grid.gemspec
+homepage: http://github.com/stalniy/grid
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: the_grid
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Yet another grid api.
+test_files: []