Module: Rulix::Registry

Included in:
Base, Mutator, Validator
Defined in:
lib/rulix/registry.rb

Class Method Summary collapse

Class Method Details

.included(other) ⇒ Object 



3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
# File 'lib/rulix/registry.rb', line 3

def self.included other
  other.class_eval do
    @registry ||= {}

    def self.register symbol, procable = nil, &block
      symbol = symbol.to_sym unless symbol.is_a? Symbol

      return register_block symbol, &block if block_given?

      if !procable.respond_to?(:to_proc)
        unless (procable.respond_to?(:new) && procable.instance_methods.include?(:to_proc))
          raise ArgumentError, "You attempted to register :#{symbol}, but the argument you passed can't be coerced into a proc!"
        end
      end

      @registry[symbol] = procable
    end

    private

    def self.register_block symbol, &block
      @registry[symbol] = block.to_proc
    end

    def self.get_operations operations
      operations.map do |op|
        get_operation op
      end
    end

    def self.get_operation operation
      case operation
      when Symbol, String
        registered_op = @registry[operation.to_sym]

        if registered_op
          return registered_op.to_proc if registered_op.respond_to?(:to_proc)

          registered_op.new.to_proc
        else
          operation.to_proc
        end
      when Hash
        # If you're passing a hash as a rule argument, we assume that it's been registered
        # The registered rule must be instantiatable or a proc, and we assume the args passed
        # should be passed to the object as config options
        key = operation.keys.first
        arguments = operation[key]

        registered_procable = @registry[key.to_sym]

        raise ArgumentError, "You've supplied a hash argument for a rule, but there's no rule registered for #{key}!" unless registered_procable

        case registered_procable
        when Proc
          registered_procable.curry[arguments]
        else
          registered_procable.new(arguments).to_proc
        end
      when Proc
        operation
      else
        raise ArgumentError, "Can't coerce #{operation} into useable proc!" unless operation.respond_to? :to_proc

        operation.to_proc
      end
    end
  end
end