dynatable_builder 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 13f04ec467ddd3c7e2c423f116f0251ffa29539d
+  data.tar.gz: eec1f0cc9d7c3c6df995c94d83ff2a64e80d5976
+SHA512:
+  metadata.gz: aae04a0ddb21748cf46e4051d4453fa61e3d4fb1c350151b8b581a85b2efd88acff7b463b9e0ccc3fcdf6a546da8f2e73f611d8f5c55f994403566a0d0ca3ade
+  data.tar.gz: d081ec36eba4928ecf5c902d03bcb51a9ab708245a16bc23b75fc0eee5c56923ba7ea7bbc0f6d46bd73425d1fa0ab9fdd59cfaa5e10fba31d2a3824ab00ff40d

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2014 YOURNAME
+
+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/Rakefile

@@ -0,0 +1,17 @@
+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    = 'DynatableBuilder'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks

data/app/assets/javascripts/dynatable_builder.js

@@ -0,0 +1,34 @@
+function DynatableBuilder(element) {
+  this.table = $(element);
+  this.sortDirection = this.table.data('order') || 'asc';
+  this.sortColumn = this.table.data('sort');
+  this.source = this.table.data('source') || document.URL;
+};
+
+DynatableBuilder.SORT_DIRECTIONS = { 'asc':  '1', 'desc': '-1' };
+
+DynatableBuilder.prototype.initialize = function() {
+  this.table.dynatable({
+    dataset: {
+      ajax: true,
+      ajaxUrl: this.source,
+      ajaxOnLoad: true,
+      records: [],
+      sorts: this.defaultSorts()
+    }
+  });
+};
+
+DynatableBuilder.prototype.defaultSorts = function() {
+  var sorts = {};
+  if (this.sortColumn) {
+    sorts[this.sortColumn] = DynatableBuilder.SORT_DIRECTIONS[this.sortDirection];
+  }
+  return sorts;
+};
+
+$(function() {
+  $('.dynatable').each(function() {
+    new DynatableBuilder(this).initialize();
+  });
+});

data/lib/dynatable_builder.rb

@@ -0,0 +1,8 @@
+require 'dynatable_builder/version'
+require 'dynatable_builder/search'
+require 'dynatable_builder/builder'
+require 'dynatable_builder/table'
+require 'dynatable_builder/engine' if defined?(Rails)
+
+module DynatableBuilder
+end

data/lib/dynatable_builder/builder.rb

@@ -0,0 +1,104 @@
+module DynatableBuilder
+  class Builder
+    attr_reader :columns, :includes, :joins, :defined_scope, :search, :view
+    delegate :total_count, to: :collection
+
+    def initialize(view, defined_scope, opts = {})
+      @view = view
+      @defined_scope = defined_scope
+
+      (opts[:helpers] || []).each { |h| add_helper(h) }
+
+      [:columns, :includes, :joins, :search].each do |arg|
+        instance_variable_set "@#{arg}", opts[arg]
+      end
+    end
+
+    def collection
+      @collection ||= fetch_collection
+    end
+
+    def to_builder
+      Jbuilder.new do |json|
+        json.records do
+          if columns
+            json.array! collection do |object|
+              if columns.respond_to?(:call)
+                generate_object_nodes(json, object)
+              else
+                json.extract!(object, *columns)
+              end
+            end
+          else
+            json.array! collection
+          end
+        end
+
+        json.queryRecordCount total_count
+        json.totalRecordCount total_count
+      end
+    end
+
+    def as_json
+      to_builder.attributes!
+    end
+
+    def to_json
+      to_builder.target!
+    end
+
+    def add_helper(helper = nil, &block)
+      helper = block if block_given?
+      if helper.respond_to?(:call)
+        extend Module.new(&helper)
+      else
+        extend helper
+      end
+    end
+
+    def respond_to?(method, include_private = false)
+      view.respond_to?(method, include_private) || super
+    end
+
+    private
+
+    def generate_object_nodes(json, object)
+      instance_exec(json, object, &columns)
+    end
+
+    def sorts
+      view.params[:sorts] && view.params[:sorts].map do |k, v|
+        "#{k} #{v.to_i < 0 ? 'desc' : 'asc'}"
+      end
+    end
+
+    def search_query
+      view.params.key?(:queries) && view.params[:queries][:search]
+    end
+
+    def fetch_collection
+      scope = base_scope
+      scope = scope.joins(joins) if joins.present?
+      scope = scope.includes(includes) if includes.present?
+      scope = Search.new(scope, search).perform(search_query) if search_query
+      scope = scope.order(sorts) if sorts.present?
+      scope.page(view.params[:page]).per(view.params[:perPage])
+    end
+
+    def base_scope
+      if defined_scope.respond_to?(:call)
+        instance_eval &defined_scope
+      else
+        defined_scope
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      if view.respond_to?(method)
+        view.send(method, *args, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/dynatable_builder/engine.rb

@@ -0,0 +1,9 @@
+require 'dynatable_builder/view_helpers'
+
+module DynatableBuilder
+  class Engine < Rails::Engine
+    initializer 'dynatable_builder.view_helpers' do
+      ActionView::Base.send :include, DynatableBuilder::ViewHelpers
+    end
+  end
+end

data/lib/dynatable_builder/search.rb

@@ -0,0 +1,63 @@
+module DynatableBuilder
+  class Search
+    attr_reader :defined_search, :scope
+
+    def initialize(scope, defined_search)
+      @scope          = scope
+      @defined_search = defined_search
+    end
+
+    def perform(search_term)
+      if defined_search.present?
+        if defined_search.respond_to?(:call) # is it a proc?
+          defined_search.call(scope, search_term)
+        else
+          query_with_column_list(search_term)
+        end
+      elsif scope.respond_to?(:search)
+        scope.search(search_term)
+      else
+        fail NotDefined, 'You need to either define self.search ' \
+          'on your model or provide a search block in your table.'
+      end
+    end
+
+    private
+
+    def table_name(model)
+      model.to_s.camelize.constantize.table_name
+    rescue NameError => e
+      raise ModelNotFound, "Couldn't find model called #{model.to_s.camelize}: #{e}"
+    end
+
+    def search_columns
+      defined_search.map do |column|
+        next column unless column.respond_to?(:keys)
+        model, col_name = column.first
+        table = table_name(model)
+
+        if col_name.respond_to?(:first) # value is array?
+          col_name.map { |c| "#{table}.#{c}" }
+        else
+          "#{table}.#{col_name}"
+        end
+      end.flatten
+    end
+
+    def query_with_column_list(search_term)
+      sql, values = [], []
+
+      search_columns.each do |column|
+        search_term.downcase.split.each do |word|
+          sql    << "lower(#{column}) like ?"
+          values << "%#{word}%"
+        end
+      end
+
+      scope.where(sql.join(' OR '), *values)
+    end
+
+    class ModelNotFound < StandardError; end
+    class NotDefined < StandardError; end
+  end
+end

data/lib/dynatable_builder/table.rb

@@ -0,0 +1,74 @@
+require 'jbuilder'
+
+module DynatableBuilder
+  class Table
+    attr_reader :view, :builder
+
+    delegate :collection, :total_count, :to_builder, to: :builder
+
+    class_attribute :defined_columns, :defined_includes, :defined_joins,
+                    :defined_scope, :defined_search, :defined_helpers
+
+    def initialize(view)
+      @view = view
+      @builder = Builder.new(@view, self.class.base_scope, {
+        columns: defined_columns,
+        includes: defined_includes,
+        joins: defined_joins,
+        search: defined_search,
+        helpers: defined_helpers
+      })
+    end
+
+    def to_json(opts = {})
+      builder.to_json
+    end
+
+    def as_json(opts = {})
+      builder.as_json
+    end
+
+    class << self
+      def scope(model_name = nil, &block)
+        self.defined_scope = block_given? ? block : model_name
+      end
+
+      def columns(*cols, &block)
+        if block_given?
+          self.defined_columns = block
+        else
+          (self.defined_columns ||= []) << cols
+          self.defined_columns.flatten!
+        end
+      end
+
+      def search(*cols, &block)
+        if block_given?
+          self.defined_search = block
+        else
+          (self.defined_search ||= []) << cols
+          self.defined_search.flatten!
+        end
+      end
+
+      def includes(*args)
+        (self.defined_includes ||= []) << args
+        self.defined_includes.flatten!
+      end
+
+      def joins(*args)
+        (self.defined_joins ||= []) << args
+        self.defined_joins.flatten!
+      end
+
+      def helpers(*mod_or_mods, &block)
+        (self.defined_helpers ||= []) << (block || mod_or_mods)
+        self.defined_helpers.flatten!
+      end
+
+      def base_scope
+        defined_scope.presence || name.gsub(/Table/, '').singularize.constantize
+      end
+    end
+  end
+end

data/lib/dynatable_builder/version.rb

@@ -0,0 +1,3 @@
+module DynatableBuilder
+  VERSION = '0.0.1'
+end

data/lib/dynatable_builder/view_helpers.rb

@@ -0,0 +1,86 @@
+module DynatableBuilder
+  module ViewHelpers
+    class Builder
+      include ActionView::Context
+      include ActionView::Helpers::TagHelper
+
+      attr_reader :view, :columns, :table_opts
+
+      def initialize(view, opts = {})
+        @view = view
+        @columns = []
+        @table_opts = opts
+      end
+
+      def column(title, opts = {})
+        col_opts, dyna_opts = { title: title }, {}
+        col_opts.merge! opts.except(:model, :attribute, :sort)
+
+        dyna_opts[:dynatable_column] = opts[:attribute] || title.underscore.tr(' ', '_')
+
+        if opts[:sort] == false
+          dyna_opts[:dynatable_no_sort] = true
+        else
+          dyna_opts[:dynatable_sorts] = opts[:sort] || dyna_opts[:dynatable_column].dup
+
+          if model_name = opts[:model] || table_opts[:model]
+            dyna_opts[:dynatable_sorts].prepend "#{table_name(model_name)}."
+          end
+
+          if direction = opts[:default_sort]
+            table_opts[:sort]  = dyna_opts[:dynatable_sorts]
+            table_opts[:order] = direction
+          end
+        end
+
+        columns << col_opts.merge(data: dyna_opts)
+        nil
+      end
+
+      def evaluate(&block)
+        with_output_buffer { instance_eval(&block) }
+      end
+
+      def render
+        # Without an id, multiple dynatables will conflict
+        table_opts[:id] ||= "dynatable#{rand(1..100)}"
+        table_opts[:class] = [table_opts[:class], 'dynatable'].compact.join(' ')
+        (table_opts[:data] ||= {}).merge! table_opts.slice(:source, :sort, :order)
+
+        content_tag(:table, table_opts.except(:model, :source, :sort, :order)) do
+          content_tag(:thead) do
+            columns.map do |column_opts|
+              content_tag(:th, column_opts[:title], column_opts.except(:title))
+            end.join('').html_safe
+          end
+        end
+      end
+
+      def respond_to?(method, include_private = false)
+        view.respond_to?(method, include_private) || super
+      end
+
+      private
+
+      def method_missing(method, *args, &block)
+        if view.respond_to?(method)
+          view.send(method, *args, &block)
+        else
+          super
+        end
+      end
+
+      def table_name(model_name)
+        model_name.to_s.camelize.constantize.table_name
+      rescue NameError
+        raise "Couldn't find a model named #{model_name}. Maybe you mispelled it?"
+      end
+    end
+
+    def dynatable(opts = {}, &block)
+      builder = DynatableBuilder::ViewHelpers::Builder.new(self, opts)
+      builder.evaluate &block
+      builder.render
+    end
+  end
+end

data/lib/generators/dynatable_generator.rb

@@ -0,0 +1,39 @@
+class DynatableGenerator < Rails::Generators::Base
+  source_root File.expand_path('../templates', __FILE__)
+  argument :model_name, type: :string
+
+  def create_table_file
+    template 'table.rb', "app/tables/#{plural_instance_name}_table.rb"
+  end
+
+  def create_view
+    app = ::Rails.application
+    ext = app.config.generators.options[:rails][:template_engine] || :erb
+    template "index.html.#{ext}", "app/views/#{plural_instance_name}/index.html.#{ext}"
+  end
+
+  def notify_controller_info
+    puts <<-EOS
+\nChange your index route in app/controllers/#{plural_instance_name}_controller.rb to the following:
+
+def index
+  respond_to do |format|
+    format.html
+    format.json { render json: #{model.name.pluralize}Table.new(view_context).to_builder.target! }
+  end
+end
+    EOS
+  end
+
+  def model
+    model_name.camelize.constantize
+  end
+
+  def model_instance_name
+    model_name.underscore
+  end
+
+  def plural_instance_name
+    model_instance_name.pluralize
+  end
+end