viniBaxterDesk 0.13.1

data/lib/administrate/search.rb

@@ -0,0 +1,157 @@
+require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/object/blank"
+
+module Administrate
+  class Search
+    class Query
+      attr_reader :filters
+
+      def blank?
+        terms.blank? && filters.empty?
+      end
+
+      def initialize(original_query)
+        @original_query = original_query
+        @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)
+        word.match?(/^\w+:$/)
+      end
+
+      def parse_query(query)
+        filters = []
+        terms = []
+        query.to_s.split.each do |word|
+          if filter?(word)
+            filters << word.split(":").first
+          else
+            terms << word
+          end
+        end
+        [filters, terms]
+      end
+    end
+
+    def initialize(scoped_resource, dashboard_class, term)
+      @dashboard_class = dashboard_class
+      @scoped_resource = scoped_resource
+      @query = Query.new(term)
+    end
+
+    def run
+      if query.blank?
+        @scoped_resource.all
+      else
+        results = search_results(@scoped_resource)
+        results = filter_results(results)
+        results
+      end
+    end
+
+    private
+
+    def apply_filter(filter, resources)
+      return resources unless filter
+      filter.call(resources)
+    end
+
+    def filter_results(resources)
+      query.filters.each do |filter_name|
+        filter = valid_filters[filter_name]
+        resources = apply_filter(filter, resources)
+      end
+      resources
+    end
+
+    def query_template
+      search_attributes.map do |attr|
+        table_name = query_table_name(attr)
+        attr_name = column_to_query(attr)
+
+        "LOWER(CAST(#{table_name}.#{attr_name} AS CHAR(256))) LIKE ?"
+      end.join(" OR ")
+    end
+
+    def query_values
+      ["%#{term.mb_chars.downcase}%"] * search_attributes.count
+    end
+
+    def search_attributes
+      attribute_types.keys.select do |attribute|
+        attribute_types[attribute].searchable?
+      end
+    end
+
+    def search_results(resources)
+      resources.
+        joins(tables_to_join).
+        where(query_template, *query_values)
+    end
+
+    def valid_filters
+      if @dashboard_class.const_defined?(:COLLECTION_FILTERS)
+        @dashboard_class.const_get(:COLLECTION_FILTERS).stringify_keys
+      else
+        {}
+      end
+    end
+
+    def attribute_types
+      @dashboard_class::ATTRIBUTE_TYPES
+    end
+
+    def query_table_name(attr)
+      if association_search?(attr)
+        provided_class_name = attribute_types[attr].options[:class_name]
+        if provided_class_name
+          provided_class_name.constantize.table_name
+        else
+          ActiveRecord::Base.connection.quote_table_name(attr.to_s.pluralize)
+        end
+      else
+        ActiveRecord::Base.connection.
+          quote_table_name(@scoped_resource.table_name)
+      end
+    end
+
+    def column_to_query(attr)
+      if association_search?(attr)
+        ActiveRecord::Base.connection.
+          quote_column_name(attribute_types[attr].searchable_field)
+      else
+        ActiveRecord::Base.connection.quote_column_name(attr)
+      end
+    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/lib/administrate/version.rb

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

data/lib/administrate/view_generator.rb

@@ -0,0 +1,36 @@
+require "rails/generators/base"
+require "administrate/generator_helpers"
+
+module Administrate
+  class ViewGenerator < Rails::Generators::Base
+    include Administrate::GeneratorHelpers
+
+    def self.template_source_path
+      File.expand_path(
+        "../../../app/views/administrate/application",
+        __FILE__,
+      )
+    end
+
+    private
+
+    def copy_resource_template(template_name)
+      template_file = "#{template_name}.html.erb"
+
+      copy_file(
+        template_file,
+        "app/views/admin/#{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/lib/administrate.rb

@@ -0,0 +1,4 @@
+require "administrate/engine"
+
+module Administrate
+end

data/lib/generators/administrate/assets/assets_generator.rb

@@ -0,0 +1,12 @@
+require "administrate/view_generator"
+
+module Administrate
+  module Generators
+    class AssetsGenerator < Administrate::ViewGenerator
+      def copy_assets
+        call_generator("administrate:assets:javascripts")
+        call_generator("administrate:assets:stylesheets")
+      end
+    end
+  end
+end

data/lib/generators/administrate/assets/javascripts_generator.rb

@@ -0,0 +1,17 @@
+require "rails/generators/base"
+
+module Administrate
+  module Generators
+    module Assets
+      class JavascriptsGenerator < Rails::Generators::Base
+        JAVASCRIPTS_PATH = "app/assets/javascripts/administrate"
+
+        source_root File.expand_path("../../../../../", __FILE__)
+
+        def copy_javascripts
+          directory JAVASCRIPTS_PATH, JAVASCRIPTS_PATH
+        end
+      end
+    end
+  end
+end

data/lib/generators/administrate/assets/stylesheets_generator.rb

@@ -0,0 +1,17 @@
+require "rails/generators/base"
+
+module Administrate
+  module Generators
+    module Assets
+      class StylesheetsGenerator < Rails::Generators::Base
+        STYLESHEETS_PATH = "app/assets/stylesheets/administrate"
+
+        source_root File.expand_path("../../../../../", __FILE__)
+
+        def copy_stylesheets
+          directory STYLESHEETS_PATH, STYLESHEETS_PATH
+        end
+      end
+    end
+  end
+end

data/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

data/lib/generators/administrate/dashboard/dashboard_generator.rb

@@ -0,0 +1,143 @@
+require "rails/generators/named_base"
+
+module Administrate
+  module Generators
+    class DashboardGenerator < Rails::Generators::NamedBase
+      ATTRIBUTE_TYPE_MAPPING = {
+        boolean: "Field::Boolean",
+        date: "Field::Date",
+        datetime: "Field::DateTime",
+        enum: "Field::String",
+        float: "Field::Number",
+        integer: "Field::Number",
+        time: "Field::Time",
+        text: "Field::Text",
+        string: "Field::String",
+      }
+
+      ATTRIBUTE_OPTIONS_MAPPING = {
+        enum: { searchable: false },
+        float: { decimals: 2 },
+      }
+
+      DEFAULT_FIELD_TYPE = "Field::String.with_options(searchable: false)"
+      COLLECTION_ATTRIBUTE_LIMIT = 4
+      READ_ONLY_ATTRIBUTES = %w[id created_at updated_at]
+
+      class_option :namespace, type: :string, default: "admin"
+
+      source_root File.expand_path("../templates", __FILE__)
+
+      def create_dashboard_definition
+        template(
+          "dashboard.rb.erb",
+          Rails.root.join("app/dashboards/#{file_name}_dashboard.rb"),
+        )
+      end
+
+      def create_resource_controller
+        destination = Rails.root.join(
+          "app/controllers/#{namespace}/#{file_name.pluralize}_controller.rb",
+        )
+
+        template("controller.rb.erb", destination)
+      end
+
+      private
+
+      def namespace
+        options[:namespace]
+      end
+
+      def attributes
+        klass.reflections.keys +
+          klass.columns.map(&:name) -
+          redundant_attributes
+      end
+
+      def form_attributes
+        attributes - READ_ONLY_ATTRIBUTES
+      end
+
+      def redundant_attributes
+        klass.reflections.keys.flat_map do |relationship|
+          redundant_attributes_for(relationship)
+        end.compact
+      end
+
+      def redundant_attributes_for(relationship)
+        case association_type(relationship)
+        when "Field::Polymorphic"
+          [relationship + "_id", relationship + "_type"]
+        when "Field::BelongsTo"
+          relationship + "_id"
+        end
+      end
+
+      def field_type(attribute)
+        type = column_type_for_attribute(attribute.to_s)
+
+        if type
+          ATTRIBUTE_TYPE_MAPPING.fetch(type, DEFAULT_FIELD_TYPE) +
+            options_string(ATTRIBUTE_OPTIONS_MAPPING.fetch(type, {}))
+        else
+          association_type(attribute)
+        end
+      end
+
+      def column_type_for_attribute(attr)
+        if enum_column?(attr)
+          :enum
+        else
+          column_types(attr)
+        end
+      end
+
+      def enum_column?(attr)
+        klass.respond_to?(:defined_enums) &&
+          klass.defined_enums.keys.include?(attr)
+      end
+
+      def column_types(attr)
+        klass.columns.find { |column| column.name == attr }.try(:type)
+      end
+
+      def association_type(attribute)
+        relationship = klass.reflections[attribute.to_s]
+        if relationship.has_one?
+          "Field::HasOne"
+        elsif relationship.collection?
+          "Field::HasMany" + relationship_options_string(relationship)
+        elsif relationship.polymorphic?
+          "Field::Polymorphic"
+        else
+          "Field::BelongsTo" + relationship_options_string(relationship)
+        end
+      end
+
+      def klass
+        @klass ||= Object.const_get(class_name)
+      end
+
+      def relationship_options_string(relationship)
+        if relationship.class_name != relationship.name.to_s.classify
+          options_string(class_name: relationship.class_name)
+        else
+          ""
+        end
+      end
+
+      def options_string(options)
+        if options.any?
+          ".with_options(#{inspect_hash_as_ruby(options)})"
+        else
+          ""
+        end
+      end
+
+      def inspect_hash_as_ruby(hash)
+        hash.map { |key, value| "#{key}: #{value.inspect}" }.join(", ")
+      end
+    end
+  end
+end

data/lib/generators/administrate/dashboard/templates/controller.rb.erb

@@ -0,0 +1,46 @@
+module <%= namespace.classify %>
+  class <%= class_name.pluralize %>Controller < <%= namespace.classify %>::ApplicationController
+    # Overwrite any of the RESTful controller actions to implement custom behavior
+    # For example, you may want to send an email after a foo is updated.
+    #
+    # def update
+    #   super
+    #   send_foo_updated_email(requested_resource)
+    # end
+
+    # Override this method to specify custom lookup behavior.
+    # This will be used to set the resource for the `show`, `edit`, and `update`
+    # actions.
+    #
+    # def find_resource(param)
+    #   Foo.find_by!(slug: param)
+    # end
+
+    # The result of this lookup will be available as `requested_resource`
+
+    # Override this if you have certain roles that require a subset
+    # this will be used to set the records shown on the `index` action.
+    #
+    # def scoped_resource
+    #   if current_user.super_admin?
+    #     resource_class
+    #   else
+    #     resource_class.with_less_stuff
+    #   end
+    # end
+
+    # Override `resource_params` if you want to transform the submitted
+    # data before it's persisted. For example, the following would turn all
+    # empty values into nil values. It uses other APIs such as `resource_class`
+    # and `dashboard`:
+    #
+    # def resource_params
+    #   params.require(resource_class.model_name.param_key).
+    #     permit(dashboard.permitted_attributes).
+    #     transform_values { |value| value == "" ? nil : value }
+    # end
+
+    # See https://administrate-prototype.herokuapp.com/customizing_controller_actions
+    # for more information
+  end
+end

data/lib/generators/administrate/dashboard/templates/dashboard.rb.erb

@@ -0,0 +1,68 @@
+require "administrate/base_dashboard"
+
+class <%= class_name %>Dashboard < Administrate::BaseDashboard
+  # ATTRIBUTE_TYPES
+  # a hash that describes the type of each of the model's fields.
+  #
+  # Each different type represents an Administrate::Field object,
+  # which determines how the attribute is displayed
+  # on pages throughout the dashboard.
+  ATTRIBUTE_TYPES = {
+<% attributes.each do |attr| -%>
+    <%= attr %>: <%= field_type(attr) %>,
+<% end -%>
+  }.freeze
+
+  # COLLECTION_ATTRIBUTES
+  # an array of attributes that will be displayed on the model's index page.
+  #
+  # By default, it's limited to four items to reduce clutter on index pages.
+  # Feel free to add, remove, or rearrange items.
+  COLLECTION_ATTRIBUTES = [
+<%=
+  attributes.first(COLLECTION_ATTRIBUTE_LIMIT).map do |attr|
+    "    :#{attr},"
+  end.join("\n")
+%>
+  ].freeze
+
+  # SHOW_PAGE_ATTRIBUTES
+  # an array of attributes that will be displayed on the model's show page.
+  SHOW_PAGE_ATTRIBUTES = [
+<%=
+  attributes.map do |attr|
+    "    :#{attr},"
+  end.join("\n")
+%>
+  ].freeze
+
+  # FORM_ATTRIBUTES
+  # an array of attributes that will be displayed
+  # on the model's form (`new` and `edit`) pages.
+  FORM_ATTRIBUTES = [
+<%=
+  form_attributes.map do |attr|
+    "    :#{attr},"
+  end.join("\n")
+%>
+  ].freeze
+
+  # COLLECTION_FILTERS
+  # a hash that defines filters that can be used while searching via the search
+  # field of the dashboard.
+  #
+  # For example to add an option to search for open resources by typing "open:"
+  # in the search field:
+  #
+  #   COLLECTION_FILTERS = {
+  #     open: ->(resources) { resources.where(open: true) }
+  #   }.freeze
+  COLLECTION_FILTERS = {}.freeze
+
+  # Overwrite this method to customize how <%= file_name.pluralize.humanize.downcase %> are displayed
+  # across all pages of the admin dashboard.
+  #
+  # def display_resource(<%= file_name %>)
+  #   "<%= class_name %> ##{<%= file_name %>.id}"
+  # end
+end

data/lib/generators/administrate/field/field_generator.rb

@@ -0,0 +1,31 @@
+module Administrate
+  module Generators
+    class FieldGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("../templates", __FILE__)
+
+      def template_field_object
+        template(
+          "field_object.rb.erb",
+          "app/fields/#{file_name}_field.rb",
+        )
+      end
+
+      def copy_partials
+        copy_partial(:show)
+        copy_partial(:index)
+        copy_partial(:form)
+      end
+
+      private
+
+      def copy_partial(partial_name)
+        partial = "_#{partial_name}.html.erb"
+
+        copy_file(
+          partial,
+          "app/views/fields/#{file_name}_field/#{partial}",
+        )
+      end
+    end
+  end
+end

data/lib/generators/administrate/field/templates/_form.html.erb

@@ -0,0 +1,6 @@
+<div class="field-unit__label">
+  <%= f.label field.attribute %>
+</div>
+<div class="field-unit__field">
+  <%= f.text_field field.attribute %>
+</div>

data/lib/generators/administrate/field/templates/_index.html.erb

@@ -0,0 +1 @@
+<%= field.to_s %>

data/lib/generators/administrate/field/templates/_show.html.erb

@@ -0,0 +1 @@
+<%= field.to_s %>

data/lib/generators/administrate/field/templates/field_object.rb.erb

@@ -0,0 +1,7 @@
+require "administrate/field/base"
+
+class <%= class_name %>Field < Administrate::Field::Base
+  def to_s
+    data
+  end
+end

data/lib/generators/administrate/install/install_generator.rb

@@ -0,0 +1,49 @@
+require "rails/generators/base"
+require "administrate/generator_helpers"
+require "administrate/namespace"
+
+module Administrate
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      include Administrate::GeneratorHelpers
+      source_root File.expand_path("../templates", __FILE__)
+
+      class_option :namespace, type: :string, default: "admin"
+
+      def run_routes_generator
+        if dashboard_resources.none?
+          call_generator("administrate:routes", "--namespace", namespace)
+          load Rails.root.join("config/routes.rb")
+        end
+      end
+
+      def create_dashboard_controller
+        template(
+          "application_controller.rb.erb",
+          "app/controllers/#{namespace}/application_controller.rb",
+        )
+      end
+
+      def run_dashboard_generators
+        singular_dashboard_resources.each do |resource|
+          call_generator "administrate:dashboard", resource,
+            "--namespace", namespace
+        end
+      end
+
+      private
+
+      def namespace
+        options[:namespace]
+      end
+
+      def singular_dashboard_resources
+        dashboard_resources.map(&:to_s).map(&:singularize)
+      end
+
+      def dashboard_resources
+        Administrate::Namespace.new(namespace).resources
+      end
+    end
+  end
+end

data/lib/generators/administrate/install/templates/application_controller.rb.erb

@@ -0,0 +1,21 @@
+# All Administrate controllers inherit from this
+# `Administrate::ApplicationController`, making it the ideal place to put
+# authentication logic or other before_actions.
+#
+# If you want to add pagination or other controller-level concerns,
+# you're free to overwrite the RESTful controller actions.
+module <%= namespace.classify %>
+  class ApplicationController < Administrate::ApplicationController
+    before_action :authenticate_admin
+
+    def authenticate_admin
+      # TODO Add authentication logic here.
+    end
+
+    # Override this value to specify the number of elements to display at a time
+    # on index pages. Defaults to 20.
+    # def records_per_page
+    #   params[:per_page] || 20
+    # end
+  end
+end