Class: Mud::Context

Inherits:
Object
  • Object
show all
Defined in:
lib/mud/context.rb

Constant Summary collapse

MODULE_DIRECTORIES = 
['js_modules', 'shared_modules']
MODULE_GLOBAL = 
Mud.home_directory('.mud', 'js_modules')

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(dir = '.') ⇒ Context

Returns a new instance of Context.



18
19
20
21
22
 
# File 'lib/mud/context.rb', line 18

def initialize(dir = '.')
  @dir = File.absolute_path(dir)
  @available_modules = {}
  reload
end

Instance Attribute Details

#available_modules ⇒ Object (readonly)

Returns the value of attribute available_modules.



16
17
18
 
# File 'lib/mud/context.rb', line 16

def available_modules
  @available_modules
end

#dir ⇒ Object (readonly)

Returns the value of attribute dir.



16
17
18
 
# File 'lib/mud/context.rb', line 16

def dir
  @dir
end

Instance Method Details

#inline(module_or_list, opts = {}) ⇒ Object 



104
105
106
107
 
# File 'lib/mud/context.rb', line 104

def inline(module_or_list, opts = {})
  resolved = resolve(module_or_list)
  Mud::JsResult.new(resolved, opts)
end

#inline_document(path, opts = {}) ⇒ Object 



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

def inline_document(path, opts = {})
  modules, type = analyze_document(path)

  result = inline(modules, opts)

  if type == :js
    main = modules.first
    result << main.content
  else
    result = Mud::HtmlResult.new(path, result)
  end

  result
end

#install(name, opts = {}) ⇒ Object 



43
44
45
46
47
48
49
50
 
# File 'lib/mud/context.rb', line 43

def install(name, opts = {})
  return if @available_modules[name]# or raise exception

  src = nil # download module src from mudhub and write to disk in module global
  path = nil

  @available_modules[name] = Mud::InstalledModule.new(path, self) # check dependencies and download if not present
end

#module(name) ⇒ Object 



55
56
57
 
# File 'lib/mud/context.rb', line 55

def module(name)
  @available_modules[name]
end

#module!(name) ⇒ Object 



59
60
61
 
# File 'lib/mud/context.rb', line 59

def module!(name)
  @available_modules[name] || (raise Mud::ResolveError.new(name))
end

#reload ⇒ Object 



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/mud/context.rb', line 24

def reload
  dirs = dirs(@dir)
  removed = @available_modules.dup

  dirs.each do |dir|
    Dir.glob(File.join(dir, '*.js')) do |mod_path|
      name = Mud::Module.parse_name(mod_path)
      mod = @available_modules[name]
      removed.delete(name)

      unless mod and mod.modified == File.mtime(mod_path) and mod.path == mod_path
        @available_modules[name] = Mud::InstalledModule.new(mod_path, self)
      end
    end
  end

  @available_modules.delete_if { |key, _| removed.key?(key) }
end

#resolve(module_or_list) ⇒ Object 



82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/mud/context.rb', line 82

def resolve(module_or_list)
  modules = module_or_list.is_a?(Mud::Module) ? [module_or_list] : module_or_list

  resolved = []

  resolver = proc do |modules|
    modules.each do |mod|
      next if resolved.include?(mod)
      resolved.unshift(mod) if mod.is_a?(Mud::InstalledModule)

      dep = mod.unresolvable_dependencies.first
      raise Mud::ResolveError.new(dep) if dep

      dependencies = mod.dependencies.map(&:resolve).delete_if { |m| resolved.include?(m) }
      resolver.call(dependencies) unless dependencies.empty?
    end
  end
  resolver.call(modules)

  resolved
end

#resolve_document(path) ⇒ Object 



63
64
65
 
# File 'lib/mud/context.rb', line 63

def resolve_document(path)
  resolve analyze_document(path).first
end

#uninstall(module_or_name) ⇒ Object 



52
53
 
# File 'lib/mud/context.rb', line 52

def uninstall(module_or_name)
end