78
79
80
81
82
83
84
85

# File 'lib/nanoc3/base/dependency_tracker.rb', line 78

def all_dependencies_for(item)
  # FIXME can result in an infinite loop

  direct_dependencies   = direct_dependencies_for(item)
  indirect_dependencies = direct_dependencies.map { |i| all_dependencies_for(i) }

  (direct_dependencies + indirect_dependencies).flatten
end

97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

# File 'lib/nanoc3/base/dependency_tracker.rb', line 97

def all_inverse_dependencies_for(item)
  # Init list of all found dependencies
  all_dependencies = []

  # Init lists with already checked and not yet checked dependencies
  checked_direct_dependencies = []
  pending_direct_dependencies = direct_inverse_dependencies_for(item)

  while !pending_direct_dependencies.empty?
    # Get next unchecked dependency
    dependency = pending_direct_dependencies.shift
    next if checked_direct_dependencies.include?(dependency)

    # Add dependencies of this unchecked dependency
    pending_direct_dependencies += direct_inverse_dependencies_for(dependency)

    # Mark this dependency as handled
    all_dependencies << dependency
    checked_direct_dependencies << dependency
  end

  all_dependencies
end

72
73
74

# File 'lib/nanoc3/base/dependency_tracker.rb', line 72

def direct_dependencies_for(item)
  @graph[item] || []
end

91
92
93

# File 'lib/nanoc3/base/dependency_tracker.rb', line 91

def direct_inverse_dependencies_for(item)
  inverted_graph[item] || []
end

225
226
227

# File 'lib/nanoc3/base/dependency_tracker.rb', line 225

def forget_dependencies_for(item)
  @graph[item] = []
end

166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185

# File 'lib/nanoc3/base/dependency_tracker.rb', line 166

def load_graph
  # Create new graph
  @graph = {}

  # Don't do anything if dependencies haven't been stored yet
  return if !File.file?(self.filename)

  # Load dependencies
  store = PStore.new(self.filename)
  store.transaction do
    # Convert graph of identifiers into graph of items
    store[:dependencies].each_pair do |second_item_identifier, first_item_identifiers|
      # Convert second and first item identifiers into items
      second_item = item_with_identifier(second_item_identifier)
      first_items = first_item_identifiers.map { |p| item_with_identifier(p) }

      @graph[second_item] = first_items
    end
  end
end

189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220

# File 'lib/nanoc3/base/dependency_tracker.rb', line 189

def mark_outdated_items
  # Unmark everything
  @items.each { |i| i.dependencies_outdated = false }

  # Mark items that appear in @items but not in the dependency graph
  added_items = @items - @graph.keys
  added_items.each { |i| i.dependencies_outdated = true }

  # Walk graph and mark items as outdated if necessary
  # (#keys and #sort is used instead of #each_pair to add determinism)
  first_items = inverted_graph.keys.sort_by { |i| i.nil? ? '/' : i.identifier }
  something_changed = true
  while something_changed
    something_changed = false

    first_items.each do |first_item|
      second_items = inverted_graph[first_item]

      if first_item.nil? ||                # item was removed
         first_item.outdated? ||           # item itself is outdated
         first_item.dependencies_outdated? # item is outdated because of its dependencies
        second_items.each do |item|
          # Ignore this item
          next if item.nil?

          something_changed = true if !item.dependencies_outdated?
          item.dependencies_outdated = true
        end
      end
    end
  end
end

123
124
125
126
127
128
129
130
131
132
133
134

# File 'lib/nanoc3/base/dependency_tracker.rb', line 123

def record_dependency(src, dst)
  # Initialize graph if necessary
  @graph[src] ||= []

  # Don't include self or doubles in dependencies
  return if src == dst
  return if @graph[src].include?(dst)

  # Record dependency
  invalidate_inverted_graph
  @graph[src] << dst
end

39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

# File 'lib/nanoc3/base/dependency_tracker.rb', line 39

def start
  # Initialize dependency stack. An item will be pushed onto this stack
  # when it is visited. Therefore, an item on the stack always depends on
  # all items pushed above it.
  @stack = []

  # Register start of visits
  Nanoc3::NotificationCenter.on(:visit_started, self) do |item|
    # Record possible dependency
    unless @stack.empty?
      self.record_dependency(@stack[-1], item)
    end

    @stack.push(item)
  end

  # Register end of visits
  Nanoc3::NotificationCenter.on(:visit_ended, self) do |item|
    @stack.pop
  end
end

62
63
64
65
66

# File 'lib/nanoc3/base/dependency_tracker.rb', line 62

def stop
  # Unregister
  Nanoc3::NotificationCenter.remove(:visit_started, self)
  Nanoc3::NotificationCenter.remove(:visit_ended,   self)
end

138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

# File 'lib/nanoc3/base/dependency_tracker.rb', line 138

def store_graph
  # Create dir
  FileUtils.mkdir_p(File.dirname(self.filename))

  # Complete the graph
  complete_graph

  # Convert graph of items into graph of item identifiers
  new_graph = {}
  @graph.each_pair do |second_item, first_items|
    # Don't store nil because that would be pointless (if first_item is
    # outdated, something that does not exist is also outdated… makes no
    # sense).
    # FIXME can second_item really be nil?
    next if second_item.nil?

    new_graph[second_item.identifier] = first_items.map { |f| f && f.identifier }.compact
  end

  # Store dependencies
  store = PStore.new(self.filename)
  store.transaction do
    store[:dependencies] = new_graph
  end
end