admin_it 1.0.7 → 1.0.8

data/lib/admin_it/resource.rb

@@ -1,62 +1,52 @@
-require File.join %w(extend_it symbolize)
-require File.join %w(extend_it asserts)
+require File.join %w(extend_it base)
 require File.join %w(extend_it callbacks)
-require File.join %w(extend_it class)
 
-using ExtendIt::Symbolize
+using ExtendIt::Ensures
 
 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
+  class Resource
+    extend ExtendIt::Base
+    include ExtendIt::Callbacks
+    include ExtendIt::Dsl
+    include Iconed
+    include FieldsHolder
+    include FiltersHolder
+
+    dsl do
+      dsl_hash_of_objects :contexts, single: :context do |name, **opts|
+        context_class = opts[:class] || opts[:context_class] || Context
+        unless context_class.is_a?(Class) && context_class <= Context
+          fail(
+            ArgumentError,
+            'context class should be AdminIt::Context descendant'
+          )
+        end
+        @contexts[name] = context_class.create(name, entity_class)
       end
-    end
 
-    def hide_fields(*names)
-      names.ensure_symbols.each do |name|
-        @fields[name].hide if @fields.key?(name)
+      dsl_boolean :confirm_destroy
+      dsl_accessor :display_name
+
+      def collection(&block)
+        return unless block_given?
+        hash = dsl_get(:contexts, {})
+        hash.select { |_, c| c.collection? }.each { |_, c| c.dsl_eval(&block) }
       end
-    end
 
-    def show_fields(*names)
-      names.ensure_symbols.each do |name|
-        @fields[name].show if @fields.key?(name)
+      def single(&block)
+        return unless block_given?
+        hash = dsl_get(:contexts, {})
+        hash.select { |_, c| c.single? }.each { |_, c| c.dsl_eval(&block) }
       end
-    end
-  end
 
-  module FiltersHolder
-    def filters(scope: :all)
-      @filters ||= {}
-      case scope
-      when nil, :all then @filters.values
-      else @filters.values
+      dsl_accessor :default_context do |value|
+        value = value.ensure_symbol
+        @contexts.key?(value) ? value : nil
       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
-    dsl_boolean :confirm_destroy
-
     define_callbacks :initialize
 
     def initialize(
@@ -66,7 +56,11 @@ module AdminIt
       destroyable: true,
       auto_filters: true
     )
-      assert_symbol(:name)
+      name = name.ensure_symbol || fail(
+        ArgumentError,
+        '`name` argument for resource constructor should be a Symbol ' \
+        'or a String'
+      )
 
       @name, @entity_class = name, entity_class
       if @entity_class.nil?
@@ -98,79 +92,32 @@ module AdminIt
       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
+    def confirm_destroy?
+      @confirm_destroy.nil? ? @confirm_destroy = true : @confirm_destroy == true
+    end
+
+    def destroyable?
+      @destroyable.nil? ? @destroyable = true : @destroyable == true
     end
 
     def [](name)
-      assert_symbol(:name)
-      @contexts[name]
+      context(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
+    def context(name)
+      @contexts[name.ensure_symbol]
     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
+      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
     end
 
@@ -179,11 +126,7 @@ module AdminIt
     end
 
     def display_name
-      plural.split('_').map { |s| s.capitalize }.join(' ')
-    end
-
-    def destroyable?
-      @destroyable
+      @display_name ||= plural.split('_').map { |s| s.capitalize }.join(' ')
     end
 
     def collection_path
@@ -280,11 +223,11 @@ module AdminIt
   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
+    resource = Resource.new(name, entity_class, **opts)
+    resource.dsl_eval(&block) if block_given?
+    resource.define_controller
     @resources ||= {}
-    @resources[_resource.name] = _resource
+    @resources[resource.name] = resource
   end
 
   def self.resources

data/lib/admin_it/shared.rb

@@ -0,0 +1,64 @@
+require File.join %w(extend_it dsl)
+
+module AdminIt
+  module Renderable
+    extend ExtendIt::DslModule
+
+    dsl { dsl_block :render }
+
+    def render(entity, instance = nil, &block)
+      return if @render.nil?
+      # method used as event emmiter, call block in instance or caller
+      # context if it present
+      if instance.nil?
+        @render.call(entity)
+      else
+        instance.instance_exec(entity, &@render)
+      end
+    end
+  end
+
+  module Iconed
+    extend ExtendIt::DslModule
+
+    dsl do
+      dsl_accessor :icon
+    end
+
+    def icon=(value)
+      @icon = value.nil? ? default_icon : value.to_s
+    end
+
+    def icon
+      @icon ||= default_icon
+    end
+
+    protected
+
+    def default_icon
+      ''
+    end
+  end
+
+  module DisplayableName
+    extend ExtendIt::DslModule
+
+    dsl do
+      dsl_accessor :display_name
+    end
+
+    def display_name=(value)
+      @display_name = value.nil? ? default_display_name : value.to_s
+    end
+
+    def display_name
+      @display_name ||= default_display_name
+    end
+
+    protected
+
+    def default_display_name
+      ''
+    end
+  end
+end

data/lib/admin_it/version.rb

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

data/lib/admin_it.rb

@@ -1,13 +1,15 @@
-#require 'extend_it'
-#module AdminIt
-#  using ExtendIt::Refines
-#end
+require 'extend_it'
+require File.join %w(extend_it ensures)
+
+module AdminIt
+  using ExtendIt::Ensures if ExtendIt.config.use_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 shared)
 require File.join %w(admin_it data)
 require File.join %w(admin_it field)
 require File.join %w(admin_it filters)

data/lib/extend_it/array_of.rb

@@ -1,8 +1,8 @@
 require 'forwardable'
-require File.join %w(extend_it symbolize)
+require File.join %w(extend_it ensures)
 require File.join %w(extend_it asserts)
 
-using ExtendIt::Symbolize
+using ExtendIt::Ensures if ExtendIt.config.use_refines?
 
 module ExtendIt
   module ArrayOf
@@ -38,7 +38,7 @@ module ExtendIt
 
       def scope(*names, &block)
         names.flatten.uniq.each do |name|
-          name = name.symbolize || next
+          name = name.ensure_symbol || next
           @scopes[name] = block.nil? ? proc { |e| e.send(name) } : block
           str = name.to_s
           if str[-1] == '?'

data/lib/extend_it/asserts.rb

@@ -1,8 +1,10 @@
 require File.join %w(extend_it caller)
-require File.join %w(extend_it symbolize)
+require File.join %w(extend_it ensures)
 
-using ExtendIt::Caller
-using ExtendIt::Symbolize
+if ExtendIt.config.use_refines?
+  using ExtendIt::Caller
+  using ExtendIt::Ensures
+end
 
 module ExtendIt
   module Asserts

data/lib/extend_it/{class.rb → base.rb}

@@ -1,9 +1,9 @@
-require File.join %w(extend_it symbolize)
-
-using ExtendIt::Symbolize
+require File.join %w(extend_it ensures)
 
 module ExtendIt
-  module Class
+  module Base
+    using ExtendIt::Ensures if ExtendIt.config.use_refines?
+
     def self.extended(base)
       base.instance_eval do
         define_singleton_method :parents do
@@ -12,6 +12,23 @@ module ExtendIt
       end
     end
 
+    def metaclass(&block)
+      if @metaclass.nil?
+        @metaclass = (class << self; self end)
+        @metaclass.extend(Base)
+      end
+      @metaclass.class_eval(&block) if block_given?
+      @metaclass
+    end
+
+    def attr_checker(*names)
+      names.ensure_symbols.each do |name|
+        define_method "#{name}?" do
+          instance_variable_get("@#{name}") == true
+        end
+      end
+    end
+
     def call_inherited(method_name, *args, base_first: false, &block)
       arr = parents.select { |parent| parent.methods.include?(method_name) }
       arr.reverse! if base_first == true
@@ -29,16 +46,18 @@ module ExtendIt
     end
 
     def class_attr_reader(*attrs)
-      attrs.flatten.uniq.each do |attr_name|
-        attr_name = attr_name.to_sym if attr_name.is_a?(String)
-        next unless attr_name.is_a?(Symbol)
+      attrs.ensure_symbols.each do |attr_name|
+        attr_name.ensure_local_name || next
         next if instance_methods.include?(attr_name)
-        var_name = "@#{attr_name}".to_sym
+        var_name = attr_name.ensure_instance_variable_name
         if methods.include?(attr_name)
           define_method(attr_name) { self.class.send(attr_name) }
-        elsif instance_variable_defined?(var_name)
+        else
           define_method attr_name do
-            self.class.instance_variable_get(var_name)
+            p = self.class.parents.find do |parent|
+              parent.instance_variable_defined?(var_name)
+            end
+            p.nil? ? nil : p.instance_variable_get(var_name)
           end
         end
       end

data/lib/extend_it/callbacks.rb

@@ -1,18 +1,18 @@
-require File.join %w(extend_it symbolize)
-require File.join %w(extend_it class)
-
-using ExtendIt::Symbolize
+require File.join %w(extend_it ensures)
+require File.join %w(extend_it base)
 
 module ExtendIt
   module Callbacks
+    using ExtendIt::Ensures if ExtendIt.config.use_refines?
+
     CALLBACKS = %i(before after around)
 
     def self.included(base)
       unless base.is_a?(Class)
         fail RuntimeError, 'Can be included in classes only'
       end
-      unless (class << base; self end).included_modules.include?(ExtendIt::Class)
-        fail RuntimeError, "#{base.name} should extend ExtendIt::Class"
+      unless (class << base; self end).included_modules.include?(Base)
+        fail RuntimeError, "#{base.name} should extend ExtendIt::Base"
       end
       base.extend(ClassMethods)
     end
@@ -83,7 +83,7 @@ module ExtendIt
         callbacks = [:before, :after] unless callbacks.is_a?(Array)
         callbacks.select! { |cb| CALLBACKS.include?(cb) }
         names.each do |name|
-          name = name.symbolize || next
+          name = name.ensure_symbol || next
           callbacks.each do |cb|
             cb_name = "#{cb}_#{name}".to_sym
             var_name = "@#{cb_name}".to_sym

data/lib/extend_it/config.rb

@@ -0,0 +1,30 @@
+module ExtendIt
+  module Config
+    def self.use_refines(value = nil)
+      if value.nil?
+        @use_refines.nil? ? @use_refines = false : @use_refines
+      else
+        self.use_refines = value
+      end
+    end
+
+    def self.use_refines=(value)
+      unless RUBY_VERSION >= '2.1.0'
+        fail(
+          RuntimeError,
+          'Refinements can be used only with ruby versions >= 2.1.0'
+        )
+      end
+      @use_refines = value == true
+    end
+
+    def self.use_refines?
+      @use_refines
+    end
+  end
+
+  def self.config
+    yield Config if block_given?
+    Config
+  end
+end