tablets 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1a1fa5246fe01b026cb2cb2eea4d8a1bdf1bb864
+  data.tar.gz: d41e7ccd372d8f2a63b702c77521a874e4baf4bc
+SHA512:
+  metadata.gz: ab12d327506c9abfc4083855019fadffcddd399db62098b44f788a5abc91e823969df57e140214f9c5d38fb6047de374dc920281c128ae84c649d7c51235ac42
+  data.tar.gz: 8a0c9608f4dfb7deb525674287114fef5f6090bca34ec10daa1a0e8b8df4342c0cb7ae6b99382ff5053323774d63d2fa64b4c30cdfa16357b14a45a22bcb9563

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 Yevhen Shemet
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,90 @@
+# Tablets
+
+## Installation
+
+Add this line to your application's `Gemfile`:
+
+```ruby
+gem 'tablets'
+```
+
+Include tablets and jquery datatables scripts in your `app/assets/application.js`:
+```
+//= require dataTables/jquery.dataTables
+//= require tablets
+```
+
+Include jquery datatables styles in your `app/assets/application.css`:
+```
+ *= require dataTables/jquery.dataTables
+```
+
+Mount engine in `config/routes.rb`:
+```
+mount Tablets::Engine, at: '/tablets'
+```
+
+## Examples
+
+In `app/tablets/posts.rb`:
+```ruby
+Tablets.register :posts do
+  # Authorization logic.
+  authorize do |controller|
+    controller.current_user.id == params[:author_id]
+  end
+
+  # jQuery-datatables options overrides.
+  options do
+    { order: [0, 'asc'] }
+  end
+
+  # Columns definitions.
+  columns do
+    [{
+      title: 'Title',
+      order: 'posts.title',
+      data: :title,
+      options: { className: 'post-title' }
+    }, {
+      title: 'User',
+      order: ['users.first_name', 'users.last_name'],
+      data: ->(user) { [user.first_name, user.last_name].compact.join(' ') },
+      search: ['users.first_name', 'users.last_name']
+    }]
+  end
+
+  # HTML for details area.
+  details do |post|
+    post.content.html_safe
+  end
+
+  # Process records before extracting data.
+  process do |posts|
+    posts.map { |post| post.use_wrapper }
+  end
+
+  # Data relation.
+  relation do |params|
+    # Note: User joined to enable ordering.
+    User.joins(:users).where(user_id: params[:user_id])
+  end
+end
+```
+
+In `app/views/posts/index.html.erb`
+```erb
+<%= render_tablet :posts, user_id: current_user.id %>
+```
+
+## JavaScripts callbacks
+
+Called just before datatable initialization.
+```javascript
+Tablets.Callbacks.beforeInit = function(element, options) {}
+```
+
+Called after datatable initialization.
+```javascript
+Tablets.Callbacks.afterInit = function(table) {}
+```

data/Rakefile

@@ -0,0 +1,19 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Tablets'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core'
+require 'rspec/core/rake_task'

data/app/assets/javascripts/tablets/callbacks.js.coffee

@@ -0,0 +1,3 @@
+Tablets.Callbacks =
+  beforeInit: (element, options) ->
+  afterInit: (table) ->

data/app/assets/javascripts/tablets/tablet.js.coffee

@@ -0,0 +1,35 @@
+class Tablets.Tablet
+  constructor: (@element, @options, @params) ->
+    @initTable()
+    @initDetails()
+
+  dataTableOptions: ->
+    $.extend {}, @options,
+      fnServerParams: (data) =>
+        data.params = @params
+
+  initTable: ->
+    options = @dataTableOptions()
+
+    Tablets.Callbacks.beforeInit(@element, options)
+
+    @table = $(@element).DataTable(options)
+
+    Tablets.Callbacks.afterInit(@table)
+
+  initDetails: ->
+    table = @table
+    table.on 'click', 'tbody > tr[role=row] > td:first-child', ->
+      tr = $(this).closest 'tr'
+      row = table.row tr
+
+      if row.child.isShown()
+        row.child.hide()
+        tr.removeClass 'expanded'
+        tr.removeClass 'shown'
+      else
+        data = row.data().details
+        if data
+          row.child("<span>#{data}</span>").show()
+          tr.addClass 'expanded'
+          tr.addClass 'shown'

data/app/assets/javascripts/tablets.js.coffee

@@ -0,0 +1,4 @@
+#= require_self
+#= require_tree './tablets'
+
+@Tablets = {}

data/app/controllers/tablets/ajax_controller.rb

@@ -0,0 +1,31 @@
+module Tablets
+  # Responsible to provide data to tablet on ajax request.
+  class AjaxController < ApplicationController
+    before_filter :authorize!
+
+    def data
+      render json: Tablets::Data.new(tablet, data_params)
+    end
+
+    private
+
+    def tablet
+      @tablet ||= Tablets[params[:name].to_sym]
+    end
+
+    def authorize!
+      render nothing: true, status: 401 unless authorized?
+    end
+
+    def authorized?
+      tablet.authorize(self)
+    rescue
+      false
+    end
+
+    def data_params
+      params.slice(:name, :start, :length, :search,
+                   :order, :params, :draw, :columns)
+    end
+  end
+end

data/app/views/tablets/_tablet.html.erb

@@ -0,0 +1,21 @@
+<table class="table tablet" id="<%= id %>" data-name="<%= name %>">
+  <thead>
+    <tr>
+      <% columns.each.with_index do |column, index| %>
+        <th class="<%= 'nosort' unless column[:order].present? %>">
+          <%= column[:title] %>
+        </th>
+      <% end %>
+    </tr>
+  </thead>
+  <tbody>
+  </tbody>
+</table>
+
+<script>
+  new Tablets.Tablet(
+    $('#<%= id %>'),
+    <%= raw options.to_json %>,
+    <%= raw params.to_json %>
+  );
+</script>

data/config/routes.rb

@@ -0,0 +1,3 @@
+Tablets::Engine.routes.draw do
+  get 'ajax/:name/data', to: 'tablets/ajax#data', as: :data
+end

data/lib/tablets/data/processing/base.rb

@@ -0,0 +1,23 @@
+module Tablets
+  class Data
+    module Processing
+      # Base class for relation processings.
+      class Base
+        # Initializes processor with relation and data reqired for processing.
+        def initialize(params, columns)
+          @params = params
+          @columns = columns
+        end
+
+        # Applies processing on relation. Need to be implemented in descendants.
+        def apply(relation)
+          fail NotImplementedError, '#apply need to be overrided by processing.'
+        end
+
+        private
+
+        attr_reader :params, :columns
+      end
+    end
+  end
+end

data/lib/tablets/data/processing/filter.rb

@@ -0,0 +1,47 @@
+require 'tablets/utils/arel'
+
+require 'tablets/data/processing/base'
+
+module Tablets
+  class Data
+    module Processing
+      # Incapsulate relation filtering logic.
+      class Filter < Tablets::Data::Processing::Base
+        # Applies filter processing on relation.
+        def apply(relation)
+          search(relation)
+        end
+
+        private
+
+        # Applies search conditions if need.
+        def search(relation)
+          return relation unless params[:search].try(:[], :value).present?
+
+          conditions = build_conditions_for(params[:search][:value])
+          relation = relation.where(conditions) if conditions
+          relation
+        end
+
+        # Builds search conditions.
+        def build_conditions_for(query)
+          query.split(' ').map do |value|
+            searchable_columns.map do |column|
+              search_condition(column, value)
+            end.reduce(:or)
+          end.reduce(:and)
+        end
+
+        # Returns searchable columns.
+        def searchable_columns
+          columns.map { |column| column[:search] }.flatten.compact
+        end
+
+        # Returs search condition.
+        def search_condition(column, value)
+          Tablets::Utils::Arel.column(column).matches("%#{value}%")
+        end
+      end
+    end
+  end
+end

data/lib/tablets/data/processing/order.rb

@@ -0,0 +1,34 @@
+require 'tablets/data/processing/base'
+
+module Tablets
+  class Data
+    module Processing
+      # Incapsulate relation ordering logic.
+      class Order < Tablets::Data::Processing::Base
+        # Applies order processing on relation.
+        def apply(relation)
+          params[:order].values.inject(relation) do |relation, item|
+            relation.order("#{column(item)} #{direction(item)}")
+          end
+        end
+
+        private
+
+        # Determines order column from params.
+        def column(item)
+          columns[item[:column].to_i][:order]
+        end
+
+        # Determines order direction from params.
+        # ASC by default.
+        def direction(item)
+          if %w(ASC DESC).include?(item[:dir].upcase)
+            item[:dir].upcase
+          else
+            'ASC'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tablets/data/processing/paginate.rb

@@ -0,0 +1,40 @@
+require 'tablets/data/processing/base'
+
+module Tablets
+  class Data
+    module Processing
+      # Incapsulate relation pagination logic.
+      class Paginate < Tablets::Data::Processing::Base
+        # Applies :start and :length from params to relation
+        # as offset and limit.
+        # :length is optional. Default value is used if no length is provided.
+        # :start recalculated to match beginnning of page.
+        def apply(relation)
+          relation.offset(offset).limit(per_page)
+        end
+
+        private
+
+        # Calculates offset as beginning of page.
+        def offset
+          (page - 1) * per_page
+        end
+
+        # Calculates page from start.
+        def page
+          (params[:start].to_i / per_page) + 1
+        end
+
+        # Returns default length.
+        def default_length
+          10
+        end
+
+        # Returns length or default value.
+        def per_page
+          params.fetch(:length, default_length).to_i
+        end
+      end
+    end
+  end
+end

data/lib/tablets/data/query.rb

@@ -0,0 +1,61 @@
+require 'tablets/data/processing/filter'
+require 'tablets/data/processing/paginate'
+require 'tablets/data/processing/order'
+
+module Tablets
+  class Data
+    # Incapsulates database query.
+    class Query
+      # Initializes query with relation, params and columns.
+      def initialize(relation, params, columns)
+        @relation = relation
+        @params = params
+        @columns = columns
+      end
+
+      # Applies all processings on relation and returns it.
+      def fetch
+        result = relation
+        result = order(result)
+        result = filter(result)
+        result = paginate(result)
+        result
+      end
+
+      # Returns total records count before filter and pagination is applied.
+      def total
+        relation.count(:all)
+      end
+
+      # Returns records count after filter is applied but before pagination.
+      def filtered
+        filter(relation).count(:all)
+      end
+
+      private
+
+      attr_reader :relation, :params, :columns
+
+      # Applies order processing.
+      def order(records)
+        return records unless params[:order].present?
+
+        Tablets::Data::Processing::Order.new(params, columns).apply(records)
+      end
+
+      # Applies filter processing.
+      def filter(records)
+        return records unless params[:search].present?
+
+        Tablets::Data::Processing::Filter.new(params, columns).apply(records)
+      end
+
+      # Applies paginate processing.
+      def paginate(records)
+        return records if params.try(:[], :length) == '-1'
+
+        Tablets::Data::Processing::Paginate.new(params, columns).apply(records)
+      end
+    end
+  end
+end

data/lib/tablets/data.rb

@@ -0,0 +1,58 @@
+require 'tablets/data/query'
+
+module Tablets
+  # Responsible to fetch and prepare data for jquery-datatables.
+  class Data
+    # Initializes data with tablet and params.
+    def initialize(tablet, params)
+      @tablet = tablet
+      @params = params
+    end
+
+    # Prepares data to render as json.
+    def as_json(_options = {})
+      {
+        draw: params[:draw].to_i,
+        recordsTotal: query.total,
+        recordsFiltered: query.filtered,
+        data: data
+      }
+    end
+
+    private
+
+    attr_reader :params, :tablet
+
+    # Initializes query with concretized relation.
+    def query
+      @query ||= Tablets::Data::Query.new(tablet.relation(params[:params]),
+                                          params,
+                                          tablet.columns)
+    end
+
+    # Fetching records and applies process tablet callback on it.
+    def records
+      @records ||= tablet.process(query.fetch)
+    end
+
+    # Fetching columns data for each row using column[:data] value.
+    # If column[:data] is symbol send it to the record.
+    # If column[:data] is proc calls it on the record.
+    # Also appends details.
+    def data
+      records.map do |record|
+        tablet.columns.map.with_index do |column, index|
+          [index, cell(record, column)]
+        end.to_h.merge(details: tablet.details(record))
+      end
+    end
+
+    # Returns single cell value, for specified record and for specified column.
+    def cell(record, column)
+      case column[:data]
+        when Symbol then record.send(column[:data])
+        when Proc then column[:data].call(record)
+      end
+    end
+  end
+end

data/lib/tablets/engine.rb

@@ -0,0 +1,9 @@
+require 'rails/engine'
+
+module Tablets
+  # Rails mountable engine.
+  class Engine < ::Rails::Engine
+    require 'jquery-datatables-rails'
+    engine_name 'tablets'
+  end
+end

data/lib/tablets/global/configurator.rb

@@ -0,0 +1,49 @@
+require 'rails'
+
+module Tablets
+  module Global
+    # Responsible to make application configurable.
+    module Configurator
+      attr_accessor :options
+      attr_accessor :tablets_dir
+
+      # Setup configuration. Used in initializers.
+      def setup
+        yield self
+      end
+
+      # Initialize default config values.
+      def self.extended(base)
+        base.options = DEFAULT_OPTIONS
+        base.tablets_dir = File.expand_path('app/tablets', Rails.root)
+      end
+
+      DEFAULT_OPTIONS = {
+        pageLength: 15,
+        processing: false,
+        info: true,
+        lengthChange: false,
+        serverSide: true,
+        pagingType: 'full_numbers',
+        order: [0, 'asc'],
+        autoWidth: true,
+        orderCellsTop: true,
+        language: {
+          lengthMenu: '<span class=\'seperator\'>|</span>View _MENU_ records',
+          info: '<span class=\'seperator\'>|</span>Found total _TOTAL_ records',
+          infoEmpty: '',
+          emptyTable: 'No records found to show',
+          zeroRecords: 'No matching records found',
+          paginate: {
+            previous: 'Prev',
+            next: 'Next',
+            last: 'Last',
+            first: 'First',
+            page: 'Page',
+            pageOf: 'of'
+          }
+        }
+      }
+    end
+  end
+end

data/lib/tablets/global/loader.rb

@@ -0,0 +1,37 @@
+module Tablets
+  module Global
+    # Tablets loader. Manages files loading from app tablets directory.
+    module Loader
+      # Unloads tablet.
+      def unload!
+        @tablets = nil
+      end
+
+      # Checks if tablet is loading.
+      # Tablets is not loaded only if tablets is nil.
+      def loaded?
+        !@tablets.nil?
+      end
+
+      # Loads tablets files.
+      def load!
+        @tablets = {}
+        files.each { |file| load file }
+      end
+
+      private
+
+      # Load paths.
+      def load_paths
+        [Tablets.tablets_dir]
+      end
+
+      # Prepares files list using load paths.
+      def files
+        load_paths.flatten.compact.uniq.flat_map do |path|
+          Dir["#{path}/**/*.rb"]
+        end
+      end
+    end
+  end
+end

data/lib/tablets/global/store.rb

@@ -0,0 +1,25 @@
+require 'tablets/tablet'
+
+module Tablets
+  module Global
+    # Tables store.
+    # Expects @tablets to be defined elsewhere.
+    module Store
+      extend Forwardable
+
+      attr_reader :tablets
+
+      def_delegators :tablets, :[]
+
+      # Initializes tablet and put tablet into store.
+      #
+      #   Tablets.register(:user) do
+      #     # Tablet configuration.
+      #   end
+      #
+      def register(name, &block)
+        @tablets[name] = Tablets::Tablet.new(name, &block)
+      end
+    end
+  end
+end

data/lib/tablets/railtie.rb

@@ -0,0 +1,27 @@
+require 'rails/railtie'
+
+require 'tablets/view_helpers'
+
+module Tablets
+  # Rails hooks.
+  class Railtie < ::Rails::Railtie
+    # Allows tablets view helper to be used anywhere in rails views.
+    initializer 'tablets.view_helpers' do
+      ActionView::Base.send :include, Tablets::ViewHelpers
+    end
+
+    # Manages tablets loading and cleanup.
+    # Also ensures tablets reloading in development environment.
+    initializer 'tablets.reloader' do |app|
+      if app.config.reload_classes_only_on_change
+        ActionDispatch::Reloader.to_prepare(prepend: true) { Tablets.unload! }
+      else
+        ActionDispatch::Reloader.to_cleanup { Tablets.unload! }
+      end
+
+      ActionDispatch::Reloader.to_prepare do
+        Tablets.load! unless Tablets.loaded?
+      end
+    end
+  end
+end