tablets 0.1.0

data/lib/tablets/renderer.rb

@@ -0,0 +1,84 @@
+require 'tablets/engine'
+
+module Tablets
+  # Prepares markup. Renders table without any data.
+  class Renderer
+    # Initializes renderer with tablet and params.
+    def initialize(tablet, params = {})
+      @tablet = tablet
+      @params = params
+    end
+
+    # Renders table in view_context.
+    def render(view_context)
+      view_context.render(partial: 'tablets/tablet', locals: locals)
+    end
+
+    private
+
+    attr_reader :params, :tablet
+
+    # Prepares locals for tablet partial.
+    def locals
+      {
+        id: id,
+        name: tablet.name,
+        columns: tablet.columns,
+        options: options,
+        params: params
+      }
+    end
+
+    # Id for HTML container. Includes name and params with values.
+    #
+    #  renderer = Tablets::Renderer.new(:posts, user_id: 1)
+    #  renderer.id #=> 'posts_user_id_1'
+    #
+    def id
+      [tablet.name, params.to_a].flatten.map(&:to_s).join('_')
+    end
+
+    # Calculates resulting options.
+    def options
+      @options ||= {}
+      .merge(Tablets.options)
+      .merge(columnDefs: columns_definitions, ajax: data_path)
+      .merge(tablet.options)
+    end
+
+    # Calculates column options and applies options on top.
+    #
+    #   ...
+    #   columns do
+    #     [{
+    #       title: 'Title',
+    #       order: 'posts.title',
+    #       data: :title,
+    #       options: { className: 'post-title' }
+    #     }]
+    #   end
+    #   ...
+    #
+    #   renderer.columns_definitions #=> [{
+    #     targets: 0,
+    #     searchable: false,
+    #     orderable: true,
+    #     className: 'post-title'
+    #   }]
+    #
+    def columns_definitions
+      tablet.columns.map.with_index do |column, index|
+        {
+          targets:    index,
+          searchable: column[:search].present?,
+          orderable:  column[:order].present?
+        }.merge!(column[:options] || {})
+      end
+    end
+
+    # Returns path to data.
+    def data_path
+      Tablets::Engine.routes.url_helpers.data_path(tablet.name)
+    end
+  end
+end

data/lib/tablets/tablet.rb

@@ -0,0 +1,60 @@
+require 'tablets/utils/config'
+
+module Tablets
+  # Incapsulates tablet related information.
+  class Tablet
+    attr_reader :name
+
+    # Initializes tablet with name, callbacks fed with block.
+    def initialize(name, &block)
+      @name = name
+      @config = Tablets::Utils::Config.new(&block)
+    end
+
+    # Returns general jquery-datatable configuration overrides.
+    # By default returns empty options.
+    def options
+      call(:options) { {} }
+    end
+
+    # Determines is user authorized.
+    # By default returns true.
+    def authorize(controller)
+      call(:authorize, controller) { true }
+    end
+
+    # Allows to make additional processing before records would be used.
+    # By default returns records.
+    def process(records)
+      call(:process, records) { records }
+    end
+
+    # Returns details HTML for the record.
+    # By default returns nil.
+    def details(record)
+      call(:details, record) { nil }
+    end
+
+    # Returns columns definitions.
+    # Required.
+    def columns
+      call(:columns)
+    end
+
+    # Returns database relation to fetch data.
+    # Required.
+    def relation(params)
+      call(:relation, params)
+    end
+
+    private
+
+    # Calls callback.
+    # Clarifies error message on error.
+    def call(callback, *params, &block)
+      @config.call(callback, *params, &block)
+    rescue ArgumentError
+      raise ArgumentError, "Please define #{callback} for '#{name}' tablet."
+    end
+  end
+end

data/lib/tablets/utils/arel.rb

@@ -0,0 +1,34 @@
+module Tablets
+  module Utils
+    # Arel related utils.
+    module Arel
+      class << self
+        # Casting arel column using db specific type.
+        def column(column)
+          model, column = column.split('.')
+          model = model.singularize.titleize.gsub(/ /, '').constantize
+
+          ::Arel::Nodes::NamedFunction.new(
+            'CAST', [model.arel_table[column.to_sym].as(typecast)]
+          )
+        end
+
+        private
+
+        # Returns database specific string type.
+        def typecast
+          case db_adapter
+            when :postgresql then 'VARCHAR'
+            when :mysql2 then 'CHAR'
+            when :sqlite3 then 'TEXT'
+          end
+        end
+
+        # Retrieves rails database adapter.
+        def db_adapter
+          ActiveRecord::Base.configurations[Rails.env]['adapter'].to_sym
+        end
+      end
+    end
+  end
+end

data/lib/tablets/utils/config.rb

@@ -0,0 +1,75 @@
+module Tablets
+  module Utils
+    # Config utility. Allows to write configs in declarative form.
+    # And fetch values with defaults.
+    #
+    #  config = Config.new do
+    #    some_var 32
+    #    another_var 42
+    #
+    #    some_callback do |arg|
+    #      do_something_with arg
+    #    end
+    #  end
+    #
+    #  config.get(:some_var) #=> 32
+    #  config.get(:non_existent_var) #=> ArgumentError
+    #  config.get(:non_existent_var, 'default') #=> 'default'
+    #
+    #  config.call(:some_callback, 'my_arg') { |arg| default_action arg }
+    #
+    class Config
+      # Initializes config with block.
+      # Block is optional and can be applied later.
+      def initialize(&block)
+        @hash = {}
+
+        apply(&block) unless block.nil?
+      end
+
+      # Executes block in config context.
+      def apply(&block)
+        instance_eval(&block)
+      end
+
+      # Returns value.
+      # If no value defined, returns default.
+      # If no default raises ArgumentError.
+      def get(name, default = nil, &default_block)
+        value = @hash[name][0] if @hash[name]
+
+        if !value.nil?
+          value
+        elsif !default.nil?
+          default
+        elsif !default_block.nil?
+          default_block.call
+        else
+          fail ArgumentError, "Value :#{name} is not set."
+        end
+      end
+
+      # Calls callback.
+      # If no calbback defined, calls default.
+      # If no default raises ArgumentError.
+      def call(name, *params, &default)
+        callback = @hash[name][0] if @hash[name]
+
+        if !callback.nil?
+          callback.call(*params)
+        elsif !default.nil?
+          default.call(*params)
+        else
+          fail ArgumentError, "Callback :#{name} is not registered."
+        end
+      end
+
+      private
+
+      # Gathers all calls.
+      def method_missing(name, *args, &block)
+        @hash[name] = [*args, block]
+      end
+    end
+  end
+end

data/lib/tablets/version.rb

@@ -0,0 +1,3 @@
+module Tablets
+  VERSION = '0.1.0'
+end

data/lib/tablets/view_helpers.rb

@@ -0,0 +1,14 @@
+require 'tablets/renderer'
+
+module Tablets
+  # View helpers included to Rails.
+  module ViewHelpers
+    # Finds tablet by name and renders is with params in current view context.
+    #
+    #  <%= render_tablet :posts, user_id: @user.id %>
+    #
+    def render_tablet(name, params = {})
+      Tablets::Renderer.new(Tablets[name], params).render(self)
+    end
+  end
+end

data/lib/tablets.rb

@@ -0,0 +1,19 @@
+require 'tablets/global/loader'
+require 'tablets/global/store'
+require 'tablets/global/configurator'
+
+# Top level tablets module. Extended with global tablets methods.
+module Tablets
+  autoload :Data, 'tablets/data'
+
+  extend Tablets::Global::Loader
+  extend Tablets::Global::Store
+  extend Tablets::Global::Configurator
+end
+
+require 'tablets/version'
+
+require 'tablets/tablet'
+
+require 'tablets/railtie'
+require 'tablets/engine'

data/spec/lib/tablets/data/processing/base_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+require 'tablets/data/processing/base'
+
+RSpec.describe Tablets::Data::Processing::Base do
+  subject { Tablets::Data::Processing::Base.new(params, columns) }
+
+  let(:relation) { 'relation' }
+  let(:params) { 'params' }
+  let(:columns) { 'columns' }
+
+  describe '#apply' do
+    it 'raises not implemented error' do
+      expect do
+        subject.apply(relation)
+      end.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/lib/tablets/data/processing/paginate_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+require 'tablets/data/processing/paginate'
+
+RSpec.describe Tablets::Data::Processing::Paginate do
+  subject { Tablets::Data::Processing::Paginate.new(params, columns) }
+
+  let(:relation) { double }
+  let(:params) { { start: start, length: length } }
+  let(:columns) { 'columns' }
+
+  describe '#apply' do
+    before do
+      allow(relation).to receive(:offset).with(anything).and_return(relation)
+      allow(relation).to receive(:limit).with(anything).and_return(relation)
+    end
+
+    let!(:result) { subject.apply(relation) }
+
+    context 'if start matches beginning of page' do
+      let(:start) { 30 }
+      let(:length) { 15 }
+
+      it 'applies start' do
+        expect(relation).to have_received(:offset).with(start)
+      end
+
+      it 'applies length' do
+        expect(relation).to have_received(:limit).with(length)
+      end
+
+      it 'returns relation' do
+        expect(result).to eq(relation)
+      end
+    end
+
+    context 'if start not matches beginning of page' do
+      let(:start) { 25 }
+      let(:page_start) { 15 }
+      let(:length) { 15 }
+
+      it 'applies page start' do
+        expect(relation).to have_received(:offset).with(page_start)
+      end
+
+      it 'applies length' do
+        expect(relation).to have_received(:limit).with(length)
+      end
+
+      it 'returns relation' do
+        expect(result).to eq(relation)
+      end
+    end
+
+    context 'without length' do
+      let(:default_length) { 10 }
+      let(:start) { 10 }
+      let(:params) { { start: start } }
+
+      it 'applies offset' do
+        expect(relation).to have_received(:offset)
+      end
+
+      it 'applies default length' do
+        expect(relation).to have_received(:limit).with(default_length)
+      end
+
+      it 'returns relation' do
+        expect(result).to eq(relation)
+      end
+    end
+  end
+end

data/spec/lib/tablets/global/store_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+require 'tablets/global/store'
+
+RSpec.describe Tablets::Global::Store do
+  subject { Object.new.tap { |object| object.extend(Tablets::Global::Store) } }
+
+  describe '#register' do
+    let(:name) { :posts }
+    let(:block) { proc {} }
+    let(:tablet) { double }
+
+    before do
+      subject.instance_eval { @tablets = {} }
+      allow(Tablets::Tablet).to receive(:new).with(name, &block)
+                                             .and_return(tablet)
+    end
+
+    let!(:result) { subject.register(name, &block) }
+
+    it 'initializes tablet' do
+      expect(Tablets::Tablet).to have_received(:new).with(name, &block)
+    end
+
+    it 'stores tablet' do
+      expect(subject.tablets).to eq(name => tablet)
+    end
+
+    it 'delegates [] to tablets' do
+      expect(subject[name]).to eq(subject.tablets[name])
+    end
+  end
+end

data/spec/lib/tablets/renderer_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+require 'tablets'
+require 'tablets/renderer'
+
+RSpec.describe Tablets::Renderer do
+  subject { Tablets::Renderer.new(tablet, params) }
+
+  describe '#render' do
+    let(:tablet) { double }
+    let(:params) { { user_id: 1 } }
+
+    let(:render_result) { 'result' }
+    let(:path) { 'path' }
+
+    let(:tablet_name) { :posts }
+    let(:tablet_columns) do
+      [{
+        title: 'Title',
+        order: 'posts.title',
+        data: :title,
+        options: { className: 'post-title' }
+      }, {
+        title: 'User',
+        order: ['users.first_name', 'users.last_name'],
+        data: :user,
+        search: ['users.first_name', 'users.last_name']
+      }]
+    end
+    let(:tablet_options) { { some_option: :some_value } }
+
+    let(:options) do
+      {
+        ajax: path,
+        columnDefs: [{
+          targets: 0,
+          searchable: false,
+          orderable: true,
+          className: 'post-title'
+        }, {
+          targets: 1,
+          searchable: true,
+          orderable: true
+        }]
+      }.merge!(tablet_options)
+    end
+
+    let(:view_context) { double }
+
+    before do
+      allow(tablet).to receive_messages(
+        name: tablet_name, columns: tablet_columns, options: tablet_options
+      )
+
+      allow(Tablets::Engine).to receive_message_chain(
+        :routes, :url_helpers, :data_path
+      ).and_return(path)
+
+      allow(view_context).to receive(:render).and_return(render_result)
+    end
+
+    let!(:result) { subject.render(view_context) }
+
+    def locals(local)
+      hash_including(locals: hash_including(local))
+    end
+
+    it 'renders tablets partial' do
+      expect(view_context).to have_received(:render).with(
+        hash_including(partial: 'tablets/tablet')
+      )
+    end
+
+    it 'passes correct id as partial locals' do
+      expect(view_context).to have_received(:render).with(
+        locals(id: 'posts_user_id_1')
+      )
+    end
+
+    it 'passes correct columns as partial locals' do
+      expect(view_context).to have_received(:render).with(
+        locals(columns: tablet_columns)
+      )
+    end
+
+    it 'passes correct config as partial locals' do
+      expect(view_context).to have_received(:render).with(
+        locals(options: hash_including(options))
+      )
+    end
+
+    it 'passes correct params as partial locals' do
+      expect(view_context).to have_received(:render).with(
+        locals(params: params)
+      )
+    end
+
+    it 'returns render result' do
+      expect(result).to eq(render_result)
+    end
+  end
+end

data/spec/lib/tablets/utils/config_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+require 'tablets/utils/config'
+
+RSpec.describe Tablets::Utils::Config do
+  subject { Tablets::Utils::Config.new(&block) }
+
+  def hash
+    subject.instance_eval { @hash }
+  end
+
+  describe '#initialize' do
+    context 'with block' do
+      let(:block) { proc { var('val') } }
+
+      it 'applies block to config' do
+        expect(hash).to_not be_empty
+      end
+    end
+
+    context 'without block' do
+      let(:block) { nil }
+
+      it 'initializes empty config' do
+        expect(hash).to be_empty
+      end
+    end
+  end
+
+  describe '#apply' do
+    let(:block) { nil }
+    let(:another_block) { proc { var('val') } }
+
+    it 'applies block' do
+      subject.apply(&another_block)
+
+      expect(hash).to_not be_empty
+    end
+  end
+
+  describe '#get' do
+    context 'if value exists' do
+      let(:block) { proc { var('val') } }
+
+      it 'returns value' do
+        expect(subject.get(:var)).to eq('val')
+      end
+    end
+
+    context 'if value not exists' do
+      let(:block) {}
+
+      it 'raises error' do
+        expect do
+          subject.get(:var)
+        end.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'if value not exists but have default' do
+      let(:block) {}
+
+      it 'returns default' do
+        expect(subject.get(:var, 'default')).to eq('default')
+      end
+    end
+
+    context 'if value not exists but have default block' do
+      let(:block) {}
+
+      it 'returns default block return value' do
+        expect(subject.get(:var) { 'default' }).to eq('default')
+      end
+    end
+  end
+
+  describe '#call' do
+    context 'if callback exists' do
+      let(:block) { proc { var { 'val' } } }
+
+      it 'returns callback return value' do
+        expect(subject.call(:var)).to eq('val')
+      end
+    end
+
+    context 'if callback not exists' do
+      let(:block) {}
+
+      it 'raises error' do
+        expect do
+          subject.call(:var)
+        end.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'if value not exists but have default block' do
+      let(:block) {}
+
+      it 'returns default block return value' do
+        expect(subject.call(:var) { 'default' }).to eq('default')
+      end
+    end
+  end
+end

data/spec/lib/tablets/view_helpers_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+require 'tablets'
+require 'tablets/view_helpers'
+
+RSpec.describe Tablets::ViewHelpers do
+  subject { Object.new.tap { |object| object.extend(Tablets::ViewHelpers) } }
+
+  describe '#render_tablet' do
+    let(:name) { :name }
+    let(:params) { 'params' }
+    let(:tablet) { double }
+    let(:renderer) { double }
+    let(:render_result) { 'render_result' }
+
+    before do
+      allow(Tablets).to receive(:[]).with(name).and_return(tablet)
+      allow(Tablets::Renderer).to receive(:new).with(tablet, params)
+                                               .and_return(renderer)
+      allow(renderer).to receive(:render).with(subject)
+                                         .and_return(render_result)
+    end
+
+    let!(:result) { subject.render_tablet(name, params) }
+
+    it 'finds tablet' do
+      expect(Tablets).to have_received(:[]).with(name)
+    end
+
+    it 'initializes renderer' do
+      expect(Tablets::Renderer).to have_received(:new).with(tablet, params)
+    end
+
+    it 'renders in current view context' do
+      expect(renderer).to have_received(:render).with(subject)
+    end
+
+    it 'returns render result' do
+      expect(result).to eq(render_result)
+    end
+  end
+end