Module: JInterface

Defined in:
lib/jinterface.rb,
lib/jinterface/arg_range.rb,
lib/jinterface/interface_class_methods.rb

Defined Under Namespace

Modules: InterfaceClassMethods Classes: ArgRange

Class Method Summary collapse

Class Method Details

.extended(obj) ⇒ Object

Raises:

  • (SyntaxError) 


54
55
56
57
58
59
 
# File 'lib/jinterface.rb', line 54

def extended(obj)
  raise SyntaxError.new(
    "Interface '#{self.name}' cannot be "\
    " extended, only included, in '#{obj.name}'."
  )
end

.included(mod) ⇒ Object

Raises:

  • (TypeError) 


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
 
# File 'lib/jinterface.rb', line 4

def included(mod)
  #Do not do anything if in production

  return if production?
  #Make sure JInterface used with module

  raise TypeError.new(
    "JInterface cannot be used with class"\
    " '#{mod.name}', only with modules."
  ) if mod.instance_of? Class
  #Extend module

  mod.class_eval do
    extend JInterface::InterfaceClassMethods
    @arg_ranges = {
      #method_name => ArgRange

    }
    #In case JInterface inclusion was

    #not first thing in class declaration:

    #Raise error if private method defined

    private_instance_methods.each do |method_name|
      private method_name
    end
    #Raise error if protected method defined

    protected_instance_methods.each do |method_name|
      protected method_name
    end
    #Raise error if class method defined

    methods(false).each do |method_name|
      singleton_method_added method_name
    end
    #Raise error if non-interface included

    included_modules.each do |mod|
      include mod unless JInterface.interface? mod
    end
    #Raise error if module prepended

    prepended_modules.each do |mod|
      prepend mod
    end if defined? prepended_modules
    #Raise error if module extended

    (
      (class << mod; self; end).included_modules - 
      Module.included_modules -
      [JInterface::InterfaceClassMethods]
    ).each do |mod|
      extend mod
    end
    #Send each method through method_added method

    public_instance_methods(false).each do |method_name|
      method_added(method_name)
    end
  end
end

.interface?(obj) ⇒ Boolean 



66
67
68
69
70
71
72
 
# File 'lib/jinterface.rb', line 66

def interface?(obj)
  (  obj == JInterface or 
    ( obj.instance_of?(Module) and 
      (class << obj; self end) < JInterface::InterfaceClassMethods
    )
  ) ? true : false
end

.prepended(obj) ⇒ Object

Raises:

  • (SyntaxError) 


60
61
62
63
64
65
 
# File 'lib/jinterface.rb', line 60

def prepended(obj)
  raise SyntaxError.new(
    "Interface '#{self.name}' cannot be "\
    " prepended, only included, in '#{obj.name}'."
  )
end

.production=(flag) ⇒ Object 



73
74
75
 
# File 'lib/jinterface.rb', line 73

def production=(flag)
  @enabled = flag == true
end

.production? ⇒ Boolean 



76
77
78
 
# File 'lib/jinterface.rb', line 76

def production?()
  return @enabled ||= false
end