admin_it 1.0.1

data/app/views/layouts/admin_it.html.slim

@@ -0,0 +1,37 @@
+doctype html
+html
+  head
+    title Admin
+    meta charset="utf-8"
+    = csrf_meta_tags
+
+    = stylesheet_link_tag 'admin_it/bootstrap.min', \
+                          media: 'all', \
+                          'data-turbolinks-track' => true
+    = stylesheet_link_tag 'admin_it/font-awesome.min', \
+                          media: 'all', \
+                          'data-turbolinks-track' => true
+    = stylesheet_link_tag 'admin_it/admin_it', \
+                          media: 'all', \
+                          'data-turbolinks-track' => true
+    = javascript_include_tag 'jquery', 'jquery_ujs', 'turbolinks'
+    = javascript_include_tag 'admin_it/bootstrap.min', \
+                             'data-turbolinks-track' => true
+    = javascript_include_tag 'admin_it/admin_it'
+
+  - html = capture do
+    body style="padding-top: 70px"
+      nav class="navbar navbar-fixed-top navbar-inverse" role="navigation"
+        div class="container"
+          <!-- top-menu -->
+
+      div class="container"
+        = render File.join(%w(admin_it shared toolbar))
+        = render File.join(%w(admin_it shared filters))
+        = yield
+
+  - top_menu_html = capture { context.top_menu.render }
+  - toolbar_html = capture { context.toolbar.render }
+  = html.gsub('<!-- top-menu -->', top_menu_html) \
+        .gsub('<!-- toolbar -->', toolbar_html) \
+        .html_safe

data/app/views/layouts/admin_it_dialog.html.slim

@@ -0,0 +1,8 @@
+div class="modal-header"
+  h4.modal-title title
+div class="modal-body"
+  = yield
+div class="modal-footer"
+  button type="button" class="btn btn-default" data-dismiss="modal"
+    = t('admin_it.action.close')
+  = yield :buttons

data/config.ru

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.require :default, :development
+
+Combustion.initialize!
+run Combustion::Application

data/lib/admin_it/config.rb

@@ -0,0 +1,24 @@
+module AdminIt
+  module Config
+    def self.root
+      @root ||= Rails.root.join('app', 'admin_it')
+    end
+
+    def self.root=(value)
+      value = File.expand_path(value, Rails.root)
+      fail ArgumentError unless File.directory?(value)
+      @root = value
+    end
+
+    def self.controller
+      @controller ||= ActionController::Base
+    end
+
+    def self.controller=(value)
+      unless value <= ActionController::Base
+        fail ArgumentError, 'Wrong controller'
+      end
+      @controller = value
+    end
+  end
+end

data/lib/admin_it/context/collection_context.rb

@@ -0,0 +1,239 @@
+require 'json'
+require File.join %w(extend_it symbolize)
+
+using ExtendIt::Symbolize
+
+module AdminIt
+  class CollectionContext < Context
+    extend FiltersHolder
+
+    @entities_getter = nil
+
+    class << self
+      dsl_block :entities
+      dsl_accessor :default_sorting
+      dsl_use_hash :filters
+    end
+
+    def self.before_configure
+      return if resource.nil?
+      visible = fields(scope: :visible).map(&:field_name)
+      @filters = Hash[
+        resource.filters
+          .select { |f| f <= FieldFilter }
+          .select { |f| visible.include?(f.field.field_name) }
+          .map { |f| [f.filter_name, f] }
+      ]
+    end
+
+    def self.filter(name, filter_class: nil, &block)
+      assert_symbol(:name)
+      if @filters.key?(name)
+        filter = @filters[name] = Class.new(@filters[name]) if block_given?
+      else
+        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
+
+    def self.entities_getter
+      @entities
+    end
+
+    def self.collection?
+      true
+    end
+
+    def self.path
+      AdminIt::Engine.routes.url_helpers.send("#{resource.plural}_path")
+    end
+
+    def self.sortable_fields(*names)
+      names = names.ensure_symbols
+      fields.each do |_field|
+        _field.sortable = names.include?(_field.field_name)
+      end
+    end
+
+    attr_accessor :entity
+    class_attr_reader :entities_getter, :path
+
+    before_load do |store: {}, params: {}|
+      self.sorting = store[:sorting] || self.class.default_sorting
+      self.sorting = params[:sorting] if params.key?(:sorting)
+      self.filters = store[:filters] || []
+      self.filters = params[:filters] if params.key?(:filters)
+    end
+
+    after_load do |store: {}, params: {}|
+      self.active_filter = params[:active_filter] || store[:active_filter]
+    end
+
+    before_save do |params: {}|
+      params.merge!(sorting: sorting.join(';'))
+      params.merge!(filters: filters.map { |f| f.dump }.join(';'))
+      unless active_filter.nil?
+        params.merge!(active_filter: active_filter.name.to_s)
+      end
+    end
+
+    def sorting
+      return @sorting unless @sorting.nil?
+      self.sorting = self.class.default_sorting
+    end
+
+    def sorting=(value)
+      value = value.to_s if value.is_a?(Symbol)
+      if value.is_a?(Array)
+        @sorting = value
+      elsif value.is_a?(String) && !value.empty?
+        @sorting = [] unless /\W[+\-]\w/ =~ value
+        @sorting ||= []
+        sortable = self.class.fields(scope: :sortable).map(&:field_name)
+        value.split(/[;,|]/).each do |sort|
+          sort.strip!
+          if sort[0] == '-'
+            sort = sort[1..-1] + ':'
+            @sorting.delete_if { |s| s.index(sort) == 0 }
+          else
+            sort = sort[1..-1] if sort[0] == '+'
+            sort, order = sort.split(':')
+            order = 'asc' if order != 'desc'
+            sort = sort.to_sym
+            @sorting << "#{sort}:#{order}" if sortable.include?(sort)
+          end
+        end
+      else
+        @sorting = []
+      end
+    end
+
+    def all_filters
+      self.class.filters
+    end
+
+    def filters
+      (@filters ||= {}).values
+    end
+
+    def filters=(value)
+      if value.is_a?(Array)
+        @filters = Hash[
+          value.select { |f| f.is_a?(Filter) }.map { |f| [f.name, f] }
+        ]
+      elsif value.is_a?(Hash)
+        self.filters = value.values
+      elsif value.is_a?(String)
+        @filters ||= {}
+        value.strip!
+        @filters = {} if value.empty?
+        value.split(/[;|]/).each do |str|
+          str.strip!
+          remove = str[0] == '-'
+          str = str[1..-1] if remove
+          m = Filter::REGEXP.match(str)
+          next if m.nil?
+          if remove
+            @filters.delete(m[:name].to_sym)
+          else
+            name = m[:name].to_sym
+            if @filters.key?(name)
+              @filters[name].change(m[:params])
+            else
+              @filters[name] = Filter.load(str, self.class.filters)
+            end
+          end
+        end
+      else
+        @filters = {}
+      end
+    end
+
+    def active_filter
+      @active_filter ||= filters.empty? ? nil : filters.first
+    end
+
+    def active_filter=(value)
+      if value.nil?
+        active_filter
+      elsif value.is_a?(Class) && value <= Filter
+        @active_filter = value
+      elsif value.is_a?(String)
+        value = value.to_sym
+        @active_filter = filters.find { |f| f.name == value }
+      end
+    end
+
+    def sortable_fields
+      @sortable_fields ||= fields(scope: :sortable)
+    end
+
+    def sortable
+      @sortable ||= sortable_fields.map(&:name)
+    end
+
+    def load_context
+      collection =
+        if entities_getter.nil?
+          if controller.respond_to?("#{resource.name}_entities")
+            controller.send("#{resource.name}_entities", name)
+          elsif controller.respond_to?(:entities)
+            controller.entities(entity_class, name)
+          else
+            load_entities
+          end
+        else
+          entities_getter.call
+        end
+      filters.each do |filter|
+        collection = filter.apply(collection)
+      end
+      self.entities = collection
+    end
+
+    def entities=(value)
+      @entities = value
+    end
+
+    def entities
+      self.entity = nil
+      collection = self
+      @enumerator ||= Enumerator.new do |yielder|
+        @entities.each do |v|
+          collection.entity = v
+          yielder << v
+        end
+        collection.entity = nil
+      end
+    end
+
+    def count
+      return @count unless @count.nil?
+      # apply filters and limits first
+      entities if @enumerator.nil?
+      # if @count is not setted yet - calculate it
+      @count = entities.count
+    end
+
+    protected
+
+    def load_entities
+      []
+    end
+  end
+
+  class ListContext < CollectionContext
+    def self.path
+      AdminIt::Engine.routes.url_helpers.send("list_#{resource.plural}_path")
+    end
+
+    class << self
+      protected
+
+      def default_icon
+        'bars'
+      end
+    end
+  end
+end

data/lib/admin_it/context/context.rb

@@ -0,0 +1,232 @@
+require 'uri'
+require File.join %w(extend_it dsl)
+require File.join %w(extend_it array_of)
+require File.join %w(extend_it symbolize)
+
+using ExtendIt::Symbolize
+
+module AdminIt
+  class Context
+    extend ExtendIt::Class
+    extend ExtendIt::Dsl
+    include ExtendIt::Callbacks
+    extend DataBehavior
+    extend FieldsHolder
+
+    class << self
+      extend ExtendIt::Dsl
+
+      attr_reader :context_name
+      attr_accessor :controller_class
+
+      dsl_accessor :icon do |value|
+        value.nil? ? default_icon : value.to_s
+      end
+      dsl_use_hash :fields
+    end
+
+    inherited_class_reader :resource, :entity_class
+    define_callbacks :initialize, :load, :save
+
+    def self.create(context_name, _resource, &block)
+      fail ArgumentError, 'Wrong resource' unless _resource.is_a?(Resource)
+      base = self
+      Class.new(base) do
+        @resource = _resource
+        @context_name = context_name
+        @entity_class = @resource.entity_class
+
+        import_data_module(base)
+
+        @fields = Hash[
+          _resource.fields(scope: :all).map { |f| [f.field_name, f] }
+        ]
+
+        before_configure if respond_to?(:before_configure)
+        instance_eval(&block) if block_given?
+        after_configure if respond_to?(:after_configure)
+      end
+    end
+
+    def self.field(*names, field_class: nil, &block)
+      names.ensure_symbols.each do |name|
+        if @fields.key?(name)
+          field = @fields[name] = Class.new(@fields[name]) if block_given?
+        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 self.collection?
+      false
+    end
+
+    def self.single?
+      false
+    end
+
+    def self.entity_path?
+      false
+    end
+
+    def self.url(context = nil, **params)
+      url = context.nil? ? path : context.path
+      params = context.nil? ? params : context.url_params(**params)
+      unless params.empty?
+        url << '?' << params.map { |k, v| "#{k}=#{v}" }.join('&')
+        url = URI.escape(url)
+      end
+      url
+    end
+
+    class << self
+      protected
+
+      def default_icon
+        ''
+      end
+    end
+
+    class_attr_reader :collection?, :single?, :entity_class, :resource, :icon,
+                      :entity_path?
+    attr_reader :top_menu, :toolbar, :parent, :template, :controller
+
+    CONTEXT_REGEXP = /\A
+      (?<resource_name>[a-zA-Z_][a-zA-Z_0-9]*)\/
+      (?<context_name>[a-zA-Z_][a-zA-Z_0-9]*)
+      (\((?<identity_value>[a-zA-Z_0-9]+)\))?
+    \z/x
+
+    def initialize(from, params: nil, store: nil, parent_init: false)
+      run_callbacks :initialize do
+        if from.is_a?(self.class.controller_class)
+          @controller = from
+        elsif from.is_a?(Context)
+          @controller = from.controller
+          self.parent = from unless parent_init == true
+          params ||= {}
+          store ||= {}
+        end
+
+        @fields = self.class.fields(scope: :all).map { |f| f.new }
+
+        if store.nil?
+          session = controller.session
+          store = session[:admin_it] ||= {}
+          store = store[resource.name] ||= {}
+          store = store[name] ||= {}
+        end
+
+        if params.nil?
+          params = controller.request.query_parameters
+        end
+        params = Hash[params.map { |k, v| [k.to_sym, v] }]
+
+        run_callbacks :load, arguments: { params: params, store: store } do
+          load_context unless parent_init == true
+        end
+      end
+    end
+
+    after_load do |store: {}, params: {}|
+      self.layout = params[:layout] if params.key?(:layout)
+      if params.key?(:parent)
+        self.parent = params[:parent]
+      elsif store.key?(:parent)
+        self.parent = store[:parent]
+      end
+    end
+
+    def name
+      @name ||= self.class.context_name
+    end
+
+    def field(name)
+      @fields.find { |f| f.name == name }
+    end
+
+    def fields(scope: :visible)
+      case scope
+      when nil, :all then @fields
+      when :visible then @fields.select { |f| f.visible? }
+      when :hidden then @fields.select { |f| !f.visible? }
+      when :readable then @fields.select { |f| f.readable? }
+      when :writable then @fields.select { |f| f.writable? }
+      when Field::TYPES then @fields.select { |f| f.type == scope }
+      else @fields
+      end
+    end
+
+    def save(**params)
+      return if controller.nil?
+      session = controller.session
+      store = session[:admin_it] ||= {}
+      store = store[resource.name] ||= {}
+      run_callbacks :save, arguments: [{ params: params }] do
+        store[name] = params
+      end
+    end
+
+    def layout
+      @layout ||= ''
+    end
+
+    def layout=(value)
+      value = value.to_sym if value.is_a?(String)
+      return unless value.is_a?(Symbol)
+      @layout = case value
+      when :dialog then 'dialog'
+      else ''
+      end
+    end
+
+    def parent=(value)
+      return if value.nil?
+      if value.is_a?(Context)
+        @parent = value
+      elsif value.is_a?(String)
+        m = CONTEXT_REGEXP.match(value)
+        unless m.nil?
+          r = AdminIt.resources[m[:resource_name].downcase.to_sym]
+          return if r.nil?
+          c = r[m[:context_name].downcase.to_sym]
+          return if c.nil?
+          @parent = c.new(self, parent_init: true)
+          unless m[:identity_value].nil?
+            @parent.entity = @parent.load_entity(identity: m[:identity_value])
+          end
+        end
+      else
+        @parent = nil
+      end
+    end
+
+    def child?
+      parent.is_a?(Context)
+    end
+
+    def begin_render(template)
+      @template = template
+      @toolbar = Helpers::Toolbar.new(template)
+      @top_menu = Helpers::TopMenu.new(template, class: 'navbar-nav')
+    end
+
+    def url_params(**params)
+      unless @parent.nil?
+        params.merge!(parent: @parent.send(:context_param))
+      end
+      params
+    end
+
+    protected
+
+    def context_param
+      "#{resource.name}/#{name}"
+    end
+
+    def load_context; end
+  end
+end

data/lib/admin_it/context/show_context.rb

@@ -0,0 +1,45 @@
+module AdminIt
+  class ShowContext < SingleContext
+    include Identifiable
+
+    class << self
+      include Renderable
+
+      protected
+
+      def default_icon
+        'info-circle'
+      end
+    end
+
+    def self.entity_path?
+      true
+    end
+
+    def self.read(entity = nil, &block)
+      if entity.nil?
+        @reader = block if block_given?
+      elsif !@reader.nil?
+        @reader.call(entity)
+      end
+    end
+
+    def destroy_entity
+      if entity_destroyer.nil?
+        if controller.respond_to?("#{resource.name}_destroy")
+          controller.send("#{resource.name}_destroy")
+        elsif controller.respond_to?(:destroy_entity)
+          controller.destroy_entity(entity_class)
+        else
+          destroy
+        end
+      else
+        entity_destroyer.call(controller)
+      end
+    end
+
+    protected
+
+    def destroy; end
+  end
+end