semantic-administrate 0.1.0

data/lib/administrate/page.rb

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

data/lib/administrate/page/base.rb

@@ -0,0 +1,35 @@
+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
+
+      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)
+      rescue NameError
+        nil
+      end
+
+      attr_reader :dashboard, :options
+    end
+  end
+end

data/lib/administrate/page/collection.rb

@@ -0,0 +1,33 @@
+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?, :order_params_for, to: :order
+
+      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/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

data/lib/administrate/search.rb

@@ -0,0 +1,47 @@
+require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/object/blank"
+
+module Administrate
+  class Search
+    def initialize(scoped_resource, dashboard_class, term)
+      @dashboard_class = dashboard_class
+      @scoped_resource = scoped_resource
+      @term = term
+    end
+
+    def run
+      if @term.blank?
+        @scoped_resource.all
+      else
+        @scoped_resource.where(query, *search_terms)
+      end
+    end
+
+    private
+
+    def query
+      search_attributes.map do |attr|
+        table_name = ActiveRecord::Base.connection.
+          quote_table_name(@scoped_resource.table_name)
+        attr_name = ActiveRecord::Base.connection.quote_column_name(attr)
+        "lower(#{table_name}.#{attr_name}) LIKE ?"
+      end.join(" OR ")
+    end
+
+    def search_terms
+      ["%#{term.mb_chars.downcase}%"] * search_attributes.count
+    end
+
+    def search_attributes
+      attribute_types.keys.select do |attribute|
+        attribute_types[attribute].searchable?
+      end
+    end
+
+    def attribute_types
+      @dashboard_class::ATTRIBUTE_TYPES
+    end
+
+    attr_reader :resolver, :term
+  end
+end

data/lib/administrate/version.rb

@@ -0,0 +1,3 @@
+module Administrate
+  VERSION = "0.1.0".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
+
+    private
+
+    def self.template_source_path
+      File.expand_path(
+        "../../../app/views/administrate/application",
+        __FILE__,
+      )
+    end
+
+    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/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,141 @@
+require "rails/generators/named_base"
+
+module Administrate
+  module Generators
+    class DashboardGenerator < Rails::Generators::NamedBase
+      ATTRIBUTE_TYPE_MAPPING = {
+        boolean: "Field::Boolean",
+        date: "Field::DateTime",
+        datetime: "Field::DateTime",
+        enum: "Field::String",
+        float: "Field::Number",
+        integer: "Field::Number",
+        time: "Field::DateTime",
+        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.attribute_names - 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