admin_it 1.0.1

data/lib/extend_it/array_of.rb

@@ -0,0 +1,181 @@
+require 'forwardable'
+require File.join %w(extend_it symbolize)
+require File.join %w(extend_it asserts)
+
+using ExtendIt::Symbolize
+
+module ExtendIt
+  module ArrayOf
+    def array_of(entity_class, &block)
+      array_name = "ArrayOf#{entity_class.name.split('::').last}"
+      array_class = Class.new(SimpleDelegator) do
+        @entity_class = entity_class
+        @scopes = {}
+        @finder = nil
+        extend ArrayOf::ArrayClassMethods
+        include ArrayOf::ArrayMethods
+      end
+      array_class.class_eval(&block) if block_given?
+      const_set(array_name, array_class)
+    end
+
+    module ArrayClassMethods
+      include Asserts
+
+      attr_reader :scopes, :finder
+
+      def select(arr)
+        if arr.is_a?(self)
+          arr.to_a
+        else
+          arr.select { |a| a.is_a?(@entity_class) }
+        end
+      end
+
+      def entity?(obj)
+        obj.is_a?(@entity_class)
+      end
+
+      def scope(*names, &block)
+        names.flatten.uniq.each do |name|
+          name = name.symbolize || next
+          @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
+          end
+        end
+      end
+
+      def find_by(name, &block)
+        assert_symbol(:name)
+        @finder = block.nil? ? proc { |e| e.send(name) } : block
+      end
+
+      def has_finder?
+        !@finder.nil?
+      end
+    end
+
+    module ArrayMethods
+      def initialize(*arr)
+        @array = self.class.select(arr.flatten)
+        super(@array)
+      end
+
+      def scope(name)
+        if name.is_a?(Symbol)
+          if self.class.scopes.include?(name)
+            self.class.new(@array.select(&self.class.scopes[name]))
+          end
+        else
+        end
+      end
+
+      def [](*args)
+        if args.size == 1 && args.first.is_a?(Symbol)
+          unless self.class.finder.nil?
+            return @array.find { |e| self.class.finder.call(e) == args.first }
+          end
+        else
+        end
+        @array[*args]
+      end
+
+      %i(& + * - | clear collect collect! delete_if drop drop_while each
+         each_index keep_if first last map reject reject! reverse reverse!
+         reverse_each rotate rotate! sample select select! shift shuffle
+         shuffle! slice slice! sort sort! sort_by! take take_while uniq uniq!
+         values_at).each do |method|
+        define_method method do |*args, &block|
+          result = @array.send(method, *args, &block)
+          if result == @array
+            self
+          elsif result.is_a?(Array)
+            self.class.new(result)
+          else
+            result
+          end
+        end
+      end
+
+      def <<(obj)
+        return unless self.class.entity?(obj)
+        @array << obj
+      end
+
+      def []=(*args)
+        return unless self.class.entity?(args.last)
+        @array.send(:[]=, *args)
+      end
+
+      def to_a
+        @array
+      end
+
+      def to_ary
+        @array
+      end
+
+      %i(concat replace).each do |method|
+        define_method method do |other|
+          @array.send(method, self.class.select(other))
+          self
+        end
+      end
+
+      def fill(*args)
+        if block_given?
+          @array.fill(*args) do |index|
+            obj = yield index
+            self.class.entity?(obj) ? obj : @array[index]
+          end
+        else
+          return self unless self.class.entity?(args.first)
+          @array.fill(*args)
+        end
+        self
+      end
+
+      def insert(index, *other)
+        @array.insert(index, self.class.select(other))
+        self
+      end
+
+      def map!(&block)
+        array = @array
+        array_class = self.class
+        enum = Enumerator.new do |yielder|
+          array.replace(array.map do |entity|
+            obj = (yielder << entity)
+            array_class.entity?(obj) ? obj : nil
+          end.compact)
+        end
+        if block_given?
+          enum.each(&block)
+          self
+        else
+          enum
+        end
+      end
+
+      %i(push unshift).each do |method|
+        define_method method do |*args|
+          @array.send(method, *self.class.select(args))
+          self
+        end
+      end
+
+      %i(assoc combination compact compact! flatten flatten pack permutation
+         product rassoc repeated_combination repeated_permutation transpose
+         zip).each do |method|
+        define_method method do |*args|
+          fail(
+            RuntimError,
+            "Method #{method} is not allowed in #{self.class.name}"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/extend_it/asserts.rb

@@ -0,0 +1,38 @@
+require File.join %w(extend_it caller)
+require File.join %w(extend_it symbolize)
+
+using ExtendIt::Caller
+using ExtendIt::Symbolize
+
+module ExtendIt
+  module Asserts
+    private
+
+    if RUBY_VERSION >= '2.1.0'
+      def assert_symbol(*names, binding: nil)
+        return unless binding ||= caller_binding
+        names.each do |name|
+          name = name.ensure_symbol || next
+          var = binding.local_variable_get(name)
+          var = var.ensure_symbol || fail(
+            ArgumentError,
+            "Argument `#{name}` should be a Symbol or String",
+            caller[1..-1]
+          )
+          binding.local_variable_set(name, var)
+        end
+      end
+    else
+      def assert_symbol(*names, binding: nil)
+        return unless binding ||= caller_binding
+        names.each do |name|
+          name = name.ensure_symbol || next
+          binding.eval(
+            "#{name} = #{name}.ensure_symbol || fail(ArgumentError," \
+            " 'Argument `#{name}` should be a Symbol or String')"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/extend_it/callbacks.rb

@@ -0,0 +1,105 @@
+require File.join %w(extend_it symbolize)
+require File.join %w(extend_it class)
+
+using ExtendIt::Symbolize
+
+module ExtendIt
+  module Callbacks
+    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"
+      end
+      base.extend(ClassMethods)
+    end
+
+    def self.extended(base)
+      fail RuntimeError, '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)
+
+      parents = self.class.parents
+      parents_rev = parents.reverse
+
+      names.ensure_symbols.each do |name|
+        around = []
+        around_name = "@around_#{name}".to_sym
+        var_name = "@before_#{name}".to_sym
+        parents_rev.each do |p|
+          if p.instance_variable_defined?(around_name)
+            arr = p.instance_variable_get(around_name)
+            arr.each do |b|
+              if original_context == true
+                b.call(*arguments)
+              else
+                instance_exec(*arguments, &b)
+              end
+            end
+            around.concat(arr)
+          end
+          if p.instance_variable_defined?(var_name)
+            p.instance_variable_get(var_name).each do |b|
+              if original_context == true
+                b.call(*arguments)
+              else
+                instance_exec(*arguments, &b)
+              end
+            end
+          end
+        end
+        yield if block_given?
+        around.reverse.each do |b|
+          if original_context == true
+            b.call(*arguments)
+          else
+            instance_exec(*arguments, &b)
+          end
+        end
+        var_name = "@after_#{name}".to_sym
+        parents.each do |p|
+          if p.instance_variable_defined?(var_name)
+            p.instance_variable_get(var_name).each do |b|
+              if original_context == true
+                b.call(*arguments)
+              else
+                instance_exec(*arguments, &b)
+              end
+            end
+          end
+        end
+      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) }
+        names.each do |name|
+          name = name.symbolize || next
+          callbacks.each do |cb|
+            cb_name = "#{cb}_#{name}".to_sym
+            var_name = "@#{cb_name}".to_sym
+            define_singleton_method cb_name do |&block|
+              return if block.nil?
+              arr =
+                if instance_variable_defined?(var_name)
+                  instance_variable_get(var_name)
+                else
+                  instance_variable_set(var_name, [])
+                end
+              arr << block
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/extend_it/caller.rb

@@ -0,0 +1,35 @@
+require 'continuation' if RUBY_VERSION >= '1.9.0'
+
+module ExtendIt
+  module Caller
+    # http://rubychallenger.blogspot.ru/2011/07/caller-binding.html
+    refine Object do
+      def caller_binding
+        cc, count = nil, 0
+        set_trace_func(lambda { |event, file, lineno, id, binding, klass|
+          if count == 2
+            set_trace_func nil
+            cc.call(binding)
+          elsif event == 'return'
+            count += 1
+          end
+        })
+        return callcc { |cont| cc = cont }
+      end
+
+      def caller_eval(str)
+        cc, ok = nil, false
+        set_trace_func(lambda { |event, file, lineno, id, binding, klass|
+          if ok
+            set_trace_func nil
+            cc.call(binding)
+          else
+            ok = event == "return"
+          end
+        })
+        return unless bb = callcc { |c| cc = c; nil }
+        eval(str, bb)
+      end
+    end
+  end
+end

data/lib/extend_it/class.rb

@@ -0,0 +1,47 @@
+require File.join %w(extend_it symbolize)
+
+using ExtendIt::Symbolize
+
+module ExtendIt
+  module Class
+    def self.extended(base)
+      base.instance_eval do
+        define_singleton_method :parents do
+          @parents ||= ancestors.take_while { |a| a != base }.concat([base])
+        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
+      arr.reduce([]) { |a, e| a << e.send(method_name, *args, &block) }
+    end
+
+    def inherited_class_reader(*names)
+      names.ensure_symbols.each do |name|
+        var = "@#{name}"
+        define_singleton_method(name) do
+          p = parents.find { |parent| parent.instance_variable_defined?(var) }
+          p.nil? ? nil : p.instance_variable_get(var)
+        end
+      end
+    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)
+        next if instance_methods.include?(attr_name)
+        var_name = "@#{attr_name}".to_sym
+        if methods.include?(attr_name)
+          define_method(attr_name) { self.class.send(attr_name) }
+        elsif instance_variable_defined?(var_name)
+          define_method attr_name do
+            self.class.instance_variable_get(var_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/extend_it/dsl.rb

@@ -0,0 +1,94 @@
+require File.join %w(extend_it asserts)
+require File.join %w(extend_it symbolize)
+
+using ExtendIt::Symbolize
+
+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
+            else
+              instance_exec(*args, &setter)
+            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)
+            else
+              obj = setter.nil? ? default : instance_exec(&setter)
+              instance_variable_set(var_name, obj)
+            end
+          else
+            obj = send(setter_name, *args)
+            obj.instance_eval(&block) unless obj.nil? || block.nil?
+            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)
+        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
+        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
+            end
+          else
+            instance_variable_set(var_name, block)
+          end
+        end
+      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
+        end
+        except = [except] if !except.nil? && !except.is_a?(Array)
+        if except.is_a?(Array)
+          names -= except.ensure_symbols
+        end
+        hash.delete_if { |k, v| !names.include?(k) }
+      end
+    end
+  end
+end

data/lib/extend_it/refines.rb

@@ -0,0 +1,6 @@
+module ExtendIt
+  module Refines; end
+end
+
+glob = File.extend_path(File.join(%w(.. refines ** *.rb)), __FILE__)
+Dir[glob].each { |file| require(file) }

data/lib/extend_it/symbolize.rb

@@ -0,0 +1,39 @@
+module ExtendIt
+  module Symbolize
+    refine Object do
+      def symbolize
+        nil
+      end
+
+      def ensure_symbol
+        nil
+      end
+    end
+
+    refine String do
+      def symbolize
+        to_sym
+      end
+
+      def ensure_symbol
+        to_sym
+      end
+    end
+
+    refine Symbol do
+      def symbolize
+        self
+      end
+
+      def ensure_symbol
+        self
+      end
+    end
+
+    refine Array do
+      def ensure_symbols
+        flatten.map { |x| x.ensure_symbol }.compact
+      end
+    end
+  end
+end

data/lib/extend_it.rb

@@ -0,0 +1,5 @@
+require File.join %w(extend_it refines)
+#require File.join %w(extend_it caller)
+#require File.join %w(extend_it array_of)
+#require File.join %w(extend_it dsl)
+

data/spec/internal/config/database.yml

@@ -0,0 +1,3 @@
+test:
+  adapter:  sqlite3
+  database: db/combustion_test.sqlite

data/spec/internal/config/routes.rb

@@ -0,0 +1,3 @@
+Rails.application.routes.draw do
+  #
+end

data/spec/internal/db/schema.rb

@@ -0,0 +1,3 @@
+ActiveRecord::Schema.define do
+  #
+end

data/spec/internal/log/.gitignore

@@ -0,0 +1 @@
+*.log

data/spec/lib/context/collection_context_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe AdminIt::CollectionContext do
+  let(:context_class) { described_class.create_class(:test, object_resource) }
+  subject { context_class.new }
+
+  # class DSL methods
+  it { expect(context_class.collection?).to be_true }
+  it { expect(context_class.single?).to be_false }
+
+  # instance methods
+  it { expect(subject.collection?).to be_true }
+  it { expect(subject.single?).to be_false }
+
+  it 'has entities setter' do
+    arr = [object_class.new, object_class.new]
+    subject.entities = arr
+    expect(subject.entities).to be_kind_of Enumerator
+  end
+end

data/spec/lib/context/context_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe AdminIt::Context do
+  let(:context_class) { described_class.create_class(:test, object_resource) }
+  subject { context_class.new }
+
+  # DSL methods
+  it { expect(context_class.collection?).to be_false }
+  it { expect(context_class.single?).to be_false }
+
+  # instance methods
+  it { expect(subject.collection?).to be_false }
+  it { expect(subject.single?).to be_false }
+
+  it 'sets entity class to Resource entity class' do
+    expect(subject.entity_class).to eq object_resource.entity_class
+  end
+
+  it 'sets fields to empty array by default' do
+    expect(subject.class.fields).to eq []
+  end
+
+  it 'extends AdminIt::Object context by default' do
+    expect(subject.class.included_modules)
+      .to include AdminIt::ObjectData::Context
+  end
+end
+

data/spec/lib/context/single_context_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe AdminIt::SingleContext do
+  let(:context_class) { described_class.create_class(:test, object_resource) }
+
+  describe 'DSL methods' do
+    subject { context_class }
+
+    it { expect(subject.collection?).to be_false }
+    it { expect(subject.single?).to be_true }
+  end
+
+  describe 'instance methods' do
+    subject { context_class.new }
+
+    it 'sets empty emtity for nil values' do
+      subject.entity = nil
+      expect(subject.values).to be_kind_of Hash
+    end
+
+    it 'sets entity Object' do
+      subject.entity = Object.new
+      expect(subject.values).to be_kind_of Hash
+    end
+  end
+end

data/spec/lib/data/object_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe AdminIt::ObjectData::Context do
+  before do
+    object_class.class_eval do
+      def r; 'r_value'; end
+      def rw; @rw_value ||= 'rw_value'; end
+      def rw=(value); @rw_value = value; end
+      def w=(value); @w_value = value; end
+      def bool?; true; end
+      def wrong_getter_arity(test); true; end
+      def wrong_setter1_arity=(test, me); true; end
+      def wrong_setter2_arity=; true; end
+    end
+  end
+
+  it 'retrieves all fields for ancestors' do
+    fields = object_context.fields(scope: :all)
+    expect(fields.size).to eq 3
+  end
+
+  it 'reads fields' do
+    single_object_context.entity = object
+    expect(single_object_context.values).to eq r: 'r_value', rw: 'rw_value'
+  end
+end
+
+describe AdminIt::ObjectData::Field do
+end