admin_it 1.0.1

data/lib/admin_it/helpers/field.rb

@@ -0,0 +1,25 @@
+module AdminIt
+  module Helpers
+    class Field < WrapIt::Base
+      include WrapIt::TextContainer
+      attr_accessor :field, :context
+      option :field
+      option :context
+      argument :field, if: AdminIt::Field
+      argument :context, if: AdminIt::Context
+
+      before_capture do
+        unless context.is_a?(AdminIt::Context)
+          self.context = @template.context
+        end
+        if field.is_a?(AdminIt::Field)
+          entity = context.entity
+          field.render(entity, instance: self)
+          body << field.show(entity).to_s if body.empty?
+        end
+      end
+    end
+
+    register :field, Field
+  end
+end

data/lib/admin_it/helpers/input.rb

@@ -0,0 +1,22 @@
+module AdminIt
+  module Helpers
+    class Input < WrapIt::Base
+      html_class 'form-control'
+      attr_accessor :field, :entity
+      option :field, :entity
+      argument :field, if: AdminIt::Field
+
+      before_capture do
+        html_attr[:type] = 'text'
+        if field.is_a?(AdminIt::Field)
+          context = @template.context
+          resource = context.resource
+          entity ||= context.entity
+          html_attr[:name] = "#{resource.name}[#{field.name}]"
+          html_attr[:id] = "#{resource.name}_#{field.name}"
+          html_attr[:value] = field.render(entity, instance: self)
+        end
+      end
+    end
+  end
+end

data/lib/admin_it/helpers/page.rb

@@ -0,0 +1,26 @@
+module AdminIt
+  module Helpers
+    class Page < WrapIt::Container
+      default_tag 'body'
+
+      child :create_top_menu, TopMenu
+      child :create_toolbar, Toolbar
+
+      def top_menu
+        children.find { |item| item.is_a?(TopMenu) }
+      end
+
+      def toolbar
+        children.find { |item| item.is_a?(Toolbar) }
+      end
+
+      after_initialize { self.deffered_render = true }
+
+      before_capture do
+        html_attr[:style] = 'padding-top: 70px;'
+      end
+    end
+
+    register :body, Page
+  end
+end

data/lib/admin_it/helpers/table.rb

@@ -0,0 +1,85 @@
+module AdminIt
+  module Helpers
+    class Cell < WrapIt::Base
+      include WrapIt::TextContainer
+      default_tag 'td'
+      attr_accessor :column
+      option :column
+
+      before_capture do
+        unless column.nil?
+          col = parent.parent.context.field(column)
+          unless col.nil?
+            col.render(parent.parent.context.entity, instance: self)
+          end
+        end
+      end
+    end
+
+    class ActionsCell < WrapIt::Base
+      default_tag 'td'
+
+      before_capture do
+        single = parent.parent.resource.singles.select { |c| !(c <= NewContext) }
+        buttons = single.map do |context|
+            cl = context <= ShowContext ? 'info' : 'default'
+            href = context.path(parent.parent.context.entity)
+            "<a class=\"btn btn-xs btn-#{cl}\" href=\"#{href}\">" \
+            "<i class=\"fa fa-#{context.icon}\"></i></a>"
+          end
+        show = single.first { |c| c <= ShowContext }
+        unless show.nil?
+          buttons << @template.link_to(
+            html_safe('<i class="fa fa-trash-o"></i>'),
+            show.path(parent.parent.context.entity),
+            method: :delete,
+            class: 'btn btn-xs btn-danger'
+          )
+        end
+
+        html = buttons.join
+        html = "<div class=\"btn-group\">#{html}</dic>" if buttons.size > 1
+
+        self[:content] = html_safe(html)
+      end
+    end
+
+    class Header < WrapIt::Container
+      default_tag 'tr'
+      child :cell, Cell, tag: 'th'
+    end
+
+    class Row < WrapIt::Container
+      default_tag 'tr'
+      child :cell, Cell
+      child :actions, ActionsCell
+
+      before_capture do
+        block = parent.context.class.row
+        unless block.nil?
+          instance_exec(parent.context.entity, &block)
+        end
+      end
+    end
+
+    class Table < WrapIt::Container
+      default_tag 'table'
+      html_class %w(table)
+      attr_writer :context
+      argument :context, if: AdminIt::Context
+
+      def context
+        @context ||= @template.context
+      end
+
+      def resource
+        context.resource
+      end
+
+      child :header, Header
+      child :row, Row
+    end
+
+    register :table, Table
+  end
+end

data/lib/admin_it/helpers/tiles.rb

@@ -0,0 +1,17 @@
+module AdminIt
+  module Helpers
+    class TileHeader < WrapIt::Base
+      include WrapIt::TextContainer
+      default_tag 'h4'
+
+      before_capture do
+        field = @template.context.field(@template.context.header)
+        unless field.nil?
+          field.render(@template.context.entity, instance: self)
+        end
+      end
+    end
+
+    register :tile_header, TileHeader
+  end
+end

data/lib/admin_it/helpers/toolbar.rb

@@ -0,0 +1,40 @@
+module AdminIt
+  module Helpers
+    class ToolbarItem < WrapIt::Link
+      attr_accessor :icon, :add_class, :add_data
+      option :icon
+      option :add_class
+      option :add_data
+      section :icon
+      place :icon, before: :body
+
+      before_capture do
+        unless icon.nil?
+          self[:icon] << html_safe("<i class=\"fa fa-#{icon}\"></i> ")
+        end
+        html_class << add_class
+        html_data.merge!(add_data) if add_data.is_a?(Hash)
+#        options = { tag: 'li' }
+#        options[:class] = 'active' if resource == @template.resource
+#        wrap(options)
+      end
+    end
+
+    class ToolbarButtons < WrapIt::Container
+      html_class 'btn-group'
+      child :button, ToolbarItem, class: 'btn navbar-btn'
+    end
+
+    class Toolbar < WrapIt::Container
+      default_tag 'nav'
+      html_class 'navbar'
+      child :item, ToolbarItem
+      child :button, ToolbarItem, class: 'btn navbar-btn'
+      child :buttons, ToolbarButtons
+
+      after_initialize { self.deffered_render = true }
+    end
+
+    register :toolbar, Toolbar
+  end
+end

data/lib/admin_it/helpers/top_menu.rb

@@ -0,0 +1,39 @@
+module AdminIt
+  module Helpers
+    class TopMenuItem < WrapIt::Link
+      attr_accessor :resource
+      option :resource
+
+      before_capture do
+        unless resource.icon.nil?
+          body << html_safe("<i class=\"fa fa-#{resource.icon}\"></i> ")
+        end
+        body << resource.display_name
+        self.link = @template.url_for(
+          controller: resource.name,
+          action: resource.default_context
+        )
+        options = { tag: 'li' }
+        options[:class] = 'active' if resource == @template.resource
+        wrap(options)
+      end
+    end
+
+    class TopMenu < WrapIt::Container
+      default_tag 'ul'
+      html_class 'nav'
+      child :item, TopMenuItem
+
+      after_initialize { self.deffered_render = true }
+
+      before_capture do
+        AdminIt.resources.each do |name, resource|
+          next unless resource.menu == true
+          item(resource: resource)
+        end
+      end
+    end
+
+    register :top_menu, TopMenu
+  end
+end

data/lib/admin_it/helpers.rb

@@ -0,0 +1,12 @@
+require 'wrap_it'
+
+module AdminIt
+  module Helpers; end
+  WrapIt.register_module Helpers
+end
+
+require File.join %w(admin_it helpers field)
+require File.join %w(admin_it helpers top_menu)
+require File.join %w(admin_it helpers toolbar)
+require File.join %w(admin_it helpers table)
+require File.join %w(admin_it helpers tiles)

data/lib/admin_it/locales/en.yml

@@ -0,0 +1,14 @@
+en:
+  admin_it:
+    collection:
+      no_data: 'No data'
+    relation:
+      no_resource: 'Resource for displaying property is not defined'
+      no_context: 'Context for displaying property is not defined'
+    section:
+      general: 'General properties'
+    action:
+      create: 'Create'
+      save: 'Save'
+      close: 'Close'
+    filters: 'FIlters'

data/lib/admin_it/locales/ru.yml

@@ -0,0 +1,14 @@
+ru:
+  admin_it:
+    collection:
+      no_data: 'Нет данных'
+    relation:
+      no_resource: 'Не определён ресурс для отображения свойства'
+      no_context: 'Не определён контекст для отображения свойства'
+    section:
+      general: 'Основные свойства'
+    action:
+      create: 'Создать'
+      save: 'Сохранить'
+      close: 'Закрыть'
+    filters: 'Фильтры'

data/lib/admin_it/renderable.rb

@@ -0,0 +1,18 @@
+module AdminIt
+  module Renderable
+    def render(entity = nil, instance = nil, &block)
+      if entity.nil? && instance.nil?
+        # method used as setter - just save block
+        @renderer = block if block_given?
+      elsif !@renderer.nil?
+        # method used as event emmiter, call block in instance or caller
+        # context if it present
+        if instance.nil?
+          @renderer.call(entity)
+        else
+          instance.instance_exec(entity, &@renderer)
+        end
+      end
+    end
+  end
+end

data/lib/admin_it/resource.rb

@@ -0,0 +1,292 @@
+require File.join %w(extend_it symbolize)
+require File.join %w(extend_it asserts)
+require File.join %w(extend_it callbacks)
+require File.join %w(extend_it class)
+
+using ExtendIt::Symbolize
+
+module AdminIt
+  module FieldsHolder
+    def fields(scope: :visible)
+      case scope
+      when nil, :all then @fields.values
+      when :visible then @fields.values.select { |f| f.visible? }
+      when :hidden then @fields.values.select { |f| !f.visible? }
+      when :readable then @fields.values.select { |f| f.readable? }
+      when :writable then @fields.values.select { |f| f.writable? }
+      when :sortable then @fields.values.select { |f| f.sortable? }
+      when Field::TYPES then @fields.values.select { |f| f.type == scope }
+      else @fields.values
+      end
+    end
+
+    def hide_fields(*names)
+      names.ensure_symbols.each do |name|
+        @fields[name].hide if @fields.key?(name)
+      end
+    end
+
+    def show_fields(*names)
+      names.ensure_symbols.each do |name|
+        @fields[name].show if @fields.key?(name)
+      end
+    end
+  end
+
+  module FiltersHolder
+    def filters(scope: :all)
+      @filters ||= {}
+      case scope
+      when nil, :all then @filters.values
+      else @filters.values
+      end
+    end
+  end
+
+  class Resource
+    extend ExtendIt::Class
+    extend ExtendIt::Dsl
+    include ExtendIt::Asserts
+    include ExtendIt::Callbacks
+    include FieldsHolder
+    include FiltersHolder
+
+    attr_reader :name, :plural, :entity_class, :menu
+
+    dsl_accessor :icon
+    dsl_use_hash :fields
+
+    define_callbacks :initialize
+
+    def initialize(
+      name,
+      entity_class = nil,
+      menu: true,
+      destroyable: true,
+      auto_filters: true
+    )
+      assert_symbol(:name)
+
+      @name, @entity_class = name, entity_class
+      if @entity_class.nil?
+        begin
+          @entity_class = Object.const_get(name.to_s.camelize) # !PORTABLE
+        rescue NameError
+          fail ArgumentError, "Can't find entity class for #{name}"
+        end
+      end
+
+      import_data_module
+
+      run_callbacks :initialize do
+        @fields = Hash[default_fields.map { |f| [f.field_name, f] }]
+
+        @filters =
+          if auto_filters
+            Hash[default_filters.map { |f| [f.filter_name, f] }]
+          else
+            {}
+          end
+
+        @contexts = Hash[default_contexts.map { |c| [c.context_name, c] }]
+
+        @menu = menu == true
+        @destroyable = destroyable == true
+        @plural = name.to_s.pluralize # !POTABLE
+        @default_context = nil
+      end
+    end
+
+    def field(*names, field_class: nil, &block)
+      names.ensure_symbols.each do |name|
+        if @fields.key?(name)
+          field = @fields[name]
+        else
+          field_class = Field if field_class.nil? || !field_class <= Field
+          field = @fields[name] = field_class.create(name, entity_class)
+        end
+        field.instance_eval(&block) if block_given?
+      end
+    end
+
+    def [](name)
+      assert_symbol(:name)
+      @contexts[name]
+    end
+
+    def context(*names, context_class: nil, &block)
+      names.ensure_symbols.each do |name|
+        if @contexts.key?(name)
+          context = @contexts[name]
+        else
+          if context_class.nil? || !context_class <= Context
+            context_class = Context
+          end
+          context = @contexts[name] = context_class.create(name, entity_class)
+        end
+        context.instance_eval(&block) if block_given?
+      end
+    end
+
+    def contexts
+      @contexts.values
+    end
+
+    dsl_use_hash :contexts
+
+    def filter(name, filter_class: nil, &block)
+      assert_symbol(:name)
+      filter = @filters[name]
+      if filter.nil?
+        filter_class = Filter if filter_class.nil? || !filter_class <= Filter
+        filter = @filters[name] = filter_class.create(name, self)
+      end
+      filter.instance_eval(&block) if block_given?
+    end
+
+    dsl_use_hash :filters
+
+    def collection(&block)
+      return unless block_given?
+      contexts.select { |c| c.collection? }.each do |c|
+        c.instance_eval(&block)
+      end
+    end
+
+    def single(&block)
+      return unless block_given?
+      contexts.select { |c| c.single? }.each do |c|
+        c.instance_eval(&block)
+      end
+    end
+
+    def default_context(value = nil)
+      if value.nil?
+        return @default_context unless @default_context.nil?
+        if collections.size > 0
+          @default_context = collections.first.context_name
+        elsif singles.size > 0
+          @default_context = singles.first.context_name
+        end
+      else
+        @default_context = @contexts.keys.include?(value) ? value : default_context
+      end
+    end
+
+    def contexts_names
+      @contexts.map(&:context_name)
+    end
+
+    def display_name
+      plural.split('_').map { |s| s.capitalize }.join(' ')
+    end
+
+    def destroyable?
+      @destroyable
+    end
+
+    def collection_path
+      AdminIt::Engine.routes.url_helpers.send("#{plural}_path")
+    end
+
+    def single_path(entity)
+      AdminIt::Engine.routes.url_helpers.send("#{name}_path", entity)
+    end
+
+    def collections
+      contexts.select { |c| c.collection? }
+    end
+
+    def singles
+      contexts.select { |c| c.single? }
+    end
+
+    def define_controller
+      c_name = "#{name.to_s.camelize}Controller" # !POTABLE
+      resource = self
+      c_class = Class.new(AdminIt.config.controller) do
+        @resource = resource
+        include AdminIt::Controller
+
+        resource.contexts.each do |_context|
+          define_method(_context.context_name) { load_context(_context) }
+
+          if _context < SavableSingleContext
+            define_method _context.save_action do
+              load_context(_context) { context.save_entity(self) }
+            end
+          end
+        end
+
+        if resource.destroyable?
+          define_method :destroy do
+            load_context(resource[:show]) { context.destroy_entity(self) }
+          end
+        end
+      end
+      AdminIt.const_set(c_name, c_class)
+      contexts.each { |c| c.controller_class = c_class }
+    end
+
+    protected
+
+    # LAYOUTS = %w(content)
+    COLLECTIONS = %i(table tiles list)
+    SINGLE = %i(show new edit)
+    CONTEXTS = COLLECTIONS + SINGLE
+
+    def sanitize_entity_class
+      @entity_class = @name.to_s.camelize if @entity_class.nil? # !PORTABLE
+      if @entity_class.is_a?(Symbol)
+        @entity_class = @entity_class.to_s.camelize # !PORTABLE
+      end
+      if @entity_class.is_a?(String)
+        begin
+          @entity_class = Object.const_get(@entity_class)
+        rescue NameError
+          @entity_class = Object
+        end
+      end
+      unless @entity_class.is_a?(Class)
+        fail ArgumentError, 'Wrong entity class'
+      end
+    end
+
+    def default_fields
+      []
+    end
+
+    def default_contexts
+      CONTEXTS.map do |c|
+        context_class = AdminIt.const_get("#{c.capitalize}Context")
+        context_class.create(c, self)
+      end
+    end
+
+    def default_filters
+      []
+    end
+
+    private
+
+    def import_data_module
+      data_module = AdminIt.data_module(entity_class)
+      return unless data_module.is_a?(Module)
+      resource_module = data_module.const_get(:Resource)
+      extend(resource_module) if resource_module.is_a?(Module)
+    rescue NameError
+    end
+  end
+
+  def self.resource(name, entity_class = nil, **opts, &block)
+    _resource = Resource.new(name, entity_class, **opts)
+    _resource.instance_eval(&block) if block_given?
+    _resource.define_controller
+    @resources ||= {}
+    @resources[_resource.name] = _resource
+  end
+
+  def self.resources
+    @resources ||= {}
+  end
+end

data/lib/admin_it/utils.rb

@@ -0,0 +1,21 @@
+module AdminIt
+  module Utils
+    def self.assert_symbol_arg!(arg, name = nil)
+      assert_symbol_arg(arg) do
+        _caller = caller_locations(3, 1).first
+        name = "#{name} " unless name.nil?
+        fail(
+          ArgumentError,
+          "Argument #{name}for #{_caller.label} should be a String or Symbol",
+          caller[3..-1]
+        )
+      end
+    end
+
+    def self.assert_symbol_arg(arg)
+      return arg if arg.is_a?(Symbol)
+      return arg.to_sym if arg.is_a?(String)
+      yield arg if block_given?
+    end
+  end
+end

data/lib/admin_it/version.rb

@@ -0,0 +1,5 @@
+#
+module AdminIt
+  # Current gem version
+  VERSION = '1.0.1'
+end

data/lib/admin_it.rb

@@ -0,0 +1,19 @@
+#require 'extend_it'
+#module AdminIt
+#  using ExtendIt::Refines
+#end
+
+require File.join %w(admin_it env)
+require File.join %w(admin_it errors)
+require File.join %w(admin_it utils)
+require File.join %w(admin_it config)
+require File.join %w(admin_it renderable)
+require File.join %w(admin_it data)
+require File.join %w(admin_it field)
+require File.join %w(admin_it filters)
+require File.join %w(admin_it resource)
+require File.join %w(admin_it context)
+require File.join %w(admin_it controller)
+require File.join %w(admin_it definitions)
+require File.join %w(admin_it engine)
+require File.join %w(admin_it helpers)