mini-max-mod 0.0.1

data/administrate-1.0.0/lib/administrate/order.rb

@@ -0,0 +1,150 @@
+module Administrate
+  class Order
+    def initialize(attribute = nil, direction = nil, sorting_column: nil)
+      @attribute = attribute
+      @direction = sanitize_direction(direction)
+      @sorting_column = sorting_column || attribute
+    end
+
+    def apply(relation)
+      return order_by_association(relation) unless
+        reflect_association(relation).nil?
+
+      order = relation.arel_table[sorting_column].public_send(direction)
+
+      return relation.reorder(order) if
+        column_exist?(relation, sorting_column)
+
+      relation
+    end
+
+    def ordered_by?(attr)
+      attr.to_s == attribute.to_s
+    end
+
+    def order_params_for(attr)
+      {
+        order: attr,
+        direction: reversed_direction_param_for(attr)
+      }
+    end
+
+    attr_reader :direction
+
+    private
+
+    attr_reader :attribute, :sorting_column
+
+    def sanitize_direction(direction)
+      %w[asc desc].include?(direction.to_s) ? direction.to_sym : :asc
+    end
+
+    def reversed_direction_param_for(attr)
+      if ordered_by?(attr)
+        opposite_direction
+      else
+        :asc
+      end
+    end
+
+    def opposite_direction
+      (direction == :asc) ? :desc : :asc
+    end
+
+    def order_by_association(relation)
+      case relation_type(relation)
+      when :has_many
+        order_by_count(relation)
+      when :belongs_to
+        order_by_belongs_to(relation)
+      when :has_one
+        order_by_has_one(relation)
+      else
+        relation
+      end
+    end
+
+    def order_by_count(relation)
+      klass = reflect_association(relation).klass
+      query = klass.arel_table[klass.primary_key].count.public_send(direction)
+      relation
+        .left_joins(attribute.to_sym)
+        .group(:id)
+        .reorder(query)
+    end
+
+    def order_by_belongs_to(relation)
+      if ordering_by_association_column?(relation)
+        order_by_association_attribute(relation)
+      else
+        order_by_id(relation)
+      end
+    end
+
+    def order_by_has_one(relation)
+      if ordering_by_association_column?(relation)
+        order_by_association_attribute(relation)
+      else
+        order_by_association_id(relation)
+      end
+    end
+
+    def order_by_id(relation)
+      relation.reorder(order_by_id_query(relation))
+    end
+
+    def ordering_by_association_column?(relation)
+      (attribute != sorting_column) &&
+        column_exist?(
+          reflect_association(relation).klass, sorting_column.to_sym
+        )
+    end
+
+    def column_exist?(table, column_name)
+      table.columns_hash.key?(column_name.to_s)
+    end
+
+    def order_by_id_query(relation)
+      relation.arel_table[association_foreign_key(relation)].public_send(direction)
+    end
+
+    def order_by_association_id(relation)
+      order_by_association_column(relation, association_primary_key(relation))
+    end
+
+    def order_by_association_attribute(relation)
+      order_by_association_column(relation, sorting_column)
+    end
+
+    def order_by_association_column(relation, column_name)
+      relation.joins(
+        attribute.to_sym
+      ).reorder(order_by_association_column_query(relation, column_name))
+    end
+
+    def order_by_association_column_query(relation, column)
+      table = Arel::Table.new(association_table_name(relation))
+      table[column].public_send(direction)
+    end
+
+    def relation_type(relation)
+      reflect_association(relation).macro
+    end
+
+    def reflect_association(relation)
+      relation.klass.reflect_on_association(attribute.to_s)
+    end
+
+    def association_foreign_key(relation)
+      reflect_association(relation).foreign_key
+    end
+
+    def association_primary_key(relation)
+      reflect_association(relation).association_primary_key
+    end
+
+    def association_table_name(relation)
+      reflect_association(relation).table_name
+    end
+  end
+end

data/administrate-1.0.0/lib/administrate/page/base.rb

@@ -0,0 +1,40 @@
+module Administrate
+  module Page
+    class Base
+      def initialize(dashboard, options = {})
+        @dashboard = dashboard
+        @options = options
+      end
+
+      def resource_name
+        @resource_name ||=
+          dashboard.class.to_s.scan(/(.+)Dashboard/).first.first.underscore
+      end
+
+      def resource_path
+        @resource_path ||= resource_name.tr("/", "_")
+      end
+
+      def collection_includes
+        dashboard.try(:collection_includes) || []
+      end
+
+      def item_includes
+        dashboard.try(:item_includes) || []
+      end
+
+      def item_associations
+        dashboard.try(:item_associations) || []
+      end
+
+      private
+
+      def attribute_field(dashboard, resource, attribute_name, page)
+        field = dashboard.attribute_type_for(attribute_name)
+        field.new(attribute_name, nil, page, resource: resource)
+      end
+
+      attr_reader :dashboard, :options
+    end
+  end
+end

data/administrate-1.0.0/lib/administrate/page/collection.rb

@@ -0,0 +1,38 @@
+require_relative "base"
+
+module Administrate
+  module Page
+    class Collection < Page::Base
+      def attribute_names
+        options.fetch(:collection_attributes, nil) ||
+          dashboard.collection_attributes
+      end
+
+      def attributes_for(resource)
+        attribute_names.map do |attr_name|
+          attribute_field(dashboard, resource, attr_name, :index)
+        end
+      end
+
+      def attribute_types
+        dashboard.attribute_types_for(attribute_names)
+      end
+
+      def ordered_html_class(attr)
+        ordered_by?(attr) && order.direction
+      end
+
+      delegate :ordered_by?, to: :order
+
+      def order_params_for(attr, key: resource_name)
+        {key => order.order_params_for(attr)}
+      end
+
+      private
+
+      def order
+        options[:order] || Order.new
+      end
+    end
+  end
+end

data/administrate-1.0.0/lib/administrate/page/form.rb

@@ -0,0 +1,36 @@
+require_relative "base"
+
+module Administrate
+  module Page
+    class Form < Page::Base
+      def initialize(dashboard, resource)
+        super(dashboard)
+        @resource = resource
+      end
+
+      attr_reader :resource
+
+      def attributes(action = nil)
+        attributes = dashboard.form_attributes(action)
+
+        if attributes.is_a? Array
+          attributes = {"" => attributes}
+        end
+
+        attributes.transform_values do |attrs|
+          attrs.map do |attribute|
+            attribute_field(dashboard, resource, attribute, :form)
+          end
+        end
+      end
+
+      def page_title
+        dashboard.display_resource(resource)
+      end
+
+      private
+
+      attr_reader :dashboard
+    end
+  end
+end

data/administrate-1.0.0/lib/administrate/page/show.rb

@@ -0,0 +1,32 @@
+require_relative "base"
+
+module Administrate
+  module Page
+    class Show < Page::Base
+      def initialize(dashboard, resource)
+        super(dashboard)
+        @resource = resource
+      end
+
+      attr_reader :resource
+
+      def page_title
+        dashboard.display_resource(resource)
+      end
+
+      def attributes
+        attributes = dashboard.show_page_attributes
+
+        if attributes.is_a? Array
+          attributes = {"" => attributes}
+        end
+
+        attributes.transform_values do |attrs|
+          attrs.map do |attr_name|
+            attribute_field(dashboard, resource, attr_name, :show)
+          end
+        end
+      end
+    end
+  end
+end

data/administrate-1.0.0/lib/administrate/page.rb

@@ -0,0 +1,4 @@
+module Administrate
+  module Page
+  end
+end

data/administrate-1.0.0/lib/administrate/resource_resolver.rb

@@ -0,0 +1,44 @@
+module Administrate
+  class ResourceResolver
+    def initialize(controller_path)
+      @controller_path = controller_path
+    end
+
+    def dashboard_class
+      ActiveSupport::Inflector.constantize("#{resource_class_name}Dashboard")
+    end
+
+    def namespace
+      controller_path.split("/").first.to_sym
+    end
+
+    def resource_class
+      ActiveSupport::Inflector.constantize(resource_class_name)
+    end
+
+    def resource_name
+      model_path_parts.map(&:underscore).join("__").to_sym
+    end
+
+    def resource_title
+      resource_class.model_name.human
+    end
+
+    private
+
+    def resource_class_name
+      model_path_parts.join("::")
+    end
+
+    def model_path_parts
+      controller_path_parts.map(&:camelize)
+    end
+
+    def controller_path_parts
+      path_parts = controller_path.split("/")[1..]
+      path_parts << path_parts.pop.singularize
+    end
+
+    attr_reader :controller_path
+  end
+end

data/administrate-1.0.0/lib/administrate/search.rb

@@ -0,0 +1,167 @@
+require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/object/blank"
+
+module Administrate
+  class Search
+    class Query
+      attr_reader :filters, :valid_filters
+
+      def blank?
+        terms.blank? && filters.empty?
+      end
+
+      def initialize(original_query, valid_filters = nil)
+        @original_query = original_query
+        @valid_filters = valid_filters
+        @filters, @terms = parse_query(original_query)
+      end
+
+      def original
+        @original_query
+      end
+
+      def terms
+        @terms.join(" ")
+      end
+
+      def to_s
+        original
+      end
+
+      private
+
+      def filter?(word)
+        valid_filters&.any? { |filter| word.match?(/^#{filter}:/) }
+      end
+
+      def parse_query(query)
+        filters = []
+        terms = []
+        query.to_s.split.each do |word|
+          if filter?(word)
+            filters << word
+          else
+            terms << word
+          end
+        end
+        [filters, terms]
+      end
+    end
+
+    def initialize(scoped_resource, dashboard, term)
+      @dashboard = dashboard
+      @scoped_resource = scoped_resource
+      @query = Query.new(term, valid_filters.keys)
+    end
+
+    def run
+      if query.blank?
+        @scoped_resource.all
+      else
+        results = search_results(@scoped_resource)
+        filter_results(results)
+      end
+    end
+
+    def valid_filters
+      if @dashboard.class.const_defined?(:COLLECTION_FILTERS)
+        @dashboard.class.const_get(:COLLECTION_FILTERS).stringify_keys
+      else
+        {}
+      end
+    end
+
+    private
+
+    def apply_filter(filter, filter_param, resources)
+      return resources unless filter
+      if filter.parameters.size == 1
+        filter.call(resources)
+      else
+        filter.call(resources, filter_param)
+      end
+    end
+
+    def filter_results(resources)
+      query.filters.each do |filter_query|
+        filter_name, filter_param = filter_query.split(":")
+        filter = valid_filters[filter_name]
+        resources = apply_filter(filter, filter_param, resources)
+      end
+      resources
+    end
+
+    def query_template
+      search_attributes.map do |attr|
+        table_name = query_table_name(attr)
+        searchable_fields(attr).map do |field|
+          column_name = column_to_query(field)
+          "LOWER(CAST(#{table_name}.#{column_name} AS CHAR(256))) LIKE ?"
+        end.join(" OR ")
+      end.join(" OR ")
+    end
+
+    def searchable_fields(attr)
+      return [attr] unless association_search?(attr)
+
+      attribute_types[attr].searchable_fields
+    end
+
+    def query_values
+      fields_count = search_attributes.sum do |attr|
+        searchable_fields(attr).count
+      end
+      ["%#{term.mb_chars.downcase}%"] * fields_count
+    end
+
+    def search_attributes
+      @dashboard.search_attributes
+    end
+
+    def search_results(resources)
+      resources
+        .left_joins(tables_to_join)
+        .where(query_template, *query_values)
+    end
+
+    def attribute_types
+      @dashboard.class.const_get(:ATTRIBUTE_TYPES)
+    end
+
+    def query_table_name(attr)
+      if association_search?(attr)
+        provided_class_name = attribute_types[attr].options[:class_name]
+        unquoted_table_name =
+          if provided_class_name
+            provided_class_name.constantize.table_name
+          else
+            @scoped_resource.reflect_on_association(attr).klass.table_name
+          end
+        ActiveRecord::Base.connection.quote_table_name(unquoted_table_name)
+      else
+        ActiveRecord::Base.connection
+          .quote_table_name(@scoped_resource.table_name)
+      end
+    end
+
+    def column_to_query(attr)
+      ActiveRecord::Base.connection.quote_column_name(attr)
+    end
+
+    def tables_to_join
+      attribute_types.keys.select do |attribute|
+        attribute_types[attribute].searchable? && association_search?(attribute)
+      end
+    end
+
+    def association_search?(attribute)
+      attribute_types[attribute].associative?
+    end
+
+    def term
+      query.terms
+    end
+
+    attr_reader :resolver, :query
+  end
+end

data/administrate-1.0.0/lib/administrate/version.rb

@@ -0,0 +1,3 @@
+module Administrate
+  VERSION = "1.0.0".freeze
+end

data/administrate-1.0.0/lib/administrate/view_generator.rb

@@ -0,0 +1,48 @@
+require "rails/generators/base"
+require "administrate/generator_helpers"
+require "administrate/namespace"
+
+module Administrate
+  class ViewGenerator < Rails::Generators::Base
+    include Administrate::GeneratorHelpers
+
+    class_option(
+      :namespace,
+      type: :string,
+      desc: "Namespace where the admin dashboards live",
+      default: "admin"
+    )
+
+    def self.template_source_path
+      File.expand_path(
+        "../../../app/views/administrate/application",
+        __FILE__
+      )
+    end
+
+    private
+
+    def namespace
+      options[:namespace]
+    end
+
+    def copy_resource_template(template_name)
+      template_file = "#{template_name}.html.erb"
+
+      copy_file(
+        template_file,
+        "app/views/#{namespace}/#{resource_path}/#{template_file}"
+      )
+    end
+
+    def resource_path
+      args.first.try(:underscore).try(:pluralize) || BaseResourcePath.new
+    end
+
+    class BaseResourcePath
+      def to_s
+        "application"
+      end
+    end
+  end
+end

data/administrate-1.0.0/lib/administrate.rb

@@ -0,0 +1,8 @@
+require "administrate/engine"
+require "administrate/version"
+
+module Administrate
+  def self.deprecator
+    @deprecator ||= ActiveSupport::Deprecation.new(VERSION, "Administrate")
+  end
+end

data/administrate-1.0.0/lib/generators/administrate/dashboard/USAGE

@@ -0,0 +1,9 @@
+Description:
+    Generates a Dashboard object for a model,
+    pulling the attributes from database columns.
+
+Example:
+    rails generate administrate:dashboard FooBar [--namespace admin]
+
+    This will create:
+        app/dashboards/foo_bar_dashboard.rb