admin_it 1.0.1

data/lib/admin_it/context/single_context.rb

@@ -0,0 +1,199 @@
+require File.join %w(extend_it dsl)
+require File.join %w(extend_it symbolize)
+
+using ExtendIt::Symbolize
+
+module AdminIt
+  class Section
+    extend ExtendIt::Dsl
+    include Renderable
+    dsl_accessor :name, :display_name
+    dsl_boolean :visible
+    # dsl_block :render_context
+    def fields(*names)
+      names.empty? ? @fields ||= [] : @fields = names
+    end
+  end
+
+  module Identifiable
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def identity; end
+
+    protected
+
+    def context_param
+      identity.nil? ? super : "#{super}(#{identity})"
+    end
+
+    module ClassMethods
+    end
+  end
+
+  class SingleContext < Context
+    class << self
+      dsl_block :entity_getter, :entity_saver, :entity_destroyer
+    end
+
+    def self.sections
+      (@sections ||= {}).values
+    end
+
+    def self.section(*names, &block)
+      @sections ||= {}
+      names.ensure_symbols.each do |name|
+        if @sections.key?(name)
+          section = @sections[name]
+        else
+          if @sections.empty?
+            general = Section.new
+            general.name(:general)
+            # TODO: require this and other files after I18n config in engine.rb
+            #general.display_name(I18n.t('admin_it.collection.no_data'))
+            general.display_name('Основные свойства')
+            general.fields(*fields.map(&:field_name))
+            @sections[:general] = general
+          end
+          section = Section.new
+          section.name(name)
+          @sections[name] = section
+        end
+        section.instance_eval(&block) if block_given?
+      end
+    end
+
+    def self.single?
+      true
+    end
+
+    def self.path(entity)
+      AdminIt::Engine.routes.url_helpers.send(
+        "#{resource.name}_path",
+        entity
+      )
+    end
+
+    class_attr_reader :entity_getter, :entity_saver, :entity_destroyer, :sections
+    attr_accessor :entity
+
+    after_load do |store: {}, params: {}|
+      self.section = params[:section] || store[:section]
+    end
+
+    before_save do |params: {}|
+      params.merge!(section: section)
+    end
+
+    def values
+      return {} if @entity.nil?
+      Hash[fields(scope: :readable).map { |f| [f.name, f.read(@entity)] }]
+    end
+
+    def path(_entity: nil)
+      _entity ||= entity
+      self.class.path(_entity)
+    end
+
+    def section
+      @section ||= sections.empty? ? :none : :general
+    end
+
+    def section=(value)
+      value = value.downcase.to_sym if value.is_a?(String)
+      return unless value.is_a?(Symbol)
+      if sections.empty?
+        return if section != :none
+      else
+        return unless sections.map(&:name).include?(value)
+      end
+      @section = section
+    end
+
+    protected
+
+    def load_context
+      self.entity =
+        if entity_getter.nil?
+          getter = "#{resource.name}_#{name}_entity".to_sym
+          if controller.respond_to?(getter)
+            controller.send(getter)
+          else
+            getter = "#{name}_entity"
+            if controller.respond_to?(getter)
+              controller.send(getter, entity_class)
+            else
+              load_entity
+            end
+          end
+        else
+          entity_getter.call(controller.params)
+        end
+    end
+
+    def load_entity(identity: nil)
+      []
+    end
+  end
+
+  class SavableSingleContext < SingleContext
+    def self.save_action; end
+
+    def save_entity
+      if entity_saver.nil?
+        if controller.respond_to?("#{resource.name}_save")
+          controller.send("#{resource.name}_save", name)
+        elsif controller.respond_to?(:save)
+          controller.save(entity_class, name)
+        else
+          save_entity
+        end
+      else
+        entity_saver.call(controller, name)
+      end
+    end
+
+    class_attr_reader :save_action
+
+    protected
+
+    def save_entity; end
+  end
+
+  class EditContext < SavableSingleContext
+    include Identifiable
+
+    def self.path(entity)
+      AdminIt::Engine.routes.url_helpers.send(
+        "edit_#{resource.name}_path", entity
+      )
+    end
+
+    def self.save_action
+      :update
+    end
+
+    def self.entity_path?
+      true
+    end
+
+    class << self
+      protected
+
+      def default_icon
+        'pencil'
+      end
+    end
+  end
+
+  class NewContext < SavableSingleContext
+    def self.path
+      AdminIt::Engine.routes.url_helpers.send("new_#{resource.name}_path")
+    end
+
+    def self.save_action
+      :create
+    end
+  end
+end

data/lib/admin_it/context/table_context.rb

@@ -0,0 +1,66 @@
+require File.join %w(extend_it dsl)
+
+module AdminIt
+  class TableContext < CollectionContext
+    class << self
+      dsl_accessor :page_size, default: 10 do |value|
+        value.is_a?(Fixnum) && value > 0 ? value : 10
+      end
+
+      dsl_boolean :actions
+
+      dsl_block :row
+
+      protected
+
+      def default_icon
+        'table'
+      end
+    end
+
+    def self.path
+      AdminIt::Engine.routes
+        .url_helpers.send("table_#{resource.plural}_path")
+    end
+
+    class_attr_reader :page_size, :actions?
+
+    after_load do |store: {}, params: {}|
+      self.page = params[:page] || store[:page]
+    end
+
+    before_save do |params: {}|
+      params.merge!(page: page)
+    end
+
+    def pages
+      @pages ||= (count.to_f / page_size).ceil
+    end
+
+    def page
+      @page ||= 1
+    end
+
+    def page=(value)
+      if value.is_a?(String)
+        value = case value.downcase
+        when 'next' then page + 1
+        when 'prev', 'previous' then page - 1
+        when 'first' then 1
+        when 'last' then pages
+        else value.to_i
+        end
+      end
+      if value.is_a?(Fixnum) && value > 0 && value <= pages
+        # reset entities enumerator if page changed
+        @enumerator = nil if !@enumerator.nil? && value != @page
+        @page = value
+      end
+      @page ||= 1
+    end
+
+    def headers
+      Hash[fields.map { |f| [f.name, f.display_name] }]
+    end
+  end
+end

data/lib/admin_it/context/tiles_context.rb

@@ -0,0 +1,31 @@
+require File.join %w(extend_it dsl)
+
+module AdminIt
+  class TilesContext < CollectionContext
+    class << self
+      dsl_accessor :header do |value|
+        if value.nil?
+          fields.empty? ? nil : fields.first.name
+        else
+          field = fields.find { |f| f.field_name == value }
+          field.nil? ? header(nil) : field.field_name
+        end
+      end
+    end
+
+    def self.path
+      AdminIt::Engine.routes
+        .url_helpers.send("tiles_#{resource.plural}_path")
+    end
+
+    class << self
+      protected
+
+      def default_icon
+        'th'
+      end
+    end
+
+    class_attr_reader :header
+  end
+end

data/lib/admin_it/context.rb

@@ -0,0 +1,6 @@
+require File.join %w(admin_it context context)
+require File.join %w(admin_it context single_context)
+require File.join %w(admin_it context collection_context)
+require File.join %w(admin_it context table_context)
+require File.join %w(admin_it context tiles_context)
+require File.join %w(admin_it context show_context)

data/lib/admin_it/controller.rb

@@ -0,0 +1,42 @@
+module AdminIt
+  module Controller
+    def self.included(base)
+      base.class_eval do
+        attr_reader :context
+        helper_method :context, :resource
+        helper AdminIt::Helpers
+        helper AdminIt::Engine.routes.url_helpers
+
+        if AdminIt::Env.pundit?
+          collections = @resource.collections.map(&:context_name)
+          after_action :verify_authorized, except: collections
+          after_action :verify_policy_scoped, only: collections
+        end
+      end
+    end
+
+    def resource
+      self.class.instance_variable_get(:@resource)
+    end
+
+    def redirect_to_default
+      redirect_to(resource[resource.default_context].path)
+    end
+
+    private
+
+    def load_context(context_class)
+      @context = context_class.new(self)
+      yield if block_given?
+      layout = ['admin_it', params[:layout]].compact.join('_')
+      if !performed?
+        if layout == 'admin_it' && !request.query_parameters.empty?
+          redirect_to request.path
+        else
+          render template: "admin_it/#{context.name}", layout: layout
+        end
+      end
+      @context.save
+    end
+  end
+end

data/lib/admin_it/data/active_record.rb

@@ -0,0 +1,283 @@
+require File.join %w(extend_it class)
+
+module AdminIt
+  module ActiveRecordData
+    module Resource
+      def display_name
+        entity_class
+          .model_name
+          .human#(count: 0)
+          .split(' ')
+          .map { |s| s.mb_chars.capitalize }
+          .join(' ')
+      end
+
+      protected
+
+      def default_fields(&block)
+        enum = Enumerator.new do |yielder|
+          exclude = []
+          entity_class.reflections.each do |name, a|
+            f = AdminIt::Field.create(name, entity_class, type: :relation)
+            f.assoc = a
+            yielder << f
+            exclude << "#{name}_id" if a.belongs_to?
+          end
+          entity_class.columns_hash.each do |name, c|
+            next if exclude.include?(name)
+            name = name.to_sym
+            opts = { type: c.type }
+            if name == :id
+              opts[:visible] = false
+              opts[:writable] = false
+            end
+            yielder << AdminIt::Field.create(name, entity_class, opts)
+          end
+        end
+        block_given? ? enum.each(&block) : enum
+      end
+
+      def default_filters
+        enum = Enumerator.new do |yielder|
+          fields.each do |field|
+            next if field.type == :relation
+            name = "#{field.field_name}_value"
+            yielder << AdminIt::ValueFilter.create(name, self, field)
+          end
+        end
+        block_given? ? enum.each(&block) : enum
+      end
+    end
+
+    module CollectionContext
+      def entities=(value)
+        super(value)
+        @count = value.count
+      end
+
+      protected
+
+      def load_entities
+        collection =
+          if AdminIt::Env.pundit?
+            controller.policy_scope(entity_class)
+          else
+            entity_class.all
+          end
+        if child?
+          collection = collection.where(parent.resource.name => parent.entity)
+        end
+        sort = {}
+        sorting.each do |_sort|
+          name, order = _sort.split(':')
+          sort[name.to_sym] = order.to_sym
+        end
+        collection = collection.order(sort) unless sort.empty?
+        collection
+      end
+    end
+
+    module SingleContext
+      protected
+
+      def load_entity(identity: nil)
+        identity ||= controller.params[:id]
+        entity = entity_class.find(identity)
+        if AdminIt::Env.pundit?
+          controller.authorize(entity, "#{name}?")
+        end
+        if child?
+          fields
+            .select { |f| f.type == :relation &&
+                          f.assoc.klass == parent.entity_class }
+            .each do |f|
+              if f.assoc.collection?
+                entity.send(f.name) << parent.entity
+              else
+                entity.send("#{f.name}=", parent.entity)
+              end
+            end
+        end
+        entity
+      end
+    end
+
+    module SavableSingleContext
+      protected
+
+      def save_entity
+        if AdminIt::Env.pundit?
+          controller.authorize(entity, "#{self.class.save_action}?")
+        end
+        params = controller.params[resource.name]
+        fields(scope: :writable).each do |field|
+          next unless params.key?(field.name)
+          next unless field.writable?
+          next if field.type == :relation
+          field.write(entity, params[field.name])
+        end
+        if entity.save
+          controller.redirect_to_default
+        end
+      end
+
+      def add_child_context(for_resource, context_class: :table)
+        child_resource = AdminIt.resources[for_resource]
+        return nil if child_resource.nil?
+        child_resource[context_class].new(self)
+      end
+    end
+
+    module NewContext
+      def self.included(base)
+        base.after_initialize do
+          if child?
+            fields
+              .select { |f| f.type == :relation &&
+                            f.assoc.klass == parent.entity_class }
+              .each do |f|
+                if f.assoc.collection?
+                  entity.send(f.name) << parent.entity
+                else
+                  entity.send("#{f.name}=", parent.entity)
+                end
+                f.visible = false
+              end
+          end
+        end
+      end
+
+      protected
+
+      def load_entity(identity: nil)
+        entity = entity_class.new
+        if AdminIt::Env.pundit?
+          controller.authorize(entity, "#{name}?")
+        end
+        entity
+      end
+    end
+
+    module ShowContext
+      def identity
+        entity.id
+      end
+
+      protected
+
+      def destroy
+        if AdminIt::Env.pundit?
+          controller.authorize(entity, :destroy?)
+        end
+        if entity.destroy
+          controller.redirect_to_default
+        end
+      end
+    end
+
+    module EditContext
+      def identity
+        entity.id
+      end
+    end
+
+    module TableContext
+      def entities
+        if @entities.count > page_size
+          # limit collection to current page
+          @entities = @entities
+            .offset(page_size * (page - 1))
+            .limit(page_size)
+        end
+        super
+      end
+    end
+
+    module Field
+      def self.included(base)
+        base.class_eval do
+          class << self
+            attr_accessor :assoc
+
+            protected
+
+            def default_display_name
+              entity_class.human_attribute_name(field_name)
+            end
+          end
+          class_attr_reader :assoc
+        end
+      end
+
+      protected
+
+      def read_value(entity)
+        value = entity.send(name)
+        if type == :relation
+          assoc.collection? ? value.map(&:id).to_json : value.id
+        else
+          value
+        end
+      end
+
+      def show_value(entity)
+        value = entity.send(name)
+        if type == :relation
+          resource = AdminIt.resources.values.find do |r|
+            r.entity_class == assoc.klass
+          end
+          return I18n.t('admin_it.relation.no_resource') if resource.nil?
+          context = resource.contexts.find { |c| c <= ShowContext }
+          return I18n.t('admin_it.relation.no_context') if context.nil?
+          if assoc.collection?
+            if value.count == 0
+              I18n.t('admin_it.collection.no_data')
+            else
+              context.read(value.first) + ' ...'
+            end
+          else
+            context.read(value)
+          end
+        else
+          value
+        end
+      end
+
+      def write_value(entity, value)
+        entity.send("#{name}=", value)
+      end
+    end
+
+    module ValueFilter
+      def all_values(collection = nil, &block)
+        enum = Enumerator.new do |yielder|
+          field
+            .entity_class
+            .select(self.class.field.field_name)
+            .group(self.class.field.field_name)
+            .count
+            .each do |v, c|
+              yielder << { value: v, count: c }
+            end
+        end
+        block_given? ? enum.each(&block) : enum
+      end
+
+      def apply(collection)
+        return collection if @values.empty?
+        binding = []
+        conditions = ''
+        if @values.size == 1 && @values[0].nil?
+          conditions = "#{field.field_name} IS NULL"
+        else
+          conditions = "#{field.field_name} IN (?)"
+          binding << @values.select { |v| !v.nil? }
+          if @values.any? { |v| v.nil? }
+            conditions += " OR #{field.field_name} IS NULL"
+          end
+        end
+        collection = collection.where(conditions, *binding)
+      end
+    end
+  end
+end

data/lib/admin_it/data/data_behavior.rb

@@ -0,0 +1,18 @@
+module AdminIt
+  module DataBehavior
+    private
+
+    def import_data_module(base)
+      @data_module = AdminIt.data_module(@entity_class)
+      return unless @data_module.is_a?(Module)
+      parents.reverse.each do |mod|
+        next if mod.name.nil?
+        begin
+          import_module = @data_module.const_get(mod.name.split('::').last)
+          include(import_module) if import_module.is_a?(Module)
+        rescue NameError
+        end
+      end
+    end
+  end
+end

data/lib/admin_it/data/hash.rb

@@ -0,0 +1,27 @@
+module AdminIt
+  module HashData
+    module Context
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def load_fields
+          []
+        end
+      end
+    end
+
+    module Field
+      protected
+
+      def read_value(entity)
+        entity[name]
+      end
+
+      def write_value(entity, value)
+        entity[name] = value
+      end
+    end
+  end
+end