semantic-administrate 0.1.0

data/lib/administrate/field/boolean.rb

@@ -0,0 +1,15 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Boolean < Base
+      def to_s
+        if data.nil?
+          "-"
+        else
+          data.to_s
+        end
+      end
+    end
+  end
+end

data/lib/administrate/field/date_time.rb

@@ -0,0 +1,21 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class DateTime < Base
+      def date
+        I18n.localize(data.to_date, format: format)
+      end
+
+      def datetime
+        I18n.localize(data, format: format, default: data)
+      end
+
+      private
+
+      def format
+        options.fetch(:format, :default)
+      end
+    end
+  end
+end

data/lib/administrate/field/deferred.rb

@@ -0,0 +1,35 @@
+require "active_support/core_ext/module/delegation"
+
+module Administrate
+  module Field
+    class Deferred
+      def initialize(deferred_class, options = {})
+        @deferred_class = deferred_class
+        @options = options
+      end
+
+      attr_reader :deferred_class, :options
+
+      def new(*args)
+        new_options = args.last.respond_to?(:merge) ? args.pop : {}
+        deferred_class.new(*args, options.merge(new_options))
+      end
+
+      def ==(other)
+        other.respond_to?(:deferred_class) &&
+          deferred_class == other.deferred_class &&
+          options == other.options
+      end
+
+      def searchable?
+        options.fetch(:searchable, deferred_class.searchable?)
+      end
+
+      def permitted_attribute(attr)
+        options.fetch(:foreign_key, deferred_class.permitted_attribute(attr))
+      end
+
+      delegate :html_class, to: :deferred_class
+    end
+  end
+end

data/lib/administrate/field/email.rb

@@ -0,0 +1,11 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Email < Field::Base
+      def self.searchable?
+        true
+      end
+    end
+  end
+end

data/lib/administrate/field/has_many.rb

@@ -0,0 +1,87 @@
+require_relative "associative"
+require "administrate/page/collection"
+require "administrate/order"
+
+module Administrate
+  module Field
+    class HasMany < Associative
+      DEFAULT_LIMIT = 5
+
+      def self.permitted_attribute(attribute)
+        { "#{attribute.to_s.singularize}_ids".to_sym => [] }
+      end
+
+      def associated_collection
+        Administrate::Page::Collection.new(associated_dashboard)
+      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)
+        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
+
+      private
+
+      def includes
+        associated_dashboard.association_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 order
+        @_order ||= Administrate::Order.new(sort_by, direction)
+      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,27 @@
+require_relative "associative"
+
+module Administrate
+  module Field
+    class HasOne < Associative
+      def initialize(attribute, data, page, options = {})
+        resolver = Administrate::ResourceResolver.new("admin/#{attribute}")
+        @nested_form = Administrate::Page::Form.new(
+          resolver.dashboard_class.new,
+          data || resolver.resource_class.new,
+        )
+
+        super
+      end
+
+      def self.permitted_attribute(attr)
+        related_dashboard_attributes =
+          Administrate::ResourceResolver.new("admin/#{attr}").
+            dashboard_class.new.permitted_attributes + [:id]
+
+        { "#{attr}_attributes": related_dashboard_attributes }
+      end
+
+      attr_reader :nested_form
+    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/polymorphic.rb

@@ -0,0 +1,51 @@
+require_relative "associative"
+
+module Administrate
+  module Field
+    class Polymorphic < BelongsTo
+      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 self.permitted_attribute(attr)
+        { attr => %i{type value} }
+      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,21 @@
+require_relative "base"
+
+module Administrate
+  module Field
+    class Select < Field::Base
+      def self.searchable?
+        true
+      end
+
+      def selectable_options
+        collection
+      end
+
+      private
+
+      def collection
+        @collection ||= options.fetch(:collection, [])
+      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/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.rb

@@ -0,0 +1,31 @@
+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.to_s)
+      end.map do |controller, action|
+        [controller.gsub(/^#{namespace}\//, ""), action]
+      end
+    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/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/order.rb

@@ -0,0 +1,45 @@
+module Administrate
+  class Order
+    def initialize(attribute = nil, direction = nil)
+      @attribute = attribute
+      @direction = direction || :asc
+    end
+
+    def apply(relation)
+      if relation.columns_hash.keys.include?(attribute.to_s)
+        relation.order("#{attribute} #{direction}")
+      else
+        relation
+      end
+    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 reversed_direction_param_for(attr)
+      if ordered_by?(attr)
+        opposite_direction
+      else
+        :asc
+      end
+    end
+
+    def opposite_direction
+      direction.to_sym == :asc ? :desc : :asc
+    end
+  end
+end