Module: Matchete

Defined in:
lib/matchete.rb,
lib/matchete/exceptions.rb

Defined Under Namespace

Modules: ClassMethods Classes: NotResolvedError

Constant Summary collapse

Any = 
-> (x) { true }
None = 
-> (x) { false }

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.included(klass) ⇒ Object 



5
6
7
8
9
 
# File 'lib/matchete.rb', line 5

def self.included(klass)
  klass.extend ClassMethods
  klass.instance_variable_set "@methods", {}
  klass.instance_variable_set "@default_methods", {}
end

Instance Method Details

#call_overloaded(method_name, args: [], kwargs: {}) ⇒ Object 



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/matchete.rb', line 50

def call_overloaded(method_name, args: [], kwargs: {})
  handler = find_handler(method_name, args, kwargs)
  if handler.parameters.any? do |type, _|
      [:key, :keyrest, :keyreq].include? type
    end
    handler.bind(self).call *args, **kwargs
  else
    handler.bind(self).call *args
  end
  #insane workaround, because if you have
  #def z(f);end
  #and you call it like that
  #a(2, **{e: 4})
  #it raises wrong number of arguments (2 for 1)
  #clean later
end

#find_handler(method_name, args, kwargs) ⇒ Object 



67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
 
# File 'lib/matchete.rb', line 67

def find_handler(method_name, args, kwargs)
  guards = self.class.instance_variable_get('@methods')[method_name].find do |guard_args, guard_kwargs, _|
    match_guards guard_args, guard_kwargs, args, kwargs
  end

  if guards.nil?
    default_method = self.class.instance_variable_get('@default_methods')[method_name]
    if default_method
      default_method
    else
      raise NotResolvedError.new("No matching #{method_name} method for args #{args}")
    end
  else
    guards[2]
  end
end

#match_guard(guard, arg) ⇒ Object 



94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
 
# File 'lib/matchete.rb', line 94

def match_guard(guard, arg)
  case guard
    when Module
      arg.is_a? guard
    when Symbol
      send guard, arg
    when Proc
      guard.call arg
    when Regexp
      arg.is_a? String and guard.match arg
    when Array
      arg.is_a?(Array) and
      guard.zip(arg).all? { |child_guard, child| match_guard child_guard, child }
    else
      guard == arg
  end
end

#match_guards(guard_args, guard_kwargs, args, kwargs) ⇒ Object 



84
85
86
87
88
89
90
91
92
 
# File 'lib/matchete.rb', line 84

def match_guards(guard_args, guard_kwargs, args, kwargs)
  return false if guard_args.count != args.count || guard_kwargs.count != kwargs.count
  guard_args.zip(args).all? do |guard, arg|
    match_guard guard, arg
  end and
  guard_kwargs.all? do |label, guard|
    match_guard guard, kwargs[label]
  end
end