viniBaxterDesk 0.13.1

data/lib/administrate/field/has_many.rb

@@ -0,0 +1,94 @@
+require_relative "associative"
+require "administrate/page/collection"
+require "administrate/order"
+
+module Administrate
+  module Field
+    class HasMany < Associative
+      DEFAULT_LIMIT = 5
+
+      def self.permitted_attribute(attr, _options = nil)
+        { "#{attr.to_s.singularize}_ids".to_sym => [] }
+      end
+
+      def associated_collection(order = self.order)
+        Administrate::Page::Collection.new(associated_dashboard, order: order)
+      end
+
+      def attribute_key
+        permitted_attribute.keys.first
+      end
+
+      def associated_resource_options
+        candidate_resources.map do |resource|
+          [display_candidate_resource(resource), resource.send(primary_key)]
+        end
+      end
+
+      def selected_options
+        return if data.empty?
+
+        data.map { |object| object.send(primary_key) }
+      end
+
+      def limit
+        options.fetch(:limit, DEFAULT_LIMIT)
+      end
+
+      def permitted_attribute
+        self.class.permitted_attribute(attribute)
+      end
+
+      def resources(page = 1, order = self.order)
+        resources = order.apply(data).page(page).per(limit)
+        includes.any? ? resources.includes(*includes) : resources
+      end
+
+      def more_than_limit?
+        data.count(:all) > limit
+      end
+
+      def data
+        @data ||= associated_class.none
+      end
+
+      def order_from_params(params)
+        Administrate::Order.new(
+          params.fetch(:order, sort_by),
+          params.fetch(:direction, direction),
+        )
+      end
+
+      def order
+        @order ||= Administrate::Order.new(sort_by, direction)
+      end
+
+      private
+
+      def includes
+        associated_dashboard.collection_includes
+      end
+
+      def candidate_resources
+        if options.key?(:includes)
+          includes = options.fetch(:includes)
+          associated_class.includes(*includes).all
+        else
+          associated_class.all
+        end
+      end
+
+      def display_candidate_resource(resource)
+        associated_dashboard.display_resource(resource)
+      end
+
+      def sort_by
+        options[:sort_by]
+      end
+
+      def direction
+        options[:direction]
+      end
+    end
+  end
+end

data/lib/administrate/field/has_one.rb

@@ -0,0 +1,35 @@
+require_relative "associative"
+
+module Administrate
+  module Field
+    class HasOne < Associative
+      def self.permitted_attribute(attr, options = nil)
+        associated_class_name =
+          if options
+            options.fetch(:class_name, attr.to_s.singularize.camelcase)
+          else
+            attr
+          end
+        related_dashboard_attributes =
+          Administrate::ResourceResolver.new("admin/#{associated_class_name}").
+            dashboard_class.new.permitted_attributes + [:id]
+
+        { "#{attr}_attributes": related_dashboard_attributes }
+      end
+
+      def nested_form
+        @nested_form ||= Administrate::Page::Form.new(
+          resolver.dashboard_class.new,
+          data || resolver.resource_class.new,
+        )
+      end
+
+      private
+
+      def resolver
+        @resolver ||=
+          Administrate::ResourceResolver.new("admin/#{associated_class_name}")
+      end
+    end
+  end
+end

data/lib/administrate/field/number.rb

@@ -0,0 +1,35 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Number < Field::Base
+      def to_s
+        data.nil? ? "-" : format_string % value
+      end
+
+      private
+
+      def format_string
+        prefix + "%.#{decimals}f" + suffix
+      end
+
+      def prefix
+        options[:prefix].to_s
+      end
+
+      def suffix
+        options[:suffix].to_s
+      end
+
+      def decimals
+        _left, right = data.to_s.split(".")
+        default = right.nil? ? 0 : right.size
+        options.fetch(:decimals, default)
+      end
+
+      def value
+        data * options.fetch(:multiplier, 1)
+      end
+    end
+  end
+end

data/lib/administrate/field/password.rb

@@ -0,0 +1,25 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Password < Field::Base
+      def self.searchable?
+        false
+      end
+
+      def truncate
+        data.to_s.gsub(/./, character)[0...truncation_length]
+      end
+
+      private
+
+      def truncation_length
+        options.fetch(:truncate, 50)
+      end
+
+      def character
+        options.fetch(:character, "•")
+      end
+    end
+  end
+end

data/lib/administrate/field/polymorphic.rb

@@ -0,0 +1,51 @@
+require_relative "associative"
+
+module Administrate
+  module Field
+    class Polymorphic < BelongsTo
+      def self.permitted_attribute(attr, _options = nil)
+        { attr => %i{type value} }
+      end
+
+      def associated_resource_grouped_options
+        classes.map do |klass|
+          [klass.to_s, candidate_resources_for(klass).map do |resource|
+            [display_candidate_resource(resource), resource.to_global_id]
+          end]
+        end
+      end
+
+      def permitted_attribute
+        { attribute => %i{type value} }
+      end
+
+      def selected_global_id
+        data ? data.to_global_id : nil
+      end
+
+      protected
+
+      def associated_dashboard(klass = data.class)
+        "#{klass.name}Dashboard".constantize.new
+      end
+
+      def classes
+        options.fetch(:classes, [])
+      end
+
+      private
+
+      def order
+        @_order ||= options.delete(:order)
+      end
+
+      def candidate_resources_for(klass)
+        order ? klass.order(order) : klass.all
+      end
+
+      def display_candidate_resource(resource)
+        associated_dashboard(resource.class).display_resource(resource)
+      end
+    end
+  end
+end

data/lib/administrate/field/select.rb

@@ -0,0 +1,24 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Select < Field::Base
+      def self.searchable?
+        true
+      end
+
+      def selectable_options
+        collection
+      end
+
+      private
+
+      def collection
+        maybe_proc = options.fetch(:collection, [])
+        return maybe_proc.call if maybe_proc.respond_to? :call
+
+        @collection ||= maybe_proc
+      end
+    end
+  end
+end

data/lib/administrate/field/string.rb

@@ -0,0 +1,21 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class String < Field::Base
+      def self.searchable?
+        true
+      end
+
+      def truncate
+        data.to_s[0...truncation_length]
+      end
+
+      private
+
+      def truncation_length
+        options.fetch(:truncate, 50)
+      end
+    end
+  end
+end

data/lib/administrate/field/text.rb

@@ -0,0 +1,21 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Text < Administrate::Field::Base
+      def self.searchable?
+        false
+      end
+
+      def truncate
+        data.to_s[0...truncation_length]
+      end
+
+      private
+
+      def truncation_length
+        options.fetch(:truncate, 50)
+      end
+    end
+  end
+end

data/lib/administrate/field/time.rb

@@ -0,0 +1,8 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Time < Base
+    end
+  end
+end

data/lib/administrate/field/url.rb

@@ -0,0 +1,21 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Url < Field::Base
+      def self.searchable?
+        true
+      end
+
+      def truncate
+        data.to_s[0...truncation_length]
+      end
+
+      private
+
+      def truncation_length
+        options.fetch(:truncate, 50)
+      end
+    end
+  end
+end

data/lib/administrate/generator_helpers.rb

@@ -0,0 +1,13 @@
+module Administrate
+  module GeneratorHelpers
+    def call_generator(generator, *args)
+      Rails::Generators.invoke(generator, args, generator_options)
+    end
+
+    private
+
+    def generator_options
+      { behavior: behavior }
+    end
+  end
+end

data/lib/administrate/namespace/resource.rb

@@ -0,0 +1,28 @@
+module Administrate
+  class Namespace
+    class Resource
+      attr_reader :namespace, :resource
+
+      def initialize(namespace, resource)
+        @namespace = namespace
+        @resource = resource
+      end
+
+      def to_s
+        name.to_s
+      end
+
+      def to_sym
+        name
+      end
+
+      def name
+        resource.to_s.gsub(/^#{namespace}\//, "").to_sym
+      end
+
+      def path
+        name.to_s.gsub("/", "_")
+      end
+    end
+  end
+end

data/lib/administrate/namespace.rb

@@ -0,0 +1,35 @@
+module Administrate
+  class Namespace
+    def initialize(namespace)
+      @namespace = namespace
+    end
+
+    def resources
+      @resources ||= routes.map(&:first).uniq.map do |path|
+        Resource.new(namespace, path)
+      end
+    end
+
+    def routes
+      @routes ||= all_routes.select do |controller, _action|
+        controller.starts_with?("#{namespace}/")
+      end.map do |controller, action|
+        [controller.gsub(/^#{namespace}\//, ""), action]
+      end
+    end
+
+    def resources_with_index_route
+      routes.select { |_resource, route| route == "index" }.map(&:first).uniq
+    end
+
+    private
+
+    attr_reader :namespace
+
+    def all_routes
+      Rails.application.routes.routes.map do |route|
+        route.defaults.values_at(:controller, :action).map(&:to_s)
+      end
+    end
+  end
+end

data/lib/administrate/order.rb

@@ -0,0 +1,88 @@
+module Administrate
+  class Order
+    def initialize(attribute = nil, direction = nil)
+      @attribute = attribute
+      @direction = sanitize_direction(direction)
+    end
+
+    def apply(relation)
+      return order_by_association(relation) unless
+        reflect_association(relation).nil?
+
+      order = "#{relation.table_name}.#{attribute} #{direction}"
+
+      return relation.reorder(Arel.sql(order)) if
+        relation.columns_hash.keys.include?(attribute.to_s)
+
+      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
+
+    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)
+      return order_by_count(relation) if has_many_attribute?(relation)
+
+      return order_by_id(relation) if belongs_to_attribute?(relation)
+
+      relation
+    end
+
+    def order_by_count(relation)
+      relation.
+        left_joins(attribute.to_sym).
+        group(:id).
+        reorder("COUNT(#{attribute}.id) #{direction}")
+    end
+
+    def order_by_id(relation)
+      relation.reorder("#{foreign_key(relation)} #{direction}")
+    end
+
+    def has_many_attribute?(relation)
+      reflect_association(relation).macro == :has_many
+    end
+
+    def belongs_to_attribute?(relation)
+      reflect_association(relation).macro == :belongs_to
+    end
+
+    def reflect_association(relation)
+      relation.klass.reflect_on_association(attribute.to_s)
+    end
+
+    def foreign_key(relation)
+      reflect_association(relation).foreign_key
+    end
+  end
+end

data/lib/administrate/page/base.rb

@@ -0,0 +1,41 @@
+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.gsub("/", "_")
+      end
+
+      def collection_includes
+        dashboard.try(:collection_includes) || []
+      end
+
+      def item_includes
+        dashboard.try(:item_includes) || []
+      end
+
+      protected
+
+      def attribute_field(dashboard, resource, attribute_name, page)
+        value = get_attribute_value(resource, attribute_name)
+        field = dashboard.attribute_type_for(attribute_name)
+        field.new(attribute_name, value, page, resource: resource)
+      end
+
+      def get_attribute_value(resource, attribute_name)
+        resource.public_send(attribute_name)
+      end
+
+      attr_reader :dashboard, :options
+    end
+  end
+end

data/lib/administrate/page/collection.rb

@@ -0,0 +1,37 @@
+require_relative "base"
+
+module Administrate
+  module Page
+    class Collection < Page::Base
+      def attribute_names
+        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/lib/administrate/page/form.rb

@@ -0,0 +1,28 @@
+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
+        dashboard.form_attributes.map do |attribute|
+          attribute_field(dashboard, resource, attribute, :form)
+        end
+      end
+
+      def page_title
+        dashboard.display_resource(resource)
+      end
+
+      protected
+
+      attr_reader :dashboard
+    end
+  end
+end

data/lib/administrate/page/show.rb

@@ -0,0 +1,24 @@
+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
+        dashboard.show_page_attributes.map do |attr_name|
+          attribute_field(dashboard, resource, attr_name, :show)
+        end
+      end
+    end
+  end
+end

data/lib/administrate/page.rb

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

data/lib/administrate/resource_resolver.rb

@@ -0,0 +1,43 @@
+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
+    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
+      model_path_parts.join(" ")
+    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
+      controller_path.split("/")[1..-1].map(&:singularize)
+    end
+
+    attr_reader :controller_path
+  end
+end