Class: Gel::LockedStore

Inherits:
Object
  • Object
show all
Defined in:
lib/gel/locked_store.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(inner) ⇒ LockedStore

Returns a new instance of LockedStore.



6
7
8
9
10
11
12
 
# File 'lib/gel/locked_store.rb', line 6

def initialize(inner)
  @inner = inner
  @locked_versions = nil

  @lib_cache = Hash.new { |h, k| h[k] = [] }
  @full_cache = false
end

Instance Attribute Details

#inner ⇒ Object (readonly)

Returns the value of attribute inner.



4
5
6
 
# File 'lib/gel/locked_store.rb', line 4

def inner
  @inner
end

Instance Method Details

#each(gem_name = nil) ⇒ Object 



111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/gel/locked_store.rb', line 111

def each(gem_name = nil)
  return enum_for(__callee__, gem_name) unless block_given?

  list = locked_gems

  @inner.each(gem_name) do |gem|
    next unless locked?(gem)
    yield gem
    list.delete gem
  end

  list.each do |gem|
    yield gem if !gem_name || gem.name == gem_name
  end
end

#gem(name, version) ⇒ Object 



69
70
71
72
73
74
75
 
# File 'lib/gel/locked_store.rb', line 69

def gem(name, version)
  if !@locked_versions || @locked_versions[name] == version
    @inner.gem(name, version)
  else
    locked_gems.find { |g| g.name == name && g.version == version }
  end
end

#gems(name_version_pairs) ⇒ Object 



77
78
79
80
81
82
83
 
# File 'lib/gel/locked_store.rb', line 77

def gems(name_version_pairs)
  r = @inner.gems(name_version_pairs)
  locked_gems.each do |g|
    r[g.name] = g
  end
  r
end

#gems_for_lib(file) ⇒ Object 



85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/gel/locked_store.rb', line 85

def gems_for_lib(file)
  if c = @lib_cache.fetch(file, nil)
    c.each { |gem, subdir| yield gem, subdir }
    return
  end

  hits = []
  unless @full_cache
    @inner.gems_for_lib(file) do |gem, subdir|
      if locked?(gem)
        hits << [gem, subdir]
        yield gem, subdir
      end
    end
  end

  locked_gems.each do |gem|
    if File.exist?(gem.path(file) + ".rb")
      hits << [gem, nil]
      yield gem, nil
    end
  end

  @lib_cache[file] = hits
end

#inspect ⇒ Object 



22
23
24
25
26
27
28
 
# File 'lib/gel/locked_store.rb', line 22

def inspect
  content = @locked_versions.map { |name, version| "#{name}=#{version.is_a?(String) ? version : version.root}" }
  content = ["(none)"] if content.empty?
  content.sort!

  "#<#{self.class} inner=#{@inner.inspect} locks=#{content.join(",")}>"
end

#lock(locks) ⇒ Object 



55
56
57
58
59
 
# File 'lib/gel/locked_store.rb', line 55

def lock(locks)
  @locked_versions = locks.dup
  prepare(locks)
  @full_cache = true
end

#locked?(gem) ⇒ Boolean

Returns:

  • (Boolean) 


61
62
63
 
# File 'lib/gel/locked_store.rb', line 61

def locked?(gem)
  !@locked_versions || @locked_versions[gem.name] == gem.version
end

#locked_gems ⇒ Object 



65
66
67
 
# File 'lib/gel/locked_store.rb', line 65

def locked_gems
  @locked_versions ? @locked_versions.values.grep(Gel::StoreGem) : []
end

#paths ⇒ Object 



14
15
16
 
# File 'lib/gel/locked_store.rb', line 14

def paths
  @inner.paths
end

#prepare(locks) ⇒ Object 



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/gel/locked_store.rb', line 30

def prepare(locks)
  return if @full_cache

  inner_versions = {}
  locks.each do |name, version|
    if version.is_a?(Gel::StoreGem)
      version.libs do |file, subdir|
        @lib_cache[file] << [version, subdir]
      end
    else
      inner_versions[name] = version
    end
  end

  g = @inner.gems(inner_versions)
  @inner.libs_for_gems(inner_versions) do |name, version, subs|
    subs.each do |subdir, files|
      v = [g[name], subdir]
      files.each do |file|
        @lib_cache[file] << v
      end
    end
  end
end

#root ⇒ Object 



18
19
20
 
# File 'lib/gel/locked_store.rb', line 18

def root
  @inner.root
end