Module: Ov

Defined in:
lib/ov.rb,
lib/ov/ov_any.rb,
lib/ov/version.rb,
lib/ov/ov_array.rb,
lib/ov/ov_method.rb,
lib/ov/ext/matching.rb

Overview

‘Ov` module provides functional for creating methods with types in Ruby.

Usage

Firstly include ‘Ov` in you class

class MyClass        
  include Ov 
end

After define method with types:

class MyClass
  include Ov   

  # with Fixnum type 
  let :cool_method, Fixnum do |num|
    num * 100
  end 

  # with String type
  let :cool_method, String do |str|
    str << "!"
  end 
end

And now

my_class = MyClass.new
my_class.cool_method(3)     # => 300
my_class.cool_method("foo") # => foo!

Any Type

class MyClass 
  include Ov
  let :cool_method, Any do |any|
    any
  end 
end

my_class = MyClass.new
my_class.cool_method(1) 
  => 1 
my_class.cool_method("foo") # => "foo"

Is the same so ruby ‘def`

Define as class methods

class MyClass
  self << class
    let :cool_method, Fixnum do |f|
      f + 1
    end
    let :cool_method, String do |s|
      "{s}"
    end
  end
end 

MyClass.cool_method(1)      #=> 2
MyClass.cool_method("test") #=> "test"

Work with blocks

Blocks, should be pass given without ampersand (&)

class MyClass

  let :my_method, Fixnum do |num, block| # instead of |num, &block|
    p num
    block.call
  end

end

MyClass.new.my_method(1) do 
  p "123"
end
# => 1
# => 123

Defined Under Namespace

Modules: Ext Classes: Any, NotImplementError, OA, OverrideMethod

Constant Summary collapse

VERSION = 
"0.1.1"

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.included(base) ⇒ Object

:nodoc:



98
99
100
101
102
103
 
# File 'lib/ov.rb', line 98

def self.included(base) # :nodoc:
  base.extend(self)
  base.class_eval do
    class_variable_set(:@@__overload_methods, OA.new) if !class_variable_defined?(:@@__overload_methods)
  end
end

Instance Method Details

#let(name, *types, &block) ⇒ Object

Create new method with name and types When method called block will be executed

name is symbol

types types for method



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/ov.rb', line 118

def let(name, *types, &block)
  included = false 
    
  if self.instance_methods.include?(name)
    included = true
    class_eval "alias :ov_old_#{name.to_s} #{name}"
    undef_method name
  end   
  
  __overload_methods << OverrideMethod.new(name, types, self, block)
  
  if !self.method_defined?(name)
    self.instance_exec do
      message = if self.class == Module
        :define_singleton_method
      else
        :define_method
      end
      
      self.send(message, name) do |*args, &block|
        types = *args.map(&:class)
        owner = need_owner()
        
        method = OverrideMethod.new(name, types, owner) 
        z = owner.send(:__overload_methods).where(method) 
        
        if z.nil?
          if included
            send("ov_old_#{name.to_s}", *args, &block)
          else 
            raise Ov::NotImplementError.new("Method `#{name}` in `#{self}` class with types `#{types.join(', ')}` not implemented.") 
          end
        else 
          k = *args
          k << block if !block.nil? 
          instance_exec(*k, &z.body)   
        end
      end
    end
  end   
end

#multimethods ⇒ Object

return all defined with let methods.



163
164
165
166
167
168
 
# File 'lib/ov.rb', line 163

def multimethods()
  owner = need_owner()
  owner.send(:__overload_methods).map do |method|
    [method.name, method.types] if method.owner == owner  
  end.compact
end