Class: Middleman::Sitemap::Store

Inherits:
Object
  • Object
show all
Includes:
Queryable::API
Defined in:
lib/middleman-core/sitemap/store.rb

Overview

The Store class

The Store manages a collection of Resource objects, which represent individual items in the sitemap. Resources are indexed by “source path”, which is the path relative to the source directory, minus any template extensions. All “path” parameters used in this class are source paths.

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Queryable::API

#limit, #offset, #order_by, #select, #where

Constructor Details

#initialize(app) ⇒ Store

Initialize with parent app

Parameters:



26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
 
# File 'lib/middleman-core/sitemap/store.rb', line 26

def initialize(app)
  @app   = app
  @resources = []
  @_cached_metadata = {}
  @resource_list_manipulators = []
  @needs_sitemap_rebuild = true
  @lock = Monitor.new

  reset_lookup_cache!

  # Register classes which can manipulate the main site map list
  register_resource_list_manipulator(:on_disk, Middleman::Sitemap::Extensions::OnDisk.new(self))

  # Request Endpoints
  register_resource_list_manipulator(:request_endpoints, @app.endpoint_manager)

  # Proxies
  register_resource_list_manipulator(:proxies, @app.proxy_manager)

  # Redirects
  register_resource_list_manipulator(:redirects, @app.redirect_manager)
end

Instance Attribute Details

#app ⇒ Middleman::Application

Returns:



20
21
22
 
# File 'lib/middleman-core/sitemap/store.rb', line 20

def app
  @app
end

Instance Method Details

#ensure_resource_list_updated! ⇒ Object

Actually update the resource list, assuming anything has called rebuild_resource_list! since the last time it was run. This is very expensive!



209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
 
# File 'lib/middleman-core/sitemap/store.rb', line 209

def ensure_resource_list_updated!
  @lock.synchronize do
    return unless @needs_sitemap_rebuild
    @needs_sitemap_rebuild = false

    @app.logger.debug "== Rebuilding resource list"

    @resources = @resource_list_manipulators.inject([]) do |result, (_, inst)|
      newres = inst.manipulate_resource_list(result)

      # Reset lookup cache
      reset_lookup_cache!
      newres.each do |resource|
        @_lookup_by_path[resource.path] = resource
        @_lookup_by_destination_path[resource.destination_path] = resource
      end

      newres
    end

    invalidate_resources_not_ignored_cache!
  end
end

#extensionless_path(file) ⇒ String

Get a path without templating extensions

Parameters:

Returns:



197
198
199
200
201
202
203
204
 
# File 'lib/middleman-core/sitemap/store.rb', line 197

def extensionless_path(file)
  path = file.dup
  path = remove_templating_extensions(path)

  # If there is no extension, look for one
  path = find_extension(path, file) if File.extname(strip_away_locale(path)).empty?
  path
end

#file_to_path(file) ⇒ String

Get the URL path for an on-disk file

Parameters:

Returns:



178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
 
# File 'lib/middleman-core/sitemap/store.rb', line 178

def file_to_path(file)
  file = File.join(@app.root, file)

  prefix = @app.source_dir.sub(/\/$/, "") + "/"
  return false unless file.start_with?(prefix)

  path = file.sub(prefix, "")

  # Replace a file name containing automatic_directory_matcher with a folder
  unless @app.config[:automatic_directory_matcher].nil?
    path = path.gsub(@app.config[:automatic_directory_matcher], "/")
  end

  extensionless_path(path)
end

#find_resource_by_destination_path(request_path) ⇒ Middleman::Sitemap::Resource

Find a resource given its destination path

Parameters:

  • request_path (String) —

    The destination (output) path of a resource.

Returns:



82
83
84
85
86
87
88
 
# File 'lib/middleman-core/sitemap/store.rb', line 82

def find_resource_by_destination_path(request_path)
  @lock.synchronize do
    request_path = ::Middleman::Util.normalize_path(request_path)
    ensure_resource_list_updated!
    @_lookup_by_destination_path[request_path]
  end
end

#find_resource_by_path(request_path) ⇒ Middleman::Sitemap::Resource

Find a resource given its original path

Parameters:

  • request_path (String) —

    The original path of a resource.

Returns:



71
72
73
74
75
76
77
 
# File 'lib/middleman-core/sitemap/store.rb', line 71

def find_resource_by_path(request_path)
  @lock.synchronize do
    request_path = ::Middleman::Util.normalize_path(request_path)
    ensure_resource_list_updated!
    @_lookup_by_path[request_path]
  end
end

#invalidate_resources_not_ignored_cache! ⇒ Object

Invalidate our cached view of resource that are not ingnored. If your extension adds ways to ignore files, you should call this to make sure #resources works right.



106
107
108
 
# File 'lib/middleman-core/sitemap/store.rb', line 106

def invalidate_resources_not_ignored_cache!
  @resources_not_ignored = nil
end

#metadata_for_file(source_file) ⇒ Hash

Get the metadata for a specific file

Parameters:

Returns:

  • (Hash) 


122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/middleman-core/sitemap/store.rb', line 122

def metadata_for_file(source_file)
  blank_metadata = { :options => {}, :locals => {}, :page => {}, :blocks => [] }

  provides_metadata.inject(blank_metadata) do |result, (callback, matcher)|
    next result if matcher && !source_file.match(matcher)

    metadata = callback.call(source_file).dup

    if metadata.has_key?(:blocks)
      result[:blocks] << metadata[:blocks]
      metadata.delete(:blocks)
    end

    result.deep_merge(metadata)
  end
end

#metadata_for_path(request_path) ⇒ Hash

Get the metadata for a specific URL

Parameters:

Returns:

  • (Hash) 


154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
 
# File 'lib/middleman-core/sitemap/store.rb', line 154

def metadata_for_path(request_path)
  return @_cached_metadata[request_path] if @_cached_metadata[request_path]

  blank_metadata = { :options => {}, :locals => {}, :page => {}, :blocks => [] }

  @_cached_metadata[request_path] = provides_metadata_for_path.inject(blank_metadata) do |result, (callback, matcher)|
    case matcher
    when Regexp
      next result unless request_path =~ matcher
    when String
      next result unless File.fnmatch("/" + Util.strip_leading_slash(matcher), "/#{request_path}")
    end

    metadata = callback.call(request_path).dup

    result[:blocks] += Array(metadata.delete(:blocks))

    result.deep_merge(metadata)
  end
end

#provides_metadata(matcher = nil, &block) ⇒ Array<Array<Proc, Regexp>>

Register a handler to provide metadata on a file path

Parameters:

  • matcher (Regexp) (defaults to: nil)

Returns:

  • (Array<Array<Proc, Regexp>>) 


113
114
115
116
117
 
# File 'lib/middleman-core/sitemap/store.rb', line 113

def provides_metadata(matcher=nil, &block)
  @_provides_metadata ||= []
  @_provides_metadata << [block, matcher] if block_given?
  @_provides_metadata
end

#provides_metadata_for_path(matcher = nil, &block) ⇒ Array<Array<Proc, Regexp>>

Register a handler to provide metadata on a url path

Parameters:

  • matcher (Regexp) (defaults to: nil)

Returns:

  • (Array<Array<Proc, Regexp>>) 


142
143
144
145
146
147
148
149
 
# File 'lib/middleman-core/sitemap/store.rb', line 142

def provides_metadata_for_path(matcher=nil, &block)
  @_provides_metadata_for_path ||= []
  if block_given?
    @_provides_metadata_for_path << [block, matcher]
    @_cached_metadata = {}
  end
  @_provides_metadata_for_path
end

#rebuild_resource_list!(reason = nil) ⇒ void

This method returns an undefined value.

Rebuild the list of resources from scratch, using registed manipulators



62
63
64
65
66
 
# File 'lib/middleman-core/sitemap/store.rb', line 62

def rebuild_resource_list!(reason=nil)
  @lock.synchronize do
    @needs_sitemap_rebuild = true
  end
end

#register_resource_list_manipulator(name, inst, unused = true) ⇒ void

This method returns an undefined value.

Register a klass which can manipulate the main site map list. Best to register these in a before_configuration or after_configuration hook.

Parameters:

  • name (Symbol) —

    Name of the manipulator for debugging

  • inst (Class, Module) —

    Abstract namespace which can update the resource list



55
56
57
58
 
# File 'lib/middleman-core/sitemap/store.rb', line 55

def register_resource_list_manipulator(name, inst, unused=true)
  @resource_list_manipulators << [name, inst]
  rebuild_resource_list!(:registered_new)
end

#resources(include_ignored = false) ⇒ Array<Middleman::Sitemap::Resource>

Get the array of all resources

Parameters:

  • include_ignored (Boolean) (defaults to: false) —

    Whether to include ignored resources

Returns:



93
94
95
96
97
98
99
100
101
102
 
# File 'lib/middleman-core/sitemap/store.rb', line 93

def resources(include_ignored=false)
  @lock.synchronize do
    ensure_resource_list_updated!
    if include_ignored
      @resources
    else
      @resources_not_ignored ||= @resources.reject(&:ignored?)
    end
  end
end