admin_it 1.0.7 → 1.0.8

data/lib/extend_it/dsl.rb

@@ -1,94 +1,253 @@
-require File.join %w(extend_it asserts)
-require File.join %w(extend_it symbolize)
-
-using ExtendIt::Symbolize
+require File.join %w(extend_it ensures)
 
 module ExtendIt
   module Dsl
-    include Asserts
-
-    def dsl_accessor(*names, default: nil, &setter)
-      names.flatten.uniq.each do |name|
-        name = name.symbolize || next
-        var_name = "@#{name}".to_sym
-        setter_name = "#{name}=".to_sym
-        define_method setter_name do |*args|
-          obj =
-            if setter.nil?
-              default || args.first
+    using ExtendIt::Ensures if ExtendIt.config.use_refines?
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.class_eval do
+        define_method :dsl_obj do
+          self.class.dsl.new(self)
+        end
+      end
+    end
+
+    def self.extended(base)
+      base.extend(ClassMethods)
+      base.define_singleton_method :dsl_obj do
+        dsl.new(self)
+      end
+    end
+
+    def dsl_eval(&block)
+      dsl_obj.instance_eval(&block) if block_given?
+    end
+
+    module ClassMethods
+      def dsl(&block)
+        if @dsl.nil?
+          parent = superclass.respond_to?(:dsl) ? [superclass.dsl] : []
+        end
+        @dsl ||= Class.new(*parent) do
+          extend DslMethods
+
+          def initialize(receiver)
+            if receiver.nil? || receiver.frozen?
+              fail(ArgumentError, 'DSL receiver should be non-frozen object')
+            end
+            @dsl_receiver = receiver
+          end
+
+          private
+
+          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}"
+            )
+            if default.nil? && !block_given?
+              fail(ArgumentError, '`default` or block should be specified')
+            end
+            if dsl_receiver.instance_variable_defined?(var_name)
+              dsl_receiver.instance_variable_get(var_name)
             else
-              instance_exec(*args, &setter)
+              default = yield if block_given?
+              dsl_receiver.instance_variable_set(var_name, default)
             end
-          instance_variable_set(var_name, obj)
-        end
-        define_method name do |*args, &block|
-          if args.empty? && block.nil?
-            if instance_variable_defined?(var_name)
-              instance_variable_get(var_name)
+          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
+            if dsl_receiver.respond_to?(setter_name)
+              dsl_receiver.send(setter_name, value)
             else
-              obj = setter.nil? ? default : instance_exec(&setter)
-              instance_variable_set(var_name, obj)
+              dsl_receiver.instance_variable_set(var_name, value)
             end
-          else
+          end
+        end
+        @dsl.class_eval(&block) if block_given?
+        @dsl
+      end
+    end
+
+    module DslMethods
+      def dsl_accessor(*names, default: nil, variable: nil, &setter)
+        names = names.ensure_symbols
+        variable = nil if names.size != 1
+        variable = variable.ensure_local_name unless variable.nil?
+        names.each do |name|
+          name = name.ensure_local_name || next
+          setter_name = name.ensure_setter_name
+
+          define_method setter_name do |*args|
+            obj =
+              if setter.nil?
+                default || args.first
+              else
+                dsl_receiver.instance_exec(*args, &setter)
+              end
+            dsl_set(variable || name, obj)
+          end
+
+          define_method name do |*args, &block|
             obj = send(setter_name, *args)
-            obj.instance_eval(&block) unless obj.nil? || block.nil?
+            obj.dsl_eval(&block) if !block.nil? && obj.is_a?(Dsl)
             obj
           end
         end
       end
-    end
 
-    def dsl_boolean(*names, default: true)
-      default = default == true
-      names.flatten.uniq.each do |name|
-        name = name.symbolize || next
-        var_name = "@#{name}".to_sym
-        define_method "#{name}=" do |value = default|
-          instance_variable_set(var_name, value == true)
+      def dsl_boolean(*names, default: true, variable: nil)
+        default = default == true
+        names = names.ensure_symbols
+        variable = nil if names.size != 1
+        variable = variable.ensure_local_name unless variable.nil?
+        names.each do |name|
+          name = name.ensure_local_name || next
+          setter_name = name.ensure_setter_name
+
+          define_method name do |value = nil|
+            send(setter_name, value.nil? ? default : value)
+          end
+
+          define_method setter_name do |value = default|
+            dsl_set(variable || name, value == true)
+          end
         end
-        define_method "#{name}?" do
-          if instance_variable_defined?(var_name)
-            instance_variable_get(var_name) == true
-          else
-            instance_variable_set(var_name, default)
+      end
+
+      def dsl_block(*names, variable: nil)
+        names = names.ensure_symbols
+        variable = nil if names.size != 1
+        variable = variable.ensure_local_name unless variable.nil?
+        names.each do |name|
+          name = name.ensure_local_name || next
+          define_method name do |&block|
+            return if block.nil?
+            dsl_set(variable || name, block)
           end
         end
       end
-    end
 
-    def dsl_block(*names)
-      names.flatten.uniq.each do |name|
-        var_name = "@#{name}".to_sym
-        define_method name do |*args, &block|
-          if block.nil?
-            if instance_variable_defined?(var_name)
-              instance_variable_get(var_name)
-#              instance_exec(*args, &b) unless b.nil?
-#            else
-#              nil
+      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?
+
+        define_method "use_#{hash_name}" do |*names, except: nil|
+          hash = dsl_get(variable || hash_name, {})
+#          puts "---< #{names}, except: #{except} #{hash.inspect}"
+          keys = hash.keys
+          names = Dsl.expand_asterisk(names.ensure_symbols, keys)
+#          puts "---> #{names}"
+          names = names.empty? ? keys : names & keys
+#          puts "---> #{names}"
+          names -= except.ensure_symbols
+#          puts "---> #{names}"
+#          puts ''
+          hash.replace(Hash[names.map { |n| [n, hash[n]] }])
+        end
+      end
+
+      def dsl_hash_of_objects(hash_name, variable: nil, single: nil, &creator)
+        unless block_given?
+          fail(
+            ArgumentError,
+            '`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?
+
+        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'
+          )
+          define_method single do |name, **opts, &block|
+            name = name.ensure_symbol
+            unless name.nil?
+              hash = dsl_get(variable || hash_name, {})
+              obj = hash[name] ||=
+                    dsl_receiver.instance_exec(name, **opts, &creator)
+              obj.dsl_eval(&block) if !block.nil? && obj.is_a?(Dsl)
             end
-          else
-            instance_variable_set(var_name, block)
           end
         end
+
+        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|
+            obj = hash[name] ||=
+                  dsl_receiver.instance_exec(name, **opts, &creator)
+            obj.dsl_eval(&block) if !block.nil? && obj.is_a?(Dsl)
+          end
+        end
+
+        dsl_use_hash(hash_name, variable: variable)
       end
     end
 
-    def dsl_use_hash(hash_name)
-      assert_symbol(:hash_name, binding: binding)
-      define_method "use_#{hash_name}" do |*names, except: nil|
-        hash = instance_variable_get("@#{hash_name}")
-        if names.empty?
-          names = hash.keys
-        else
-          names = names.ensure_symbols & hash.keys
+    protected
+
+    def self.expand_asterisk(arr, keys)
+      return arr unless arr.include?(:*)
+      arr.map { |a| a == :* ? keys - arr : a }.flatten
+    end
+  end
+
+  module DslModule
+    def self.incuded(base)
+      fail RuntimeError, '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'
+      end
+
+      base.define_singleton_method :included do |superbase|
+        if @included.is_a?(Array)
+          @included.each { |i| superbase.instance_eval(&i) }
         end
-        except = [except] if !except.nil? && !except.is_a?(Array)
-        if except.is_a?(Array)
-          names -= except.ensure_symbols
+        if @dsl.is_a?(Array) && superbase.respond_to?(:dsl)
+          @dsl.each { |d| superbase.dsl(&d) }
         end
-        hash.delete_if { |k, v| !names.include?(k) }
       end
+
+      base.define_singleton_method :extended do |superbase|
+        if @extended.is_a?(Array)
+          @extended.each { |e| superbase.instance_eval(&e) }
+        end
+        if @dsl.is_a?(Array) && superbase.respond_to?(:dsl)
+          @dsl.each { |d| superbase.dsl(&d) }
+        end
+      end
+    end
+
+    def included(&block)
+      (@included ||= []) << block if block_given?
+    end
+
+    def extended(&block)
+      (@extended ||= []) << block if block_given?
+    end
+
+    def dsl(&block)
+      (@dsl ||= []) << block if block_given?
     end
   end
 end

data/lib/extend_it/ensures.rb

@@ -0,0 +1,193 @@
+module ExtendIt
+  module Ensures
+    VAR_REGEXP = /\A
+      (?<class_access>@{1,2})?
+      (?<name>[a-z_][a-zA-Z_0-9]*)
+      (?<modifier>[?!=])?
+    \z/x
+  end
+end
+
+if ExtendIt.config.use_refines?
+  module ExtendIt
+    module Ensures
+      refine Object do
+        def ensure_symbol; end
+        def ensure_instance_variable_name; end
+        def ensure_setter_name; end
+        def ensure_checker_name; end
+        def ensure_bang_name; end
+        def ensure_local_name; end
+      end
+
+      refine String do
+        def ensure_symbol
+          to_sym
+        end
+
+        def ensure_symbols
+          [to_sym]
+        end
+
+        def ensure_instance_variable_name
+          matches = VAR_REGEXP.match(self)
+          matches.nil? ? nil : "@#{matches[:name]}".to_sym
+        end
+
+        def ensure_setter_name
+          matches = VAR_REGEXP.match(self)
+          matches.nil? ? nil : "#{matches[:name]}=".to_sym
+        end
+
+        def ensure_checker_name
+          matches = VAR_REGEXP.match(self)
+          matches.nil? ? nil : "#{matches[:name]}?".to_sym
+        end
+
+        def ensure_bang_name
+          matches = VAR_REGEXP.match(self)
+          matches.nil? ? nil : "#{matches[:name]}!".to_sym
+        end
+
+        def ensure_local_name
+          matches = VAR_REGEXP.match(self)
+          matches.nil? ? nil : matches[:name].to_sym
+        end
+      end
+
+      refine Symbol do
+        def ensure_symbol
+          self
+        end
+
+        def ensure_symbols
+          [self]
+        end
+
+        def ensure_instance_variable_name
+          matches = VAR_REGEXP.match(to_s)
+          matches.nil? ? nil : "@#{matches[:name]}".to_sym
+        end
+
+        def ensure_setter_name
+          matches = VAR_REGEXP.match(to_s)
+          matches.nil? ? nil : "#{matches[:name]}=".to_sym
+        end
+
+        def ensure_checker_name
+          matches = VAR_REGEXP.match(to_s)
+          matches.nil? ? nil : "#{matches[:name]}?".to_sym
+        end
+
+        def ensure_bang_name
+          matches = VAR_REGEXP.match(to_s)
+          matches.nil? ? nil : "#{matches[:name]}!".to_sym
+        end
+
+        def ensure_local_name
+          matches = VAR_REGEXP.match(to_s)
+          matches.nil? ? nil : matches[:name].to_sym
+        end
+      end
+
+      refine Array do
+        def ensure_symbols
+          flatten.map { |x| x.ensure_symbol }.compact
+        end
+      end
+    end
+  end
+else
+  module ExtendIt
+    module Ensures; end
+  end
+
+  class Object
+    def ensure_symbol; end
+    def ensure_instance_variable_name; end
+    def ensure_setter_name; end
+    def ensure_checker_name; end
+    def ensure_bang_name; end
+    def ensure_local_name; end
+
+    def ensure_symbols
+      []
+    end
+  end
+
+  class String
+    def ensure_symbol
+      to_sym
+    end
+
+    def ensure_symbols
+      [to_sym]
+    end
+
+    def ensure_instance_variable_name
+      matches = ExtendIt::Ensures::VAR_REGEXP.match(self)
+      matches.nil? ? nil : "@#{matches[:name]}".to_sym
+    end
+
+    def ensure_setter_name
+      matches = ExtendIt::Ensures::VAR_REGEXP.match(self)
+      matches.nil? ? nil : "#{matches[:name]}=".to_sym
+    end
+
+    def ensure_checker_name
+      matches = ExtendIt::Ensures::VAR_REGEXP.match(self)
+      matches.nil? ? nil : "#{matches[:name]}?".to_sym
+    end
+
+    def ensure_bang_name
+      matches = ExtendIt::Ensures::VAR_REGEXP.match(self)
+      matches.nil? ? nil : "#{matches[:name]}!".to_sym
+    end
+
+    def ensure_local_name
+      matches = ExtendIt::Ensures::VAR_REGEXP.match(self)
+      matches.nil? ? nil : matches[:name].to_sym
+    end
+  end
+
+  class Symbol
+    def ensure_symbol
+      self
+    end
+
+    def ensure_symbols
+      [self]
+    end
+
+    def ensure_instance_variable_name
+      matches = ExtendIt::Ensures::VAR_REGEXP.match(to_s)
+      matches.nil? ? nil : "@#{matches[:name]}".to_sym
+    end
+
+    def ensure_setter_name
+      matches = ExtendIt::Ensures::VAR_REGEXP.match(to_s)
+      matches.nil? ? nil : "#{matches[:name]}=".to_sym
+    end
+
+    def ensure_checker_name
+      matches = ExtendIt::Ensures::VAR_REGEXP.match(to_s)
+      matches.nil? ? nil : "#{matches[:name]}?".to_sym
+    end
+
+    def ensure_bang_name
+      matches = ExtendIt::Ensures::VAR_REGEXP.match(to_s)
+      matches.nil? ? nil : "#{matches[:name]}!".to_sym
+    end
+
+    def ensure_local_name
+      matches = ExtendIt::Ensures::VAR_REGEXP.match(to_s)
+      matches.nil? ? nil : matches[:name].to_sym
+    end
+  end
+
+  class Array
+    def ensure_symbols
+      flatten.map { |x| x.ensure_symbol }.compact
+    end
+  end
+end

data/lib/extend_it.rb

@@ -1,4 +1,4 @@
-require File.join %w(extend_it refines)
+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)

data/spec/extend_it/config_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe ExtendIt::Config do
+  before do
+    @tmp_use_refines = described_class.instance_variable_get(:@use_refines)
+    described_class.instance_variable_set(:@use_refines, nil)
+  end
+
+  after do
+    described_class.instance_variable_set(:@use_refines, @tmp_use_refines)
+  end
+
+  describe '::use_refines' do
+    it 'sets to false as default' do
+      expect(described_class.use_refines).to be_false
+    end
+
+    if RUBY_VERSION >= '2.1.0'
+      it 'sets value from argument' do
+        described_class.use_refines(true)
+        expect(described_class.use_refines).to be_true
+      end
+    else
+      it 'avoids of setting true value' do
+        expect {
+          described_class.use_refines(true)
+        }.to raise_error RuntimeError
+      end
+    end
+  end
+
+  describe '::use_refines=' do
+    if RUBY_VERSION >= '2.1.0'
+      it 'sets value from argument' do
+        described_class.use_refines = true
+        expect(described_class.use_refines).to be_true
+      end
+    else
+      it 'avoids of setting true value' do
+        expect {
+          described_class.use_refines = true
+        }.to raise_error RuntimeError
+      end
+    end
+  end
+
+  describe '::use_refines?' do
+    it 'sets to false as default' do
+      expect(described_class.use_refines?).to be_false
+    end
+  end
+end