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:



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

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:



17
18
19
 
# File 'lib/middleman-core/sitemap/store.rb', line 17

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!



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

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.reduce([]) 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:

  • file (String)

Returns:

  • (String) 


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

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:

  • file (String)

Returns:

  • (String) 


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

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

  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:



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

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:



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

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.



104
105
106
 
# File 'lib/middleman-core/sitemap/store.rb', line 104

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:

  • source_file (String)

Returns:

  • (Hash) 


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

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

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

    metadata = callback.call(source_file).dup

    if metadata.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:

  • request_path (String)

Returns:

  • (Hash) 


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

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.reduce(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>>) 


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

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>>) 


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

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)

This method returns an undefined value.

Rebuild the list of resources from scratch, using registed manipulators rubocop:disable UnusedMethodArgument



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

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

#register_resource_list_manipulator(name, inst)

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



52
53
54
55
 
# File 'lib/middleman-core/sitemap/store.rb', line 52

def register_resource_list_manipulator(name, inst, *)
  @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:



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

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