Class: RTM::Engine

Inherits:
Object
  • Object
show all
Includes:
TopicMapSystem
Defined in:
lib/rtm/engine.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(params = {}) ⇒ Engine

Returns a new instance of Engine.



96
97
98
 
# File 'lib/rtm/engine.rb', line 96

def initialize(params={})
  @params = params
end

Instance Attribute Details

#connections ⇒ Object (readonly)

Returns the value of attribute connections.



94
95
96
 
# File 'lib/rtm/engine.rb', line 94

def connections
  @connections
end

Class Method Details

.[](identifier) ⇒ Object 



38
39
40
 
# File 'lib/rtm/engine.rb', line 38

def self.[](identifier)
  all.find {|e| e.identifier == identifier}
end

.abstract? ⇒ Boolean

Returns:



5
6
7
 
# File 'lib/rtm/engine.rb', line 5

def self.abstract?
  self == Engine
end

.add(engine) ⇒ Object 



13
14
15
16
 
# File 'lib/rtm/engine.rb', line 13

def self.add(engine)
  @engines ||= []
  @engines << engine
end

.all ⇒ Object 



28
29
30
31
32
 
# File 'lib/rtm/engine.rb', line 28

def self.all
  @engines ||= []
  @engines.reject!{|e| e.abstract?} # this needs to be done here because in the inherited hook the method is not yet available.
  @engines
end

.default ⇒ Object 



86
87
88
89
90
91
92
 
# File 'lib/rtm/engine.rb', line 86

def self.default
  if RUBY_PLATFORM =~ /java/
    :ontopia
  else
    :activerecord
  end
end

.detect(preferred = nil) ⇒ Object 



69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
 
# File 'lib/rtm/engine.rb', line 69

def self.detect(preferred=nil)
  if preferred # return the users preference, if given
    implementation = preferred
  elsif engine_name = ENV['RTM_IMPLEMENTATION'] # inspect system environment
    implementation = engine_name.to_sym
  elsif engine_name = ENV['RTM_ENGINE'] # inspect system environment (alternative)
    implementation = engine_name.to_sym
  elsif implementation = self.list.first # check if one is already loaded
    warn("No engine implementation was specified for RTM.connect. Using the first already loaded engine (#{implementation.inspect}).")
  else
    implementation = self.default # use hardcoded default
    warn("No engine implementation was specified for RTM.connect. Choosing default (#{implementation.inspect}).")
    implementation
  end
  implementation
end

.identifier(i = nil) ⇒ Object 



18
19
20
21
22
23
24
25
26
 
# File 'lib/rtm/engine.rb', line 18

def self.identifier(i=nil)
  if i
    # setter / declaration
    @identifier = i
  else
    # getter
    @identifier
  end
end

.inherited(subclass) ⇒ Object 



9
10
11
 
# File 'lib/rtm/engine.rb', line 9

def self.inherited(subclass)
  Engine.add(subclass) # this MUST be Engine and not self! Otherwise every intermediate class in the inheritance chain will have it's own list
end

.list ⇒ Object 



34
35
36
 
# File 'lib/rtm/engine.rb', line 34

def self.list
  all.map{|e| e.identifier}
end

.load(engine_name) ⇒ Object 



42
43
44
45
46
47
48
49
50
51
52
53
 
# File 'lib/rtm/engine.rb', line 42

def self.load(engine_name)
  if Object.const_defined?("Gem") && rtmgem = Gem.loaded_specs["rtm"]
    require "rtm/#{engine_name}"
  else
    engine_path = File.expand_path(File.join(File.dirname(__FILE__), "../../../rtm-#{engine_name}/lib"))
    if File.directory?(engine_path)
      $LOAD_PATH.unshift engine_path
      require "rtm/#{engine_name}"
    end
  end
  self[engine_name]
end

.load!(engine_name = nil) ⇒ Object 



55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/rtm/engine.rb', line 55

def self.load!(engine_name=nil)
  engine_name = self.detect unless engine_name
  unless list.include?(engine_name)
    warn("Requested engine '#{engine_name}' not loaded. Trying to autoload it.")
    engine = load(engine_name)
    if list.include?(engine_name)
      warn("Autoloading '#{engine_name}' was successful")
    else
      raise "Autoloading '#{engine_name}' failed. Make sure rtm-#{engine_name} exists and is installed or require it manually."
    end
  end
  engine || load(engine_name)
end