datagrid 1.8.2 → 2.0.0

data/lib/datagrid/filters/composite_filters.rb

@@ -1,49 +0,0 @@
-module Datagrid
-  module Filters
-    # @!visibility private
-    module CompositeFilters
-
-      def self.included(base)
-        base.extend         ClassMethods
-        base.class_eval do
-        end
-      end
-
-      # @!visibility private
-      module ClassMethods
-
-        def date_range_filters(field, from_options = {}, to_options = {})
-          Utils.warn_once('date_range_filters is deprecated in favor of range option for date filter')
-          from_options = normalize_composite_filter_options(from_options, field)
-          to_options = normalize_composite_filter_options(to_options, field)
-
-          filter(from_options[:name] || :"from_#{field.to_s.tr('.', '_')}", :date, **from_options) do |date, scope, grid|
-            grid.driver.greater_equal(scope, field, date)
-          end
-          filter(to_options[:name] || :"to_#{field.to_s.tr('.', '_')}", :date, **to_options) do |date, scope, grid|
-            grid.driver.less_equal(scope, field, date)
-          end
-        end
-
-        def integer_range_filters(field, from_options = {}, to_options = {})
-          Utils.warn_once('integer_range_filters is deprecated in favor of range option for integer filter')
-          from_options = normalize_composite_filter_options(from_options, field)
-          to_options = normalize_composite_filter_options(to_options, field)
-          filter(from_options[:name] || :"from_#{field.to_s.tr('.', '_')}", :integer, **from_options) do |value, scope, grid|
-            grid.driver.greater_equal(scope, field, value)
-          end
-          filter(to_options[:name] || :"to_#{field.to_s.tr('.', '_')}", :integer, **to_options) do |value, scope, grid|
-            grid.driver.less_equal(scope, field, value)
-          end
-        end
-
-        def normalize_composite_filter_options(options, field)
-          if options.is_a?(String) || options.is_a?(Symbol)
-            options = {name: options}
-          end
-          options
-        end
-      end
-    end
-  end
-end

data/lib/datagrid/renderer.rb

@@ -1,157 +0,0 @@
-require "action_view"
-
-module Datagrid
-  # @!visibility private
-  class Renderer
-
-    def self.for(template)
-      new(template)
-    end
-
-    def initialize(template)
-      @template = template
-    end
-
-    def format_value(grid, column, asset)
-      if column.is_a?(String) || column.is_a?(Symbol)
-        column = grid.column_by_name(column)
-      end
-
-      value = grid.html_value(column, @template, asset)
-
-      url = column.options[:url] && column.options[:url].call(asset)
-      if url
-        @template.link_to(value, url)
-      else
-        value
-      end
-    end
-
-    def form_for(grid, options = {})
-      options[:method] ||= :get
-      options[:html] ||= {}
-      options[:html][:class] ||= "datagrid-form #{@template.dom_class(grid)}"
-      options[:as] ||= grid.param_name
-      _render_partial('form', options[:partials], {:grid => grid, :options => options})
-    end
-
-    def table(grid, assets, **options)
-      options[:html] ||= {}
-      options[:html][:class] ||= "datagrid #{@template.dom_class(grid)}"
-
-      _render_partial('table', options[:partials],
-                      {
-                        grid: grid,
-                        options: options,
-                        assets: assets
-                      })
-    end
-
-    def header(grid, options = {})
-      options[:order] = true unless options.has_key?(:order)
-
-      _render_partial('head', options[:partials],
-                      { :grid => grid, :options => options })
-    end
-
-    def rows(grid, assets = grid.assets, **options, &block)
-      result = assets.map do |asset|
-        row(grid, asset, **options, &block)
-      end.to_a.join
-
-      _safe(result)
-    end
-
-    def row(grid, asset, **options, &block)
-      Datagrid::Helper::HtmlRow.new(self, grid, asset, options).tap do |row|
-        if block_given?
-          return @template.capture(row, &block)
-        end
-      end
-    end
-
-    def order_for(grid, column, options = {})
-      _render_partial('order_for', options[:partials],
-                      { :grid => grid, :column => column })
-    end
-
-    def order_path(grid, column, descending, request)
-      column = grid.column_by_name(column)
-      query = request ? request.query_parameters : {}
-      ActionDispatch::Http::URL.path_for(
-        path: request ? request.path : '/',
-        params: query.merge(grid.query_params(order: column.name, descending: descending))
-      )
-    end
-
-    private
-
-    def _safe(string)
-      string.respond_to?(:html_safe) ? string.html_safe : string
-    end
-
-    def _render_partial(partial_name, partials_path, locals = {})
-      @template.render({
-        :partial => File.join(partials_path || 'datagrid', partial_name),
-        :locals => locals
-      })
-    end
-  end
-
-  module Helper
-    # Represents a datagrid row that provides access to column values for the given asset
-    # @example
-    #   row = datagrid_row(grid, user)
-    #   row.class      # => Datagrid::Helper::HtmlRow
-    #   row.first_name # => "<strong>Bogdan</strong>"
-    #   row.grid       # => Grid object
-    #   row.asset      # => User object
-    #   row.each do |value|
-    #     puts value
-    #   end
-    class HtmlRow
-
-      include Enumerable
-
-      attr_reader :grid, :asset, :options
-
-      # @!visibility private
-      def initialize(renderer, grid, asset, options)
-        @renderer = renderer
-        @grid = grid
-        @asset = asset
-        @options = options
-      end
-
-      # @return [Object] a column value for given column name
-      def get(column)
-        @renderer.format_value(@grid, column, @asset)
-      end
-
-      # Iterates over all column values that are available in the row
-      # param block [Proc] column value iterator
-      def each(&block)
-        (@options[:columns] || @grid.html_columns).each do |column|
-          block.call(get(column))
-        end
-      end
-
-      def to_s
-        @renderer.send(:_render_partial, 'row', options[:partials], {
-          :grid => grid,
-          :options => options,
-          :asset => asset
-        })
-      end
-
-      protected
-      def method_missing(method, *args, &blk)
-        if column = @grid.column_by_name(method)
-          get(column)
-        else
-          super
-        end
-      end
-    end
-  end
-end

data/lib/datagrid/scaffold.rb

@@ -1,129 +0,0 @@
-require "rails/generators"
-
-class Datagrid::Scaffold < Rails::Generators::NamedBase
-
-  include Rails::Generators::ResourceHelpers
-
-  check_class_collision suffix: "Grid"
-  source_root File.expand_path(__FILE__ + "/../../../templates")
-
-  def create_scaffold
-    unless file_exists?(base_grid_file)
-      template "base.rb.erb", base_grid_file
-    end
-    template "grid.rb.erb", "app/grids/#{grid_class_name.underscore}.rb"
-    if file_exists?(grid_controller_file)
-      inject_into_file grid_controller_file, index_action, after: %r{class .*#{grid_controller_class_name}.*\n}
-    else
-      template "controller.rb.erb", grid_controller_file
-    end
-    template "index.html.erb", view_file
-    route(generate_routing_namespace("resources :#{grid_controller_short_name}"))
-    unless defined?(::Kaminari) || defined?(::WillPaginate)
-      gem 'kaminari'
-    end
-    in_root do
-      {
-        "css" => " *= require datagrid",
-        "css.sass" => " *= require datagrid",
-        "css.scss" => " *= require datagrid",
-      }.each do |extension, string|
-        file = "app/assets/stylesheets/application.#{extension}"
-        if file_exists?(file)
-          inject_into_file file, string + "\n", {before: %r{.*require_self}} # before all
-        end
-      end
-    end
-  end
-
-  def view_file
-    Rails.root.join("app/views").join(controller_file_path).join("index.html.erb")
-  end
-
-  def grid_class_name
-    file_name.camelize.pluralize + "Grid"
-  end
-
-  def grid_controller_class_name
-    controller_class_name.camelize + "Controller"
-  end
-
-  def grid_controller_file
-    Rails.root.join("app/controllers").join("#{grid_controller_class_name.underscore}.rb")
-  end
-
-  def grid_controller_short_name
-    controller_file_name
-  end
-
-  def grid_model_name
-    file_name.camelize.singularize
-  end
-
-  def grid_param_name
-    grid_class_name.underscore
-  end
-
-  def pagination_helper_code
-    if defined?(::WillPaginate)
-      "will_paginate(@grid.assets)"
-    else
-      # Kaminari is default
-      "paginate(@grid.assets)"
-    end
-  end
-
-  def base_grid_file
-    "app/grids/base_grid.rb"
-  end
-
-  def grid_route_name
-    controller_class_name.underscore.gsub("/", "_") + "_path"
-  end
-
-  def index_action
-    indent(<<-RUBY)
-def index
-  @grid = #{grid_class_name}.new(grid_params) do |scope|
-    scope.page(params[:page])
-  end
-end
-
-protected
-
-def grid_params
-  params.fetch(:#{grid_param_name}, {}).permit!
-end
-RUBY
-  end
-
-  protected
-  def generate_routing_namespace(code)
-    depth = regular_class_path.length
-    # Create 'namespace' ladder
-    # namespace :foo do
-    #   namespace :bar do
-    namespace_ladder = regular_class_path.each_with_index.map do |ns, i|
-      indent("namespace :#{ns} do\n", i * 2)
-    end.join
-
-    # Create route
-    #     get 'baz/index'
-    route = indent(code, depth * 2)
-
-    # Create `end` ladder
-    #   end
-    # end
-    end_ladder = (1..depth).reverse_each.map do |i|
-      indent("end\n", i * 2)
-    end.join
-
-    # Combine the 3 parts to generate complete route entry
-    namespace_ladder + route + "\n" + end_ladder
-  end
-
-  def file_exists?(name)
-    name = Rails.root.join(name) unless name.to_s.first == "/"
-    File.exist?(name)
-  end
-end

data/lib/tasks/datagrid_tasks.rake

@@ -1,15 +0,0 @@
-namespace :datagrid do
-
-  desc "Copy table partials into rails application"
-  task :copy_partials do
-    require "fileutils"
-    views_path = "app/views/datagrid"
-    destination_dir = (Rails.root + views_path).to_s
-    pattern = File.expand_path(File.dirname(__FILE__) + "/../../#{views_path}") + "/*"
-    Dir[pattern].each do |template|
-      puts "* copy #{template} => #{destination_dir}"
-      FileUtils.mkdir_p destination_dir
-      FileUtils.cp template, destination_dir
-    end
-  end
-end

data/templates/controller.rb.erb

@@ -1,6 +0,0 @@
-class <%= grid_controller_class_name %> < ApplicationController
-
-<%= index_action -%>
-
-end
-

data/templates/index.html.erb

@@ -1,5 +0,0 @@
-<%%= datagrid_form_for @grid, method: :get, url: <%= grid_route_name %> %>
-
-<%%= <%=pagination_helper_code%> %>
-<%%= datagrid_table @grid %>
-<%%= <%=pagination_helper_code%> %>