admin_it 1.0.11 → 1.1.0

data/lib/admin_it/version.rb

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

data/lib/extend_it.rb

@@ -1,5 +1,9 @@
-require File.join %w(extend_it config)
-#require File.join %w(extend_it caller)
-#require File.join %w(extend_it array_of)
-#require File.join %w(extend_it dsl)
+if !defined?(EnsureIt) && RUBY_VERSION >= '2.1.0'
+  require 'ensure_it_refined'
+else
+  require 'ensure_it'
+end
 
+EnsureIt.configure do |config|
+  config.error_class = ArgumentError
+end

data/lib/extend_it/array_of.rb

@@ -1,10 +1,7 @@
 require 'forwardable'
-require File.join %w(extend_it ensures)
-require File.join %w(extend_it asserts)
-
-using ExtendIt::Ensures if ExtendIt.config.use_refines?
 
 module ExtendIt
+  #
   module ArrayOf
     def array_of(entity_class, &block)
       array_name = "ArrayOf#{entity_class.name.split('::').last}"
@@ -19,8 +16,9 @@ module ExtendIt
       const_set(array_name, array_class)
     end
 
+    #
     module ArrayClassMethods
-      include Asserts
+      using EnsureIt if ENSURE_IT_REFINED
 
       attr_reader :scopes, :finder
 
@@ -37,27 +35,31 @@ module ExtendIt
       end
 
       def scope(*names, &block)
-        names.flatten.uniq.each do |name|
-          name = name.ensure_symbol || next
+        names = names.ensure_array(:flatten, :ensure_symbol, :compact, :uniq)
+        names.each do |name|
           @scopes[name] = block.nil? ? proc { |e| e.send(name) } : block
           str = name.to_s
           if str[-1] == '?'
-            @scopes[str[0..-2].to_sym] = block.nil? ? proc { |e| e.send(name) } : block
+            @scopes[str[0..-2].to_sym] =
+              block.nil? ? proc { |e| e.send(name) } : block
           end
         end
       end
 
       def find_by(name, &block)
-        assert_symbol(:name)
+        name = name.ensure_symbol!
         @finder = block.nil? ? proc { |e| e.send(name) } : block
       end
 
-      def has_finder?
+      def finder?
         !@finder.nil?
       end
     end
 
+    #
     module ArrayMethods
+      using EnsureIt if ENSURE_IT_REFINED
+
       def initialize(*arr)
         @array = self.class.select(arr.flatten)
         super(@array)

data/lib/extend_it/base.rb

@@ -1,8 +1,7 @@
-require File.join %w(extend_it ensures)
-
 module ExtendIt
+  #
   module Base
-    using ExtendIt::Ensures if ExtendIt.config.use_refines?
+    using EnsureIt if ENSURE_IT_REFINED
 
     def self.extended(base)
       base.instance_eval do
@@ -22,7 +21,8 @@ module ExtendIt
     end
 
     def attr_checker(*names)
-      names.ensure_symbols.each do |name|
+      names = names.ensure_array(:flatten, :ensure_symbol, :compact, :uniq)
+      names.each do |name|
         define_method "#{name}?" do
           instance_variable_get("@#{name}") == true
         end
@@ -36,7 +36,8 @@ module ExtendIt
     end
 
     def inherited_class_reader(*names)
-      names.ensure_symbols.each do |name|
+      names = names.ensure_array(:flatten, :ensure_symbol, :compact, :uniq)
+      names.each do |name|
         var = "@#{name}"
         define_singleton_method(name) do
           p = parents.find { |parent| parent.instance_variable_defined?(var) }
@@ -46,10 +47,10 @@ module ExtendIt
     end
 
     def class_attr_reader(*attrs)
-      attrs.ensure_symbols.each do |attr_name|
-        attr_name.ensure_local_name || next
+      attrs.ensure_array(:flatten).each do |attr_name|
+        attr_name.ensure_symbol(name_of: :local) || next
         next if instance_methods.include?(attr_name)
-        var_name = attr_name.ensure_instance_variable_name
+        var_name = attr_name.ensure_symbol(name_of: :instance_variable)
         if methods.include?(attr_name)
           define_method(attr_name) { self.class.send(attr_name) }
         else

data/lib/extend_it/callbacks.rb

@@ -1,35 +1,33 @@
-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?
+    using EnsureIt if EnsureIt.refined?
 
     CALLBACKS = %i(before after around)
 
     def self.included(base)
-      unless base.is_a?(Class)
-        fail RuntimeError, 'Can be included in classes only'
-      end
+      fail 'Can be included in classes only' unless base.is_a?(Class)
       unless (class << base; self end).included_modules.include?(Base)
-        fail RuntimeError, "#{base.name} should extend ExtendIt::Base"
+        fail "#{base.name} should extend ExtendIt::Base"
       end
       base.extend(ClassMethods)
     end
 
     def self.extended(base)
-      fail RuntimeError, 'This module can\'t be extended'
+      fail 'This module can\'t be extended'
     end
 
     def run_callbacks(*names, arguments: [], original_context: false)
       # sanitize arguments
-      arguments = [] if arguments.nil?
-      arguments = [arguments] unless arguments.is_a?(Array)
+      arguments = arguments.ensure_array(make: true)
 
       parents = self.class.parents
       parents_rev = parents.reverse
 
-      names.ensure_symbols.each do |name|
+      names = names.ensure_array(:flatten, :ensure_symbol, :compact, :uniq)
+      names.each do |name|
         around = []
         around_name = "@around_#{name}".to_sym
         var_name = "@before_#{name}".to_sym
@@ -78,12 +76,13 @@ module ExtendIt
       end
     end
 
+    #
     module ClassMethods
       def define_callbacks(*names, callbacks: [:before, :after])
         callbacks = [:before, :after] unless callbacks.is_a?(Array)
-        callbacks.select! { |cb| CALLBACKS.include?(cb) }
+        callbacks = callbacks.ensure_array(values: CALLBACKS)
+        names = names.ensure_array(:flatten, :ensure_symbol, :compact, :uniq)
         names.each do |name|
-          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/dsl.rb

@@ -1,9 +1,9 @@
-require File.join %w(extend_it ensures)
-
+#
 module ExtendIt
-  module Dsl
-    using ExtendIt::Ensures if ExtendIt.config.use_refines?
+  using EnsureIt if EnsureIt.refined?
 
+  #
+  module Dsl
     def self.included(base)
       base.extend(ClassMethods)
       base.class_eval do
@@ -24,6 +24,7 @@ module ExtendIt
       dsl_obj.instance_eval(&block) if block_given?
     end
 
+    #
     module ClassMethods
       def dsl(&block)
         if @dsl.nil?
@@ -44,9 +45,7 @@ module ExtendIt
           attr_reader :dsl_receiver
 
           def dsl_get(var_name, default = nil)
-            var_name = var_name.ensure_instance_variable_name || fail(
-              ArgumentError, "Wrong `var_name` argument: #{var_name.inspect}"
-            )
+            var_name = var_name.ensure_symbol!(name_of: :instance_variable)
             if default.nil? && !block_given?
               fail(ArgumentError, '`default` or block should be specified')
             end
@@ -59,10 +58,8 @@ module ExtendIt
           end
 
           def dsl_set(var_name, value)
-            var_name = var_name.ensure_instance_variable_name || fail(
-              ArgumentError, "Wrong `var_name` argument: #{var_name.inspect}"
-            )
-            setter_name = var_name.ensure_setter_name
+            var_name = var_name.ensure_symbol!(name_of: :instance_variable)
+            setter_name = var_name.ensure_symbol!(name_of: :setter)
             if dsl_receiver.respond_to?(setter_name)
               dsl_receiver.send(setter_name, value)
             else
@@ -75,14 +72,15 @@ module ExtendIt
       end
     end
 
+    #
     module DslMethods
       def dsl_accessor(*names, default: nil, variable: nil, &setter)
-        names = names.ensure_symbols
+        names = names.ensure_array(:flatten, :compact, :uniq)
         variable = nil if names.size != 1
-        variable = variable.ensure_local_name unless variable.nil?
+        variable = variable.ensure_symbol(name_of: :local)
         names.each do |name|
-          name = name.ensure_local_name || next
-          setter_name = name.ensure_setter_name
+          name = name.ensure_symbol(name_of: :getter) || next
+          setter_name = name.ensure_symbol(name_of: :setter) || next
 
           define_method setter_name do |*args|
             obj =
@@ -104,12 +102,12 @@ module ExtendIt
 
       def dsl_boolean(*names, default: true, variable: nil)
         default = default == true
-        names = names.ensure_symbols
+        names = names.ensure_array(:flatten, :compact, :uniq)
         variable = nil if names.size != 1
-        variable = variable.ensure_local_name unless variable.nil?
+        variable = variable.ensure_symbol(name_of: :local)
         names.each do |name|
-          name = name.ensure_local_name || next
-          setter_name = name.ensure_setter_name
+          name = name.ensure_symbol(name_of: :getter) || next
+          setter_name = name.ensure_symbol(name_of: :setter) || next
 
           define_method name do |value = nil|
             send(setter_name, value.nil? ? default : value)
@@ -122,11 +120,11 @@ module ExtendIt
       end
 
       def dsl_block(*names, variable: nil)
-        names = names.ensure_symbols
+        names = names.ensure_array(:flatten, :compact, :uniq)
         variable = nil if names.size != 1
-        variable = variable.ensure_local_name unless variable.nil?
+        variable = variable.ensure_symbol(name_of: :local)
         names.each do |name|
-          name = name.ensure_local_name || next
+          name = name.ensure_symbol(name_of: :getter) || next
           define_method name do |&block|
             return if block.nil?
             dsl_set(variable || name, block)
@@ -135,19 +133,16 @@ module ExtendIt
       end
 
       def dsl_use_hash(hash_name, variable: nil)
-        hash_name = hash_name.ensure_local_name || fail(
-          ArgumentError,
-          '`hash_name` argument for `dsl_use_hash` should be a Symbol ' \
-          'or a String'
-        )
-        variable = variable.ensure_local_name unless variable.nil?
+        hash_name = hash_name.ensure_symbol!(name_of: :local)
+        variable = variable.ensure_symbol(name_of: :local)
 
         define_method "use_#{hash_name}" do |*names, except: nil|
           hash = dsl_get(variable || hash_name, {})
           keys = hash.keys
-          names = Dsl.expand_asterisk(names.ensure_symbols, keys)
+          names = names.ensure_array(:flatten, :ensure_symbol, :compact, :uniq)
+          names = Dsl.expand_asterisk(names, keys)
           names = names.empty? ? keys : names & keys
-          names -= except.ensure_symbols
+          names -= except.ensure_array(:flatten, :ensure_symbol, :compact, make: true)
           hash.replace(Hash[names.map { |n| [n, hash[n]] }])
         end
       end
@@ -159,19 +154,11 @@ module ExtendIt
             '`dsl_hash_of_objects` requires creator block to be present'
           )
         end
-        hash_name = hash_name.ensure_local_name || fail(
-          ArgumentError,
-          '`hash_name` argument for `dsl_hash_of_objects` should be' \
-          ' a Symbol or a String'
-        )
-        variable = variable.ensure_local_name unless variable.nil?
+        hash_name = hash_name.ensure_symbol!(name_of: :local)
+        variable = variable.ensure_symbol(name_of: :local)
 
         unless single.nil?
-          single = single.ensure_local_name || fail(
-            ArgumentError,
-            '`single` option for `dsl_hash_of_objects` should be' \
-            ' a Symbol or a String or nil'
-          )
+          single = single.ensure_symbol!(name_of: :local)
           define_method single do |name, **opts, &block|
             name = name.ensure_symbol
             unless name.nil?
@@ -185,7 +172,8 @@ module ExtendIt
 
         define_method hash_name do |*names, **opts, &block|
           hash = dsl_get(variable || hash_name, {})
-          Dsl.expand_asterisk(names.ensure_symbols, hash.keys).each do |name|
+          names = names.ensure_array(:flatten, :ensure_symbol, :compact, :uniq)
+          Dsl.expand_asterisk(names, hash.keys).each do |name|
             obj = hash[name] ||=
                   dsl_receiver.instance_exec(name, **opts, &creator)
             obj.dsl_eval(&block) if !block.nil? && obj.is_a?(Dsl)
@@ -204,14 +192,15 @@ module ExtendIt
     end
   end
 
+  #
   module DslModule
     def self.incuded(base)
-      fail RuntimeError, 'DslModule can be only extended by other modules'
+      fail 'DslModule can be only extended by other modules'
     end
 
     def self.extended(base)
       unless base.is_a?(Module)
-        fail RuntimeError, 'DslModule can be only extended by modules'
+        fail 'DslModule can be only extended by modules'
       end
 
       base.define_singleton_method :included do |superbase|

data/spec/extend_it/dsl_spec.rb

@@ -14,10 +14,6 @@ describe ExtendIt::Dsl do
     includer_class.new
   end
 
-  let :dsl_instance do
-    includer_obj.dsl
-  end
-
   let :dsl_class do
     mod = described_class
     Class.new do
@@ -25,10 +21,6 @@ describe ExtendIt::Dsl do
     end
   end
 
-  let :dsl_obj do
-    dsl_class.new
-  end
-
   describe '#dsl_accessor' do
     it 'creates getter and setter' do
       includer_class.dsl { dsl_accessor :test }
@@ -44,49 +36,47 @@ describe ExtendIt::Dsl do
 
     it 'creates accessors from array' do
       includer_class.dsl { dsl_accessor :test, ['one', :two], 10 }
-      expect(dsl_instance).to respond_to :test
-      expect(dsl_instance).to respond_to :one
-      expect(dsl_instance).to respond_to :two
+      expect(includer_obj.dsl_obj).to respond_to :test
+      expect(includer_obj.dsl_obj).to respond_to :one
+      expect(includer_obj.dsl_obj).to respond_to :two
     end
 
     it 'uses default value' do
       includer_class.dsl { dsl_accessor :test, default: 10 }
-      expect(includer_obj.dsl.test).to eq 10
+      expect(includer_obj.dsl_obj.test).to eq 10
     end
 
     it 'uses setter to set value if it given' do
       includer_class.dsl { dsl_accessor(:test) { 10 } }
-      expect(includer_obj.dsl.test).to eq 10
+      expect(includer_obj.dsl_obj.test).to eq 10
     end
 
-    it 'evals block in object context with getter if is Dsl' do
+    xit 'evals block in object context with getter if is Dsl' do
       includer_class.dsl { dsl_accessor :test }
       dsl_class.dsl { dsl_accessor :child }
-      obj = dsl_obj
+      obj = includer_obj.dsl_obj
       includer_obj.dsl_eval { test(obj) { child 'test' } }
-      expect(dsl_obj.instance_variable_get(:@child)).to eq 'test'
+      expect(includer_obj.instance_variable_get(:@child)).to eq 'test'
     end
   end
 
   describe '#dsl_boolean' do
-    it 'creates getter, setter and checker' do
+    it 'creates getter and setter' do
       includer_class.dsl { dsl_boolean :test }
-      dsl_instance.test = false
-      expect(dsl_instance.test).to be_false
-      expect(dsl_instance.test?).to be_false
+      includer_obj.dsl_obj.test = false
       expect(includer_obj.test).to be_false
     end
 
     it 'sets values to true by default' do
       includer_class.dsl { dsl_boolean :test }
-      expect(includer_obj.dsl.test?).to be_true
+      expect(includer_obj.dsl_obj.test).to be_true
     end
 
     it 'creates booleans from array' do
       includer_class.dsl { dsl_boolean :test, ['one', :two], 10 }
-      expect(dsl_instance).to respond_to :test?
-      expect(dsl_instance).to respond_to :one?
-      expect(dsl_instance).to respond_to :two?
+      expect(includer_obj.dsl_obj).to respond_to :test
+      expect(includer_obj.dsl_obj).to respond_to :one
+      expect(includer_obj.dsl_obj).to respond_to :two
     end
   end
 
@@ -94,35 +84,34 @@ describe ExtendIt::Dsl do
     it 'creates setter and getter' do
       block = proc { :test }
       includer_class.dsl { dsl_block :test }
-      includer_obj.dsl.test(&block)
+      includer_obj.dsl_obj.test(&block)
       expect(includer_obj.test).to eq block
     end
   end
 
   describe '#dsl_use_hash' do
     before do
-#      includer_class.dsl_accessor :fields
       includer_class.dsl { dsl_use_hash :tests }
       includer_obj.tests = { one: 1, two: 2, three: 3 }
     end
 
     it 'reorders hash' do
-      includer_obj.dsl.use_tests :two, :three, :one
+      includer_obj.dsl_obj.use_tests :two, :three, :one
       expect(includer_obj.tests).to eq(two: 2, three: 3, one: 1)
     end
 
     it 'recreates hash' do
-      includer_obj.dsl.use_tests :two, :three
+      includer_obj.dsl_obj.use_tests :two, :three
       expect(includer_obj.tests).to eq(two: 2, three: 3)
     end
 
     it 'excludes hash' do
-      includer_obj.dsl.use_tests :three, :one, :two, except: :one
+      includer_obj.dsl_obj.use_tests :three, :one, :two, except: :one
       expect(includer_obj.tests).to eq(three: 3, two: 2)
     end
 
     it 'excludes hash with except only option' do
-      includer_obj.dsl.use_tests except: :one
+      includer_obj.dsl_obj.use_tests except: :one
       expect(includer_obj.tests).to eq(two: 2, three: 3)
     end
   end
@@ -133,7 +122,7 @@ describe ExtendIt::Dsl do
       includer_class.dsl do
         dsl_hash_of_objects(:tests) { |name| objects[name] }
       end
-      includer_obj.dsl.tests :one, :two
+      includer_obj.dsl_obj.tests :one, :two
       expect(includer_obj.tests).to eq objects
     end
 
@@ -142,7 +131,7 @@ describe ExtendIt::Dsl do
       demand = Object.new
       includer_class.dsl { dsl_hash_of_objects(:tests) { |_| demand } }
       includer_obj.tests = objects
-      includer_obj.dsl.tests :one, :two
+      includer_obj.dsl_obj.tests :one, :two
       expect(includer_obj.tests).to eq(objects.merge(two: demand))
     end
   end