Class: Dry::Logic::Rule::Interface

Inherits:
Module
  • Object
show all
Defined in:
lib/dry/logic/rule/interface.rb

Constant Summary collapse

SPLAT = 
["*rest"].freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(arity, curried) ⇒ Interface

Returns a new instance of Interface.



13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/dry/logic/rule/interface.rb', line 13

def initialize(arity, curried)
  super()

  @arity = arity
  @curried = curried

  if !variable_arity? && curried > arity
    raise ArgumentError, "wrong number of arguments (#{curried} for #{arity})"
  end

  define_constructor if curried?

  if constant?
    define_constant_application
  else
    define_application
  end
end

Instance Attribute Details

#arity ⇒ Object (readonly)

Returns the value of attribute arity.



9
10
11
 
# File 'lib/dry/logic/rule/interface.rb', line 9

def arity
  @arity
end

#curried ⇒ Object (readonly)

Returns the value of attribute curried.



11
12
13
 
# File 'lib/dry/logic/rule/interface.rb', line 11

def curried
  @curried
end

Instance Method Details

#constant? ⇒ Boolean

Returns:

  • (Boolean) 


32
33
34
 
# File 'lib/dry/logic/rule/interface.rb', line 32

def constant?
  arity.zero?
end

#curried? ⇒ Boolean

Returns:

  • (Boolean) 


40
41
42
 
# File 'lib/dry/logic/rule/interface.rb', line 40

def curried?
  !curried.zero?
end

#curried_args ⇒ Object 



133
134
135
 
# File 'lib/dry/logic/rule/interface.rb', line 133

def curried_args
  @curried_args ||= ::Array.new(curried) { |i| "@arg#{i}" }
end

#define_application ⇒ Object 



113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
 
# File 'lib/dry/logic/rule/interface.rb', line 113

def define_application
  splat = variable_arity? ? SPLAT : EMPTY_ARRAY
  parameters = (unapplied_args + splat).join(", ")
  application = "@predicate[#{(curried_args + unapplied_args + splat).join(", ")}]"

  module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
    def call(#{parameters})                                         # def call(input0, input1, *rest)
      if #{application}                                             #   if @predicate[@arg0, @arg1, input0, input1, *rest]
        Result::SUCCESS                               #     ::Dry::Logic::Result::Success
      else                                                          #   else
        Result.new(false, id) { ast(#{parameters}) }  #     ::Dry::Logic::Result.new(false, id) { ast(input0, input1, *rest) }
      end                                                           #   end
    end                                                             # end
                                                                    #
    def [](#{parameters})                                           # def [](@arg0, @arg1, input0, input1, *rest)
      #{application}                                                #   @predicate[@arg0, @arg1, input0, input1, *rest]
    end                                                             # end
  RUBY
end

#define_constant_application ⇒ Object 



97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
 
# File 'lib/dry/logic/rule/interface.rb', line 97

def define_constant_application
  module_exec do
    def call(*)
      if @predicate[]
        Result::SUCCESS
      else
        Result.new(false, id) { ast }
      end
    end

    def [](*)
      @predicate[]
    end
  end
end

#define_constructor ⇒ Object 



80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/dry/logic/rule/interface.rb', line 80

def define_constructor
  assignment =
    if curried.equal?(1)
      "@arg0 = @args[0]"
    else
      "#{curried_args.join(", ")} = @args"
    end

  module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
    def initialize(*)  # def initialize(*)
      super            #   super
                       #
      #{assignment}    #   @arg0 = @args[0]
    end                # end
  RUBY
end

#name ⇒ Object 



58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/dry/logic/rule/interface.rb', line 58

def name
  if constant?
    "Constant"
  else
    arity_str =
      if variable_arity?
        "Variable#{arity.abs - 1}Arity"
      else
        "#{arity}Arity"
      end

    curried_str =
      if curried?
        "#{curried}Curried"
      else
        EMPTY_STRING
      end

    "#{arity_str}#{curried_str}"
  end
end

#unapplied ⇒ Object 



44
45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/dry/logic/rule/interface.rb', line 44

def unapplied
  if variable_arity?
    unapplied = arity.abs - 1 - curried

    if unapplied.negative?
      0
    else
      unapplied
    end
  else
    arity - curried
  end
end

#unapplied_args ⇒ Object 



137
138
139
 
# File 'lib/dry/logic/rule/interface.rb', line 137

def unapplied_args
  @unapplied_args ||= ::Array.new(unapplied) { |i| "input#{i}" }
end

#variable_arity? ⇒ Boolean

Returns:

  • (Boolean) 


36
37
38
 
# File 'lib/dry/logic/rule/interface.rb', line 36

def variable_arity?
  arity.negative?
end