nanoc-4.4.7/0000755000004100000410000000000013033443476012663 5ustar www-datawww-datananoc-4.4.7/Rakefile0000644000004100000410000000066613033443476014340 0ustar www-datawww-datarequire 'rubocop/rake_task' require 'rspec/core/rake_task' require 'rake/testtask' require 'coveralls/rake/task' RuboCop::RakeTask.new(:rubocop) Coveralls::RakeTask.new Rake::TestTask.new(:test_all) do |t| t.test_files = Dir['test/**/*_spec.rb'] + Dir['test/**/test_*.rb'] t.libs << 'test' end RSpec::Core::RakeTask.new(:spec) task test: [:spec, :test_all, :rubocop] task test_ci: [:test, :'coveralls:push'] task default: :test nanoc-4.4.7/NEWS.md0000644000004100000410000013272213033443476013770 0ustar www-datawww-data# Nanoc news ## 4.4.7 (2017-01-05) Fixes: * Fixed issue that caused an item not to be considered outdated when only the mtime has changed (#1046) * Removed stray `require 'parallel'` which could break the `external_links` check (#1051) [Cédric Boutillier] Enhancements: * Made Nanoc not recompile compiled items after an exception occurs (#1044) ## 4.4.6 (2016-12-28) Fixes: * Fixed issue where `#compiled_content` would not return the correct content (#1040, #1041) ## 4.4.5 (2016-12-24) Fixes: * Prevented stale data from making it into the checksum store and thereby blowing up in memory (#1004, #1027) * Fixed slow recompile after adding many items to a site (#1028) * Fixed wrong capturing helper output when the output field separator (`$,`) is set * Fixed issue that could cause items with multiple reps not to be recompiled when needed (#1031, #1032) * Fixed error when fetching textual content of item whose `:last` snapshot is binary (#1035, #1036) ## 4.4.4 (2016-12-19) Enhancements: * Improved speed of incremental compilations (#1017, #1019, #1024) ## 4.4.3 (2016-12-17) Fixes: * Prevented stale data from making it into the compiled content cache and thereby blowing up in memory (#1004, #1013) * Fixed “about” and “IRC channel” links in default site * Fixed accuracy of `` in Atom feed (use most recent `updated_at` or `created_at`) (#1007, #1014) Enhancements: * Added support for non-legacy identifiers in `#breadcrumbs_trail` (#1010, #1011) * Defined checksum for `Nanoc::Int::Context` to make outdatedness checker more precise (#1008, #1012) * Made Nanoc raise an error when item reps are routed to a path that does not start with a slash (#1015, #1016) ## 4.4.2 (2016-11-27) Fixes: * Fixed “Maximum call stack size exceeded” issue in the `less` filter (#1001) * Fixed issue that could cause the `less` filter to not generate all necessary dependencies (#1003) Enhancements: * Improved the way that the crash log displays the item rep that is being compiled (#1000) ## 4.4.1 (2016-11-21) Fixes: * Fixed an issue where the `xsl` filter would not generate a correct dependency on the layout (#996) Enhancements: * Made `view` command use index filenames specified in the `index_filenames` site configuration attribute (#998) ## 4.4.0 (2016-11-19) Features: * Added support for Nanoc environments (#859) ## 4.3.8 (2016-11-18) Enhancements: * Improved support for Rouge 1.x and 2.x (#880) [Rémi Barraquand] * Added `#include` to the `nanoc shell` command (#973) * Improved speed of full and incremental compilations (#977, #985) Fixes: * Made routing rules and `#write` calls accept an identifier, and not just a string (#976) * Removed GC speed-up hacks, which became counterproductive in Ruby 2.2 (#975) * Fixed issue which caused items to be always recompiled if `rep`/`item_rep` or `self` are used in those items’ rules (#982) ## 4.3.7 (2016-10-29) Fixes: * Fixed issue with `show-data` and `show-rules` commands not showing all data (#970) [Chris Chapman] Enhancements: * Improved speed of `compile` command (#968) * Improved speed of `prune` command (#969) * Made kramdown warnings include affected item rep (#967) [Gregory Pakosz] * Made kramdown warnings configurable (#967) [Gregory Pakosz] ## 4.3.6 (2016-10-23) Fixes: * Made legacy patterns properly support full identifiers (#957) * Fixed timezone issues in `#to_iso8601_date` (#961) * Fixed error when accessing item (rep) paths in shell command (#963) * Fixed issue that caused `#path` to be nil inside compilation rules (#964) * Made `__FILE__` in Checks file be a absolute path (#966) Enhancements: * Made the command line write status information to stderr, not stdout (#958) ## 4.3.5 (2016-10-14) Fixes: * Handle `form/@action` in `relativize_paths` filter (#950) [Lorin Werthen] Experimental features: * `profiler`: adds `--profile` option to the `compile` command to profile compilation (#903) * `environments`: adds support for Nanoc environments (#859) ## 4.3.4 (2016-10-02) Fixes: * Fixed compilation crash when output directory does not exist and auto-pruning is enabled (#948, #949) ## 4.3.3 (2016-09-26) Fixes: * Fixed issue causing `Bundler::GemfileNotFound` to be thrown (#936) [Lorin Werthen] * Fixed issue when replacing a directory with a file or vice versa (#942, #946) Enhancements: * Modified the `compile` command to allow specifying the deploy target as argument (#945) ## 4.3.2 (2016-08-23) Identical to 4.3.1, but with corrected release notes. ## 4.3.1 (2016-08-23) Fixes: * Fixed “outdatedness of LayoutView” error (#927, #931) * Fixed bug causing some checks not to appear in `nanoc check --list` (#928, #930) * Fixed `@item`, … not being accessible in filters defined with `Nanoc::Filter.define` (#932, #934) ## 4.3 (2016-08-21) Features: * Added `Nanoc::Filter.define`, to easily define filters (#895) * Made the `nanoc` Gemfile group be auto-required when Nanoc starts (#910) [whitequark] ## 4.2.4 (2016-07-24) Fixes: * Fixed `UnmetDependency` errors in postprocessor (#913, #917) Enhancements: * Sped up Nanoc by not releasing cache memory as quickly (#902) * Let `internal_links` check also verify resource paths, such as scripts and images (#912) [Lorin Werthen] * Improved error reporting for errors in the Rules file (#908, #914, #915, #916) * Removed `win32console` support, as it’s deprecated and causing problems (#900, #918) ## 4.2.3 (2016-07-03) Fixes: * Fixed issue with `#inspect` raising a `WeakRef::RefError` (#877, #897) Enhancements: * Sped up compiler (#894) * Improved `#inspect` output of some classes (#896) * Deprecated `Item#modified` and replaced it with `Item#modified_reps` (#898) ## 4.2.2 (2016-07-02) Fixes: * Fixed confusing “invalid prefix” error message (#873, #879) * Ensured filter arguments are frozen, to prevent outdatedness checker errors (#881, #886) * Fixed issue with dependencies of items generated in the preprocessor not being tracked (#885, #891, #893) Enhancements: * Added specific handling for `Sass::Importers::Filesystem` in the checksummer, which should reduce unnecessary recompiles in sites using Compass (#866, #884) * Improved speed of checksummer (#864, #887) ## 4.2.1 (2016-06-19) Fixes: * Fixed an occasional `WeakRef::RefError` (#863, #865) * Fixed `show-data` command not running preprocessor (#867, #870) ## 4.2 (2016-06-04) Enhancements: * Dropped Ruby 2.1 support (#856) This release also includes the changes from 4.2.0b1. ## 4.1.6 (2016-04-17) Fixes: * Strip index.html only if it is a full component (#850, #851) * Force UTF-8 for item rep paths (#837, #852) ## 4.2.0b1 (2016-04-17) Features: * Allow creating items and layouts with a pre-calculated checksum (#793) [Ruben Verborgh] * Allow lazy-loading item/layout content and attributes (#794) [Ruben Verborgh] * Added `exclude_origins` configuration option to internal links checker (#847) * Added `ChildParent` helper, providing `#children_of` and `#parent_of` (#849) Enhancements: * Made `#html_escape` raise an appropriate error when the given argument is not a String (#840) [Micha Rosenbaum] * Improved memory usage of memoized values by using weak refs (#846) ## 4.1.5 (2016-03-24) Fixes: * Fixed crash in `show-data` command (#833, #835) * Fixed preprocessor not being invoked before running checks (#841, #842) ## 4.1.4 (2016-02-13) Fixes: * Added missing `Configuration#key?` method (#815, #820) * Made output diff use correct snapshot rather than `:last` (#813, #814) Enhancements: * Sped up item resolution in Sass filter (#821) * Made `#link_to` more resilient to unsupported argument types (#816, #819) ## 4.1.3 (2016-01-30) Fixes: * Fixed crash in `check` command when the subject of an issue is nil (#804, #811) * Made stale check not ignore non-final snapshot paths (#809, #810) ## 4.1.2 (2016-01-16) Fixes: * Made @-variables (e.g. `@items`) report their frozenness properly, so that optimisations based on frozenness work once again (#795, #797) * Removed environment from `crash.log` to prevent leaking sensitive information (#798, #800) Enhancements: * Removed redundant checksum calculation (#789) [Ruben Verborgh] ## 4.1.1 (2015-12-30) Fixes: * Fixed preprocessor not being run before check/deploy/prune commands (#763, #784, #787, #788) Enhancements: * Made `#breadcrumbs_trail` explicitly fail when using full identifiers (#781, #783) ## 4.1 (2015-12-18) Fixes: * Fixed crash when attempting to `#puts` an object that’s not a string (#778) * Made pruner not prune away files from routes defined for custom snapshots (#779) * Wrapped `@layout` in a layout view (#773) Enhancements: * Added a base path to the Checks file, so that it supports `#require_relative` (#774) This release also includes the changes from 4.1.0a1 to 4.1.0rc2. ## 4.1.0rc2 (2015-12-13) Fixes: * Fixed children of the root item not having a parent (#769, #770) Enhancements: * Made `#path`, `#compiled_content` and `#reps` unavailable during pre-processing, compilation and routing, because they do not make sense in these contexts (#571, #767, #768) ## 4.1.0rc1 (2015-12-12) Fixes: * Fixed `@item.compiled_content` in a layout raising an exception (#761, #766) ## 4.1.0b1 (2015-12-11) Fixes: * Fixed issue with `:pre` snapshot not being generated properly (#764) Enhancements: * Updated default site to use `#write` (#759) ## 4.1.0a1 (2015-12-05) Features: * Added `postprocess` block (#726) [Garen Torikian] * Added `#write` compilation instruction and `path` option to `#snapshot` (#753) Fixes: * Fixed crash when printing non-string object (#712) [Garen Torikian] * Removed English text from `#link_to` helper (#736) [Lucas Vuotto] Enhancements: * Allowed excluding URLs from external links check (#686) [Yannick Ihmels] * Added `atom` to list of text extensions (#657) [Yannick Ihmels] * Added `#each` to `Nanoc::ConfigView` (#705) [Garen Torikian] * Made `#attribute_to_time` handle `DateTime` (#717) [Micha Rosenbaum] * Added `Identifier#components` (#677) * Added `:existing` option to `#content_for` (can be `:error`, `:overwrite` and `:append`) (#744) ## 4.0.2 (2015-11-30) Fixes: * Properly set required Ruby version to 2.1 in the gem specification (#747) * Fixed issue with CLI commands not being loaded as UTF-8 (#742) * Added missing `#identifier=` method to items and layouts during preprocessing (#750) Enhancements: * Let attempts to fetch an item rep by number, rather than symbol, fail with a meaningful error (#749) ## 4.0.1 (2015-11-28) Fixes: * Fixed params documentation for :rdiscount filter (#722) * Fixed crash when comparing item rep views (#735, #738) Enhancements: * Lowered minimum required Ruby version from 2.2 to 2.1 (#732) ## 4.0 (2015-11-07) Enhancements: * `#parent` and `#children` now raise an exception when used on items with a non-legacy identifier (#710) This release also includes the changes from 4.0.0a1 to 4.0.0rc3. ## 4.0.0rc3 (2015-09-20) Features: * Added `Identifier#without_exts` and `Identifier#exts` (#644, #696) [Rémi Barraquand] * Added `DocumentView#attributes` (#699, #702) Fixes: * Fixed issue when comparing document views (#680, #693) Enhancements: * Made `#base_url` argument in `#tags_for` optional (#687) [Croath Liu] * Allowed `IdentifiableCollection#[]` to be passed an identifier (#681, #695) * Improved `Pattern.from` error message (#683, #692) * Let default site use a direct link to the stylesheet (#685, #701) Changes: * Removed `Identifier#with_ext` because its behavior was confusing (#697, #700) * Disallowed storing document (views) in attributes (#682, #694) ## 4.0.0rc2 (2015-07-11) Fixes: * Fixed broken `shell` command (#672) [Jim Mendenhall] * Fixed absolute path check on Windows (#656) Enhancements: * Made Nanoc error when multiple items have the same output path (#665, #669) * Improved error message for non-hash frontmatter (#670, #673) Changes: * nanoc is now called Nanoc ## 4.0.0rc1 (2015-06-21) Fixes: * Fixed double-wrapping of `@layout` in rendering helper (#631) * Fixed `show-rules` command (#633) ## 4.0.0b4 (2015-06-10) Fixes: * Added missing `#ext` method to identifiers (#612) * Fixed issue where identifiers would have the wrong extension (#611) * Fixed rule context exposing entities rather than views (#614, #615) * Fixed `#key?` and `#fetch` not being available on layout views (#618) * Fixed `#update_attributes` not being available on mutable layout views (#619) ## 4.0.0b3 (2015-05-31) Changes: * Removed `filesystem_verbose` data source (#599) * Set minimum required Ruby version to 2.2 Enhancements: * Made `@config`, `@items` and `@layouts` available in checks (#598) * Made `filesystem` an alias for `filesystem_unified` (#599) * Made specific reps for an item accessible using `@item.reps[:name]` (#586, #607) * Removed `allow_periods_in_identifiers` documentation (#605) * Made fog deployer not upload files with identical ETags to AWS (#480, #536, #552) [Paul Boone] Fixes: * Made `ItemView#parent` return nil if parent is nil (#600, #602) * Added missing `identifier_type` documentation (#604) ## 4.0.0b2 (2015-05-23) Changes: * Removed `ItemCollectionView#at` (#582) * Removed support for calling `ItemCollectionView#[]` with an integer (#582) * Renamed `identifier_style` to `identifier_type`, and made its values be `"full"` or `"legacy"` (#593) * Renamed `pattern_syntax` to `string_pattern_type`, and made its values be `"glob"` or `"legacy"` (#593) * Made `"full"` the default for `identifier_type` (#592, #594) * Made `"glob"` the default for `string_pattern_type` (#592) * Enabled auto-pruning by default for new sites (#590) Enhancements: * Added `--force` to `create-site` command (#580) [David Alexander] * Made default Rules file more future-proof (#591) Fixes: * Fixed `LayoutCollectionView#[]` documentation (it mentioned items) * Fixed `ItemCollectionView#[]` returning an array when passed a regex * Fixed an issue with mutable collection views’ `#delete_if` not yielding mutable views * Fixed an issue with collection views’ `#find_all` returning entities instead of views ## 4.0.0b1 (2015-05-14) Changes: * Removed tasks * Removed several private methods in the view API * Removed default `base_url` in tagging helper Enhancements: * Removed unused options from CLI * Added `Nanoc::Identifier#without_ext` * Made `Nanoc::Identifier#=~` work with a glob * Added `Nanoc::LayoutCollectionView#[]` * Allowed creation of site in current directory (#549) [David Alexander] Fixes: * Fixed `#passthrough` for identifiers with extensions * Fixed rendering helper for identifiers with extensions * Fixed filtering helper ## 4.0.0a2 (2015-05-12) Features: * Glob patterns (opt-in by setting `pattern_syntax` to `"glob"` in the site configuration) * Identifiers with extensions (opt-in by setting `identifier_style` to `"full"` in the data source configuration) Enhancements: * Added several convenience methods to view classes (#570, #572) See the [nanoc 4 upgrade guide](http://nanoc.ws/docs/nanoc-4-upgrade-guide/) for details. ## 4.0.0a1 (2015-05-09) This is a major upgrade. For details on upgrading, see the [nanoc 4 upgrade guide](http://nanoc.ws/docs/nanoc-4-upgrade-guide/). This release provides no new features, but streamlines the API and functionality, in order to easen future development, both for features and for optimisations. ## 3.8 (2015-05-04) Features: * Added `mixed_content` check (#542, #543) [Mike Pennisi] * Added `commands_dirs` configuration option for specifying directories to read commands from (#475) [Gregory Pakosz] * Added `:cdn_id` option to fog deployer for invalidating CDN objects (#451) [Vlatko Kosturjak] * Add access to regular expressions group matches in rules (#478) [Michal Papis] * Allow filtering the items array by regex (#458) [Mike Pennisi] Enhancements: * Added `:preserve_order` option to preserve order in Atom feed (#533, #534) * Allowed accessing `:pre` snapshot from within item itself (#537, #538, #548) Fixes: * Allowed passing generic Pandoc options with :args (#526, #535) * Fix crash when compiling extensionless binary items (#524, #525) * Fix double snapshot creation error (#547) ## 3.7.5 (2015-01-12) Enhancements: * Allowed extra patterns to be specified in the data source configuration, so that dotfiles are no longer necessary ignored (e.g. `extra_files: ['.htaccess']`) (#492, #498) [Andy Drop, Michal Papis] * Removed Ruby 1.8.x support ([details](https://groups.google.com/forum/#!topic/nanoc/pSL1i15EFz8)) (#517) * Improved CSS and HTML error messages (#484, #504) * Let kramdown filter print warnings (#459, #519) Fixes: * Fixed HTML class names for recent Rouge versions (#502) * Fixed crash when using items or layouts in attributes (#469, #518) ## 3.7.4 (2014-11-23) Enhancements: * Made `check` command fail when output directory is missing (#472) [Mike Pennisi] * Made external links check timeouts start small and grow (#483) [Michal Papis] * Made code and API adhere much more closely to the Ruby style guide (#476) Fixes: * Fixed potential “parent directory is world writable” error (#465, #474) * Fixed retrying requests in the external link checker (#483) [Michal Papis] * Fixed issue with data sources not being unloaded (#491) [Michal Papis] ## 3.7.3 (2014-08-31) Fixes: * Fixed issue which caused metadata sections not be recognised in files that use CRLF line endings (#470, #471) [Gregory Pakosz] ## 3.7.2 (2014-08-17) Fixes: * Fixed broken links to the now defunct RubyForge (#454, #467) * Fixed crash when Gemfile is missing but Bundler is installed (#464) * Made filesystem data source not strip any whitespace (#463) [Gregory Pakosz] Enhancements: * Fixed issue which could cause items to be unnecessarily marked as outdated (#461) [Gregory Pakosz] * Prevented binary layouts from being generated (#468) [Gregory Pakosz] ## 3.7.1 (2014-06-16) Fixes: * Fixed bug which would cause nanoc to crash if no Gemfile is present (#447, #449) ## 3.7 (2014-06-08) New features: * Allowed excluding links from the internal links check (`@config[:checks][:internal_links][:exclude]`) (#242) [Remko Tronçon] * Added Rouge syntax coloring filter (#398) [Guilherme Garnier] * Backported `after_setup` from nanoc 4 to make it easier to create CLI plugins (#407) [Rémi Barraquand] * Make lib dirs configurable using `lib_dirs` config attribute (#424) [Gregory Pakosz] * Added support for setting parent config dir using `parent_config_file` config attribute (#419) [Gregory Pakosz] Enhancements: * Added `:with_toc` support to RedCarpet (#222, #232) * Added `slim` to the list of text extensions (#316) * Made `content/` and `layouts/` dirs configurable (#412) [Gregory Pakosz] * Allowed included rules files to have their own preprocess block (#420) [Gregory Pakosz] Fixes: * Fixed bug which caused temporary directories not to be removed (#440, #444) ## 3.6.11 (2014-05-09) Identical to 3.6.10 but published with corrected release notes. This release was previously known as 3.6.10.1, but was renamed due to incompatibilities with the Semantic Versioning specification. ## 3.6.10 (2014-05-09) Fixes: * Fixed occasional "no such file" error on JRuby (#422) * Prevented multiple items and layouts from having the same identifier (#434, #435) Enhancements: * Set default encoding to UTF-8 (#428) * Improved checksummer to reduce number of unnecessary recompiles (#310, #431) * Disabled USR1 on JRuby in order to suppress warning (#425, #426) * Made pandoc filter argument passing more generic (#210, #433) ## 3.6.9 (2014-04-15) Fixes: * Fixed path to default stylesheet (#410, #411) * Improved reliability of piping from/to external processes in JRuby (#417) * Added workaround for “cannot modify” errors when using Nokogiri on JRuby (#416) * Made corrupted cached data auto-repair itself if possible (#409, #418) ## 3.6.8 (2014-03-22) Fixes: * Fixed issue with missing compilation durations (#374, #379) * Made XSL filter transform item rather than layout (#399, #401) [Simon South] * Made XSL filter honor omit-xml-declaration (#403, #404) [Simon South] * Removed "see full crash log" line from crash log (#397, #402) Enhancements: * Added warning when multiple preprocessors are defined (#389) * Improve stylesheet handling in default site (#339, #395) ## 3.6.7 (2013-12-09) Fixes: * Made Handlebars filter usable outside layouts (#346, #348) * Fixed ANSI color support on Windows (#352, #356) * Made fog deployer handle prefixes properly (#351) [Oliver Byford] * Fixed crash in watcher (#358) * Fixed huge durations when showing skipped items after compilation (#360, #364) * Fixed output of `--verbose` compilation statistics (#359, #365) * Fixed issue with Sass files not recompiling (#350, #370) Enhancements: * Fixed Windows compatibility issues in test suite (#353) [Raphael von der Grün] * Hid deprecated `autocompile` and `watch` commands in help * Made CLI swallow broken pipe errors when piping to a process that terminates prematurely (#318, #369) ## 3.6.6 (2013-11-08) Enhancements: * Reduced number of dependencies generated by Sass filter (#306) [Gregory Pakosz] * Recognised lowercase `utf` in language value (e.g. `en_US.utf8`) as being UTF-8 (#335, #338) * Set [Thin](http://code.macournoyer.com/thin/) as the default server for `nanoc view` (#342, #345) * Removed watcher section from the default configuration file (#343, #344) Fixes: * Prevented capturing helper from erroneously compiling items twice (#331, #337) ## 3.6.5 (2013-09-29) Fixes: * Fixed bug which could cause incorrect dependencies to be generated in some cases (#329) * Fixed handling of index filenames when allowing periods in identifiers (#330) ## 3.6.4 (2013-05-29) Enhancements: * Deprecated `watch` and `autocompile` commands in favour of [`guard-nanoc`](https://github.com/nanoc/guard-nanoc) Fixes: * Fixed bug which could cause the `tmp/` dir to blow up in size * Unescaped URLs when checking internal links ## 3.6.3 (2013-04-24) Fixes: * Added support for growlnotify on Windows (#253, #267) * Fixed bug which caused the external links checker to ignore the query string (#279, #297) * Removed weird treatment of `DOCTYPE`s in the `relativize_paths` filter (#296) * Fixed CodeRay syntax coloring on Ruby 2.0 * Silenced "Could not find files for the given pattern(s)" message on Windows (#298) * Fixed issue which could cause `output.diff` not to be generated correctly (#255, #301) * Let filesystem and static data sources follow symlinks (#299, #302) * Added compatibility with Listen 1.0 (#309) * Let `#passthrough` in Rules work well with the static data source (#251) [Gregory Pakosz] * Made timing information be more accurate (#303) ## 3.6.2 (2013-03-23) Fixes: * Removed the list of available deployers from the `deploy` help text and moved them into a new `--list-deployers` option [Damien Pollet] * Fixed warning about `__send__ `and `object_id` being redefined on Ruby 1.8.x [Justin Hileman] Enhancements: * Added possible alternative names for the `Checks` file for consistency with the `Rules` file: `Checks.rb`, `checks`, `checks.rb` [Damien Pollet] * Made sure unchanged files never have their mtime updated [Justin Hileman] * Made link checker retry 405 Method Not Allowed results with GET instead of HEAD [Daniel Hofstetter] ## 3.6.1 (2013-02-25) Fixes: * Fixed bug which could cause the Sass filter to raise a load error [Damien Pollet] * Fixed warnings about `__send__` and `object_id` being redefined [Justin Hileman] * Made `files_to_watch` contain `nanoc.yaml`, not `config.yaml` by default ## 3.6 (2013-02-24) Features: * Added `sync` command, allowing data sources to update local caches of external data [Justin Hileman] * Added `#ignore` compiler DSL method * Allowed accessing items by identifier using e.g. `@items['/about/']` * Added `shell` command Enhancements: * Renamed the nanoc configuration file from `config.yaml` to `nanoc.yaml` Fixes: * Updated references to old web site and old repository * Made `require` errors mention Bundler if appropriate * Fixed bug which caused pruner not to delete directories in some cases [Matthias Reitinger] * Made `check` command exit with the proper exit status * Added support for the `HTML_TOC` Redcarpet renderer * Made `stale` check honor files excluded by the pruner ## 3.5 (2013-01-27) Major changes: * Added checks Minor changes: * Added `#include_rules` for modularising Rules files [Justin Hileman] * Replaced FSSM with Listen [Takashi Uchibe] * Made USR1 print stack trace (not on Windows) * Added ability to configure autocompiler host/port in config.yaml [Stuart Montgomery] * Added static data source * Added `:rep_select` parameter to XML sitemap to allow filtering reps * Removed use of bright/bold colors for compatibility with Solarized Exensions: * Added support for parameters in Less filter [Ruben Verborgh] * Added support for icon and logo in Atom feed [Ruben Verborgh] Fixes: * Made syntax colorizer only use the first non-empty line when extracting the language comment * Fixed XSL filter ## 3.4.3 (2012-12-09) Improvements: * Item reps are now accessible in a consistent way: in Rules and during compilation, they can be accessed using both `@rep` and `@item_rep` Fixes: * Made cleaning streams (stdout/stderr as used by nanoc) compatible with Ruby’s built-in Logger * Made prune work when the output directory is a symlink * Made Handlebars filter compatible with the latest version * Made `show-data` command show more accurate dependencies [Stefan Bühler] * Restored compatibility with Sass 3.2.2 ## 3.4.2 (2012-11-01) Fixes: * Made passthrough rules be inserted in the right place [Gregory Pakosz] * Fixed crashes in the progress indicator when compiling * Made auto-pruning honor excluded files [Grégory Karékinian] * Made lack of which/where not crash watch command Improvements: * Fixed constant reinitialization warnings [Damien Pollet] * Made UTF-8 not be decomposed when outputting to a file from a non-UTF-8 terminal * Made syntax colorizer wrap CodeRay output in required CodeRay divs * Made fog delete after upload, not before [Go Maeda] * Made requesting compiled content of binary item impossible ## 3.4.1 (2012-09-22) Fixes: * Fixed auto-pruning * Made slim filter work with the capturing helper [Bil Bas] Improvements: * Made several speed improvements * Added prune configuration to config.yaml * Made nanoc check for presence of nanoc in Gemfile * Made compile command not show identicals (use `--verbose` if you want them) * Made `relativize_paths` filter recognise more paths to relativize [Arnau Siches] * Fixed #passthrough for items without extensions [Justin Hileman] * Added more IO/File proxy methods to cleaning streams ## 3.4 (2012-06-09) * Improved error output and added crash log * Renamed `debug` and `info` commands to `show-data` and `show-plugins`, respectively * Added `show-rules` command (aka `explain`) Extensions: * Added `:yield` key for Mustache filter * Added Handebars filter * Added Pandoc filter * Made the deployer use the `default` target if no target is specified * Converted HTML/CSS/link validation tasks to commands * Made link validator follow relative redirects ## 3.3.7 (2012-05-28) * Added filename to YAML parser errors * Fixed issue which caused extra dependencies to be generated * Made timing information take filtering helper into account ## 3.3.6 (2012-04-27) * Fixed issue with relative_link_to stripping HTML boilerplate ## 3.3.5 (2012-04-23) * Fixed issue with relative_link_to not working properly ## 3.3.4 (2012-04-23) * Fixed bug which caused the compilation stack to be empty * Restored Ruby 1.8 compatibility ## 3.3.3 (2012-04-11) * Fixed directed graph implementation on Rubinius * Made capturing helper not remember content between runs * Fixed Date#freeze issue on Ruby 1.8.x * Made it possible to have any kind of object as parameters in the Rules file * Fixed bug which caused changed routes not to cause a recompile ## 3.3.2 (2012-03-16) * Removed bin/nanoc3 (use nanoc3 gem if you want it) * Fixed wrong “no such snapshot” errors * Made deployer default to rsync for backwards compatibility * Fixed missing Nanoc::CLI in deployment tasks * Fixed “unrecognised kind” deployer error ## 3.3.1 (2012-02-18) * Fixed issue with long paths on Windows * Fixed a few deployer crashes * Added nanoc3.rb, nanoc3/tasks.rb, … for compatibility with older versions * Made nanoc setup Bundler at startup [John Nishinaga] ## 3.3 (2012-02-12) Base: * Dropped the “3” suffix on nanoc3/Nanoc3 * Turned Rake tasks into proper nanoc commands * Improved dependency tracking * Added support for locals in filters and layouts Extensions: * Added support for deployment using Fog [Jack Chu] * Added CoffeeScript filter [Riley Goodside] * Added XSL filter [Arnau Siches] * Added YUICompress filter [Matt Keveney] * Added pygments.rb to supported syntax colorizers * Allowed syntax colorizer to colorize outside `pre` elements [Kevin Lynagh] * Added support for HTTPS link validation [Fabian Buch] * Added support for (automatically) pruning stray output files [Justin Hileman] * Added deploy command ## 3.2.4 (2012-01-09) * Fixed bug which would cause some reps not to be compiled when invoking nanoc programmatically * Made data source configuration location a bit more obvious * Fixed watch command under Windows * Made filesystem data source ignore UTF-8 BOM * Improved compatibility of `colorize_syntax` filter with older libxml versions ## 3.2.3 (2011-10-31) * Made syntax colorizer only strip trailing blank lines instead of all blanks * Improved Ruby 1.9.x compatibility * Made default rakefile require rubygems if necessary * Made filename/content argument of `Nanoc3::Item#initialize` mandatory ## 3.2.2 (2011-09-04) * Fixed command usage printing * Made `relativize_paths` filter handle Windows network paths [Ruben Verborgh] * Made watcher use correct configuration * Allowed code blocks to start with a non-language shebang line ## 3.2.1 (2011-07-27) * Made `@config` available in rules file * Fixed `#readpartial` issue on JRuby [Matt Keveney] * Fixed possible `@cache` name clash in memoization module * Fixed options with required arguments (such as `--port` and `--host`) * Fixed broken `#check_availability` * Fixed error handling in watch command ## 3.2 (2011-07-24) Base: * Sped up nanoc quite a bit * Added progress indicator for long-running filters * Made all source data, such as item attributes, frozen during compilation * Added --color option to force color on * Cleaned up internals, deprecating several parts and/or marking them as private in the progress * Allowed custom commands in commands/ Extensions: * Added AsciiDoc filter * Added Redcarpet filter [Peter Aronoff] * Added Slim filter [Zaiste de Grengolada] * Added Typogruby filter * Added UglifyJS filter [Justin Hileman] * Added `:items` parameter for the XML site map [Justin Hileman] * Added support for params to ERB * Added `:default_colorizer` parameter to the `:colorize_syntax` filter * Allowed for passing arbitrary options to pygmentize [Matthias Vallentin] * Exposed RedCloth parameters in the filter [Vincent Driessen] ## 3.1.9 (2011-06-30) * Really fixed dependency generation between Sass partials this time * Updated Less filter to 2.0 * Made `colorize_syntax` filter throw an error if pygmentize is not available ## 3.1.8 (2011-06-25) * Made link validator accept https: URLs * Fixed erroneous handling of layouts with names ending in index * Fixed dependency generation between Sass partials * Fixed errors related to thread requires * Fixed crash while handling load errors * Improved encoding handling while reading files ## 3.1.7 (2011-05-03) * Restored compatibility with Sass 3.1 ## 3.1.6 (2010-11-21) * Fixed issues with incompatible encodings ## 3.1.5 (2010-08-24) * Improved `#render` documentation * Improved metadata section check so that e.g. raw diffs are handled properly * Deprecated using `Nanoc3::Site#initialize` with a non-`"."` argument * Added Ruby engine to version string * Allowed the `created_at` and `updated_at` attributes used in the `Blogging` helper to be `Date` instances ## 3.1.4 (2010-07-25) * Made INT and TERM signals always quit the CLI * Allowed relative imports in LESS * Made sure modification times are unchanged for identical recompiled items * Improved link validator error handling * Made pygmentize not output extra divs and pres * Allowed colorizers to be specified using symbols instead of strings * Added scss to the default list of text extensions ## 3.1.3 (2010-04-25) * Removed annoying win32console warning [Eric Sunshine] * Removed color codes when not writing to a terminal, or when writing to Windows’ console when win32console is not installed [Eric Sunshine] * Added .xhtml and .xml to list of text extensions * Improved support for relative Sass @imports [Chris Eppstein] ## 3.1.2 (2010-04-07) * Fixed bug which could cause incorrect output when compilation of an item is delayed due to an unmet dependency ## 3.1.1 (2010-04-05) * Sass `@import`s now work for files not managed by nanoc * Rake tasks now have their Unicode description decomposed if necessary ## 3.1 (2010-04-03) New: * An `Item#rep_named(name)` function for quickly getting a certain rep * An `Item#compiled_content` function for quickly getting compiled content * An `Item#path` function for quickly getting the path of an item rep * A new “+” wildcard in rule patterns that matches one or more characters * A `view` command that starts a web server in the output directory * A `debug` command that shows information about the items, reps and layouts * A `kramdown` filter ([kramdown site](http://kramdown.gettalong.org/)) * A diff between the previously compiled content and the last compiled content is now written to `output.diff` if the `enable_output_diff` site configuration attribute is true * Assigns, such as `@items`, `@layouts`, `@item`, … are accessible without `@` * Support for binary items Changed: * New sites now come with a stylesheet item instead of a `style.css` file in the output directory * The `deploy:rsync` task now use sensible default options * The `deploy:rsync` task now accepts a config environment variable * The `deploy:rsync` task now uses a lowercase `dry_run` environment variable * The `maruku` filter now accepts parameters * The `rainpress` filter now accepts parameters * The `filesystem` data source is now known as `filesystem_verbose` * Meta files and content files are now optional * The `filesystem_compact` and `filesystem_combined` data sources have been merged into a new `filesystem_unified` data source * The metadata section in `filesystem_unified` is now optional [Chris Eppstein] * The `--server` autocompile option is now known as `--handler` * Assigns in filters are now available as instance variables and methods * The `#breadcrumbs_trail` function now allows missing parents * The `sass` filter now properly handles `@import` dependencies Deprecated: * `Nanoc3::FileProxy`; use one of the filename attributes instead * `ItemRep#content_at_snapshot`; use `#compiled_content` instead * The `last_fm`, `delicious` and `twitter` data sources; fetch online content into a cache by a rake task and load data from this cache instead ## 3.0.9 (2010-02-24) * Fixed 1.8.x parsing bug due to lack of parens which could cause “undefined method `to_iso8601_time` for #” errors ## 3.0.8 (2010-02-24) * `#atom_tag_for` now works with `base_url`s that contain a path [Eric Sunshine] * Generated root URLs in `#atom_feed` now end with a slash [Eric Sunshine] * Autocompiler now recognises requests to index files * `Blogging` helper now allows `created_at` to be a Time instance ## 3.0.7 (2010-01-29) * Fixed bug which could cause layout rules not be matched in order ## 3.0.6 (2010-01-17) * Error checking in `filesystem_combined` has been improved [Brian Candler] * Generated HTML files now have a default encoding of UTF-8 * Periods in identifiers for layouts now behave correctly * The `relativize_paths` filter now correctly handles “/” [Eric Sunshine] ## 3.0.5 (2010-01-12) * Restored pre-3.0.3 behaviour of periods in identifiers. By default, a file can have multiple extensions (e.g. `content/foo.html.erb` will have the identifier `/foo/`), but if `allow_periods_in_identifiers` in the site configuration is true, a file can have only one extension (e.g. `content/blog/stuff.entry.html` will have the identifier `/blog/stuff.entry/`). ## 3.0.4 (2010-01-07) * Fixed a bug which would cause the `filesystem_compact` data source to incorrectly determine the content filename, leading to weird “Expected 1 content file but found 3” errors [Eric Sunshine] ## 3.0.3 (2010-01-06) * The `Blogging` helper now properly handles item reps without paths * The `relativize_paths` filter now only operates inside tags * The autocompiler now handles escaped paths * The `LinkTo` and `Tagging` helpers now output escaped HTML * Fixed `played_at` attribute assignment in the `LastFM` data source for tracks playing now, and added a `now_playing` attribute [Nicky Peeters] * The `filesystem_*` data sources can now handle dots in identifiers * Required enumerator to make sure `#enum_with_index` always works * `Array#stringify_keys` now properly recurses ## 3.0.2 (2009-11-07) * Children-only identifier patterns no longer erroneously also match parent (e.g.` /foo/*/` no longer matches `/foo/`) * The `create_site` command no longer uses those ugly HTML entities * Install message now mentions the IRC channel ## 3.0.1 (2009-10-05) * The proper exception is now raised when no matching compilation rules can be found * The autocompile command no longer has a duplicate `--port` option * The `#url_for` and `#feed_url` methods now check the presence of the `base_url` site configuration attribute * Several outdated URLs are now up-to-date * Error handling has been improved in general ## 3.0 (2009-08-14) New: * Multiple data sources * Dependency tracking between items * Filters can now optionally take arguments * `#create_page` and `#create_layout` methods in data sources * A new way to specify compilation/routing rules using a Rules file * A `coderay` filter ([CodeRay site](http://coderay.rubychan.de/)) * A `filesystem_compact` data source which uses less directories Changed: * Pages and textual assets are now known as “items” Removed: * Support for drafts * Support for binary assets * Support for templates * Everything that was deprecated in nanoc 2.x * `save_*`, `move_*` and `delete_*` methods in data sources * Processing instructions in metadata ## 2.2.2 (2009-05-18) * Removed `relativize_paths` filter; use `relativize_paths_in_html` or `relativize_paths_in_css` instead * Fixed bug which could cause nanoc to eat massive amounts of memory when an exception occurs * Fixed bug which would cause nanoc to complain about the open file limit being reached when using a large amount of assets ## 2.2.1 (2009-04-08) * Fixed bug which prevented `relative_path_to` from working * Split `relativize_paths` filter into two filter: `relativize_paths_in_html` and `relativize_paths_in_css` * Removed bundled mime-types library ## 2.2 (2009-04-06) New: * `--pages` and `--assets` compiler options * `--no-color` command-line option * `Filtering` helper * `#relative_path_to` function in `LinkTo` helper * `rainpress` filter ([Rainpress site](http://code.google.com/p/rainpress/)) * `relativize_paths` filter * The current layout is now accessible through the `@layout` variable * Much more informative stack traces when something goes wrong Changed: * The command-line option parser is now a lot more reliable * `#atom_feed` now takes optional `:content_proc`, `:excerpt_proc` and `:articles` parameters * The compile command show non-written items (those with `skip_output: true`) * The compile command compiles everything by default * Added `--only-outdated` option to compile only outdated pages Removed: * deprecated extension-based code ## 2.1.6 (2009-02-28) * The `filesystem_combined` data source now supports empty metadata sections * The `rdoc` filter now works for both RDoc 1.x and 2.x * The autocompiler now serves a 500 when an exception occurs outside compilation * The autocompiler no longer serves index files when the request path does not end with a slash * The autocompiler now always serves asset content correctly ## 2.1.5 (2009-02-01) * Added Ruby 1.9 compatibility * The `filesystem` and `filesystem_combined` data sources now preserve custom extensions ## 2.1.4 (2008-11-15) * Fixed an issue where the autocompiler in Windows would serve broken assets ## 2.1.3 (2008-09-27) * The `haml` and `sass` filters now correctly take their options from assets * The autocompiler now serves index files instead of 404s * Layouts named “index” are now handled correctly * The `filesystem_combined` data source now properly handles assets ## 2.1.2 (2008-09-08) * The utocompiler now compiles assets as well * The `sass` filter now takes options (just like the `haml` filter) * Haml/Sass options are now taken from the page *rep* instead of the page ## 2.1.1 (2008-08-18) * Fixed issue which would cause files not to be required in the right order ## 2.1 (2008-08-17) This is only a short summary of all changes in 2.1. For details, see the [nanoc web site](http://nanoc.stoneship.org/). Especially the blog and the updated manual will be useful. New: * New `rdiscount` filter ([RDiscount site](http://github.com/rtomayko/rdiscount)) * New `maruku` filter ([Maruku site](https://github.com/bhollis/maruku/)) * New `erubis` filter ([Erubis site](http://www.kuwata-lab.com/erubis/)) * A better command-line frontend * A new filesystem data source named `filesystem_combined` * Routers, which decide where compiled pages should be written to * Page/layout mtimes can now be retrieved through `page.mtime`/`layout.mtime` Changed: * Already compiled pages will no longer be re-compiled unless outdated * Layout processors and filters have been merged * Layouts no longer rely on file extensions to determine the layout processor * Greatly improved source code documentation * Greatly improved unit test suite Removed: * Several filters have been removed and replaced by newer filters: * `eruby`: use `erb` or `erubis` instead * `markdown`: use `bluecloth`, `rdiscount` or `maruku` instead * `textile`: use `redcloth` instead ## 2.0.4 (2008-05-04) * Fixed `default.rb`’s `#html_escape` * Updated Haml filter and layout processor so that @page, @pages and @config are now available as instance variables instead of local variables ## 2.0.3 (2008-03-25) * The autocompiler now honors custom paths * The autocompiler now attempts to serve pages with the most appropriate MIME type, instead of always serving everything as `text/html` ## 2.0.2 (2008-01-26) * nanoc now requires Ruby 1.8.5 instead of 1.8.6 ## 2.0.1 (2008-01-21) * Fixed a “too many open files” error that could appear during (auto)compiling ## 2.0 (2007-12-25) New: * Support for custom layout processors * Support for custom data sources * Database data source * An auto-compiler * Pages have `parent` and `children` Changed: * The source has been restructured and cleaned up a great deal * Filters are defined in a different way now * The `eruby` filter now uses ERB instead of Erubis Removed: * The `filters` property; use `filters_pre` instead * Support for Liquid ## 1.6.2 (2007-10-23) * Fixed an issue which prevented the content capturing plugin from working ## 1.6.1 (2007-10-14) * Removed a stray debug message ## 1.6 (2007-10-13) * Added support for post-layout filters * Added support for getting a File object for the page, so you can now e.g. easily get the modification time for a given page (`@page.file.mtime`) * Cleaned up the source code a lot * Removed deprecated asset-copying functionality ## 1.5 (2007-09-10) * Added support for custom filters * Improved Liquid support -- Liquid is now a first-class nanoc citizen * Deprecated assets -- use something like rsync instead * Added `eruby_engine` option, which can be `erb` or `erubis` ## 1.4 (2007-07-06) * nanoc now supports ERB (as well as Erubis); Erubis no longer is a dependency * `meta.yaml` can now have `haml_options` property, which is passed to Haml * Pages can now have a `filename` property, which defaults to `index` [Dennis Sutch] * Pages now know in what order they should be compiled, eliminating the need for custom page ordering [Dennis Sutch] ## 1.3.1 (2007-06-30) * The contents of the `assets` directory are now copied into the output directory specified in `config.yaml` ## 1.3 (2007-06-24) * The `@pages` array now also contains uncompiled pages * Pages with `skip_output` set to true will not be outputted * Added new filters * Textile/RedCloth * Sass * nanoc now warns before overwriting in `create_site`, `create_page` and `create_template` (but not in compile) ## 1.2 (2007-06-05) * Sites now have an `assets` directory, whose contents are copied to the `output` directory when compiling [Stanley Rost] * Added support for non-eRuby layouts (Markaby, Haml, Liquid, …) * Added more filters (Markaby, Haml, Liquid, RDoc [Dmitry Bilunov]) * Improved error reporting * Accessing page attributes using instance variables, and not through `@page`, is no longer possible * Page attributes can now be accessed using dot notation, i.e. `@page.title` as well as `@page[:title]` ## 1.1.3 (2007-05-18) * Fixed bug which would cause layoutless pages to be outputted incorrectly ## 1.1.2 (2007-05-17) * Backup files (files ending with a “~”) are now ignored * Fixed bug which would cause subpages not to be generated correctly ## 1.1 (2007-05-08) * Added support for nested layouts * Added coloured logging * `@page` now hold the page that is currently being processed * Index files are now called “content” files and are now named after the directory they are in [Colin Barrett] * It is now possible to access `@page` in the page’s content file ## 1.0.1 (2007-05-05) * Fixed a bug which would cause a “no such template” error to be displayed when the template existed but compiling it would raise an exception * Fixed bug which would cause pages not to be sorted by order before compiling ## 1.0 (2007-05-03) * Initial release nanoc-4.4.7/Gemfile.lock0000644000004100000410000002133513033443476015111 0ustar www-datawww-dataGIT remote: git://github.com/bbatsov/rubocop.git revision: 7c95534e1906539e53341cd53265fadfc0aba0e2 specs: rubocop (0.46.0) parser (>= 2.3.3.1, < 3.0) powerpack (~> 0.1) rainbow (>= 1.99.1, < 3.0) ruby-progressbar (~> 1.7) unicode-display_width (~> 1.0, >= 1.0.1) GIT remote: git://github.com/cowboyd/therubyracer.git revision: a635aee79b2057c396f8af92417cadf93415c275 specs: therubyracer (0.12.3) libv8 (~> 3.16.14.15) ref GIT remote: git://github.com/tmm1/pygments.rb.git revision: cf50cbeda48e8a242ef9cba9467e092935730f66 specs: pygments.rb (1.1.1) multi_json (>= 1.0.0) PATH remote: . specs: nanoc (4.4.7) cri (~> 2.3) hamster (~> 3.0) ref (~> 2.0) GEM remote: https://rubygems.org/ specs: CFPropertyList (2.3.4) RedCloth (4.3.2) addressable (2.5.0) public_suffix (~> 2.0, >= 2.0.2) adsf (1.2.1) rack (>= 1.0.0) appraisal (2.1.0) bundler rake thor (>= 0.14.0) ast (2.3.0) bluecloth (2.2.0) builder (3.2.2) chunky_png (1.3.8) coderay (1.1.1) coffee-script (2.4.1) coffee-script-source execjs coffee-script-source (1.12.2) colored (1.2) commonjs (0.2.7) compass (1.0.3) chunky_png (~> 1.2) compass-core (~> 1.0.2) compass-import-once (~> 1.0.5) rb-fsevent (>= 0.9.3) rb-inotify (>= 0.9) sass (>= 3.3.13, < 3.5) compass-core (1.0.3) multi_json (~> 1.0) sass (>= 3.3.0, < 3.5) compass-import-once (1.0.5) sass (>= 3.2, < 3.5) concurrent-ruby (1.0.4) contracts (0.14.0) coveralls (0.8.17) json (>= 1.8, < 3) simplecov (~> 0.12.0) term-ansicolor (~> 1.3) thor (~> 0.19.1) tins (~> 1.6) crack (0.4.3) safe_yaml (~> 1.0.0) cri (2.7.1) colored (~> 1.2) diff-lcs (1.2.5) docile (1.1.5) erubis (2.7.0) excon (0.54.0) execjs (2.7.0) ffi (1.9.14) fission (0.5.0) CFPropertyList (~> 2.2) fog (1.38.0) fog-aliyun (>= 0.1.0) fog-atmos fog-aws (>= 0.6.0) fog-brightbox (~> 0.4) fog-cloudatcost (~> 0.1.0) fog-core (~> 1.32) fog-dynect (~> 0.0.2) fog-ecloud (~> 0.1) fog-google (<= 0.1.0) fog-json fog-local fog-openstack fog-powerdns (>= 0.1.1) fog-profitbricks fog-rackspace fog-radosgw (>= 0.0.2) fog-riakcs fog-sakuracloud (>= 0.0.4) fog-serverlove fog-softlayer fog-storm_on_demand fog-terremark fog-vmfusion fog-voxel fog-vsphere (>= 0.4.0) fog-xenserver fog-xml (~> 0.1.1) ipaddress (~> 0.5) fog-aliyun (0.1.0) fog-core (~> 1.27) fog-json (~> 1.0) ipaddress (~> 0.8) xml-simple (~> 1.1) fog-atmos (0.1.0) fog-core fog-xml fog-aws (1.1.0) fog-core (~> 1.38) fog-json (~> 1.0) fog-xml (~> 0.1) ipaddress (~> 0.8) fog-brightbox (0.11.0) fog-core (~> 1.22) fog-json inflecto (~> 0.0.2) fog-cloudatcost (0.1.2) fog-core (~> 1.36) fog-json (~> 1.0) fog-xml (~> 0.1) ipaddress (~> 0.8) fog-core (1.43.0) builder excon (~> 0.49) formatador (~> 0.2) fog-dynect (0.0.3) fog-core fog-json fog-xml fog-ecloud (0.3.0) fog-core fog-xml fog-google (0.1.0) fog-core fog-json fog-xml fog-json (1.0.2) fog-core (~> 1.0) multi_json (~> 1.10) fog-local (0.3.1) fog-core (~> 1.27) fog-openstack (0.1.18) fog-core (>= 1.40) fog-json (>= 1.0) ipaddress (>= 0.8) fog-powerdns (0.1.1) fog-core (~> 1.27) fog-json (~> 1.0) fog-xml (~> 0.1) fog-profitbricks (3.0.0) fog-core (~> 1.42) fog-json (~> 1.0) fog-rackspace (0.1.2) fog-core (>= 1.35) fog-json (>= 1.0) fog-xml (>= 0.1) ipaddress (>= 0.8) fog-radosgw (0.0.5) fog-core (>= 1.21.0) fog-json fog-xml (>= 0.0.1) fog-riakcs (0.1.0) fog-core fog-json fog-xml fog-sakuracloud (1.7.5) fog-core fog-json fog-serverlove (0.1.2) fog-core fog-json fog-softlayer (1.1.4) fog-core fog-json fog-storm_on_demand (0.1.1) fog-core fog-json fog-terremark (0.1.0) fog-core fog-xml fog-vmfusion (0.1.0) fission fog-core fog-voxel (0.1.0) fog-core fog-xml fog-vsphere (1.6.0) fog-core rbvmomi (~> 1.9) fog-xenserver (0.2.3) fog-core fog-xml fog-xml (0.1.2) fog-core nokogiri (~> 1.5, >= 1.5.11) formatador (0.2.5) fuubar (2.2.0) rspec-core (~> 3.0) ruby-progressbar (~> 1.4) guard (2.14.0) formatador (>= 0.2.4) listen (>= 2.7, < 4.0) lumberjack (~> 1.0) nenv (~> 0.1) notiffany (~> 0.0) pry (>= 0.9.12) shellany (~> 0.0) thor (>= 0.18.1) guard-rake (1.0.0) guard rake haml (4.0.7) tilt hamster (3.0.0) concurrent-ruby (~> 1.0) handlebars (0.8.0) handlebars-source (~> 4.0.5) therubyracer (~> 0.12.1) handlebars-source (4.0.6) hashdiff (0.3.2) inflecto (0.0.2) ipaddress (0.8.3) json (2.0.2) kramdown (1.13.1) less (2.6.0) commonjs (~> 0.2.7) libv8 (3.16.14.17) listen (3.1.5) rb-fsevent (~> 0.9, >= 0.9.4) rb-inotify (~> 0.9, >= 0.9.7) ruby_dep (~> 1.2) lumberjack (1.0.10) m (1.5.0) method_source (>= 0.6.7) rake (>= 0.9.2.2) markaby (0.8.0) builder maruku (0.7.2) metaclass (0.0.4) method_source (0.8.2) mime-types (3.1) mime-types-data (~> 3.2015) mime-types-data (3.2016.0521) mini_portile2 (2.1.0) minitest (5.10.1) mocha (1.2.1) metaclass (~> 0.0.1) multi_json (1.12.1) mustache (1.0.3) nenv (0.3.0) nokogiri (1.7.0.1) mini_portile2 (~> 2.1.0) notiffany (0.1.1) nenv (~> 0.1) shellany (~> 0.0) pandoc-ruby (2.0.1) parser (2.3.3.1) ast (~> 2.2) powerpack (0.1.1) pry (0.10.4) coderay (~> 1.1.0) method_source (~> 0.8.1) slop (~> 3.4) public_suffix (2.0.5) rack (2.0.1) rainbow (2.2.1) rainpress (1.0) rake (12.0.0) rb-fsevent (0.9.8) rb-inotify (0.9.7) ffi (>= 0.5.0) rbvmomi (1.9.4) builder (~> 3.2) json (>= 1.8) nokogiri (~> 1.5) trollop (~> 2.1) rdiscount (2.2.0.1) rdoc (5.0.0) redcarpet (3.4.0) ref (2.0.0) rouge (2.0.7) rspec (3.5.0) rspec-core (~> 3.5.0) rspec-expectations (~> 3.5.0) rspec-mocks (~> 3.5.0) rspec-core (3.5.4) rspec-support (~> 3.5.0) rspec-expectations (3.5.0) diff-lcs (>= 1.2.0, < 2.0) rspec-support (~> 3.5.0) rspec-its (1.2.0) rspec-core (>= 3.0.0) rspec-expectations (>= 3.0.0) rspec-mocks (3.5.0) diff-lcs (>= 1.2.0, < 2.0) rspec-support (~> 3.5.0) rspec-support (3.5.0) ruby-progressbar (1.8.1) ruby_dep (1.5.0) rubypants (0.6.0) safe_yaml (1.0.4) sass (3.4.23) shellany (0.0.1) simplecov (0.12.0) docile (~> 1.1.0) json (>= 1.8, < 3) simplecov-html (~> 0.10.0) simplecov-html (0.10.0) slim (3.0.7) temple (~> 0.7.6) tilt (>= 1.3.3, < 2.1) slop (3.6.0) temple (0.7.7) term-ansicolor (1.4.0) tins (~> 1.0) thor (0.19.4) tilt (2.0.5) timecop (0.8.1) tins (1.13.0) trollop (2.1.2) typogruby (1.0.18) rubypants uglifier (3.0.4) execjs (>= 0.3.0, < 3) unicode-display_width (1.1.2) vcr (3.0.3) w3c_validators (1.3.1) json (~> 2.0) nokogiri (~> 1.6) webmock (2.3.2) addressable (>= 2.3.6) crack (>= 0.3.2) hashdiff xml-simple (1.1.5) yard (0.9.5) yard-contracts (0.1.5) contracts (~> 0.7) yard (~> 0.8) yuicompressor (1.3.3) PLATFORMS ruby DEPENDENCIES RedCloth adsf appraisal (~> 2.1) bluecloth builder bundler (>= 1.7.10, < 2.0) coderay coffee-script compass contracts (~> 0.14) coveralls erubis fog fuubar guard-rake haml handlebars json (~> 2.0) kramdown less (~> 2.0) listen m (~> 1.5) markaby maruku mime-types minitest (~> 5.0) mocha mustache (~> 1.0) nanoc! nokogiri (~> 1.6) pandoc-ruby pry pygments.rb! rack rainbow (~> 2.1) rainpress rake rdiscount (~> 2.2) rdoc (~> 5.0) redcarpet rouge rspec rspec-its (~> 1.2) rspec-mocks rubocop! rubypants sass simplecov slim therubyracer! timecop typogruby uglifier vcr w3c_validators webmock yard yard-contracts yuicompressor BUNDLED WITH 1.13.7 nanoc-4.4.7/nanoc.gemspec0000644000004100000410000000240113033443476015323 0ustar www-datawww-datarequire_relative 'lib/nanoc/version' Gem::Specification.new do |s| s.name = 'nanoc' s.version = Nanoc::VERSION s.homepage = 'http://nanoc.ws/' s.summary = 'A static-site generator with a focus on flexibility.' s.description = 'Nanoc is a static-site generator focused on flexibility. It transforms content from a format such as Markdown or AsciiDoc into another format, usually HTML, and lays out pages consistently to retain the site’s look and feel throughout. Static sites built with Nanoc can be deployed to any web server.' s.author = 'Denis Defreyne' s.email = 'denis.defreyne@stoneship.org' s.license = 'MIT' s.files = Dir['[A-Z]*'] + Dir['doc/yardoc_{templates,handlers}/**/*'] + Dir['{bin,lib,tasks,test,spec}/**/*'] + ['nanoc.gemspec'] s.executables = ['nanoc'] s.require_paths = ['lib'] s.rdoc_options = ['--main', 'README.md'] s.extra_rdoc_files = ['LICENSE', 'README.md', 'NEWS.md'] s.required_ruby_version = '>= 2.1.0' s.add_runtime_dependency('cri', '~> 2.3') s.add_runtime_dependency('hamster', '~> 3.0') s.add_runtime_dependency('ref', '~> 2.0') s.add_development_dependency('bundler', '>= 1.7.10', '< 2.0') s.add_development_dependency('appraisal', '~> 2.1') end nanoc-4.4.7/bin/0000755000004100000410000000000013033443476013433 5ustar www-datawww-datananoc-4.4.7/bin/nanoc0000755000004100000410000000042613033443476014461 0ustar www-datawww-data#!/usr/bin/env ruby require 'nanoc' require 'nanoc/cli' if File.file?('Gemfile') && !defined?(Bundler) warn 'A Gemfile was detected, but Bundler is not loaded. This is probably not what you want. To run Nanoc with Bundler, use `bundle exec nanoc`.' end Nanoc::CLI.run(ARGV) nanoc-4.4.7/Gemfile0000644000004100000410000000255113033443476014161 0ustar www-datawww-datasource 'https://rubygems.org' gemspec group :devel do gem 'contracts', '~> 0.14' gem 'coveralls', require: false gem 'fuubar' gem 'guard-rake' gem 'json', '~> 2.0' gem 'm', '~> 1.5' gem 'minitest', '~> 5.0' gem 'mocha' gem 'pry' gem 'rainbow', '~> 2.1' gem 'rake' gem 'rdoc', '~> 5.0' gem 'rspec' gem 'rspec-its', '~> 1.2' gem 'rspec-mocks' gem 'rubocop', github: 'bbatsov/rubocop' gem 'simplecov', require: false gem 'timecop' gem 'vcr' gem 'webmock' gem 'yard' gem 'yard-contracts' end group :plugins do gem 'adsf' gem 'bluecloth', platforms: :ruby gem 'builder' gem 'coderay' gem 'coffee-script' gem 'compass' gem 'erubis' gem 'fog' gem 'haml' gem 'handlebars', platforms: :ruby gem 'kramdown' gem 'less', '~> 2.0', platforms: :ruby gem 'listen' gem 'markaby' gem 'maruku' gem 'mime-types' gem 'mustache', '~> 1.0' gem 'nokogiri', '~> 1.6' gem 'pandoc-ruby' gem 'pygments.rb', github: 'tmm1/pygments.rb', platforms: [:ruby, :mswin] gem 'rack' gem 'rainpress' gem 'rdiscount', '~> 2.2', platforms: [:ruby, :mswin] gem 'redcarpet', platforms: [:ruby, :mswin] gem 'RedCloth', platforms: :ruby gem 'rouge' gem 'rubypants' gem 'sass' gem 'slim' gem 'therubyracer', github: 'cowboyd/therubyracer' gem 'typogruby' gem 'uglifier' gem 'w3c_validators' gem 'yuicompressor' end nanoc-4.4.7/spec/0000755000004100000410000000000013033443476013615 5ustar www-datawww-datananoc-4.4.7/spec/spec_helper.rb0000644000004100000410000000726413033443476016444 0ustar www-datawww-datarequire 'simplecov' SimpleCov.start require 'nanoc' require 'nanoc/cli' require 'nanoc/spec' require 'timecop' require 'rspec/its' Nanoc::CLI.setup RSpec.configure do |c| c.around(:each) do |example| Nanoc::CLI::ErrorHandler.disable example.run Nanoc::CLI::ErrorHandler.enable end c.around(:each) do |example| Dir.mktmpdir('nanoc-test') do |dir| FileUtils.cd(dir) do example.run end end end c.around(:each, chdir: false) do |example| FileUtils.cd(File.dirname(__FILE__) + '/..') do example.run end end c.before(:each) do Nanoc::Int::NotificationCenter.reset end c.before(:each, v8: true) do if ENV.key?('DISABLE_V8') skip 'V8 specs are disabled (broken on Ruby 2.4)' end end c.around(:each, stdio: true) do |example| orig_stdout = $stdout orig_stderr = $stderr unless ENV['QUIET'] == 'false' $stdout = StringIO.new $stderr = StringIO.new end example.run $stdout = orig_stdout $stderr = orig_stderr end c.before(:each, site: true) do FileUtils.mkdir_p('content') FileUtils.mkdir_p('layouts') FileUtils.mkdir_p('lib') FileUtils.mkdir_p('output') File.write('nanoc.yaml', '{}') File.write('Rules', 'passthrough "/**/*"') end c.include(Nanoc::Spec::HelperHelper, helper: true) # Set focus if any if ENV.fetch('FOCUS', false) $stdout.puts "Focusing spec on '#{ENV['FOCUS']}'" c.filter_run_including ENV['FOCUS'].to_sym => true end end RSpec::Matchers.define :raise_frozen_error do |_expected| match do |actual| begin actual.call false rescue => e if e.is_a?(RuntimeError) || e.is_a?(TypeError) e.message =~ /(^can't modify frozen |^unable to modify frozen object$)/ else false end end end supports_block_expectations failure_message do |_actual| 'expected that proc would raise a frozen error' end failure_message_when_negated do |_actual| 'expected that proc would not raise a frozen error' end end RSpec::Matchers.define :be_humanly_sorted do match do |actual| actual == sort(actual) end description do 'be humanly sorted' end failure_message do |actual| expected_order = [] actual.zip(sort(actual)).each do |a, b| if a != b expected_order << b end end "expected collection to be sorted (incorrect order: #{expected_order.join(' < ')})" end def sort(x) x.sort_by { |n| n.dup.unicode_normalize(:nfd).encode('ASCII', fallback: ->(_) { '' }).downcase } end end RSpec::Matchers.define :finish_in_under do |expected| supports_block_expectations match do |actual| before = Time.now actual.call after = Time.now @actual_duration = after - before @actual_duration < expected end chain :seconds do end failure_message do |_actual| "expected that proc would finish in under #{expected}s, but took #{format '%0.1fs', @actual_duration}" end failure_message_when_negated do |_actual| "expected that proc would not finish in under #{expected}s, but took #{format '%0.1fs', @actual_duration}" end end RSpec::Matchers.define :yield_from_fiber do |expected| supports_block_expectations include RSpec::Matchers::Composable match do |actual| @res = Fiber.new { actual.call }.resume values_match?(expected, @res) end description do "yield #{expected.inspect} from fiber" end failure_message do |_actual| "expected that proc would yield #{expected.inspect} from fiber, but was #{@res.inspect}" end failure_message_when_negated do |_actual| "expected that proc would not yield #{expected.inspect} from fiber, but was #{@res.inspect}" end end nanoc-4.4.7/spec/regression_filenames_spec.rb0000644000004100000410000000075713033443476021370 0ustar www-datawww-datadescribe 'regression tests', chdir: false do let(:regression_test_filenames) do Dir['spec/nanoc/regressions/*'] end let(:regression_test_numbers) do regression_test_filenames .map { |fn| File.readlines(fn).first.match(/GH-(\d+)/)[1] } end it 'should have the proper filenames' do regression_test_filenames.zip(regression_test_numbers) do |fn, num| expect(fn).to match(/gh_#{num}[a-z]*_spec/), "#{fn} has the wrong name in its #define block" end end end nanoc-4.4.7/spec/nanoc/0000755000004100000410000000000013033443476014713 5ustar www-datawww-datananoc-4.4.7/spec/nanoc/base/0000755000004100000410000000000013033443476015625 5ustar www-datawww-datananoc-4.4.7/spec/nanoc/base/views/0000755000004100000410000000000013033443476016762 5ustar www-datawww-datananoc-4.4.7/spec/nanoc/base/views/document_view_spec.rb0000644000004100000410000002240713033443476023176 0ustar www-datawww-datashared_examples 'a document view' do let(:view) { described_class.new(document, view_context) } let(:view_context) do Nanoc::ViewContext.new( reps: double(:reps), items: double(:items), dependency_tracker: dependency_tracker, compilation_context: double(:compilation_context), ) end let(:dependency_tracker) { Nanoc::Int::DependencyTracker.new(dependency_store) } let(:dependency_store) { Nanoc::Int::DependencyStore.new([]) } let(:base_item) { Nanoc::Int::Item.new('base', {}, '/base.md') } before do dependency_tracker.enter(base_item) end describe '#frozen?' do let(:document) { entity_class.new('content', {}, '/asdf/') } subject { view.frozen? } context 'non-frozen document' do it { is_expected.to be(false) } end context 'frozen document' do before { document.freeze } it { is_expected.to be(true) } end end describe '#== and #eql?' do let(:document) { entity_class.new('content', {}, '/asdf/') } context 'comparing with document with same identifier' do let(:other) { entity_class.new('content', {}, '/asdf/') } it 'is ==' do expect(view).to eq(other) end it 'is not eql?' do expect(view).not_to eql(other) end end context 'comparing with document with different identifier' do let(:other) { entity_class.new('content', {}, '/fdsa/') } it 'is not ==' do expect(view).not_to eq(other) end it 'is not eql?' do expect(view).not_to eql(other) end end context 'comparing with document view with same identifier' do let(:other) { other_view_class.new(entity_class.new('content', {}, '/asdf/'), nil) } it 'is ==' do expect(view).to eq(other) end it 'is not eql?' do expect(view).not_to eql(other) end end context 'comparing with document view with different identifier' do let(:other) { other_view_class.new(entity_class.new('content', {}, '/fdsa/'), nil) } it 'is not ==' do expect(view).not_to eq(other) end it 'is not eql?' do expect(view).not_to eql(other) end end context 'comparing with other object' do let(:other) { nil } it 'is not ==' do expect(view).not_to eq(other) end it 'is not eql?' do expect(view).not_to eql(other) end end end describe '#[]' do let(:document) { entity_class.new('stuff', { animal: 'donkey' }, '/foo/') } subject { view[key] } context 'with existant key' do let(:key) { :animal } it { is_expected.to eql('donkey') } it 'creates a dependency' do expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([document]) end it 'creates a dependency with the right props' do subject dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0] expect(dep.props.attributes?).to eq(true) expect(dep.props.raw_content?).to eq(false) expect(dep.props.compiled_content?).to eq(false) expect(dep.props.path?).to eq(false) end end context 'with non-existant key' do let(:key) { :weapon } it { is_expected.to eql(nil) } it 'creates a dependency' do expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([document]) end it 'creates a dependency with the right props' do subject dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0] expect(dep.props.attributes?).to eq(true) expect(dep.props.raw_content?).to eq(false) expect(dep.props.compiled_content?).to eq(false) expect(dep.props.path?).to eq(false) end end end describe '#attributes' do let(:document) { entity_class.new('stuff', { animal: 'donkey' }, '/foo/') } subject { view.attributes } it 'creates a dependency' do expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([document]) end it 'creates a dependency with the right props' do subject dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0] expect(dep.props.attributes?).to eq(true) expect(dep.props.raw_content?).to eq(false) expect(dep.props.compiled_content?).to eq(false) expect(dep.props.path?).to eq(false) end it 'returns attributes' do expect(subject).to eql(animal: 'donkey') end end describe '#fetch' do let(:document) { entity_class.new('stuff', { animal: 'donkey' }, '/foo/') } context 'with existant key' do let(:key) { :animal } subject { view.fetch(key) } it { is_expected.to eql('donkey') } it 'creates a dependency' do expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([document]) end it 'creates a dependency with the right props' do subject dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0] expect(dep.props.attributes?).to eq(true) expect(dep.props.raw_content?).to eq(false) expect(dep.props.compiled_content?).to eq(false) expect(dep.props.path?).to eq(false) end end context 'with non-existant key' do let(:key) { :weapon } context 'with fallback' do subject { view.fetch(key, 'nothing sorry') } it { is_expected.to eql('nothing sorry') } it 'creates a dependency' do expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([document]) end it 'creates a dependency with the right props' do subject dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0] expect(dep.props.attributes?).to eq(true) expect(dep.props.raw_content?).to eq(false) expect(dep.props.compiled_content?).to eq(false) expect(dep.props.path?).to eq(false) end end context 'with block' do subject { view.fetch(key) { 'nothing sorry' } } it { is_expected.to eql('nothing sorry') } it 'creates a dependency' do expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([document]) end it 'creates a dependency with the right props' do subject dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0] expect(dep.props.attributes?).to eq(true) expect(dep.props.raw_content?).to eq(false) expect(dep.props.compiled_content?).to eq(false) expect(dep.props.path?).to eq(false) end end context 'with no fallback and no block' do subject { view.fetch(key) } it 'raises' do expect { subject }.to raise_error(KeyError) end end end end describe '#key?' do let(:document) { entity_class.new('stuff', { animal: 'donkey' }, '/foo/') } subject { view.key?(key) } context 'with existant key' do let(:key) { :animal } it { is_expected.to eql(true) } it 'creates a dependency' do expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([document]) end it 'creates a dependency with the right props' do subject dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0] expect(dep.props.attributes?).to eq(true) expect(dep.props.raw_content?).to eq(false) expect(dep.props.compiled_content?).to eq(false) expect(dep.props.path?).to eq(false) end end context 'with non-existant key' do let(:key) { :weapon } it { is_expected.to eql(false) } it 'creates a dependency' do expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([document]) end it 'creates a dependency with the right props' do subject dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0] expect(dep.props.attributes?).to eq(true) expect(dep.props.raw_content?).to eq(false) expect(dep.props.compiled_content?).to eq(false) expect(dep.props.path?).to eq(false) end end end describe '#hash' do let(:document) { double(:document, identifier: '/foo/') } subject { view.hash } it { should == described_class.hash ^ '/foo/'.hash } end describe '#raw_content' do let(:document) { entity_class.new('stuff', { animal: 'donkey' }, '/foo/') } subject { view.raw_content } it { is_expected.to eql('stuff') } it 'creates a dependency' do expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([document]) end it 'creates a dependency with the right props' do subject dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0] expect(dep.props.raw_content?).to eq(true) expect(dep.props.attributes?).to eq(false) expect(dep.props.compiled_content?).to eq(false) expect(dep.props.path?).to eq(false) end end end nanoc-4.4.7/spec/nanoc/base/views/mutable_layout_collection_view_spec.rb0000644000004100000410000000240413033443476026614 0ustar www-datawww-datadescribe Nanoc::MutableLayoutCollectionView do let(:view_class) { Nanoc::MutableLayoutView } it_behaves_like 'an identifiable collection' it_behaves_like 'a mutable identifiable collection' let(:config) do { string_pattern_type: 'glob' } end describe '#create' do let(:layout) do Nanoc::Int::Layout.new('content', {}, '/asdf/') end let(:wrapped) do Nanoc::Int::IdentifiableCollection.new(config).tap do |coll| coll << layout end end let(:view) { described_class.new(wrapped, nil) } it 'creates an object' do view.create('new content', { title: 'New Page' }, '/new/') expect(wrapped.size).to eq(2) expect(wrapped['/new/'].content.string).to eq('new content') end it 'returns self' do ret = view.create('new content', { title: 'New Page' }, '/new/') expect(ret).to equal(view) end end describe '#inspect' do let(:wrapped) do Nanoc::Int::IdentifiableCollection.new(config) end let(:view) { described_class.new(wrapped, view_context) } let(:view_context) { double(:view_context) } let(:config) { { string_pattern_type: 'glob' } } subject { view.inspect } it { is_expected.to eql('') } end end nanoc-4.4.7/spec/nanoc/base/views/item_collection_with_reps_view_spec.rb0000644000004100000410000000101313033443476026603 0ustar www-datawww-datadescribe Nanoc::ItemCollectionWithRepsView do let(:view_class) { Nanoc::ItemWithRepsView } it_behaves_like 'an identifiable collection' describe '#inspect' do let(:wrapped) do Nanoc::Int::IdentifiableCollection.new(config) end let(:view) { described_class.new(wrapped, view_context) } let(:view_context) { double(:view_context) } let(:config) { { string_pattern_type: 'glob' } } subject { view.inspect } it { is_expected.to eql('') } end end nanoc-4.4.7/spec/nanoc/base/views/mutable_document_view_spec.rb0000644000004100000410000000524413033443476024707 0ustar www-datawww-datashared_examples 'a mutable document view' do let(:view) { described_class.new(item, view_context) } let(:view_context) do Nanoc::ViewContext.new( reps: double(:reps), items: double(:items), dependency_tracker: dependency_tracker, compilation_context: double(:compilation_context), ) end let(:dependency_tracker) { Nanoc::Int::DependencyTracker.new(double(:dependency_store)) } describe '#[]=' do # FIXME: rename :item to :document let(:item) { entity_class.new('content', {}, '/asdf/') } it 'sets attributes' do view[:title] = 'Donkey' expect(view[:title]).to eq('Donkey') end it 'disallows items' do item = Nanoc::Int::Item.new('content', {}, '/foo.md') expect { view[:item] = item }.to raise_error(Nanoc::MutableDocumentViewMixin::DisallowedAttributeValueError) end it 'disallows layouts' do layout = Nanoc::Int::Layout.new('content', {}, '/foo.md') expect { view[:layout] = layout }.to raise_error(Nanoc::MutableDocumentViewMixin::DisallowedAttributeValueError) end it 'disallows item views' do item = Nanoc::ItemWithRepsView.new(Nanoc::Int::Item.new('content', {}, '/foo.md'), nil) expect { view[:item] = item }.to raise_error(Nanoc::MutableDocumentViewMixin::DisallowedAttributeValueError) end it 'disallows layout views' do layout = Nanoc::LayoutView.new(Nanoc::Int::Layout.new('content', {}, '/foo.md'), nil) expect { view[:layout] = layout }.to raise_error(Nanoc::MutableDocumentViewMixin::DisallowedAttributeValueError) end end describe '#identifier=' do let(:item) { entity_class.new('content', {}, '/about.md') } subject { view.identifier = arg } context 'given a string' do let(:arg) { '/about.adoc' } it 'changes the identifier' do subject expect(view.identifier).to eq('/about.adoc') end end context 'given an identifier' do let(:arg) { Nanoc::Identifier.new('/about.adoc') } it 'changes the identifier' do subject expect(view.identifier).to eq('/about.adoc') end end context 'given anything else' do let(:arg) { :donkey } it 'raises' do expect { subject }.to raise_error(Nanoc::Identifier::NonCoercibleObjectError) end end end describe '#update_attributes' do let(:item) { entity_class.new('content', {}, '/asdf/') } let(:update) { { friend: 'Giraffe' } } subject { view.update_attributes(update) } it 'sets attributes' do expect { subject }.to change { view[:friend] }.from(nil).to('Giraffe') end it 'returns self' do expect(subject).to equal(view) end end end nanoc-4.4.7/spec/nanoc/base/views/config_view_spec.rb0000644000004100000410000000400113033443476022613 0ustar www-datawww-datadescribe Nanoc::ConfigView do let(:config) do Nanoc::Int::Configuration.new(hash: hash) end let(:hash) { { amount: 9000, animal: 'donkey' } } let(:view) { described_class.new(config, nil) } describe '#frozen?' do subject { view.frozen? } context 'non-frozen config' do it { is_expected.to be(false) } end context 'frozen config' do before { config.freeze } it { is_expected.to be(true) } end end describe '#[]' do subject { view[key] } context 'with existant key' do let(:key) { :animal } it { is_expected.to eql('donkey') } end context 'with non-existant key' do let(:key) { :weapon } it { is_expected.to eql(nil) } end end describe '#fetch' do context 'with existant key' do let(:key) { :animal } subject { view.fetch(key) } it { is_expected.to eql('donkey') } end context 'with non-existant key' do let(:key) { :weapon } context 'with fallback' do subject { view.fetch(key, 'nothing sorry') } it { is_expected.to eql('nothing sorry') } end context 'with block' do subject { view.fetch(key) { 'nothing sorry' } } it { is_expected.to eql('nothing sorry') } end context 'with no fallback and no block' do subject { view.fetch(key) } it 'raises' do expect { subject }.to raise_error(KeyError) end end end end describe '#key?' do subject { view.key?(key) } context 'with existant key' do let(:key) { :animal } it { is_expected.to eql(true) } end context 'with non-existant key' do let(:key) { :weapon } it { is_expected.to eql(false) } end end describe '#each' do example do res = [] view.each { |k, v| res << [k, v] } expect(res).to eql([[:amount, 9000], [:animal, 'donkey']]) end end describe '#inspect' do subject { view.inspect } it { is_expected.to eql('') } end end nanoc-4.4.7/spec/nanoc/base/views/mutable_item_collection_view_spec.rb0000644000004100000410000000237213033443476026241 0ustar www-datawww-datadescribe Nanoc::MutableItemCollectionView do let(:view_class) { Nanoc::MutableItemView } it_behaves_like 'an identifiable collection' it_behaves_like 'a mutable identifiable collection' let(:config) do { string_pattern_type: 'glob' } end describe '#create' do let(:item) do Nanoc::Int::Layout.new('content', {}, '/asdf/') end let(:wrapped) do Nanoc::Int::IdentifiableCollection.new(config).tap do |coll| coll << item end end let(:view) { described_class.new(wrapped, nil) } it 'creates an object' do view.create('new content', { title: 'New Page' }, '/new/') expect(wrapped.size).to eq(2) expect(wrapped['/new/'].content.string).to eq('new content') end it 'returns self' do ret = view.create('new content', { title: 'New Page' }, '/new/') expect(ret).to equal(view) end end describe '#inspect' do let(:wrapped) do Nanoc::Int::IdentifiableCollection.new(config) end let(:view) { described_class.new(wrapped, view_context) } let(:view_context) { double(:view_context) } let(:config) { { string_pattern_type: 'glob' } } subject { view.inspect } it { is_expected.to eql('') } end end nanoc-4.4.7/spec/nanoc/base/views/mutable_item_view_spec.rb0000644000004100000410000000122713033443476024024 0ustar www-datawww-datadescribe Nanoc::MutableItemView do let(:entity_class) { Nanoc::Int::Item } it_behaves_like 'a mutable document view' let(:item) { entity_class.new('content', {}, '/asdf/') } let(:view) { described_class.new(item, nil) } it 'does have rep access' do expect(view).not_to respond_to(:compiled_content) expect(view).not_to respond_to(:path) expect(view).not_to respond_to(:reps) end describe '#inspect' do let(:item) { Nanoc::Int::Item.new('content', {}, '/asdf/') } let(:view) { described_class.new(item, nil) } subject { view.inspect } it { is_expected.to eql('') } end end nanoc-4.4.7/spec/nanoc/base/views/post_compile_item_rep_view_spec.rb0000644000004100000410000001001413033443476025730 0ustar www-datawww-datadescribe Nanoc::PostCompileItemRepView do let(:item_rep) { Nanoc::Int::ItemRep.new(item, :jacques) } let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo/') } let(:view) { described_class.new(item_rep, view_context) } let(:view_context) do Nanoc::ViewContext.new( reps: reps, items: items, dependency_tracker: dependency_tracker, compilation_context: compilation_context, ) end let(:reps) { double(:reps) } let(:items) { Nanoc::Int::IdentifiableCollection.new(config) } let(:config) { Nanoc::Int::Configuration.new } let(:dependency_tracker) { Nanoc::Int::DependencyTracker.new(double(:dependency_store)) } let(:compilation_context) { double(:compilation_context, compiled_content_cache: compiled_content_cache) } let(:snapshot_contents) do { last: Nanoc::Int::TextualContent.new('content-last'), pre: Nanoc::Int::TextualContent.new('content-pre'), donkey: Nanoc::Int::TextualContent.new('content-donkey'), } end let(:compiled_content_cache) do Nanoc::Int::CompiledContentCache.new(items: items).tap do |ccc| ccc[item_rep] = snapshot_contents end end describe '#compiled_content' do subject { view.compiled_content } context 'binary' do let(:item) do content = Nanoc::Int::Content.create('/foo.dat', binary: true) Nanoc::Int::Item.new(content, {}, '/foo.dat') end it 'raises error' do err = Nanoc::Int::Errors::CannotGetCompiledContentOfBinaryItem expect { subject }.to raise_error(err) end end shared_examples 'returns pre content' do example { expect(subject).to eq('content-pre') } end shared_examples 'returns last content' do example { expect(subject).to eq('content-last') } end shared_examples 'returns donkey content' do example { expect(subject).to eq('content-donkey') } end shared_examples 'raises no-such-snapshot error' do it 'raises error' do err = Nanoc::Int::Errors::NoSuchSnapshot expect { subject }.to raise_error(err) end end context 'textual' do context 'snapshot provided' do subject { view.compiled_content(snapshot: :donkey) } let(:expected_snapshot) { :donkey } context 'snapshot exists' do include_examples 'returns donkey content' end context 'snapshot does not exist' do let(:snapshot_contents) do { last: Nanoc::Int::TextualContent.new('content-last'), pre: Nanoc::Int::TextualContent.new('content-pre'), } end include_examples 'raises no-such-snapshot error' end end context 'no snapshot provided' do context 'pre and last snapshots exist' do let(:snapshot_contents) do { last: Nanoc::Int::TextualContent.new('content-last'), pre: Nanoc::Int::TextualContent.new('content-pre'), donkey: Nanoc::Int::TextualContent.new('content-donkey'), } end include_examples 'returns pre content' end context 'pre snapshot exists' do let(:snapshot_contents) do { pre: Nanoc::Int::TextualContent.new('content-pre'), donkey: Nanoc::Int::TextualContent.new('content-donkey'), } end include_examples 'returns pre content' end context 'last snapshot exists' do let(:snapshot_contents) do { last: Nanoc::Int::TextualContent.new('content-last'), donkey: Nanoc::Int::TextualContent.new('content-donkey'), } end include_examples 'returns last content' end context 'neither pre nor last snapshot exists' do let(:snapshot_contents) do { donkey: Nanoc::Int::TextualContent.new('content-donkey'), } end include_examples 'raises no-such-snapshot error' end end end end end nanoc-4.4.7/spec/nanoc/base/views/item_rep_view_spec.rb0000644000004100000410000001721613033443476023166 0ustar www-datawww-datadescribe Nanoc::ItemRepView do let(:view_context) { Nanoc::ViewContext.new(reps: reps, items: items, dependency_tracker: dependency_tracker, compilation_context: compilation_context) } let(:reps) { double(:reps) } let(:items) { double(:items) } let(:compilation_context) { double(:compilation_context) } let(:dependency_tracker) { Nanoc::Int::DependencyTracker.new(dependency_store) } let(:dependency_store) { Nanoc::Int::DependencyStore.new([]) } let(:base_item) { Nanoc::Int::Item.new('base', {}, '/base.md') } before do dependency_tracker.enter(base_item) end describe '#frozen?' do let(:item_rep) { Nanoc::Int::ItemRep.new(item, :jacques) } let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo/') } let(:view) { described_class.new(item_rep, view_context) } subject { view.frozen? } context 'non-frozen item rep' do it { is_expected.to be(false) } end context 'frozen item rep' do before { item_rep.freeze } it { is_expected.to be(true) } end end describe '#== and #eql?' do let(:item_rep) { Nanoc::Int::ItemRep.new(item, :jacques) } let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo/') } let(:view) { described_class.new(item_rep, view_context) } context 'comparing with item rep with same identifier' do let(:other_item) { double(:other_item, identifier: '/foo/') } let(:other) { double(:other_item_rep, item: other_item, name: :jacques) } it 'is ==' do expect(view).to eq(other) end it 'is eql?' do expect(view).not_to eql(other) end end context 'comparing with item rep with different identifier' do let(:other_item) { double(:other_item, identifier: '/bar/') } let(:other) { double(:other_item_rep, item: other_item, name: :jacques) } it 'is not ==' do expect(view).not_to eq(other) end it 'is not eql?' do expect(view).not_to eql(other) end end context 'comparing with item rep with different name' do let(:other_item) { double(:other_item, identifier: '/foo/') } let(:other) { double(:other_item_rep, item: other_item, name: :marvin) } it 'is not ==' do expect(view).not_to eq(other) end it 'is not eql?' do expect(view).not_to eql(other) end end context 'comparing with item rep with same identifier' do let(:other_item) { double(:other_item, identifier: '/foo/') } let(:other) { described_class.new(double(:other_item_rep, item: other_item, name: :jacques), view_context) } it 'is ==' do expect(view).to eq(other) end it 'is eql?' do expect(view).not_to eql(other) end end context 'comparing with item rep with different identifier' do let(:other_item) { double(:other_item, identifier: '/bar/') } let(:other) { described_class.new(double(:other_item_rep, item: other_item, name: :jacques), view_context) } it 'is not equal' do expect(view).not_to eq(other) expect(view).not_to eql(other) end end context 'comparing with item rep with different name' do let(:other_item) { double(:other_item, identifier: '/foo/') } let(:other) { described_class.new(double(:other_item_rep, item: other_item, name: :marvin), view_context) } it 'is not equal' do expect(view).not_to eq(other) expect(view).not_to eql(other) end end context 'comparing with something that is not an item rep' do let(:other_item) { double(:other_item, identifier: '/foo/') } let(:other) { :donkey } it 'is not equal' do expect(view).not_to eq(other) expect(view).not_to eql(other) end end end describe '#hash' do let(:item_rep) { Nanoc::Int::ItemRep.new(item, :jacques) } let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo/') } let(:view) { described_class.new(item_rep, view_context) } subject { view.hash } it { should == described_class.hash ^ Nanoc::Identifier.new('/foo/').hash ^ :jacques.hash } end describe '#compiled_content' do subject { view.compiled_content } let(:view) { described_class.new(rep, view_context) } let(:rep) do Nanoc::Int::ItemRep.new(item, :default).tap do |ir| ir.compiled = true ir.snapshot_defs = [ Nanoc::Int::SnapshotDef.new(:last), ] ir.snapshot_contents = { last: Nanoc::Int::TextualContent.new('Hallo'), } end end let(:item) do Nanoc::Int::Item.new('content', {}, '/asdf.md') end it 'creates a dependency' do expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([item]) end it 'creates a dependency with the right props' do subject dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0] expect(dep.props.compiled_content?).to eq(true) expect(dep.props.raw_content?).to eq(false) expect(dep.props.attributes?).to eq(false) expect(dep.props.path?).to eq(false) end it { should eq('Hallo') } end describe '#path' do subject { view.path } let(:view) { described_class.new(rep, view_context) } let(:rep) do Nanoc::Int::ItemRep.new(item, :default).tap do |ir| ir.paths = { last: '/about/', } end end let(:item) do Nanoc::Int::Item.new('content', {}, '/asdf.md') end it 'creates a dependency' do expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([item]) end it 'creates a dependency with the right props' do subject dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0] expect(dep.props.path?).to eq(true) expect(dep.props.raw_content?).to eq(false) expect(dep.props.attributes?).to eq(false) expect(dep.props.compiled_content?).to eq(false) end it { should eq('/about/') } end describe '#raw_path' do subject { view.raw_path } let(:view) { described_class.new(rep, view_context) } let(:rep) do Nanoc::Int::ItemRep.new(item, :default).tap do |ir| ir.raw_paths = { last: 'output/about/index.html', } end end let(:item) do Nanoc::Int::Item.new('content', {}, '/asdf.md') end it 'creates a dependency' do expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([item]) end it 'creates a dependency with the right props' do subject dep = dependency_store.dependencies_causing_outdatedness_of(base_item)[0] expect(dep.props.path?).to eq(true) expect(dep.props.raw_content?).to eq(false) expect(dep.props.attributes?).to eq(false) expect(dep.props.compiled_content?).to eq(false) end it { should eq('output/about/index.html') } end describe '#item' do let(:item_rep) { Nanoc::Int::ItemRep.new(item, :jacques) } let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo/') } let(:view) { described_class.new(item_rep, view_context) } subject { view.item } it 'returns an item view' do expect(subject).to be_a(Nanoc::ItemWithRepsView) end it 'returns an item view with the right context' do expect(subject._context).to equal(view_context) end end describe '#inspect' do let(:item_rep) { Nanoc::Int::ItemRep.new(item, :jacques) } let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo/') } let(:view) { described_class.new(item_rep, view_context) } subject { view.inspect } it { is_expected.to eql('') } end end nanoc-4.4.7/spec/nanoc/base/views/item_view_spec.rb0000644000004100000410000002172713033443476022322 0ustar www-datawww-datadescribe Nanoc::ItemWithRepsView do let(:entity_class) { Nanoc::Int::Item } let(:other_view_class) { Nanoc::LayoutView } it_behaves_like 'a document view' let(:view_context) { Nanoc::ViewContext.new(reps: reps, items: items, dependency_tracker: dependency_tracker, compilation_context: compilation_context) } let(:reps) { [] } let(:items) { [] } let(:dependency_tracker) { Nanoc::Int::DependencyTracker.new(dependency_store) } let(:dependency_store) { Nanoc::Int::DependencyStore.new([]) } let(:compilation_context) { double(:compilation_context) } let(:base_item) { Nanoc::Int::Item.new('base', {}, '/base.md') } before do dependency_tracker.enter(base_item) end describe '#parent' do let(:item) do Nanoc::Int::Item.new('me', {}, identifier) end let(:view) { described_class.new(item, view_context) } let(:items) do Nanoc::Int::IdentifiableCollection.new({}).tap do |arr| arr << item arr << parent_item if parent_item end end subject { view.parent } context 'with parent' do let(:parent_item) do Nanoc::Int::Item.new('parent', {}, '/parent/') end context 'full identifier' do let(:identifier) do Nanoc::Identifier.new('/parent/me.md') end it 'raises' do expect { subject }.to raise_error(Nanoc::Int::Errors::CannotGetParentOrChildrenOfNonLegacyItem) end end context 'legacy identifier' do let(:identifier) do Nanoc::Identifier.new('/parent/me/', type: :legacy) end it 'returns a view for the parent' do expect(subject.class).to eql(Nanoc::ItemWithRepsView) expect(subject.unwrap).to eql(parent_item) end it 'returns a view with the right context' do expect(subject._context).to equal(view_context) end context 'frozen parent' do before { parent_item.freeze } it { is_expected.to be_frozen } end context 'non-frozen parent' do it { is_expected.not_to be_frozen } end context 'with root parent' do let(:parent_item) { Nanoc::Int::Item.new('parent', {}, '/') } let(:identifier) { Nanoc::Identifier.new('/me/', type: :legacy) } it 'returns a view for the parent' do expect(subject.class).to eql(Nanoc::ItemWithRepsView) expect(subject.unwrap).to eql(parent_item) end end end end context 'without parent' do let(:parent_item) do nil end context 'full identifier' do let(:identifier) do Nanoc::Identifier.new('/me.md') end it 'raises' do expect { subject }.to raise_error(Nanoc::Int::Errors::CannotGetParentOrChildrenOfNonLegacyItem) end end context 'legacy identifier' do let(:identifier) do Nanoc::Identifier.new('/me/', type: :legacy) end it { is_expected.to be_nil } it { is_expected.to be_frozen } end end end describe '#children' do let(:item) do Nanoc::Int::Item.new('me', {}, identifier) end let(:children) do [Nanoc::Int::Item.new('child', {}, '/me/child/')] end let(:view) { described_class.new(item, view_context) } let(:items) do Nanoc::Int::IdentifiableCollection.new({}).tap do |arr| arr << item children.each { |child| arr << child } end end subject { view.children } context 'full identifier' do let(:identifier) do Nanoc::Identifier.new('/me.md') end it 'raises' do expect { subject }.to raise_error(Nanoc::Int::Errors::CannotGetParentOrChildrenOfNonLegacyItem) end end context 'legacy identifier' do let(:identifier) do Nanoc::Identifier.new('/me/', type: :legacy) end it 'returns views for the children' do expect(subject.size).to eql(1) expect(subject[0].class).to eql(Nanoc::ItemWithRepsView) expect(subject[0].unwrap).to eql(children[0]) end it { is_expected.to be_frozen } end end describe '#reps' do let(:item) { Nanoc::Int::Item.new('blah', {}, '/foo.md') } let(:rep_a) { Nanoc::Int::ItemRep.new(item, :a) } let(:rep_b) { Nanoc::Int::ItemRep.new(item, :b) } let(:reps) do Nanoc::Int::ItemRepRepo.new.tap do |reps| reps << rep_a reps << rep_b end end let(:view) { described_class.new(item, view_context) } subject { view.reps } it 'returns a proper item rep collection' do expect(subject.size).to eq(2) expect(subject.class).to eql(Nanoc::ItemRepCollectionView) end it 'returns a view with the right context' do expect(subject._context).to eq(view_context) end end describe '#compiled_content' do subject { view.compiled_content(params) } let(:view) { described_class.new(item, view_context) } let(:item) do Nanoc::Int::Item.new('content', {}, '/asdf/') end let(:reps) do Nanoc::Int::ItemRepRepo.new.tap do |reps| reps << rep end end let(:rep) do Nanoc::Int::ItemRep.new(item, :default).tap do |ir| ir.compiled = true ir.snapshot_defs = [ Nanoc::Int::SnapshotDef.new(:last), Nanoc::Int::SnapshotDef.new(:pre), Nanoc::Int::SnapshotDef.new(:post), Nanoc::Int::SnapshotDef.new(:specific), ] ir.snapshot_contents = { last: Nanoc::Int::TextualContent.new('Last Hallo'), pre: Nanoc::Int::TextualContent.new('Pre Hallo'), post: Nanoc::Int::TextualContent.new('Post Hallo'), specific: Nanoc::Int::TextualContent.new('Specific Hallo'), } end end context 'requesting implicit default rep' do let(:params) { {} } it { is_expected.to eq('Pre Hallo') } it 'creates a dependency' do expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([item]) end context 'requesting explicit snapshot' do let(:params) { { snapshot: :specific } } it { is_expected.to eq('Specific Hallo') } it 'creates a dependency' do expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([item]) end end end context 'requesting explicit default rep' do let(:params) { { rep: :default } } it 'creates a dependency' do expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([item]) end it { is_expected.to eq('Pre Hallo') } context 'requesting explicit snapshot' do let(:params) { { snapshot: :specific } } it { is_expected.to eq('Specific Hallo') } end end context 'requesting other rep' do let(:params) { { rep: :other } } it 'raises an error' do expect { subject }.to raise_error(Nanoc::ItemRepCollectionView::NoSuchItemRepError) end end end describe '#path' do subject { view.path(params) } let(:view) { described_class.new(item, view_context) } let(:item) do Nanoc::Int::Item.new('content', {}, '/asdf.md') end let(:reps) do Nanoc::Int::ItemRepRepo.new.tap do |reps| reps << rep end end let(:rep) do Nanoc::Int::ItemRep.new(item, :default).tap do |ir| ir.paths = { last: '/about/', specific: '/about.txt', } end end context 'requesting implicit default rep' do let(:params) { {} } it 'creates a dependency' do expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([item]) end it { is_expected.to eq('/about/') } context 'requesting explicit snapshot' do let(:params) { { snapshot: :specific } } it { is_expected.to eq('/about.txt') } end end context 'requesting explicit default rep' do let(:params) { { rep: :default } } it 'creates a dependency' do expect { subject }.to change { dependency_store.objects_causing_outdatedness_of(base_item) }.from([]).to([item]) end it { is_expected.to eq('/about/') } context 'requesting explicit snapshot' do let(:params) { { snapshot: :specific } } it { is_expected.to eq('/about.txt') } end end context 'requesting other rep' do let(:params) { { rep: :other } } it 'raises an error' do expect { subject }.to raise_error(Nanoc::ItemRepCollectionView::NoSuchItemRepError) end end end describe '#binary?' do # TODO: implement end describe '#raw_filename' do # TODO: implement end describe '#inspect' do let(:item) { Nanoc::Int::Item.new('content', {}, '/asdf/') } let(:view) { described_class.new(item, nil) } subject { view.inspect } it { is_expected.to eql('') } end end nanoc-4.4.7/spec/nanoc/base/views/post_compile_item_view_spec.rb0000644000004100000410000000312613033443476025070 0ustar www-datawww-datadescribe Nanoc::PostCompileItemView do let(:item) { Nanoc::Int::Item.new('blah', {}, '/foo.md') } let(:rep_a) { Nanoc::Int::ItemRep.new(item, :no_mod) } let(:rep_b) { Nanoc::Int::ItemRep.new(item, :modded).tap { |r| r.modified = true } } let(:reps) do Nanoc::Int::ItemRepRepo.new.tap do |reps| reps << rep_a reps << rep_b end end let(:view_context) { double(:view_context, reps: reps) } let(:view) { described_class.new(item, view_context) } shared_examples 'a method that returns modified reps only' do it 'returns only modified items' do expect(subject.size).to eq(1) expect(subject.map(&:name)).to eq(%i(modded)) end it 'returns an array' do expect(subject.class).to eql(Array) end end shared_examples 'a method that returns PostCompileItemRepViews' do it 'returns PostCompileItemRepViews' do expect(subject).to all(be_a(Nanoc::PostCompileItemRepView)) end end describe '#modified_reps' do subject { view.modified_reps } it_behaves_like 'a method that returns modified reps only' it_behaves_like 'a method that returns PostCompileItemRepViews' end describe '#modified' do subject { view.modified } it_behaves_like 'a method that returns modified reps only' it_behaves_like 'a method that returns PostCompileItemRepViews' end describe '#reps' do subject { view.reps } it_behaves_like 'a method that returns PostCompileItemRepViews' it 'returns a PostCompileItemRepCollectionView' do expect(subject).to be_a(Nanoc::PostCompileItemRepCollectionView) end end end nanoc-4.4.7/spec/nanoc/base/views/mutable_config_view_spec.rb0000644000004100000410000000061313033443476024331 0ustar www-datawww-datadescribe Nanoc::MutableConfigView do let(:config) { {} } let(:view) { described_class.new(config, nil) } describe '#[]=' do it 'sets attributes' do view[:awesomeness] = 'rather high' expect(config[:awesomeness]).to eq('rather high') end end describe '#inspect' do subject { view.inspect } it { is_expected.to eql('') } end end nanoc-4.4.7/spec/nanoc/base/views/item_rep_collection_view_spec.rb0000644000004100000410000000641613033443476025401 0ustar www-datawww-datashared_examples 'an item rep collection view' do let(:view) { described_class.new(wrapped, view_context) } let(:view_context) { double(:view_context) } let(:wrapped) do [ double(:item_rep, name: :foo), double(:item_rep, name: :bar), double(:item_rep, name: :baz), ] end describe '#unwrap' do subject { view.unwrap } it { should equal(wrapped) } end describe '#frozen?' do subject { view.frozen? } context 'non-frozen collection' do it { is_expected.to be(false) } end context 'frozen collection' do before { wrapped.freeze } it { is_expected.to be(true) } end end describe '#each' do it 'yields' do actual = [].tap { |res| view.each { |v| res << v } } expect(actual.size).to eq(3) end it 'returns self' do expect(view.each { |_i| }).to equal(view) end it 'yields elements with the right context' do view.each { |v| expect(v._context).to equal(view_context) } end end describe '#size' do subject { view.size } it { should == 3 } end describe '#to_ary' do subject { view.to_ary } it 'returns an array of item rep views' do expect(subject.class).to eq(Array) expect(subject.size).to eq(3) expect(subject[0].class).to eql(expected_view_class) expect(subject[0].name).to eql(:foo) end it 'returns an array with correct contexts' do expect(subject[0]._context).to equal(view_context) end end describe '#[]' do subject { view[name] } context 'when not found' do let(:name) { :donkey } it { should be_nil } end context 'when found' do let(:name) { :foo } it 'returns a view' do expect(subject.class).to eq(expected_view_class) expect(subject.name).to eq(:foo) end it 'returns a view with the correct context' do expect(subject._context).to equal(view_context) end end context 'when given a string' do let(:name) { 'foo' } it 'raises' do expect { subject }.to raise_error(ArgumentError, 'expected ItemRepCollectionView#[] to be called with a symbol') end end context 'when given a number' do let(:name) { 0 } it 'raises' do expect { subject }.to raise_error(ArgumentError, 'expected ItemRepCollectionView#[] to be called with a symbol (you likely want `.reps[:default]` rather than `.reps[0]`)') end end end describe '#fetch' do subject { view.fetch(name) } context 'when not found' do let(:name) { :donkey } it 'raises' do expect { subject }.to raise_error(Nanoc::ItemRepCollectionView::NoSuchItemRepError) end end context 'when found' do let(:name) { :foo } it 'returns a view' do expect(subject.class).to eq(expected_view_class) expect(subject.name).to eq(:foo) end it 'returns a view with the correct context' do expect(subject._context).to equal(view_context) end end end describe '#inspect' do subject { view.inspect } it { is_expected.to eql('<' + described_class.name + '>') } end end describe Nanoc::ItemRepCollectionView do it_behaves_like 'an item rep collection view' let(:expected_view_class) { Nanoc::ItemRepView } end nanoc-4.4.7/spec/nanoc/base/views/mutable_layout_view_spec.rb0000644000004100000410000000060113033443476024376 0ustar www-datawww-datadescribe Nanoc::MutableLayoutView do let(:entity_class) { Nanoc::Int::Layout } it_behaves_like 'a mutable document view' describe '#inspect' do let(:item) { Nanoc::Int::Item.new('content', {}, '/asdf/') } let(:view) { described_class.new(item, nil) } subject { view.inspect } it { is_expected.to eql('') } end end nanoc-4.4.7/spec/nanoc/base/views/mutable_identifiable_collection_view_spec.rb0000644000004100000410000000163313033443476027721 0ustar www-datawww-datashared_examples 'a mutable identifiable collection' do let(:view) { described_class.new(wrapped, view_context) } let(:view_context) { double(:view_context) } let(:config) do {} end describe '#delete_if' do let(:wrapped) do Nanoc::Int::IdentifiableCollection.new(config).tap do |coll| coll << double(:identifiable, identifier: Nanoc::Identifier.new('/asdf/')) end end it 'deletes matching' do view.delete_if { |i| i.identifier == '/asdf/' } expect(wrapped).to be_empty end it 'deletes no non-matching' do view.delete_if { |i| i.identifier == '/blah/' } expect(wrapped).not_to be_empty end it 'returns self' do ret = view.delete_if { |_i| false } expect(ret).to equal(view) end it 'yields items with the proper context' do view.delete_if { |i| expect(i._context).to equal(view_context) } end end end nanoc-4.4.7/spec/nanoc/base/views/item_collection_without_reps_view_spec.rb0000644000004100000410000000102413033443476027335 0ustar www-datawww-datadescribe Nanoc::ItemCollectionWithoutRepsView do let(:view_class) { Nanoc::ItemWithoutRepsView } it_behaves_like 'an identifiable collection' describe '#inspect' do let(:wrapped) do Nanoc::Int::IdentifiableCollection.new(config) end let(:view) { described_class.new(wrapped, view_context) } let(:view_context) { double(:view_context) } let(:config) { { string_pattern_type: 'glob' } } subject { view.inspect } it { is_expected.to eql('') } end end nanoc-4.4.7/spec/nanoc/base/views/post_compile_item_rep_collection_view_spec.rb0000644000004100000410000000024613033443476030151 0ustar www-datawww-datadescribe Nanoc::PostCompileItemRepCollectionView do it_behaves_like 'an item rep collection view' let(:expected_view_class) { Nanoc::PostCompileItemRepView } end nanoc-4.4.7/spec/nanoc/base/views/layout_view_spec.rb0000644000004100000410000000064213033443476022672 0ustar www-datawww-datadescribe Nanoc::LayoutView do let(:entity_class) { Nanoc::Int::Layout } let(:other_view_class) { Nanoc::ItemWithRepsView } it_behaves_like 'a document view' describe '#inspect' do let(:item) { Nanoc::Int::Layout.new('content', {}, '/asdf/') } let(:view) { described_class.new(item, nil) } subject { view.inspect } it { is_expected.to eql('') } end end nanoc-4.4.7/spec/nanoc/base/views/identifiable_collection_view_spec.rb0000644000004100000410000001226713033443476026215 0ustar www-datawww-data# Needs :view_class shared_examples 'an identifiable collection' do let(:view) { described_class.new(wrapped, view_context) } let(:view_context) { double(:view_context) } let(:config) do { string_pattern_type: 'glob' } end describe '#frozen?' do let(:wrapped) do Nanoc::Int::IdentifiableCollection.new(config).tap do |arr| arr << double(:identifiable, identifier: Nanoc::Identifier.new('/foo')) arr << double(:identifiable, identifier: Nanoc::Identifier.new('/bar')) end end subject { view.frozen? } context 'non-frozen collection' do it { is_expected.to be(false) } end context 'frozen collection' do before do wrapped.each { |o| expect(o).to receive(:freeze) } wrapped.freeze end it { is_expected.to be(true) } end end describe '#unwrap' do let(:wrapped) do Nanoc::Int::IdentifiableCollection.new(config).tap do |arr| arr << double(:identifiable, identifier: Nanoc::Identifier.new('/foo')) arr << double(:identifiable, identifier: Nanoc::Identifier.new('/bar')) arr << double(:identifiable, identifier: Nanoc::Identifier.new('/baz')) end end subject { view.unwrap } it { should equal(wrapped) } end describe '#each' do let(:wrapped) do Nanoc::Int::IdentifiableCollection.new(config).tap do |arr| arr << double(:identifiable, identifier: Nanoc::Identifier.new('/foo')) arr << double(:identifiable, identifier: Nanoc::Identifier.new('/bar')) arr << double(:identifiable, identifier: Nanoc::Identifier.new('/baz')) end end it 'returns self' do expect(view.each { |_i| }).to equal(view) end it 'yields elements with the right context' do view.each { |v| expect(v._context).to equal(view_context) } end end describe '#size' do let(:wrapped) do Nanoc::Int::IdentifiableCollection.new(config).tap do |arr| arr << double(:identifiable, identifier: Nanoc::Identifier.new('/foo')) arr << double(:identifiable, identifier: Nanoc::Identifier.new('/bar')) arr << double(:identifiable, identifier: Nanoc::Identifier.new('/baz')) end end subject { view.size } it { should == 3 } end describe '#[]' do let(:page_object) do double(:identifiable, identifier: Nanoc::Identifier.new('/page.erb')) end let(:home_object) do double(:identifiable, identifier: Nanoc::Identifier.new('/home.erb')) end let(:wrapped) do Nanoc::Int::IdentifiableCollection.new(config).tap do |arr| arr << page_object arr << home_object end end subject { view[arg] } context 'no objects found' do let(:arg) { '/donkey.*' } it { is_expected.to equal(nil) } end context 'string' do let(:arg) { '/home.erb' } it 'returns wrapped object' do expect(subject.class).to equal(view_class) expect(subject.unwrap).to equal(home_object) end it 'returns objects with right context' do expect(subject._context).to equal(view_context) end end context 'identifier' do let(:arg) { Nanoc::Identifier.new('/home.erb') } it 'returns wrapped object' do expect(subject.class).to equal(view_class) expect(subject.unwrap).to equal(home_object) end end context 'glob' do let(:arg) { '/home.*' } context 'globs not enabled' do let(:config) { { string_pattern_type: 'legacy' } } it 'returns nil' do expect(subject).to be_nil end end context 'globs enabled' do it 'returns wrapped object' do expect(subject.class).to equal(view_class) expect(subject.unwrap).to equal(home_object) end end end context 'regex' do let(:arg) { %r{\A/home} } it 'returns wrapped object' do expect(subject.class).to equal(view_class) expect(subject.unwrap).to equal(home_object) end end end describe '#find_all' do let(:wrapped) do Nanoc::Int::IdentifiableCollection.new(config).tap do |arr| arr << double(:identifiable, identifier: Nanoc::Identifier.new('/about.css')) arr << double(:identifiable, identifier: Nanoc::Identifier.new('/about.md')) arr << double(:identifiable, identifier: Nanoc::Identifier.new('/style.css')) end end subject { view.find_all(arg) } context 'with string' do let(:arg) { '/*.css' } it 'contains views' do expect(subject.size).to eql(2) about_css = subject.find { |iv| iv.identifier == '/about.css' } style_css = subject.find { |iv| iv.identifier == '/style.css' } expect(about_css.class).to equal(view_class) expect(style_css.class).to equal(view_class) end end context 'with regex' do let(:arg) { %r{\.css\z} } it 'contains views' do expect(subject.size).to eql(2) about_css = subject.find { |iv| iv.identifier == '/about.css' } style_css = subject.find { |iv| iv.identifier == '/style.css' } expect(about_css.class).to equal(view_class) expect(style_css.class).to equal(view_class) end end end end nanoc-4.4.7/spec/nanoc/base/views/layout_collection_view_spec.rb0000644000004100000410000000077113033443476025110 0ustar www-datawww-datadescribe Nanoc::LayoutCollectionView do let(:view_class) { Nanoc::LayoutView } it_behaves_like 'an identifiable collection' describe '#inspect' do let(:wrapped) do Nanoc::Int::IdentifiableCollection.new(config) end let(:view) { described_class.new(wrapped, view_context) } let(:view_context) { double(:view_context) } let(:config) { { string_pattern_type: 'glob' } } subject { view.inspect } it { is_expected.to eql('') } end end nanoc-4.4.7/spec/nanoc/base/entities/0000755000004100000410000000000013033443476017451 5ustar www-datawww-datananoc-4.4.7/spec/nanoc/base/entities/layout_spec.rb0000644000004100000410000000010213033443476022316 0ustar www-datawww-datadescribe Nanoc::Int::Layout do it_behaves_like 'a document' end nanoc-4.4.7/spec/nanoc/base/entities/site_spec.rb0000644000004100000410000000330413033443476021754 0ustar www-datawww-datadescribe Nanoc::Int::Site do describe '#freeze' do let(:site) do described_class.new( config: config, code_snippets: code_snippets, items: items, layouts: layouts, ) end let(:config) do Nanoc::Int::Configuration.new.with_defaults end let(:code_snippets) do [ Nanoc::Int::CodeSnippet.new('FOO = 123', 'hello.rb'), Nanoc::Int::CodeSnippet.new('BAR = 123', 'hi.rb'), ] end let(:items) do Nanoc::Int::IdentifiableCollection.new(config).tap do |coll| coll << Nanoc::Int::Item.new('foo', {}, '/foo.md') coll << Nanoc::Int::Item.new('bar', {}, '/bar.md') end end let(:layouts) do Nanoc::Int::IdentifiableCollection.new(config).tap do |coll| coll << Nanoc::Int::Layout.new('foo', {}, '/foo.md') coll << Nanoc::Int::Layout.new('bar', {}, '/bar.md') end end before do site.freeze end it 'freezes the configuration' do expect(site.config).to be_frozen end it 'freezes the configuration contents' do expect(site.config[:output_dir]).to be_frozen end it 'freezes items collection' do expect(site.items).to be_frozen end it 'freezes individual items' do expect(site.items).to all(be_frozen) end it 'freezes layouts collection' do expect(site.layouts).to be_frozen end it 'freezes individual layouts' do expect(site.layouts).to all(be_frozen) end it 'freezes code snippets collection' do expect(site.code_snippets).to be_frozen end it 'freezes individual code snippets' do expect(site.code_snippets).to all(be_frozen) end end end nanoc-4.4.7/spec/nanoc/base/entities/item_rep_spec.rb0000644000004100000410000001557713033443476022633 0ustar www-datawww-datadescribe Nanoc::Int::ItemRep do let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo.md') } let(:rep) { Nanoc::Int::ItemRep.new(item, :giraffe) } describe '#compiled_content' do let(:snapshot_name) { raise 'override me' } subject { rep.compiled_content(snapshot: snapshot_name) } shared_examples 'a non-moving snapshot with content' do context 'no snapshot def' do it 'raises' do expect { subject }.to raise_error(Nanoc::Int::Errors::NoSuchSnapshot) end end context 'snapshot def exists' do before do rep.snapshot_defs = [Nanoc::Int::SnapshotDef.new(snapshot_name)] rep.snapshot_contents = { snapshot_name => content } end context 'content is textual' do let(:content) { Nanoc::Int::TextualContent.new('hellos') } it { is_expected.to eql('hellos') } end context 'content is binary' do before { File.write('donkey.dat', 'binary data') } let(:content) { Nanoc::Int::BinaryContent.new(File.expand_path('donkey.dat')) } it 'raises' do expect { subject }.to raise_error(Nanoc::Int::Errors::CannotGetCompiledContentOfBinaryItem) end end end end shared_examples 'a non-moving snapshot' do include_examples 'a non-moving snapshot with content' context 'snapshot def exists, but not content' do before do rep.snapshot_defs = [Nanoc::Int::SnapshotDef.new(snapshot_name)] rep.snapshot_contents = {} end it 'errors' do expect { subject }.to yield_from_fiber(an_instance_of(Nanoc::Int::Errors::UnmetDependency)) end end end shared_examples 'snapshot :last' do context 'no snapshot def' do it 'errors' do expect { subject }.to raise_error(Nanoc::Int::Errors::NoSuchSnapshot) end end context 'snapshot exists' do context 'snapshot is not final' do before do rep.snapshot_defs = [Nanoc::Int::SnapshotDef.new(snapshot_name)] end context 'snapshot content does not exist' do before do rep.snapshot_contents = {} end it 'errors' do expect { subject }.to yield_from_fiber(an_instance_of(Nanoc::Int::Errors::UnmetDependency)) end end context 'snapshot content exists' do context 'content is textual' do before do rep.snapshot_contents[snapshot_name] = Nanoc::Int::TextualContent.new('hellos') end context 'not compiled' do before { rep.compiled = false } it 'raises' do expect { subject }.to yield_from_fiber(an_instance_of(Nanoc::Int::Errors::UnmetDependency)) end end context 'compiled' do before { rep.compiled = true } it { is_expected.to eql('hellos') } end end context 'content is binary' do before do File.write('donkey.dat', 'binary data') rep.snapshot_contents[snapshot_name] = Nanoc::Int::BinaryContent.new(File.expand_path('donkey.dat')) end context 'not compiled' do before { rep.compiled = false } it 'raises' do expect { subject }.to yield_from_fiber(an_instance_of(Nanoc::Int::Errors::UnmetDependency)) end end context 'compiled' do before { rep.compiled = true } it 'raises' do expect { subject }.to raise_error(Nanoc::Int::Errors::CannotGetCompiledContentOfBinaryItem) end end end end end context 'snapshot is final' do before do rep.snapshot_defs = [Nanoc::Int::SnapshotDef.new(snapshot_name)] end context 'snapshot content does not exist' do before do rep.snapshot_contents = {} end it 'errors' do expect { subject }.to yield_from_fiber(an_instance_of(Nanoc::Int::Errors::UnmetDependency)) end end context 'snapshot content exists' do context 'content is textual' do before do rep.snapshot_contents[snapshot_name] = Nanoc::Int::TextualContent.new('hellos') end context 'not compiled' do before { rep.compiled = false } it 'errors' do expect { subject }.to yield_from_fiber(an_instance_of(Nanoc::Int::Errors::UnmetDependency)) end end context 'compiled' do before { rep.compiled = true } it { is_expected.to eql('hellos') } end end context 'content is binary' do before do File.write('donkey.dat', 'binary data') rep.snapshot_contents[snapshot_name] = Nanoc::Int::BinaryContent.new(File.expand_path('donkey.dat')) end context 'not compiled' do before { rep.compiled = false } it 'raises' do expect { subject }.to yield_from_fiber(an_instance_of(Nanoc::Int::Errors::UnmetDependency)) end end context 'compiled' do before { rep.compiled = true } it 'raises' do expect { subject }.to raise_error(Nanoc::Int::Errors::CannotGetCompiledContentOfBinaryItem) end end end end end end end context 'snapshot nil' do let(:snapshot_name) { :last } subject { rep.compiled_content(snapshot: nil) } include_examples 'snapshot :last' end context 'snapshot not specified' do subject { rep.compiled_content } context 'pre exists' do before { rep.snapshot_contents[:pre] = Nanoc::Int::TextualContent.new('omg') } let(:snapshot_name) { :pre } include_examples 'a non-moving snapshot with content' end context 'pre does not exist' do let(:snapshot_name) { :last } include_examples 'snapshot :last' end end context 'snapshot :pre specified' do let(:snapshot_name) { :pre } include_examples 'a non-moving snapshot' end context 'snapshot :post specified' do let(:snapshot_name) { :post } include_examples 'a non-moving snapshot' end context 'snapshot :last specified' do let(:snapshot_name) { :last } include_examples 'snapshot :last' end context 'snapshot :donkey specified' do let(:snapshot_name) { :donkey } include_examples 'a non-moving snapshot' end end end nanoc-4.4.7/spec/nanoc/base/entities/document_spec.rb0000644000004100000410000001364213033443476022634 0ustar www-datawww-datashared_examples 'a document' do describe '#initialize' do let(:content_arg) { 'Hello world' } let(:attributes_arg) { { 'title' => 'Home' } } let(:identifier_arg) { '/home.md' } let(:checksum_data_arg) { 'abcdef' } let(:content_checksum_data_arg) { 'con-cs' } let(:attributes_checksum_data_arg) { 'attr-cs' } subject do described_class.new( content_arg, attributes_arg, identifier_arg, checksum_data: checksum_data_arg, content_checksum_data: content_checksum_data_arg, attributes_checksum_data: attributes_checksum_data_arg, ) end describe 'content arg' do context 'string' do it 'converts content' do expect(subject.content).to be_a(Nanoc::Int::TextualContent) expect(subject.content.string).to eql('Hello world') end end context 'content' do let(:content_arg) { Nanoc::Int::TextualContent.new('foo') } it 'reuses content' do expect(subject.content).to equal(content_arg) end end end describe 'attributes arg' do context 'hash' do it 'symbolizes attributes' do expect(subject.attributes).to eq(title: 'Home') end end context 'proc' do call_count = 0 let(:attributes_arg) do proc do call_count += 1 { 'title' => 'Home' } end end before do call_count = 0 end it 'does not call the proc immediately' do expect(call_count).to eql(0) end it 'symbolizes attributes' do expect(subject.attributes).to eq(title: 'Home') end it 'only calls the proc once' do subject.attributes subject.attributes expect(call_count).to eql(1) end end end describe 'identifier arg' do context 'string' do it 'converts identifier' do expect(subject.identifier).to be_a(Nanoc::Identifier) expect(subject.identifier.to_s).to eql('/home.md') end end context 'identifier' do let(:identifier_arg) { Nanoc::Identifier.new('/foo.md') } it 'retains identifier' do expect(subject.identifier).to equal(identifier_arg) end end end describe 'checksum_data arg' do it 'reuses checksum_data' do expect(subject.checksum_data).to eql(checksum_data_arg) end end describe 'content_checksum_data arg' do it 'reuses content_checksum_data' do expect(subject.content_checksum_data).to eql(content_checksum_data_arg) end end describe 'attributes_checksum_data arg' do it 'reuses attributes_checksum_data' do expect(subject.attributes_checksum_data).to eql(attributes_checksum_data_arg) end end end describe '#freeze' do let(:content_arg) { 'Hallo' } let(:attributes_arg) { { foo: { bar: 'asdf' } } } let(:document) { described_class.new(content_arg, attributes_arg, '/foo.md') } before do document.freeze end it 'refuses changes to content' do expect { document.instance_variable_set(:@content, 'hah') }.to raise_frozen_error expect { document.content.string << 'hah' }.to raise_frozen_error end it 'refuses to change attributes' do expect { document.instance_variable_set(:@attributes, a: 'Hi') }.to raise_frozen_error expect { document.attributes[:title] = 'Bye' }.to raise_frozen_error expect { document.attributes[:foo][:bar] = 'fdsa' }.to raise_frozen_error end it 'refuses to change identifier' do expect { document.identifier = '/asdf' }.to raise_frozen_error expect { document.identifier.to_s << '/omg' }.to raise_frozen_error end context 'binary content' do let(:content_arg) { Nanoc::Int::BinaryContent.new(File.expand_path('foo.dat')) } it 'refuses changes to content' do expect { document.instance_variable_set(:@content, 'hah') }.to raise_frozen_error expect { document.content.filename << 'hah' }.to raise_frozen_error end end context 'attributes block' do let(:attributes_arg) { proc { { foo: { bar: 'asdf' } } } } it 'gives access to the attributes' do expect(document.attributes).to eql(foo: { bar: 'asdf' }) end it 'refuses to change attributes' do expect { document.instance_variable_set(:@attributes, a: 'Hi') }.to raise_frozen_error expect { document.attributes[:title] = 'Bye' }.to raise_frozen_error expect { document.attributes[:foo][:bar] = 'fdsa' }.to raise_frozen_error end end end describe 'equality' do let(:content_arg_a) { 'Hello world' } let(:content_arg_b) { 'Bye world' } let(:attributes_arg_a) { { 'title' => 'Home' } } let(:attributes_arg_b) { { 'title' => 'About' } } let(:identifier_arg_a) { '/home.md' } let(:identifier_arg_b) { '/home.md' } let(:document_a) { described_class.new(content_arg_a, attributes_arg_a, identifier_arg_a) } let(:document_b) { described_class.new(content_arg_b, attributes_arg_b, identifier_arg_b) } subject { document_a == document_b } context 'same identifier' do let(:identifier_arg_a) { '/home.md' } let(:identifier_arg_b) { '/home.md' } it { is_expected.to eql(true) } it 'has same hashes' do expect(document_a.hash).to eql(document_b.hash) end end context 'different identifier' do let(:identifier_arg_a) { '/home.md' } let(:identifier_arg_b) { '/about.md' } it { is_expected.to eql(false) } it 'has different hashes' do expect(document_a.hash).not_to eql(document_b.hash) end end context 'comparing with non-document' do let(:document_b) { nil } it { is_expected.to eql(false) } it 'has different hashes' do expect(document_a.hash).not_to eql(document_b.hash) end end end end nanoc-4.4.7/spec/nanoc/base/entities/outdatedness_status_spec.rb0000644000004100000410000000545513033443476025126 0ustar www-datawww-datadescribe Nanoc::Int::OutdatednessStatus do let(:status) { described_class.new } describe '#reasons' do subject { status.reasons } context 'default' do it { is_expected.to eql([]) } end context 'one passed in' do let(:reasons) do [ Nanoc::Int::OutdatednessReasons::CodeSnippetsModified, ] end let(:status) { described_class.new(reasons: reasons) } it { is_expected.to eql(reasons) } end context 'two passed in' do let(:reasons) do [ Nanoc::Int::OutdatednessReasons::CodeSnippetsModified, Nanoc::Int::OutdatednessReasons::ContentModified, ] end let(:status) { described_class.new(reasons: reasons) } it { is_expected.to eql(reasons) } end end describe '#props' do subject { status.props.active } context 'default' do it { is_expected.to eql(Set.new) } end context 'specific one passed in' do let(:props) do Nanoc::Int::Props.new(attributes: true) end let(:status) { described_class.new(props: props) } it { is_expected.to eql(Set.new([:attributes])) } end end describe '#useful_to_apply' do subject { status.useful_to_apply?(rule) } let(:status) { described_class.new(props: props) } let(:props) { Nanoc::Int::Props.new } let(:rule) { Nanoc::Int::OutdatednessRules::RulesModified } context 'no props' do it { is_expected.to be } end context 'some props' do context 'same props' do let(:props) { Nanoc::Int::Props.new(compiled_content: true, path: true) } it { is_expected.not_to be } end context 'different props' do let(:props) { Nanoc::Int::Props.new(attributes: true) } it { is_expected.to be } end end context 'all props' do let(:props) { Nanoc::Int::Props.new(raw_content: true, attributes: true, compiled_content: true, path: true) } it { is_expected.not_to be } end end describe '#update' do subject { status.update(reason) } let(:reason) { Nanoc::Int::OutdatednessReasons::ContentModified } context 'no existing reason or props' do it 'adds a reason' do expect(subject.reasons).to eql([reason]) end end context 'existing reason' do let(:status) { described_class.new(reasons: [old_reason]) } let(:old_reason) { Nanoc::Int::OutdatednessReasons::NotWritten } it 'adds a reason' do expect(subject.reasons).to eql([old_reason, reason]) end end context 'existing props' do let(:status) { described_class.new(props: Nanoc::Int::Props.new(attributes: true)) } it 'updates props' do expect(subject.props.active).to eql(Set.new([:raw_content, :attributes, :compiled_content])) end end end end nanoc-4.4.7/spec/nanoc/base/entities/content_spec.rb0000644000004100000410000001154313033443476022466 0ustar www-datawww-datadescribe Nanoc::Int::Content do describe '.create' do subject { described_class.create(arg, params) } let(:params) { {} } context 'nil arg' do let(:arg) { nil } it 'raises' do expect { subject }.to raise_error(ArgumentError) end end context 'content arg' do let(:arg) { Nanoc::Int::TextualContent.new('foo') } it { is_expected.to eql(arg) } end context 'with binary: true param' do let(:arg) { '/foo.dat' } let(:params) { { binary: true } } it 'returns binary content' do expect(subject).to be_a(Nanoc::Int::BinaryContent) expect(subject.filename).to eql('/foo.dat') end end context 'with binary: false param' do context 'with filename param' do let(:arg) { 'foo' } let(:params) { { binary: false, filename: '/foo.md' } } it 'returns textual content' do expect(subject).to be_a(Nanoc::Int::TextualContent) expect(subject.string).to eql('foo') expect(subject.filename).to eql('/foo.md') end end context 'without filename param' do let(:arg) { 'foo' } let(:params) { { binary: false } } it 'returns textual content' do expect(subject).to be_a(Nanoc::Int::TextualContent) expect(subject.string).to eql('foo') expect(subject.filename).to be_nil end end end end end describe Nanoc::Int::TextualContent do describe '#initialize' do context 'without filename' do let(:content) { described_class.new('foo') } it 'sets string and filename' do expect(content.string).to eq('foo') expect(content.filename).to be_nil end end context 'with absolute filename' do let(:content) { described_class.new('foo', filename: '/foo.md') } it 'sets string and filename' do expect(content.string).to eq('foo') expect(content.filename).to eq('/foo.md') end end context 'with relative filename' do let(:content) { described_class.new('foo', filename: 'foo.md') } it 'errors' do expect { content }.to raise_error(ArgumentError) end end context 'with proc' do let(:content_proc) { -> { 'foo' } } let(:content) { described_class.new(content_proc) } it 'does not call the proc immediately' do expect(content_proc).not_to receive(:call) content end it 'sets string' do expect(content_proc).to receive(:call).once.and_return('dataz') expect(content.string).to eq('dataz') end it 'only calls the proc once' do expect(content_proc).to receive(:call).once.and_return('dataz') expect(content.string).to eq('dataz') expect(content.string).to eq('dataz') end end end describe '#binary?' do subject { content.binary? } let(:content) { described_class.new('foo') } it { is_expected.to eql(false) } end describe '#freeze' do let(:content) { described_class.new('foo', filename: '/asdf.md') } before do content.freeze end it 'prevents changes to string' do expect(content.string).to be_frozen expect { content.string << 'asdf' }.to raise_frozen_error end it 'prevents changes to filename' do expect(content.filename).to be_frozen expect { content.filename << 'asdf' }.to raise_frozen_error end context 'with proc' do let(:content) { described_class.new(proc { 'foo' }) } it 'prevents changes to string' do expect(content.string).to be_frozen expect { content.string << 'asdf' }.to raise_frozen_error end end end describe 'marshalling' do let(:content) { described_class.new('foo', filename: '/foo.md') } it 'dumps as an array' do expect(content.marshal_dump).to eq(['/foo.md', 'foo']) end it 'restores a dumped object' do restored = Marshal.load(Marshal.dump(content)) expect(restored.string).to eq('foo') expect(restored.filename).to eq('/foo.md') end end end describe Nanoc::Int::BinaryContent do describe '#initialize' do let(:content) { described_class.new('/foo.dat') } it 'sets filename' do expect(content.filename).to eql('/foo.dat') end context 'with relative filename' do let(:content) { described_class.new('foo.dat') } it 'errors' do expect { content }.to raise_error(ArgumentError) end end end describe '#binary?' do subject { content.binary? } let(:content) { described_class.new('/foo.dat') } it { is_expected.to eql(true) } end describe '#freeze' do let(:content) { described_class.new('/foo.dat') } before do content.freeze end it 'prevents changes' do expect(content.filename).to be_frozen expect { content.filename << 'asdf' }.to raise_frozen_error end end end nanoc-4.4.7/spec/nanoc/base/entities/processing_action_spec.rb0000644000004100000410000000046613033443476024527 0ustar www-datawww-datadescribe Nanoc::Int::ProcessingAction do let(:action) { described_class.new } it 'is abstract' do expect { action.serialize }.to raise_error(NotImplementedError) expect { action.to_s }.to raise_error(NotImplementedError) expect { action.inspect }.to raise_error(NotImplementedError) end end nanoc-4.4.7/spec/nanoc/base/entities/identifier_spec.rb0000644000004100000410000003020113033443476023126 0ustar www-datawww-datadescribe Nanoc::Identifier do describe '.from' do subject { described_class.from(arg) } context 'given an identifier' do let(:arg) { Nanoc::Identifier.new('/foo.md') } it 'returns an identifier' do expect(subject).to be_a(Nanoc::Identifier) expect(subject.to_s).to eq('/foo.md') expect(subject).to be_full end end context 'given a string' do let(:arg) { '/foo.md' } it 'returns an identifier' do expect(subject).to be_a(Nanoc::Identifier) expect(subject.to_s).to eq('/foo.md') expect(subject).to be_full end end context 'given something else' do let(:arg) { 12_345 } it 'raises' do expect { subject }.to raise_error(Nanoc::Identifier::NonCoercibleObjectError) end end end describe '#initialize' do context 'legacy type' do it 'does not convert already clean paths' do expect(described_class.new('/foo/bar/', type: :legacy).to_s).to eql('/foo/bar/') end it 'prepends slash if necessary' do expect(described_class.new('foo/bar/', type: :legacy).to_s).to eql('/foo/bar/') end it 'appends slash if necessary' do expect(described_class.new('/foo/bar', type: :legacy).to_s).to eql('/foo/bar/') end it 'removes double slashes at start' do expect(described_class.new('//foo/bar/', type: :legacy).to_s).to eql('/foo/bar/') end it 'removes double slashes at end' do expect(described_class.new('/foo/bar//', type: :legacy).to_s).to eql('/foo/bar/') end it 'freezes' do identifier = described_class.new('/foo/bar/', type: :legacy) expect { identifier.to_s << 'bbq' }.to raise_frozen_error end end context 'full type' do it 'refuses string not starting with a slash' do expect { described_class.new('foo') } .to raise_error(Nanoc::Identifier::InvalidIdentifierError) end it 'has proper string representation' do expect(described_class.new('/foo').to_s).to eql('/foo') end it 'freezes' do identifier = described_class.new('/foo/bar') expect { identifier.to_s << 'bbq' }.to raise_frozen_error end end context 'other type' do it 'errors' do expect { described_class.new('foo', type: :donkey) } .to raise_error(Nanoc::Identifier::InvalidTypeError) end end context 'default type' do it 'is full' do expect(described_class.new('/foo')).to be_full end end context 'other args specified' do it 'errors' do expect { described_class.new('?', animal: :donkey) } .to raise_error(ArgumentError) end end end describe '#to_s' do it 'returns immutable string' do expect { described_class.new('foo/', type: :legacy).to_s << 'lols' }.to raise_frozen_error expect { described_class.new('/foo').to_s << 'lols' }.to raise_frozen_error end end describe '#to_str' do it 'returns immutable string' do expect { described_class.new('/foo/bar').to_str << 'lols' }.to raise_frozen_error end end describe 'Comparable' do it 'can be compared' do expect(described_class.new('/foo/bar') <= '/qux').to eql(true) end end describe '#inspect' do let(:identifier) { described_class.new('/foo/bar') } subject { identifier.inspect } it { should == '' } end describe '#== and #eql?' do context 'comparing with equal identifier' do let(:identifier_a) { described_class.new('//foo/bar/', type: :legacy) } let(:identifier_b) { described_class.new('/foo/bar//', type: :legacy) } it 'is ==' do expect(identifier_a).to eq(identifier_b) end it 'is eql?' do expect(identifier_a).to eql(identifier_b) end end context 'comparing with equal string' do let(:identifier_a) { described_class.new('//foo/bar/', type: :legacy) } let(:identifier_b) { '/foo/bar/' } it 'is ==' do expect(identifier_a).to eq(identifier_b.to_s) end it 'is not eql?' do expect(identifier_a).not_to eql(identifier_b.to_s) end end context 'comparing with different identifier' do let(:identifier_a) { described_class.new('//foo/bar/', type: :legacy) } let(:identifier_b) { described_class.new('/baz/qux//', type: :legacy) } it 'is not ==' do expect(identifier_a).not_to eq(identifier_b) end it 'is not eql?' do expect(identifier_a).not_to eql(identifier_b) end end context 'comparing with different string' do let(:identifier_a) { described_class.new('//foo/bar/', type: :legacy) } let(:identifier_b) { '/baz/qux/' } it 'is not equal' do expect(identifier_a).not_to eq(identifier_b) end it 'is not eql?' do expect(identifier_a).not_to eql(identifier_b) end end context 'comparing with something that is not an identifier' do let(:identifier_a) { described_class.new('//foo/bar/', type: :legacy) } let(:identifier_b) { :donkey } it 'is not equal' do expect(identifier_a).not_to eq(identifier_b) expect(identifier_a).not_to eql(identifier_b) end end end describe '#hash' do context 'equal identifiers' do let(:identifier_a) { described_class.new('//foo/bar/', type: :legacy) } let(:identifier_b) { described_class.new('/foo/bar//', type: :legacy) } it 'is the same' do expect(identifier_a.hash == identifier_b.hash).to eql(true) end end context 'different identifiers' do let(:identifier_a) { described_class.new('//foo/bar/', type: :legacy) } let(:identifier_b) { described_class.new('/monkey/', type: :legacy) } it 'is different' do expect(identifier_a.hash == identifier_b.hash).to eql(false) end end end describe '#=~' do let(:identifier) { described_class.new('/foo/bar') } subject { identifier =~ pat } context 'given a regex' do context 'matching regex' do let(:pat) { %r{\A/foo/bar} } it { is_expected.to eql(0) } end context 'non-matching regex' do let(:pat) { %r{\A/qux/monkey} } it { is_expected.to eql(nil) } end end context 'given a string' do context 'matching string' do let(:pat) { '/foo/*' } it { is_expected.to eql(0) } end context 'non-matching string' do let(:pat) { '/qux/*' } it { is_expected.to eql(nil) } end end end describe '#<=>' do let(:identifier) { described_class.new('/foo/bar') } it 'compares by string' do expect(identifier <=> '/foo/aarghh').to eql(1) expect(identifier <=> '/foo/bar').to eql(0) expect(identifier <=> '/foo/qux').to eql(-1) end end describe '#prefix' do let(:identifier) { described_class.new('/foo') } subject { identifier.prefix(prefix) } context 'prefix not ending nor starting with a slash' do let(:prefix) { 'asdf' } it 'raises an error' do expect { subject }.to raise_error( Nanoc::Identifier::InvalidPrefixError, 'Invalid prefix (does not start with a slash): "asdf"', ) end end context 'prefix ending with a slash' do let(:prefix) { 'asdf/' } it 'raises an error' do expect { subject }.to raise_error( Nanoc::Identifier::InvalidPrefixError, 'Invalid prefix (does not start with a slash): "asdf/"', ) end end context 'prefix ending and starting with a slash' do let(:prefix) { '/asdf/' } it 'returns a proper new identifier' do expect(subject).to be_a(Nanoc::Identifier) expect(subject.to_s).to eql('/asdf/foo') end end context 'prefix nstarting with a slash' do let(:prefix) { '/asdf' } it 'returns a proper new identifier' do expect(subject).to be_a(Nanoc::Identifier) expect(subject.to_s).to eql('/asdf/foo') end end end describe '#without_ext' do subject { identifier.without_ext } context 'legacy type' do let(:identifier) { described_class.new('/foo/', type: :legacy) } it 'raises an error' do expect { subject }.to raise_error(Nanoc::Identifier::UnsupportedLegacyOperationError) end end context 'identifier with no extension' do let(:identifier) { described_class.new('/foo') } it 'does nothing' do expect(subject).to eql('/foo') end end context 'identifier with extension' do let(:identifier) { described_class.new('/foo.md') } it 'removes the extension' do expect(subject).to eql('/foo') end end end describe '#ext' do subject { identifier.ext } context 'legacy type' do let(:identifier) { described_class.new('/foo/', type: :legacy) } it 'raises an error' do expect { subject }.to raise_error(Nanoc::Identifier::UnsupportedLegacyOperationError) end end context 'identifier with no extension' do let(:identifier) { described_class.new('/foo') } it { is_expected.to be_nil } end context 'identifier with extension' do let(:identifier) { described_class.new('/foo.md') } it { is_expected.to eql('md') } end end describe '#without_exts' do subject { identifier.without_exts } context 'legacy type' do let(:identifier) { described_class.new('/foo/', type: :legacy) } it 'raises an error' do expect { subject }.to raise_error(Nanoc::Identifier::UnsupportedLegacyOperationError) end end context 'identifier with no extension' do let(:identifier) { described_class.new('/foo') } it 'does nothing' do expect(subject).to eql('/foo') end end context 'identifier with one extension' do let(:identifier) { described_class.new('/foo.md') } it 'removes the extension' do expect(subject).to eql('/foo') end end context 'identifier with multiple extensions' do let(:identifier) { described_class.new('/foo.html.md') } it 'removes the extension' do expect(subject).to eql('/foo') end end end describe '#exts' do subject { identifier.exts } context 'legacy type' do let(:identifier) { described_class.new('/foo/', type: :legacy) } it 'raises an error' do expect { subject }.to raise_error(Nanoc::Identifier::UnsupportedLegacyOperationError) end end context 'identifier with no extension' do let(:identifier) { described_class.new('/foo') } it { is_expected.to be_empty } end context 'identifier with one extension' do let(:identifier) { described_class.new('/foo.md') } it { is_expected.to eql(['md']) } end context 'identifier with multiple extensions' do let(:identifier) { described_class.new('/foo.html.md') } it { is_expected.to eql(%w(html md)) } end end describe '#legacy?' do subject { identifier.legacy? } context 'legacy type' do let(:identifier) { described_class.new('/foo/', type: :legacy) } it { is_expected.to eql(true) } end context 'full type' do let(:identifier) { described_class.new('/foo/', type: :full) } it { is_expected.to eql(false) } end end describe '#full?' do subject { identifier.full? } context 'legacy type' do let(:identifier) { described_class.new('/foo/', type: :legacy) } it { is_expected.to eql(false) } end context 'full type' do let(:identifier) { described_class.new('/foo/', type: :full) } it { is_expected.to eql(true) } end end describe '#components' do subject { identifier.components } context 'no components' do let(:identifier) { described_class.new('/') } it { is_expected.to eql([]) } end context 'one component' do let(:identifier) { described_class.new('/foo.md') } it { is_expected.to eql(['foo.md']) } end context 'two components' do let(:identifier) { described_class.new('/foo/bar.md') } it { is_expected.to eql(['foo', 'bar.md']) } end end end nanoc-4.4.7/spec/nanoc/base/entities/rule_memory_spec.rb0000644000004100000410000000662613033443476023361 0ustar www-datawww-datadescribe Nanoc::Int::RuleMemory do let(:rule_memory) { described_class.new(rep) } let(:rep) { double(:rep) } describe '#size' do subject { rule_memory.size } context 'no actions' do it { is_expected.to eql(0) } end context 'some actions' do before do rule_memory.add_filter(:foo, {}) end it { is_expected.to eql(1) } end end describe '#[]' do subject { rule_memory[index] } let(:index) { 0 } context 'no actions' do it { is_expected.to be_nil } end context 'some actions' do before do rule_memory.add_filter(:foo, {}) end it { is_expected.to be_a(Nanoc::Int::ProcessingActions::Filter) } end end describe '#add_filter' do example do rule_memory.add_filter(:foo, donkey: 123) expect(rule_memory.size).to eql(1) expect(rule_memory[0]).to be_a(Nanoc::Int::ProcessingActions::Filter) expect(rule_memory[0].filter_name).to eql(:foo) expect(rule_memory[0].params).to eql(donkey: 123) end end describe '#add_layout' do example do rule_memory.add_layout('/foo.*', donkey: 123) expect(rule_memory.size).to eql(1) expect(rule_memory[0]).to be_a(Nanoc::Int::ProcessingActions::Layout) expect(rule_memory[0].layout_identifier).to eql('/foo.*') expect(rule_memory[0].params).to eql(donkey: 123) end end describe '#add_snapshot' do context 'snapshot does not yet exist' do example do rule_memory.add_snapshot(:before_layout, '/foo.md') expect(rule_memory.size).to eql(1) expect(rule_memory[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot) expect(rule_memory[0].snapshot_name).to eql(:before_layout) expect(rule_memory[0].path).to eql('/foo.md') end end context 'snapshot already exist' do before do rule_memory.add_snapshot(:before_layout, '/bar.md') end it 'raises' do expect { rule_memory.add_snapshot(:before_layout, '/foo.md') } .to raise_error(Nanoc::Int::Errors::CannotCreateMultipleSnapshotsWithSameName) end end end describe '#each' do before do rule_memory.add_filter(:erb, awesomeness: 'high') rule_memory.add_snapshot(:bar, '/foo.md') rule_memory.add_layout('/default.erb', somelayoutparam: 'yes') end example do actions = [] rule_memory.each { |a| actions << a } expect(actions.size).to eq(3) end end describe '#map' do before do rule_memory.add_filter(:erb, awesomeness: 'high') rule_memory.add_snapshot(:bar, '/foo.md') rule_memory.add_layout('/default.erb', somelayoutparam: 'yes') end example do res = rule_memory.map { Nanoc::Int::ProcessingActions::Filter.new(:donkey, {}) } expect(res.to_a.size).to eq(3) expect(res.to_a).to all(be_a(Nanoc::Int::ProcessingActions::Filter)) end end describe '#serialize' do subject { rule_memory.serialize } before do rule_memory.add_filter(:erb, awesomeness: 'high') rule_memory.add_snapshot(:bar, '/foo.md') rule_memory.add_layout('/default.erb', somelayoutparam: 'yes') end example do expect(subject).to eql( [ [:filter, :erb, 'PeWUm2PtXYtqeHJdTqnY7kkwAow='], [:snapshot, :bar, true, '/foo.md'], [:layout, '/default.erb', '97LAe1pYTLKczxBsu+x4MmvqdkU='], ], ) end end end nanoc-4.4.7/spec/nanoc/base/entities/pattern_spec.rb0000644000004100000410000000675113033443476022476 0ustar www-datawww-datadescribe Nanoc::Int::Pattern do describe '.from' do it 'converts from string' do pattern = described_class.from('/foo/x[ab]z/bar.*') expect(pattern.match?('/foo/xaz/bar.html')).to eql(true) expect(pattern.match?('/foo/xyz/bar.html')).to eql(false) end it 'converts from regex' do pattern = described_class.from(%r{\A/foo/x[ab]z/bar\..*\z}) expect(pattern.match?('/foo/xaz/bar.html')).to eql(true) expect(pattern.match?('/foo/xyz/bar.html')).to eql(false) end it 'converts from pattern' do pattern = described_class.from('/foo/x[ab]z/bar.*') pattern = described_class.from(pattern) expect(pattern.match?('/foo/xaz/bar.html')).to eql(true) expect(pattern.match?('/foo/xyz/bar.html')).to eql(false) end it 'errors on other inputs' do expect { described_class.from(123) }.to raise_error(ArgumentError) end it 'errors with a proper error message on other inputs' do expect { described_class.from(nil) } .to raise_error(ArgumentError, 'Do not know how to convert `nil` into a Nanoc::Pattern') end end describe '#initialize' do it 'errors' do expect { described_class.new('/stuff') } .to raise_error(NotImplementedError) end end describe '#match?' do it 'errors' do expect { described_class.allocate.match?('/foo.md') } .to raise_error(NotImplementedError) end end describe '#captures' do it 'errors' do expect { described_class.allocate.captures('/foo.md') } .to raise_error(NotImplementedError) end end end describe Nanoc::Int::RegexpPattern do let(:pattern) { described_class.new(/the answer is (\d+)/) } describe '#match?' do it 'matches' do expect(pattern.match?('the answer is 42')).to eql(true) expect(pattern.match?('the answer is donkey')).to eql(false) end end describe '#captures' do it 'returns nil if it does not match' do expect(pattern.captures('the answer is donkey')).to be_nil end it 'returns array if it matches' do expect(pattern.captures('the answer is 42')).to eql(['42']) end end describe '#to_s' do subject { pattern.to_s } it 'returns the regex' do expect(subject).to eq('(?-mix:the answer is (\d+))') end end end describe Nanoc::Int::StringPattern do describe '#match?' do it 'matches simple strings' do pattern = described_class.new('d*key') expect(pattern.match?('donkey')).to eql(true) expect(pattern.match?('giraffe')).to eql(false) end it 'matches with pathname option' do pattern = described_class.new('/foo/*/bar/**/*.animal') expect(pattern.match?('/foo/x/bar/a/b/donkey.animal')).to eql(true) expect(pattern.match?('/foo/x/bar/donkey.animal')).to eql(true) expect(pattern.match?('/foo/x/railroad/donkey.animal')).to eql(false) end it 'matches with extglob option' do pattern = described_class.new('{b,gl}oat') expect(pattern.match?('boat')).to eql(true) expect(pattern.match?('gloat')).to eql(true) expect(pattern.match?('stoat')).to eql(false) end end describe '#captures' do it 'returns nil' do pattern = described_class.new('d*key') expect(pattern.captures('donkey')).to be_nil end end describe '#to_s' do let(:pattern) { described_class.new('/foo/*/bar/**/*.animal') } subject { pattern.to_s } it 'returns the regex' do expect(subject).to eq('/foo/*/bar/**/*.animal') end end end nanoc-4.4.7/spec/nanoc/base/entities/configuration_spec.rb0000644000004100000410000000234713033443476023665 0ustar www-datawww-datadescribe Nanoc::Int::Configuration do let(:hash) { { foo: 'bar' } } let(:config) { described_class.new(hash: hash) } describe '#key?' do subject { config.key?(key) } context 'non-existent key' do let(:key) { :donkey } it { is_expected.not_to be } end context 'existent key' do let(:key) { :foo } it { is_expected.to be } end end context 'with environments defined' do let(:hash) { { foo: 'bar', environments: { test: { foo: 'test-bar' }, default: { foo: 'default-bar' } } } } let(:config) { described_class.new(hash: hash, env_name: env_name).with_environment } subject { config } context 'with existing environment' do let(:env_name) { 'test' } it 'inherits options from given environment' do expect(subject[:foo]).to eq('test-bar') end end context 'with unknown environment' do let(:env_name) { 'wtf' } it 'does not inherits options from any environment' do expect(subject[:foo]).to eq('bar') end end context 'without given environment' do let(:env_name) { nil } it 'inherits options from default environment' do expect(subject[:foo]).to eq('default-bar') end end end end nanoc-4.4.7/spec/nanoc/base/entities/props_spec.rb0000644000004100000410000001320313033443476022152 0ustar www-datawww-datadescribe Nanoc::Int::Props do let(:props) { described_class.new } let(:props_all) do described_class.new(raw_content: true, attributes: true, compiled_content: true, path: true) end describe '#inspect' do subject { props.inspect } context 'nothing active' do it { is_expected.to eql('Props(____)') } end context 'attributes active' do let(:props) { described_class.new(attributes: true) } it { is_expected.to eql('Props(_a__)') } end context 'attributes and compiled_content active' do let(:props) { described_class.new(attributes: true, compiled_content: true) } it { is_expected.to eql('Props(_ac_)') } end context 'compiled_content active' do let(:props) { described_class.new(compiled_content: true) } it { is_expected.to eql('Props(__c_)') } end end describe '#raw_content?' do # … end describe '#attributes?' do subject { props.attributes? } context 'nothing active' do it { is_expected.not_to be } end context 'attributes active' do let(:props) { described_class.new(attributes: true) } it { is_expected.to be } end context 'attributes and compiled_content active' do let(:props) { described_class.new(attributes: true, compiled_content: true) } it { is_expected.to be } end context 'compiled_content active' do let(:props) { described_class.new(compiled_content: true) } it { is_expected.not_to be } end context 'all active' do let(:props) { described_class.new(raw_content: true, attributes: true, compiled_content: true, path: true) } it { is_expected.to be } end end describe '#compiled_content?' do # … end describe '#path?' do # … end describe '#merge' do subject { props.merge(other_props).active } context 'nothing + nothing' do let(:props) { described_class.new } let(:other_props) { described_class.new } it { is_expected.to eql(Set.new) } end context 'nothing + some' do let(:props) { described_class.new } let(:other_props) { described_class.new(raw_content: true) } it { is_expected.to eql(Set.new([:raw_content])) } end context 'nothing + all' do let(:props) { described_class.new } let(:other_props) { props_all } it { is_expected.to eql(Set.new([:raw_content, :attributes, :compiled_content, :path])) } end context 'some + nothing' do let(:props) { described_class.new(compiled_content: true) } let(:other_props) { described_class.new } it { is_expected.to eql(Set.new([:compiled_content])) } end context 'some + others' do let(:props) { described_class.new(compiled_content: true) } let(:other_props) { described_class.new(raw_content: true) } it { is_expected.to eql(Set.new([:raw_content, :compiled_content])) } end context 'some + all' do let(:props) { described_class.new(compiled_content: true) } let(:other_props) { props_all } it { is_expected.to eql(Set.new([:raw_content, :attributes, :compiled_content, :path])) } end context 'all + nothing' do let(:props) { props_all } let(:other_props) { described_class.new } it { is_expected.to eql(Set.new([:raw_content, :attributes, :compiled_content, :path])) } end context 'some + all' do let(:props) { props_all } let(:other_props) { described_class.new(compiled_content: true) } it { is_expected.to eql(Set.new([:raw_content, :attributes, :compiled_content, :path])) } end context 'all + all' do let(:props) { props_all } let(:other_props) { props_all } it { is_expected.to eql(Set.new([:raw_content, :attributes, :compiled_content, :path])) } end end describe '#active' do subject { props.active } context 'nothing active' do let(:props) { described_class.new } it { is_expected.to eql(Set.new) } end context 'raw_content active' do let(:props) { described_class.new(raw_content: true) } it { is_expected.to eql(Set.new([:raw_content])) } end context 'attributes active' do let(:props) { described_class.new(attributes: true) } it { is_expected.to eql(Set.new([:attributes])) } end context 'compiled_content active' do let(:props) { described_class.new(compiled_content: true) } it { is_expected.to eql(Set.new([:compiled_content])) } end context 'path active' do let(:props) { described_class.new(path: true) } it { is_expected.to eql(Set.new([:path])) } end context 'attributes and compiled_content active' do let(:props) { described_class.new(attributes: true, compiled_content: true) } it { is_expected.to eql(Set.new([:attributes, :compiled_content])) } end context 'all active' do let(:props) { described_class.new(raw_content: true, attributes: true, compiled_content: true, path: true) } it { is_expected.to eql(Set.new([:raw_content, :attributes, :compiled_content, :path])) } end end describe '#to_h' do subject { props.to_h } context 'nothing' do let(:props) { described_class.new } it { is_expected.to eql(raw_content: false, attributes: false, compiled_content: false, path: false) } end context 'some' do let(:props) { described_class.new(attributes: true, compiled_content: true) } it { is_expected.to eql(raw_content: false, attributes: true, compiled_content: true, path: false) } end context 'all' do let(:props) { props_all } it { is_expected.to eql(raw_content: true, attributes: true, compiled_content: true, path: true) } end end end nanoc-4.4.7/spec/nanoc/base/entities/processing_actions/0000755000004100000410000000000013033443476023345 5ustar www-datawww-datananoc-4.4.7/spec/nanoc/base/entities/processing_actions/layout_spec.rb0000644000004100000410000000110113033443476026212 0ustar www-datawww-datadescribe Nanoc::Int::ProcessingActions::Layout do let(:action) { described_class.new('/foo.erb', awesome: true) } describe '#serialize' do subject { action.serialize } it { is_expected.to eql([:layout, '/foo.erb', 'sJYzLjHGo1e4ytuDfnOLkqrt9QE=']) } end describe '#to_s' do subject { action.to_s } it { is_expected.to eql('layout "/foo.erb", {:awesome=>true}') } end describe '#inspect' do subject { action.inspect } it { is_expected.to eql('') } end describe '#copy' do context 'without path' do subject { action.copy } its(:snapshot_name) { is_expected.to eql(:before_layout) } its(:path) { is_expected.to eql('/foo.md') } end context 'with path' do subject { action.copy(path: '/donkey.md') } its(:snapshot_name) { is_expected.to eql(:before_layout) } its(:path) { is_expected.to eql('/donkey.md') } end end end nanoc-4.4.7/spec/nanoc/base/entities/lazy_value_spec.rb0000644000004100000410000000451213033443476023165 0ustar www-datawww-datadescribe Nanoc::Int::LazyValue do describe '#value' do let(:value_arg) { 'Hello world' } let(:lazy_value) { described_class.new(value_arg) } subject { lazy_value.value } context 'object' do it { is_expected.to equal(value_arg) } end context 'proc' do it 'does not call the proc immediately' do expect(value_arg).not_to receive(:call) lazy_value end it 'returns proc return value' do expect(value_arg).to receive(:call).once.and_return('Hello proc') expect(subject).to eql('Hello proc') end it 'only calls the proc once' do expect(value_arg).to receive(:call).once.and_return('Hello proc') expect(subject).to eql('Hello proc') expect(subject).to eql('Hello proc') end end end describe '#map' do let(:value_arg) { -> { 'Hello world' } } let(:lazy_value) { described_class.new(value_arg) } subject { lazy_value.map(&:upcase) } it 'does not call the proc immediately' do expect(value_arg).not_to receive(:call) subject end it 'returns proc return value' do expect(value_arg).to receive(:call).once.and_return('Hello proc') expect(subject.value).to eql('HELLO PROC') end it 'only calls the proc once' do expect(value_arg).to receive(:call).once.and_return('Hello proc') expect(subject.value).to eql('HELLO PROC') expect(subject.value).to eql('HELLO PROC') end end describe '#freeze' do let(:value_arg) { 'Hello world' } subject { described_class.new(value_arg) } before do subject.freeze end context 'object' do it 'returns value' do expect(subject.value).to equal(value_arg) end it 'freezes value' do expect(subject.value).to be_frozen end end context 'proc' do call_count = 0 let(:value_arg) do proc do call_count += 1 'Hello proc' end end before do call_count = 0 subject.freeze end it 'does not call the proc immediately' do expect(call_count).to eql(0) end it 'returns proc return value' do expect(subject.value).to eq('Hello proc') end it 'freezes upon access' do expect(subject.value).to be_frozen end end end end nanoc-4.4.7/spec/nanoc/base/entities/item_spec.rb0000644000004100000410000000010013033443476021735 0ustar www-datawww-datadescribe Nanoc::Int::Item do it_behaves_like 'a document' end nanoc-4.4.7/spec/nanoc/base/feature_spec.rb0000644000004100000410000000544413033443476020626 0ustar www-datawww-datadescribe Nanoc::Feature do describe '.enabled?' do subject { described_class.enabled?(feature_name) } let(:feature_name) { 'magic' } before do Nanoc::Feature.reset_caches ENV['NANOC_FEATURES'] = '' end context 'not set' do it { is_expected.not_to be } end context 'set to list not including feature' do before { ENV['NANOC_FEATURES'] = 'foo,bar' } it { is_expected.not_to be } end context 'set to all' do before { ENV['NANOC_FEATURES'] = 'all' } it { is_expected.to be } end context 'set to list including feature' do before { ENV['NANOC_FEATURES'] = 'foo,magic,bar' } it { is_expected.to be } end end describe '.enable' do subject do described_class.enable(feature_name) do Nanoc::Feature.enabled?(feature_name) end end let(:feature_name) { 'magic' } before do Nanoc::Feature.reset_caches ENV['NANOC_FEATURES'] = '' end context 'not set' do it { is_expected.to be } it 'unsets afterwards' do expect(Nanoc::Feature.enabled?(feature_name)).not_to be end end context 'set to list not including feature' do before { ENV['NANOC_FEATURES'] = 'foo,bar' } it { is_expected.to be } it 'unsets afterwards' do expect(Nanoc::Feature.enabled?(feature_name)).not_to be end end context 'set to all' do before { ENV['NANOC_FEATURES'] = 'all' } it { is_expected.to be } end context 'set to list including feature' do before { ENV['NANOC_FEATURES'] = 'foo,magic,bar' } it { is_expected.to be } end end describe '.all_outdated' do it 'refuses outdated features' do # If this spec fails, there are features marked as experimental in the previous minor or major # release, but not in the current one. Either remove the feature, or mark it as experimental # in the current release. expect(Nanoc::Feature.all_outdated).to be_empty end describe 'fake outdated features' do before { Nanoc::Feature.define('abc', version: '4.2.x') } after { Nanoc::Feature.undefine('abc') } it 'detects outdated features' do expect(Nanoc::Feature.all_outdated).to eq(['abc']) end end end describe '.define and .undefine' do let(:feature_name) { 'testing123' } after { Nanoc::Feature.undefine(feature_name) if defined?(Nanoc::Feature::TESTING123) } it 'can define' do Nanoc::Feature.define(feature_name, version: '4.3.x') expect(Nanoc::Feature::TESTING123).not_to be_nil end it 'can undefine' do Nanoc::Feature.define(feature_name, version: '4.3.x') Nanoc::Feature.undefine(feature_name) expect { Nanoc::Feature::TESTING123 }.to raise_error(NameError) end end end nanoc-4.4.7/spec/nanoc/base/plugin_registry_spec.rb0000644000004100000410000000125513033443476022415 0ustar www-datawww-datadescribe Nanoc::Int::PluginRegistry do describe '.identifier(s)' do let(:identifier) { :ce79f6b8ddb22233e9aaf7d8f011689492acf02f } context 'direct subclass' do example do klass = Class.new(Nanoc::Filter) do identifier :plugin_registry_spec end expect(klass.identifier).to eql(:plugin_registry_spec) end end context 'indirect subclass' do example do superclass = Class.new(Nanoc::Filter) klass = Class.new(superclass) do identifier :plugin_registry_spec end expect(klass.identifier).to eql(:plugin_registry_spec) end end end end nanoc-4.4.7/spec/nanoc/base/checksummer_spec.rb0000644000004100000410000003271513033443476021502 0ustar www-datawww-datarequire 'tempfile' describe Nanoc::Int::Checksummer::VerboseDigest do let(:digest) { described_class.new } it 'concatenates' do digest.update('foo') digest.update('bar') expect(digest.to_s).to eql('foobar') end end describe Nanoc::Int::Checksummer::CompactDigest do let(:digest) { described_class.new } it 'uses SHA1 and Base64' do digest.update('foo') digest.update('bar') expect(digest.to_s).to eql(Digest::SHA1.base64digest('foobar')) end end describe Nanoc::Int::Checksummer do subject { described_class.calc(obj, Nanoc::Int::Checksummer::VerboseDigest) } context 'String' do let(:obj) { 'hello' } it { is_expected.to eql('String') } end context 'Symbol' do let(:obj) { :hello } it { is_expected.to eql('Symbol') } end context 'nil' do let(:obj) { nil } it { is_expected.to eql('NilClass<>') } end context 'true' do let(:obj) { true } it { is_expected.to eql('TrueClass<>') } end context 'false' do let(:obj) { false } it { is_expected.to eql('FalseClass<>') } end context 'Array' do let(:obj) { %w(hello goodbye) } it { is_expected.to eql('Array,String,>') } context 'different order' do let(:obj) { %w(goodbye hello) } it { is_expected.to eql('Array,String,>') } end context 'recursive' do let(:obj) { [].tap { |arr| arr << ['hello', arr] } } it { is_expected.to eql('Array,Array,>,>') } end context 'non-serializable' do let(:obj) { [-> {}] } it { is_expected.to match(/\AArray>,>\z/) } end end context 'Hash' do let(:obj) { { 'a' => 'foo', 'b' => 'bar' } } it { is_expected.to eql('Hash=String,String=String,>') } context 'different order' do let(:obj) { { 'b' => 'bar', 'a' => 'foo' } } it { is_expected.to eql('Hash=String,String=String,>') } end context 'non-serializable' do let(:obj) { { 'a' => -> {} } } it { is_expected.to match(/\AHash=Proc<#>,>\z/) } end context 'recursive values' do let(:obj) { {}.tap { |hash| hash['a'] = hash } } it { is_expected.to eql('Hash=Hash,>') } end context 'recursive keys' do let(:obj) { {}.tap { |hash| hash[hash] = 'hello' } } it { is_expected.to eql('Hash=String,>') } end end context 'Pathname' do let(:obj) { ::Pathname.new(filename) } let(:filename) { '/tmp/whatever' } let(:mtime) { 200 } let(:data) { 'stuffs' } before do FileUtils.mkdir_p(File.dirname(filename)) File.write(filename, data) File.utime(mtime, mtime, filename) end it { is_expected.to eql('Pathname<6-200>') } context 'does not exist' do before do FileUtils.rm_rf(filename) end it { is_expected.to eql('Pathname') } end context 'different data' do let(:data) { 'other stuffs :o' } it { is_expected.to eql('Pathname<15-200>') } end end context 'Time' do let(:obj) { Time.at(111_223) } it { is_expected.to eql('Time<111223>') } end context 'Float' do let(:obj) { 3.14 } it { is_expected.to eql('Float<3.14>') } end context 'Fixnum/Integer' do let(:obj) { 3 } it { is_expected.to match(/\A(Integer|Fixnum)<3>\z/) } end context 'Nanoc::Identifier' do let(:obj) { Nanoc::Identifier.new('/foo.md') } it { is_expected.to eql('Nanoc::Identifier>') } end context 'Nanoc::RuleDSL::RulesCollection' do let(:obj) do Nanoc::RuleDSL::RulesCollection.new.tap { |rc| rc.data = data } end let(:data) { 'STUFF!' } it { is_expected.to eql('Nanoc::RuleDSL::RulesCollection>') } end context 'Nanoc::Int::CodeSnippet' do let(:obj) { Nanoc::Int::CodeSnippet.new('asdf', '/bob.rb') } it { is_expected.to eql('Nanoc::Int::CodeSnippet>') } end context 'Nanoc::Int::Configuration' do let(:obj) { Nanoc::Int::Configuration.new(hash: { 'foo' => 'bar' }) } it { is_expected.to eql('Nanoc::Int::Configuration=String,>') } end context 'Nanoc::Int::Item' do let(:obj) { Nanoc::Int::Item.new('asdf', { 'foo' => 'bar' }, '/foo.md') } it { is_expected.to eql('Nanoc::Int::Item>,attributes=Hash=String,>,identifier=Nanoc::Identifier>>') } context 'binary' do let(:filename) { File.expand_path('foo.dat') } let(:content) { Nanoc::Int::BinaryContent.new(filename) } let(:obj) { Nanoc::Int::Item.new(content, { 'foo' => 'bar' }, '/foo.md') } let(:mtime) { 200 } let(:data) { 'stuffs' } before do File.write(content.filename, data) File.utime(mtime, mtime, content.filename) end it { is_expected.to eql('Nanoc::Int::Item>,attributes=Hash=String,>,identifier=Nanoc::Identifier>>') } end context 'recursive attributes' do before do obj.attributes[:foo] = obj end it { is_expected.to eql('Nanoc::Int::Item>,attributes=Hash=Nanoc::Int::Item,>,identifier=Nanoc::Identifier>>') } end context 'with checksum' do let(:obj) { Nanoc::Int::Item.new('asdf', { 'foo' => 'bar' }, '/foo.md', checksum_data: 'abcdef') } it { is_expected.to eql('Nanoc::Int::Item') } end context 'with content checksum' do let(:obj) { Nanoc::Int::Item.new('asdf', { 'foo' => 'bar' }, '/foo.md', content_checksum_data: 'con-cs') } it { is_expected.to eql('Nanoc::Int::Item=String,>,identifier=Nanoc::Identifier>>') } end context 'with attributes checksum' do let(:obj) { Nanoc::Int::Item.new('asdf', { 'foo' => 'bar' }, '/foo.md', attributes_checksum_data: 'attr-cs') } it { is_expected.to eql('Nanoc::Int::Item>,attributes_checksum_data=attr-cs,identifier=Nanoc::Identifier>>') } end end context 'Nanoc::Int::Layout' do let(:obj) { Nanoc::Int::Layout.new('asdf', { 'foo' => 'bar' }, '/foo.md') } it { is_expected.to eql('Nanoc::Int::Layout>,attributes=Hash=String,>,identifier=Nanoc::Identifier>>') } context 'recursive attributes' do before do obj.attributes[:foo] = obj end it { is_expected.to eql('Nanoc::Int::Layout>,attributes=Hash=Nanoc::Int::Layout,>,identifier=Nanoc::Identifier>>') } end context 'with checksum' do let(:obj) { Nanoc::Int::Layout.new('asdf', { 'foo' => 'bar' }, '/foo.md', checksum_data: 'abcdef') } it { is_expected.to eql('Nanoc::Int::Layout') } end end context 'Nanoc::ItemWithRepsView' do let(:obj) { Nanoc::ItemWithRepsView.new(item, nil) } let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo.md') } it { is_expected.to eql('Nanoc::ItemWithRepsView>,attributes=Hash<>,identifier=Nanoc::Identifier>>>') } end context 'Nanoc::Int::ItemRep' do let(:obj) { Nanoc::Int::ItemRep.new(item, :pdf) } let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo.md') } it { is_expected.to eql('Nanoc::Int::ItemRep>,attributes=Hash<>,identifier=Nanoc::Identifier>>,name=Symbol>') } end context 'Nanoc::ItemRepView' do let(:obj) { Nanoc::ItemRepView.new(rep, :_unused_context) } let(:rep) { Nanoc::Int::ItemRep.new(item, :pdf) } let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo.md') } it { is_expected.to eql('Nanoc::ItemRepView>,attributes=Hash<>,identifier=Nanoc::Identifier>>,name=Symbol>>') } end context 'Nanoc::ItemWithoutRepsView' do let(:obj) { Nanoc::ItemWithoutRepsView.new(item, nil) } let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo.md') } it { is_expected.to eql('Nanoc::ItemWithoutRepsView>,attributes=Hash<>,identifier=Nanoc::Identifier>>>') } end context 'Nanoc::LayoutView' do let(:obj) { Nanoc::LayoutView.new(layout, nil) } let(:layout) { Nanoc::Int::Layout.new('asdf', {}, '/foo.md') } it { is_expected.to eql('Nanoc::LayoutView>,attributes=Hash<>,identifier=Nanoc::Identifier>>>') } end context 'Nanoc::ConfigView' do let(:obj) { Nanoc::ConfigView.new(config, nil) } let(:config) { Nanoc::Int::Configuration.new(hash: { 'foo' => 'bar' }) } it { is_expected.to eql('Nanoc::ConfigView=String,>>') } end context 'Nanoc::ItemCollectionWithRepsView' do let(:obj) { Nanoc::ItemCollectionWithRepsView.new(wrapped, nil) } let(:config) { Nanoc::Int::Configuration.new(hash: { 'foo' => 'bar' }) } let(:wrapped) do Nanoc::Int::IdentifiableCollection.new(config).tap do |arr| arr << Nanoc::Int::Item.new('foo', {}, '/foo.md') arr << Nanoc::Int::Item.new('bar', {}, '/foo.md') end end it { is_expected.to eql('Nanoc::ItemCollectionWithRepsView>,attributes=Hash<>,identifier=Nanoc::Identifier>>,Nanoc::Int::Item>,attributes=Hash<>,identifier=Nanoc::Identifier>>,>>') } end context 'Nanoc::ItemCollectionWithoutRepsView' do let(:obj) { Nanoc::ItemCollectionWithoutRepsView.new(wrapped, nil) } let(:config) { Nanoc::Int::Configuration.new(hash: { 'foo' => 'bar' }) } let(:wrapped) do Nanoc::Int::IdentifiableCollection.new(config).tap do |arr| arr << Nanoc::Int::Item.new('foo', {}, '/foo.md') arr << Nanoc::Int::Item.new('bar', {}, '/foo.md') end end it { is_expected.to eql('Nanoc::ItemCollectionWithoutRepsView>,attributes=Hash<>,identifier=Nanoc::Identifier>>,Nanoc::Int::Item>,attributes=Hash<>,identifier=Nanoc::Identifier>>,>>') } end context 'Nanoc::RuleDSL::RuleContext' do let(:obj) { Nanoc::RuleDSL::RuleContext.new(rep: rep, site: site, executor: executor, view_context: view_context) } let(:rep) { Nanoc::Int::ItemRep.new(item, :pdf) } let(:item) { Nanoc::Int::Item.new('stuff', {}, '/stuff.md') } let(:site) do Nanoc::Int::Site.new(config: config, code_snippets: code_snippets, items: items, layouts: layouts) end let(:config) { Nanoc::Int::Configuration.new(hash: { 'foo' => 'bar' }) } let(:code_snippets) { [Nanoc::Int::CodeSnippet.new('asdf', '/bob.rb')] } let(:items) { [item] } let(:layouts) { [Nanoc::Int::Layout.new('asdf', {}, '/foo.md')] } let(:executor) { :_unused_ } let(:view_context) { :_unused_ } let(:expected_item_checksum) { 'Nanoc::Int::Item>,attributes=Hash<>,identifier=Nanoc::Identifier>>' } let(:expected_item_rep_checksum) { 'Nanoc::Int::ItemRep>' } let(:expected_layout_checksum) { 'Nanoc::Int::Layout>,attributes=Hash<>,identifier=Nanoc::Identifier>>' } let(:expected_config_checksum) { 'Nanoc::Int::Configuration=String,>' } let(:expected_checksum) do [ 'Nanoc::RuleDSL::RuleContext<', 'item=', 'Nanoc::ItemWithoutRepsView<' + expected_item_checksum + '>', ',rep=', 'Nanoc::ItemRepView<' + expected_item_rep_checksum + '>', ',items=', 'Nanoc::ItemCollectionWithoutRepsView>', ',layouts=', 'Nanoc::LayoutCollectionView>', ',config=', 'Nanoc::ConfigView<' + expected_config_checksum + '>', '>', ].join('') end it { is_expected.to eql(expected_checksum) } end context 'Nanoc::Int::Context' do let(:obj) { Nanoc::Int::Context.new(foo: 123) } it { is_expected.to match(/\ANanoc::Int::Context<@foo=(Fixnum|Integer)<123>,>\z/) } end context 'Sass::Importers::Filesystem' do let(:obj) { Sass::Importers::Filesystem.new('/foo') } before { require 'sass' } it { is_expected.to eql('Sass::Importers::Filesystem') } end context 'other marshal-able classes' do let(:obj) { klass.new('hello') } let(:klass) do Class.new do def initialize(a) @a = a end end end it { is_expected.to match(/\A#<.*>\z/) } end context 'other non-marshal-able classes' do let(:obj) { proc {} } it { is_expected.to match(/\AProc<#>\z/) } end end nanoc-4.4.7/spec/nanoc/base/filter_spec.rb0000644000004100000410000000501713033443476020454 0ustar www-datawww-datadescribe Nanoc::Filter do describe '.define' do context 'simple filter' do let(:filter_name) { 'b5355bbb4d772b9853d21be57da614dba521dbbb' } let(:filter_class) { Nanoc::Filter.named(filter_name) } before do Nanoc::Filter.define(filter_name) do |content, _params| content.upcase end end it 'defines a filter' do expect(filter_class).not_to be_nil end it 'defines a callable filter' do expect(filter_class.new.run('foo', {})).to eql('FOO') end end context 'filter that accesses assigns' do let(:filter_name) { 'd7ed105d460e99a3d38f46af023d9490c140fdd9' } let(:filter_class) { Nanoc::Filter.named(filter_name) } let(:filter) { filter_class.new(assigns) } let(:assigns) { { animal: 'Giraffe' } } before do Nanoc::Filter.define(filter_name) do |_content, _params| @animal end end it 'can access assigns' do expect(filter.setup_and_run(:__irrelevant__, {})).to eq('Giraffe') end end end describe '#depend_on' do subject { filter.depend_on(item_views) } let(:filter) { Nanoc::Filters::ERB.new(assigns) } let(:item_views) { [item_view] } let(:item) { Nanoc::Int::Item.new('foo', {}, '/stuff.md') } let(:item_view) { Nanoc::ItemWithRepsView.new(item, view_context) } let(:rep) { Nanoc::Int::ItemRep.new(item, :default) } let(:view_context) do Nanoc::ViewContext.new( reps: reps, items: double(:items), dependency_tracker: dependency_tracker, compilation_context: double(:compilation_context), ) end let(:dependency_tracker) { double(:dependency_tracker) } let(:reps) { Nanoc::Int::ItemRepRepo.new } let(:assigns) do { item: item_view, } end before do reps << rep expect(dependency_tracker).to receive(:bounce).with(item, compiled_content: true) end context 'rep is compiled' do before do rep.compiled = true end example do expect { subject }.not_to yield_from_fiber(an_instance_of(Nanoc::Int::Errors::UnmetDependency)) end end context 'rep is not compiled' do example do fiber = Fiber.new { subject } # resume 1 res = fiber.resume expect(res).to be_a(Nanoc::Int::Errors::UnmetDependency) expect(res.rep).to eql(rep) # resume 2 expect(fiber.resume).not_to be_a(Nanoc::Int::Errors::UnmetDependency) end end end end nanoc-4.4.7/spec/nanoc/base/item_rep_writer_spec.rb0000644000004100000410000000733413033443476022373 0ustar www-datawww-datadescribe Nanoc::Int::ItemRepWriter do describe '#write' do let(:raw_path) { 'output/blah.dat' } let(:item) { Nanoc::Int::Item.new(orig_content, {}, '/') } let(:item_rep) do Nanoc::Int::ItemRep.new(item, :default).tap do |ir| ir.snapshot_contents = snapshot_contents ir.raw_paths = raw_paths end end let(:snapshot_contents) do { last: Nanoc::Int::TextualContent.new('last content'), donkey: Nanoc::Int::TextualContent.new('donkey content'), } end let(:snapshot_name) { :donkey } let(:raw_paths) do { snapshot_name => raw_path } end subject { described_class.new.write(item_rep, snapshot_name) } before do expect(File.directory?('output')).to be_falsy end context 'binary item rep' do let(:orig_content) { Nanoc::Int::BinaryContent.new(File.expand_path('foo.dat')) } let(:snapshot_contents) do { last: Nanoc::Int::BinaryContent.new(File.expand_path('input-last.dat')), donkey: Nanoc::Int::BinaryContent.new(File.expand_path('input-donkey.dat')), } end before do File.write(snapshot_contents[:last].filename, 'binary last stuff') File.write(snapshot_contents[:donkey].filename, 'binary donkey stuff') end it 'copies' do expect(Nanoc::Int::NotificationCenter).to receive(:post) .with(:will_write_rep, item_rep, 'output/blah.dat') expect(Nanoc::Int::NotificationCenter).to receive(:post) .with(:rep_written, item_rep, 'output/blah.dat', true, true) subject expect(File.read('output/blah.dat')).to eql('binary donkey stuff') end context 'output file already exists' do let(:old_mtime) { Time.at((Time.now - 600).to_i) } before do FileUtils.mkdir_p('output') File.write('output/blah.dat', old_content) FileUtils.touch('output/blah.dat', mtime: old_mtime) end context 'file is identical' do let(:old_content) { 'binary donkey stuff' } it 'keeps mtime' do subject expect(File.mtime('output/blah.dat')).to eql(old_mtime) end end context 'file is not identical' do let(:old_content) { 'other binary donkey stuff' } it 'updates mtime' do subject expect(File.mtime('output/blah.dat')).to be > (Time.now - 1) end end end end context 'textual item rep' do let(:orig_content) { Nanoc::Int::TextualContent.new('Hallo Welt') } it 'writes' do expect(Nanoc::Int::NotificationCenter).to receive(:post) .with(:will_write_rep, item_rep, 'output/blah.dat') expect(Nanoc::Int::NotificationCenter).to receive(:post) .with(:rep_written, item_rep, 'output/blah.dat', true, true) subject expect(File.read('output/blah.dat')).to eql('donkey content') end context 'output file already exists' do let(:old_mtime) { Time.at((Time.now - 600).to_i) } before do FileUtils.mkdir_p('output') File.write('output/blah.dat', old_content) FileUtils.touch('output/blah.dat', mtime: old_mtime) end context 'file is identical' do let(:old_content) { 'donkey content' } it 'keeps mtime' do subject expect(File.mtime('output/blah.dat')).to eql(old_mtime) end end context 'file is not identical' do let(:old_content) { 'other donkey content' } it 'updates mtime' do subject expect(File.mtime('output/blah.dat')).to be > (Time.now - 1) end end end end end end nanoc-4.4.7/spec/nanoc/base/services/0000755000004100000410000000000013033443476017450 5ustar www-datawww-datananoc-4.4.7/spec/nanoc/base/services/outdatedness_checker_spec.rb0000644000004100000410000002672213033443476025206 0ustar www-datawww-datadescribe Nanoc::Int::OutdatednessChecker do let(:outdatedness_checker) do described_class.new( site: site, checksum_store: checksum_store, dependency_store: dependency_store, rule_memory_store: rule_memory_store, action_provider: action_provider, reps: reps, ) end let(:checksum_store) { double(:checksum_store) } let(:dependency_store) do Nanoc::Int::DependencyStore.new(objects) end let(:objects) { [item] } let(:site) do Nanoc::Int::Site.new( config: config, items: [], layouts: [], code_snippets: [], ) end let(:rule_memory_store) do Nanoc::Int::RuleMemoryStore.new end let(:old_memory_for_item_rep) do Nanoc::Int::RuleMemory.new(item_rep).tap do |mem| mem.add_filter(:erb, {}) end end let(:new_memory_for_item_rep) { old_memory_for_item_rep } let(:action_provider) { double(:action_provider) } let(:reps) do Nanoc::Int::ItemRepRepo.new end let(:item_rep) { Nanoc::Int::ItemRep.new(item, :default) } let(:item) { Nanoc::Int::Item.new('stuff', {}, '/foo.md') } let(:objects) { [item] } before do reps << item_rep rule_memory_store[item_rep] = old_memory_for_item_rep.serialize allow(action_provider).to receive(:memory_for).with(item_rep).and_return(new_memory_for_item_rep) end describe '#basic_outdatedness_reason_for' do subject { outdatedness_checker.send(:basic_outdatedness_reason_for, obj) } let(:checksum_store) { Nanoc::Int::ChecksumStore.new(objects: objects) } let(:config) { Nanoc::Int::Configuration.new } before do checksum_store.add(item) allow(site).to receive(:code_snippets).and_return([]) allow(site).to receive(:config).and_return(config) end context 'with item' do let(:obj) { item } context 'rule memory differs' do let(:new_memory_for_item_rep) do Nanoc::Int::RuleMemory.new(item_rep).tap do |mem| mem.add_filter(:super_erb, {}) end end it 'is outdated due to rule differences' do expect(subject).to eql(Nanoc::Int::OutdatednessReasons::RulesModified) end end # … end context 'with item rep' do let(:obj) { item_rep } context 'rule memory differs' do let(:new_memory_for_item_rep) do Nanoc::Int::RuleMemory.new(item_rep).tap do |mem| mem.add_filter(:super_erb, {}) end end it 'is outdated due to rule differences' do expect(subject).to eql(Nanoc::Int::OutdatednessReasons::RulesModified) end end # … end context 'with layout' do # … end end describe '#outdated_due_to_dependencies?' do subject { outdatedness_checker.send(:outdated_due_to_dependencies?, item) } let(:checksum_store) { Nanoc::Int::ChecksumStore.new(objects: objects) } let(:other_item) { Nanoc::Int::Item.new('other stuff', {}, '/other.md') } let(:other_item_rep) { Nanoc::Int::ItemRep.new(other_item, :default) } let(:config) { Nanoc::Int::Configuration.new } let(:objects) { [item, other_item] } let(:old_memory_for_other_item_rep) do Nanoc::Int::RuleMemory.new(other_item_rep).tap do |mem| mem.add_filter(:erb, {}) end end let(:new_memory_for_other_item_rep) { old_memory_for_other_item_rep } before do reps << other_item_rep rule_memory_store[other_item_rep] = old_memory_for_other_item_rep.serialize checksum_store.add(item) checksum_store.add(other_item) checksum_store.add(config) allow(action_provider).to receive(:memory_for).with(other_item_rep).and_return(new_memory_for_other_item_rep) allow(site).to receive(:code_snippets).and_return([]) allow(site).to receive(:config).and_return(config) end context 'transitive dependency' do let(:distant_item) { Nanoc::Int::Item.new('distant stuff', {}, '/distant.md') } let(:distant_item_rep) { Nanoc::Int::ItemRep.new(distant_item, :default) } before do reps << distant_item_rep checksum_store.add(distant_item) rule_memory_store[distant_item_rep] = old_memory_for_other_item_rep.serialize allow(action_provider).to receive(:memory_for).with(distant_item_rep).and_return(new_memory_for_other_item_rep) end context 'on attribute + attribute' do before do dependency_store.record_dependency(item, other_item, attributes: true) dependency_store.record_dependency(other_item, distant_item, attributes: true) end context 'distant attribute changed' do before { distant_item.attributes[:title] = 'omg new title' } it 'has correct outdatedness of item' do expect(outdatedness_checker.send(:outdated_due_to_dependencies?, item)).not_to be end it 'has correct outdatedness of other item' do expect(outdatedness_checker.send(:outdated_due_to_dependencies?, other_item)).to be end end context 'distant raw content changed' do before { distant_item.content = Nanoc::Int::TextualContent.new('omg new content') } it 'has correct outdatedness of item' do expect(outdatedness_checker.send(:outdated_due_to_dependencies?, item)).not_to be end it 'has correct outdatedness of other item' do expect(outdatedness_checker.send(:outdated_due_to_dependencies?, other_item)).not_to be end end end context 'on compiled content + attribute' do before do dependency_store.record_dependency(item, other_item, compiled_content: true) dependency_store.record_dependency(other_item, distant_item, attributes: true) end context 'distant attribute changed' do before { distant_item.attributes[:title] = 'omg new title' } it 'has correct outdatedness of item' do expect(outdatedness_checker.send(:outdated_due_to_dependencies?, item)).to be end it 'has correct outdatedness of other item' do expect(outdatedness_checker.send(:outdated_due_to_dependencies?, other_item)).to be end end context 'distant raw content changed' do before { distant_item.content = Nanoc::Int::TextualContent.new('omg new content') } it 'has correct outdatedness of item' do expect(outdatedness_checker.send(:outdated_due_to_dependencies?, item)).not_to be end it 'has correct outdatedness of other item' do expect(outdatedness_checker.send(:outdated_due_to_dependencies?, other_item)).not_to be end end end end context 'only attribute dependency' do before do dependency_store.record_dependency(item, other_item, attributes: true) end context 'attribute changed' do before { other_item.attributes[:title] = 'omg new title' } it { is_expected.to be } end context 'raw content changed' do before { other_item.content = Nanoc::Int::TextualContent.new('omg new content') } it { is_expected.not_to be } end context 'attribute + raw content changed' do before { other_item.attributes[:title] = 'omg new title' } before { other_item.content = Nanoc::Int::TextualContent.new('omg new content') } it { is_expected.to be } end context 'path changed' do let(:new_memory_for_other_item_rep) do Nanoc::Int::RuleMemory.new(other_item_rep).tap do |mem| mem.add_filter(:erb, {}) mem.add_snapshot(:donkey, '/giraffe.txt') end end it { is_expected.not_to be } end end context 'only raw content dependency' do before do dependency_store.record_dependency(item, other_item, raw_content: true) end context 'attribute changed' do before { other_item.attributes[:title] = 'omg new title' } it { is_expected.not_to be } end context 'raw content changed' do before { other_item.content = Nanoc::Int::TextualContent.new('omg new content') } it { is_expected.to be } end context 'attribute + raw content changed' do before { other_item.attributes[:title] = 'omg new title' } before { other_item.content = Nanoc::Int::TextualContent.new('omg new content') } it { is_expected.to be } end context 'path changed' do let(:new_memory_for_other_item_rep) do Nanoc::Int::RuleMemory.new(other_item_rep).tap do |mem| mem.add_filter(:erb, {}) mem.add_snapshot(:donkey, '/giraffe.txt') end end it { is_expected.not_to be } end end context 'only path dependency' do before do dependency_store.record_dependency(item, other_item, raw_content: true) end context 'attribute changed' do before { other_item.attributes[:title] = 'omg new title' } it { is_expected.not_to be } end context 'raw content changed' do before { other_item.content = Nanoc::Int::TextualContent.new('omg new content') } it { is_expected.to be } end context 'path changed' do let(:new_memory_for_other_item_rep) do Nanoc::Int::RuleMemory.new(other_item_rep).tap do |mem| mem.add_filter(:erb, {}) mem.add_snapshot(:donkey, '/giraffe.txt') end end it { is_expected.not_to be } end end context 'attribute + raw content dependency' do before do dependency_store.record_dependency(item, other_item, attributes: true, raw_content: true) end context 'attribute changed' do before { other_item.attributes[:title] = 'omg new title' } it { is_expected.to be } end context 'raw content changed' do before { other_item.content = Nanoc::Int::TextualContent.new('omg new content') } it { is_expected.to be } end context 'attribute + raw content changed' do before { other_item.attributes[:title] = 'omg new title' } before { other_item.content = Nanoc::Int::TextualContent.new('omg new content') } it { is_expected.to be } end context 'rules changed' do let(:new_memory_for_other_item_rep) do Nanoc::Int::RuleMemory.new(other_item_rep).tap do |mem| mem.add_filter(:erb, {}) mem.add_filter(:donkey, {}) end end it { is_expected.not_to be } end end context 'attribute + other dependency' do before do dependency_store.record_dependency(item, other_item, attributes: true, path: true) end context 'attribute changed' do before { other_item.attributes[:title] = 'omg new title' } it { is_expected.to be } end context 'raw content changed' do before { other_item.content = Nanoc::Int::TextualContent.new('omg new content') } it { is_expected.not_to be } end end context 'other dependency' do before do dependency_store.record_dependency(item, other_item, path: true) end context 'attribute changed' do before { other_item.attributes[:title] = 'omg new title' } it { is_expected.not_to be } end context 'raw content changed' do before { other_item.content = Nanoc::Int::TextualContent.new('omg new content') } it { is_expected.not_to be } end end end end nanoc-4.4.7/spec/nanoc/base/services/item_rep_selector_spec.rb0000644000004100000410000000757013033443476024524 0ustar www-datawww-datadescribe Nanoc::Int::ItemRepSelector do let(:selector) { described_class.new(reps_for_selector) } let(:item) do Nanoc::Int::Item.new('stuff', {}, '/foo.md') end let(:reps_array) do [ Nanoc::Int::ItemRep.new(item, :a), Nanoc::Int::ItemRep.new(item, :b), Nanoc::Int::ItemRep.new(item, :c), Nanoc::Int::ItemRep.new(item, :d), Nanoc::Int::ItemRep.new(item, :e), ] end let(:reps_for_selector) { reps_array } let(:names_to_reps) do reps_array.each_with_object({}) do |rep, acc| acc[rep.name] = rep end end let(:dependencies) { {} } let(:result) do tentatively_yielded = [] successfully_yielded = [] selector.each do |rep| tentatively_yielded << rep.name dependencies.fetch(rep.name, []).each do |name| unless successfully_yielded.include?(name) raise Nanoc::Int::Errors::UnmetDependency.new(names_to_reps[name]) end end successfully_yielded << rep.name end [tentatively_yielded, successfully_yielded] end let(:tentatively_yielded) { result[0] } let(:successfully_yielded) { result[1] } describe 'error' do context 'plain error' do subject { selector.each { |_rep| raise 'heh' } } it 'raises' do expect { subject }.to raise_error(RuntimeError, 'heh') end end context 'plain dependency error' do subject do idx = 0 selector.each do |_rep| idx += 1 raise Nanoc::Int::Errors::UnmetDependency.new(reps_array[2]) if idx == 1 end end it 'does not raise' do expect { subject }.not_to raise_error end end context 'wrapped error' do subject do selector.each do |rep| begin raise 'heh' rescue => e raise Nanoc::Int::Errors::CompilationError.new(e, rep) end end end it 'raises original error' do expect { subject }.to raise_error(Nanoc::Int::Errors::CompilationError) do |err| expect(err.unwrap).to be_a(RuntimeError) expect(err.unwrap.message).to eq('heh') end end end context 'wrapped dependency error' do subject do idx = 0 selector.each do |rep| idx += 1 begin raise Nanoc::Int::Errors::UnmetDependency.new(reps_array[2]) if idx == 1 rescue => e raise Nanoc::Int::Errors::CompilationError.new(e, rep) end end end it 'does not raise' do expect { subject }.not_to raise_error end end end describe 'yield order' do context 'linear dependencies' do let(:dependencies) do { a: [:b], b: [:c], c: [:d], d: [:e], e: [], } end example do expect(successfully_yielded).to eq [:e, :d, :c, :b, :a] expect(tentatively_yielded).to eq [:a, :b, :c, :d, :e, :d, :c, :b, :a] end end context 'no dependencies' do let(:dependencies) do {} end example do expect(successfully_yielded).to eq [:a, :b, :c, :d, :e] expect(tentatively_yielded).to eq [:a, :b, :c, :d, :e] end end context 'star dependencies' do let(:dependencies) do { a: [:b, :c, :d, :e], } end example do expect(successfully_yielded).to eq [:b, :c, :d, :e, :a] expect(tentatively_yielded).to eq [:a, :b, :c, :d, :e, :a] end end context 'star dependencies; selectively recompiling' do let(:reps_for_selector) { reps_array.first(1) } let(:dependencies) do { a: [:b, :c, :d, :e], } end example do expect(successfully_yielded).to eq [:b, :c, :d, :e, :a] expect(tentatively_yielded).to eq [:a, :b, :a, :c, :a, :d, :a, :e, :a] end end end end nanoc-4.4.7/spec/nanoc/base/services/executor_spec.rb0000644000004100000410000003437413033443476022660 0ustar www-datawww-datadescribe Nanoc::Int::Executor do let(:executor) { described_class.new(rep, compilation_context, dependency_tracker) } let(:compilation_context) do Nanoc::Int::Compiler::CompilationContext.new( action_provider: action_provider, reps: reps, site: site, compiled_content_cache: compiled_content_cache, ) end let(:item) { Nanoc::Int::Item.new(content, {}, '/index.md') } let(:rep) { Nanoc::Int::ItemRep.new(item, :donkey) } let(:content) { Nanoc::Int::TextualContent.new('Donkey Power').tap(&:freeze) } let(:action_provider) { double(:action_provider) } let(:reps) { double(:reps) } let(:site) { double(:site) } let(:compiled_content_cache) { double(:compiled_content_cache) } let(:dependency_tracker) { Nanoc::Int::DependencyTracker.new(double(:dependency_store)) } describe '#filter' do let(:assigns) { {} } let(:content) { Nanoc::Int::TextualContent.new('<%= "Donkey" %> Power') } before do allow(compilation_context).to receive(:assigns_for) { assigns } end context 'normal flow with textual rep' do before do expect(Nanoc::Int::NotificationCenter) .to receive(:post).with(:filtering_started, rep, :erb) expect(Nanoc::Int::NotificationCenter) .to receive(:post).with(:filtering_ended, rep, :erb) end example do executor.filter(:erb) expect(rep.snapshot_contents[:last].string).to eq('Donkey Power') expect(rep.snapshot_contents[:pre]).to be_nil expect(rep.snapshot_contents[:post]).to be_nil end it 'returns frozen data' do executor.filter(:erb) expect(rep.snapshot_contents[:last]).to be_frozen end end context 'normal flow with binary rep' do let(:content) { Nanoc::Int::BinaryContent.new(File.expand_path('foo.dat')) } before do expect(Nanoc::Int::NotificationCenter) .to receive(:post).with(:filtering_started, rep, :whatever) expect(Nanoc::Int::NotificationCenter) .to receive(:post).with(:filtering_ended, rep, :whatever) File.write(content.filename, 'Foo Data') filter_class = Class.new(::Nanoc::Filter) do type :binary def run(filename, _params = {}) File.write(output_filename, "Compiled data for #{filename}") end end expect(Nanoc::Filter).to receive(:named).with(:whatever) { filter_class } end example do executor.filter(:whatever) expect(File.read(rep.snapshot_contents[:last].filename)) .to match(/\ACompiled data for \/.*\/foo.dat\z/) expect(rep.snapshot_contents[:pre]).to be_nil expect(rep.snapshot_contents[:post]).to be_nil end it 'returns frozen data' do executor.filter(:whatever) expect(rep.snapshot_contents[:last]).to be_frozen end end context 'normal flow with binary rep and binary-to-text filter' do let(:content) { Nanoc::Int::BinaryContent.new(File.expand_path('foo.dat')) } before do expect(Nanoc::Int::NotificationCenter) .to receive(:post).with(:filtering_started, rep, :whatever) expect(Nanoc::Int::NotificationCenter) .to receive(:post).with(:filtering_ended, rep, :whatever) File.write(content.filename, 'Foo Data') filter_class = Class.new(::Nanoc::Filter) do type binary: :text def run(filename, _params = {}) "Compiled data for #{filename}" end end expect(Nanoc::Filter).to receive(:named).with(:whatever) { filter_class } end example do executor.filter(:whatever) expect(rep.snapshot_contents[:last].string).to match(/\ACompiled data for \/.*\/foo.dat\z/) expect(rep.snapshot_contents[:pre]).to be_nil expect(rep.snapshot_contents[:post]).to be_nil end end context 'normal flow with textual rep and text-to-binary filter' do before do expect(Nanoc::Int::NotificationCenter) .to receive(:post).with(:filtering_started, rep, :whatever) expect(Nanoc::Int::NotificationCenter) .to receive(:post).with(:filtering_ended, rep, :whatever) filter_class = Class.new(::Nanoc::Filter) do type text: :binary def run(content, _params = {}) File.write(output_filename, "Binary #{content}") end end expect(Nanoc::Filter).to receive(:named).with(:whatever) { filter_class } end example do executor.filter(:whatever) expect(File.read(rep.snapshot_contents[:last].filename)) .to eq('Binary <%= "Donkey" %> Power') expect(rep.snapshot_contents[:pre]).to be_nil expect(rep.snapshot_contents[:post]).to be_nil end end context 'non-existant filter' do it 'raises' do expect { executor.filter(:ajlsdfjklaskldfj) } .to raise_error(Nanoc::Int::Errors::UnknownFilter) end end context 'non-binary rep, binary-to-something filter' do before do filter_class = Class.new(::Nanoc::Filter) do type :binary def run(_content, _params = {}); end end expect(Nanoc::Filter).to receive(:named).with(:whatever) { filter_class } end it 'raises' do expect { executor.filter(:whatever) } .to raise_error(Nanoc::Int::Errors::CannotUseBinaryFilter) end end context 'binary rep, text-to-something filter' do let(:content) { Nanoc::Int::BinaryContent.new(File.expand_path('foo.md')) } it 'raises' do expect { executor.filter(:erb) } .to raise_error(Nanoc::Int::Errors::CannotUseTextualFilter) end end context 'binary filter that does not write anything' do let(:content) { Nanoc::Int::BinaryContent.new(File.expand_path('foo.dat')) } before do expect(Nanoc::Int::NotificationCenter) .to receive(:post).with(:filtering_started, rep, :whatever) expect(Nanoc::Int::NotificationCenter) .to receive(:post).with(:filtering_ended, rep, :whatever) File.write(content.filename, 'Foo Data') filter_class = Class.new(::Nanoc::Filter) do type :binary def run(_filename, _params = {}); end end expect(Nanoc::Filter).to receive(:named).with(:whatever) { filter_class } end example do expect { executor.filter(:whatever) } .to raise_error(Nanoc::Int::Executor::OutputNotWrittenError) end end context 'content is frozen' do let(:item) do Nanoc::Int::Item.new('foo bar', {}, '/foo.md').tap(&:freeze) end let(:filter_that_modifies_content) do Class.new(::Nanoc::Filter) do def run(content, _params = {}) content.gsub!('foo', 'moo') content end end end let(:filter_that_modifies_params) do Class.new(::Nanoc::Filter) do def run(_content, params = {}) params[:foo] = 'bar' 'asdf' end end end it 'errors when attempting to modify content' do expect(Nanoc::Filter).to receive(:named).with(:whatever).and_return(filter_that_modifies_content) expect { executor.filter(:whatever) }.to raise_frozen_error end it 'receives frozen filter args' do expect(Nanoc::Filter).to receive(:named).with(:whatever).and_return(filter_that_modifies_params) expect { executor.filter(:whatever) }.to raise_frozen_error end end end describe '#layout' do let(:site) { double(:site, config: config, layouts: layouts) } let(:config) do { string_pattern_type: 'glob', } end let(:layout) do Nanoc::Int::Layout.new(layout_content, { bug: 'Gum Emperor' }, '/default.erb') end let(:layouts) { [layout] } let(:layout_content) { 'head <%= @foo %> foot' } let(:assigns) do { foo: 'hallo' } end let(:view_context) do Nanoc::ViewContext.new( reps: double(:reps), items: double(:items), dependency_tracker: dependency_tracker, compilation_context: double(:compilation_context), ) end let(:rule_memory) do Nanoc::Int::RuleMemory.new(rep).tap do |mem| mem.add_filter(:erb, {}) end end before do rep.snapshot_defs = [Nanoc::Int::SnapshotDef.new(:pre)] allow(compilation_context).to receive(:site) { site } allow(compilation_context).to receive(:assigns_for).with(rep, dependency_tracker) { assigns } allow(compilation_context).to receive(:create_view_context).with(dependency_tracker).and_return(view_context) allow(action_provider).to receive(:memory_for).with(layout).and_return(rule_memory) end subject { executor.layout('/default.*') } context 'accessing layout attributes' do let(:layout_content) { 'head <%= @layout[:bug] %> foot' } it 'exposes @layout as view' do allow(dependency_tracker).to receive(:enter) .with(layout, raw_content: true, attributes: false, compiled_content: false, path: false) allow(dependency_tracker).to receive(:enter) .with(layout, raw_content: false, attributes: true, compiled_content: false, path: false) allow(dependency_tracker).to receive(:exit) subject expect(rep.snapshot_contents[:last].string).to eq('head Gum Emperor foot') end end context 'normal flow' do it 'updates last content' do subject expect(rep.snapshot_contents[:last].string).to eq('head hallo foot') end it 'sets frozen content' do subject expect(rep.snapshot_contents[:last]).to be_frozen expect(rep.snapshot_contents[:pre]).to be_frozen end it 'does not create pre snapshot' do # a #layout is followed by a #snapshot(:pre, …) expect(rep.snapshot_contents[:pre]).to be_nil subject expect(rep.snapshot_contents[:pre]).to be_nil end it 'sends notifications' do expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:filtering_started, rep, :erb).ordered expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:filtering_ended, rep, :erb).ordered subject end context 'compiled_content reference in layout' do let(:layout_content) { 'head <%= @item_rep.compiled_content(snapshot: :pre) %> foot' } let(:assigns) do { item_rep: Nanoc::ItemRepView.new(rep, view_context) } end before do executor.snapshot(:pre) end it 'can contain compiled_content reference' do subject expect(rep.snapshot_contents[:last].string).to eq('head Donkey Power foot') end end context 'content with layout reference' do let(:layout_content) { 'head <%= @layout.identifier %> foot' } it 'includes layout in assigns' do subject expect(rep.snapshot_contents[:last].string).to eq('head /default.erb foot') end end end context 'no layout found' do let(:layouts) do [Nanoc::Int::Layout.new('head <%= @foo %> foot', {}, '/other.erb')] end it 'raises' do expect { subject }.to raise_error(Nanoc::Int::Errors::UnknownLayout) end end context 'no filter specified' do let(:rule_memory) do Nanoc::Int::RuleMemory.new(rep) end it 'raises' do expect { subject }.to raise_error(Nanoc::Int::Errors::UndefinedFilterForLayout) end end context 'binary item' do let(:content) { Nanoc::Int::BinaryContent.new(File.expand_path('donkey.md')) } it 'raises' do expect { subject }.to raise_error(Nanoc::Int::Errors::CannotLayoutBinaryItem) end end it 'receives frozen filter args' do filter_class = Class.new(::Nanoc::Filter) do def run(_content, params = {}) params[:foo] = 'bar' 'asdf' end end expect(Nanoc::Filter).to receive(:named).with(:erb) { filter_class } expect { subject }.to raise_frozen_error end end describe '#snapshot' do context 'binary content' do let(:content) { Nanoc::Int::BinaryContent.new(File.expand_path('donkey.dat')) } it 'creates snapshots' do executor.snapshot(:something) expect(rep.snapshot_contents[:something]).not_to be_nil end end context 'textual content' do let(:content) { Nanoc::Int::TextualContent.new('Donkey Power') } it 'creates a snapshot' do executor.snapshot(:something) expect(rep.snapshot_contents[:something].string).to eq('Donkey Power') end end context 'final snapshot' do let(:content) { Nanoc::Int::TextualContent.new('Donkey Power') } context 'raw path' do before do rep.raw_paths = { something: 'output/donkey.md' } end it 'does not write' do executor.snapshot(:something) expect(File.file?('output/donkey.md')).not_to be end end context 'no raw path' do it 'does not write' do executor.snapshot(:something) expect(File.file?('output/donkey.md')).to eq(false) end end end end describe '#find_layout' do let(:site) { double(:site, config: config, layouts: layouts) } let(:config) { {} } before do allow(compilation_context).to receive(:site) { site } end subject { executor.find_layout(arg) } context 'layout with cleaned identifier exists' do let(:arg) { '/default' } let(:layouts) do [Nanoc::Int::Layout.new('head <%= @foo %> foot', {}, '/default/')] end it { is_expected.to eq(layouts[0]) } end context 'no layout with cleaned identifier exists' do let(:layouts) do [Nanoc::Int::Layout.new('head <%= @foo %> foot', {}, '/default.erb')] end context 'globs' do let(:config) { { string_pattern_type: 'glob' } } let(:arg) { '/default.*' } it { is_expected.to eq(layouts[0]) } end context 'no globs' do let(:config) { { string_pattern_type: 'legacy' } } let(:arg) { '/default.*' } it 'raises' do expect { subject }.to raise_error(Nanoc::Int::Errors::UnknownLayout) end end end end end nanoc-4.4.7/spec/nanoc/base/services/pruner_spec.rb0000644000004100000410000000517713033443476022334 0ustar www-datawww-datadescribe Nanoc::Pruner do subject(:pruner) { described_class.new(config, reps, dry_run: dry_run, exclude: exclude) } let(:config) { Nanoc::Int::Configuration.new({}) } let(:dry_run) { false } let(:exclude) { [] } let(:reps) do Nanoc::Int::ItemRepRepo.new.tap do |reps| reps << Nanoc::Int::ItemRep.new(item, :default).tap do |rep| rep.raw_paths = { last: 'output/asdf.html' } end reps << Nanoc::Int::ItemRep.new(item, :text).tap do |rep| rep.raw_paths = { last: 'output/asdf.txt' } end end end let(:item) { Nanoc::Int::Item.new('asdf', {}, '/a.md') } it 'is accessible through Nanoc::Extra::Pruner' do expect(Nanoc::Extra::Pruner).to equal(Nanoc::Pruner) end describe '#files_and_dirs_in' do subject { pruner.files_and_dirs_in('output/') } before do FileUtils.mkdir_p('output/projects') FileUtils.mkdir_p('output/.git') File.write('output/asdf.html', '

text

') File.write('output/.htaccess', 'secret stuff here') File.write('output/projects/nanoc.html', '

Nanoc is v cool!!

') File.write('output/.git/HEAD', 'some content here') end context 'nothing excluded' do let(:exclude) { [] } it 'returns all files' do files = [ 'output/asdf.html', 'output/.htaccess', 'output/projects/nanoc.html', 'output/.git/HEAD', ] expect(subject[0]).to match_array(files) end it 'returns all directories' do dirs = [ 'output/', 'output/projects', 'output/.git', ] expect(subject[1]).to match_array(dirs) end end context 'directory (.git) excluded' do let(:exclude) { ['.git'] } it 'returns all files' do files = [ 'output/asdf.html', 'output/.htaccess', 'output/projects/nanoc.html', ] expect(subject[0]).to match_array(files) end it 'returns all directories' do dirs = [ 'output/', 'output/projects', ] expect(subject[1]).to match_array(dirs) end end context 'file (.htaccess) excluded' do let(:exclude) { ['.htaccess'] } it 'returns all files' do files = [ 'output/asdf.html', 'output/projects/nanoc.html', 'output/.git/HEAD', ] expect(subject[0]).to match_array(files) end it 'returns all directories' do dirs = [ 'output/', 'output/projects', 'output/.git', ] expect(subject[1]).to match_array(dirs) end end end end nanoc-4.4.7/spec/nanoc/base/services/dependency_tracker_spec.rb0000644000004100000410000001564413033443476024652 0ustar www-datawww-datadescribe Nanoc::Int::DependencyTracker do let(:tracker) { described_class.new(store) } let(:store) { Nanoc::Int::DependencyStore.new([]) } let(:item_a) { Nanoc::Int::Item.new('a', {}, '/a.md') } let(:item_b) { Nanoc::Int::Item.new('b', {}, '/b.md') } let(:item_c) { Nanoc::Int::Item.new('c', {}, '/c.md') } shared_examples 'a null dependency tracker' do let(:tracker) { Nanoc::Int::DependencyTracker::Null.new } example do expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_a) } end example do expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_b) } end example do expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_c) } end example do expect { subject }.not_to change { store.dependencies_causing_outdatedness_of(item_a) } end example do expect { subject }.not_to change { store.dependencies_causing_outdatedness_of(item_b) } end example do expect { subject }.not_to change { store.dependencies_causing_outdatedness_of(item_c) } end end describe '#enter and #exit' do context 'enter' do subject do tracker.enter(item_a) end it_behaves_like 'a null dependency tracker' example do expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_a) } end example do expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_b) } end example do expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_c) } end end context 'enter + enter' do subject do tracker.enter(item_a) tracker.enter(item_b) end it_behaves_like 'a null dependency tracker' it 'changes predecessors of item A' do expect { subject }.to change { store.objects_causing_outdatedness_of(item_a) } .from([]).to([item_b]) end example do expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_b) } end example do expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_c) } end end context 'enter + enter with props' do subject do tracker.enter(item_a) tracker.enter(item_b, compiled_content: true) end it_behaves_like 'a null dependency tracker' it 'changes predecessors of item A' do expect { subject }.to change { store.objects_causing_outdatedness_of(item_a) } .from([]).to([item_b]) end it 'changes dependencies causing outdatedness of item A' do expect { subject }.to change { store.dependencies_causing_outdatedness_of(item_a).size } .from(0).to(1) end it 'creates correct new dependency causing outdatedness of item A' do subject dep = store.dependencies_causing_outdatedness_of(item_a)[0] expect(dep.from).to eql(item_b) expect(dep.to).to eql(item_a) end it 'creates dependency with correct props causing outdatedness of item A' do subject dep = store.dependencies_causing_outdatedness_of(item_a)[0] expect(dep.props.compiled_content?).to eq(true) expect(dep.props.raw_content?).to eq(false) expect(dep.props.attributes?).to eq(false) expect(dep.props.path?).to eq(false) end example do expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_b) } end example do expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_c) } end example do expect { subject }.not_to change { store.dependencies_causing_outdatedness_of(item_b) } end example do expect { subject }.not_to change { store.dependencies_causing_outdatedness_of(item_c) } end end context 'enter + enter with prop + exit + enter with prop' do subject do tracker.enter(item_a) tracker.enter(item_b, compiled_content: true) tracker.exit tracker.enter(item_b, attributes: true) end it_behaves_like 'a null dependency tracker' it 'changes predecessors of item A' do expect { subject }.to change { store.objects_causing_outdatedness_of(item_a) } .from([]).to([item_b]) end it 'changes dependencies causing outdatedness of item A' do expect { subject }.to change { store.dependencies_causing_outdatedness_of(item_a).size } .from(0).to(1) end it 'creates correct new dependency causing outdatedness of item A' do subject dep = store.dependencies_causing_outdatedness_of(item_a)[0] expect(dep.from).to eql(item_b) expect(dep.to).to eql(item_a) end it 'creates dependency with correct props causing outdatedness of item A' do subject dep = store.dependencies_causing_outdatedness_of(item_a)[0] expect(dep.props.compiled_content?).to eq(true) expect(dep.props.attributes?).to eq(true) expect(dep.props.raw_content?).to eq(false) expect(dep.props.path?).to eq(false) end example do expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_b) } end example do expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_c) } end example do expect { subject }.not_to change { store.dependencies_causing_outdatedness_of(item_b) } end example do expect { subject }.not_to change { store.dependencies_causing_outdatedness_of(item_c) } end end context 'enter + enter + exit + enter' do subject do tracker.enter(item_a) tracker.enter(item_b) tracker.exit tracker.enter(item_c) end it_behaves_like 'a null dependency tracker' it 'changes predecessors of item A' do expect { subject }.to change { store.objects_causing_outdatedness_of(item_a) } .from([]).to([item_b, item_c]) end example do expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_b) } end example do expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_c) } end end context 'enter + bounce + enter' do subject do tracker.enter(item_a) tracker.bounce(item_b) tracker.enter(item_c) end it_behaves_like 'a null dependency tracker' it 'changes predecessors of item A' do expect { subject }.to change { store.objects_causing_outdatedness_of(item_a) } .from([]).to([item_b, item_c]) end example do expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_b) } end example do expect { subject }.not_to change { store.objects_causing_outdatedness_of(item_c) } end end end end nanoc-4.4.7/spec/nanoc/base/services/temp_filename_factory_spec.rb0000644000004100000410000000411613033443476025345 0ustar www-datawww-datadescribe Nanoc::Int::TempFilenameFactory do subject(:factory) { described_class.new } let(:prefix) { 'foo' } describe '#create' do it 'creates unique paths' do path_a = subject.create(prefix) path_b = subject.create(prefix) expect(path_a).not_to eq(path_b) end it 'returns absolute paths' do path = subject.create(prefix) expect(path).to match(/\A\//) end it 'creates the containing directory' do expect(Dir[subject.root_dir + '/**/*']).to be_empty path = subject.create(prefix) expect(File.directory?(File.dirname(path))).to be(true) end it 'reuses the same path after cleanup' do path_a = subject.create(prefix) subject.cleanup(prefix) path_b = subject.create(prefix) expect(path_a).to eq(path_b) end it 'does not create the file' do path = subject.create(prefix) expect(File.file?(path)).not_to be(true) end end describe '#cleanup' do subject { factory.cleanup(prefix) } let!(:path) { factory.create(prefix) } before { File.write(path, 'hello') } def files Dir[factory.root_dir + '/**/*'].select { |fn| File.file?(fn) } end it 'removes generated files' do expect { subject }.to change { files }.from([path]).to([]) end context 'files with other prefixes exist' do before do factory.create('donkey') end it 'does not delete root dir' do expect(File.directory?(factory.root_dir)).to be(true) expect { subject }.not_to change { File.directory?(factory.root_dir) } end end context 'no files with other prefixes exist' do it 'deletes root dir' do expect { subject }.to change { File.directory?(factory.root_dir) }.from(true).to(false) end end end describe 'other instance' do let(:other_instance) do Nanoc::Int::TempFilenameFactory.new end it 'creates unique paths across instances' do path_a = subject.create(prefix) path_b = other_instance.create(prefix) expect(path_a).not_to eq(path_b) end end end nanoc-4.4.7/spec/nanoc/base/services/item_rep_router_spec.rb0000644000004100000410000000752113033443476024220 0ustar www-datawww-datadescribe(Nanoc::Int::ItemRepRouter) do subject(:item_rep_router) { described_class.new(reps, action_provider, site) } let(:reps) { double(:reps) } let(:action_provider) { double(:action_provider) } let(:site) { double(:site, config: config) } let(:config) { Nanoc::Int::Configuration.new.with_defaults } describe '#run' do subject { item_rep_router.run } let(:item) { Nanoc::Int::Item.new('content', {}, '/foo.md') } let(:reps) do [ Nanoc::Int::ItemRep.new(item, :default), Nanoc::Int::ItemRep.new(item, :csv), ] end let(:paths_0) do { last: '/foo/index.html' } end let(:paths_1) do { last: '/bar.html' } end example do expect(action_provider).to receive(:paths_for).with(reps[0]).and_return(paths_0) expect(action_provider).to receive(:paths_for).with(reps[1]).and_return(paths_1) subject expect(reps[0].raw_paths).to eql(last: 'output/foo/index.html') expect(reps[0].paths).to eql(last: '/foo/') expect(reps[1].raw_paths).to eql(last: 'output/bar.html') expect(reps[1].paths).to eql(last: '/bar.html') end end describe '#route_rep' do subject { item_rep_router.route_rep(rep, path, snapshot_name, paths_to_reps) } let(:path) { basic_path } let(:snapshot_name) { :foo } let(:rep) { Nanoc::Int::ItemRep.new(item, :default) } let(:item) { Nanoc::Int::Item.new('content', {}, '/foo.md') } let(:paths_to_reps) { {} } context 'basic path is nil' do let(:basic_path) { nil } it { is_expected.to be_nil } end context 'basic path is not nil' do let(:basic_path) { '/foo/index.html' } context 'other snapshot with this path already exists' do let(:paths_to_reps) { { '/foo/index.html' => double(:other_rep) } } it 'errors' do expect { subject }.to raise_error(Nanoc::Int::ItemRepRouter::IdenticalRoutesError) end end context 'path is unique' do it 'sets the raw path' do subject expect(rep.raw_paths).to eql(foo: 'output/foo/index.html') end it 'sets the path' do subject expect(rep.paths).to eql(foo: '/foo/') end it 'adds to paths_to_reps' do subject expect(paths_to_reps).to have_key('/foo/index.html') end context 'path does not start with a slash' do let(:basic_path) { 'foo/index.html' } it 'errors' do expect { subject }.to raise_error(Nanoc::Int::ItemRepRouter::RouteWithoutSlashError) end end context 'path is not UTF-8' do let(:basic_path) { '/foo/index.html'.encode('ISO-8859-1') } it 'sets the path as UTF-8' do subject expect(rep.paths).to eql(foo: '/foo/') expect(rep.paths[:foo].encoding.to_s).to eql('UTF-8') end it 'sets the raw path as UTF-8' do subject expect(rep.raw_paths).to eql(foo: 'output/foo/index.html') expect(rep.raw_paths[:foo].encoding.to_s).to eql('UTF-8') end end end end end describe '#strip_index_filename' do subject { item_rep_router.strip_index_filename(basic_path) } context 'basic path ends with /index.html' do let(:basic_path) { '/bar/index.html' } it { is_expected.to eql('/bar/') } end context 'basic path contains /index.html' do let(:basic_path) { '/bar/index.html/foo' } it { is_expected.to eql('/bar/index.html/foo') } end context 'basic path ends with xindex.html' do let(:basic_path) { '/bar/xindex.html' } it { is_expected.to eql('/bar/xindex.html') } end context 'basic path does not contain /index.html' do let(:basic_path) { '/bar/foo.html' } it { is_expected.to eql('/bar/foo.html') } end end end nanoc-4.4.7/spec/nanoc/base/services/outdatedness_rules_spec.rb0000644000004100000410000003147113033443476024731 0ustar www-datawww-datadescribe Nanoc::Int::OutdatednessRules do describe '#apply' do subject { rule_class.instance.apply(obj, outdatedness_checker) } let(:obj) { item_rep } let(:outdatedness_checker) do Nanoc::Int::OutdatednessChecker.new( site: site, checksum_store: checksum_store, dependency_store: dependency_store, rule_memory_store: rule_memory_store, action_provider: action_provider, reps: reps, ) end let(:item_rep) { Nanoc::Int::ItemRep.new(item, :default) } let(:item) { Nanoc::Int::Item.new('stuff', {}, '/foo.md') } let(:config) { Nanoc::Int::Configuration.new } let(:code_snippets) { [] } let(:objects) { [config] + code_snippets + [item] } let(:site) do Nanoc::Int::Site.new( config: config, items: [], layouts: [], code_snippets: code_snippets, ) end let(:action_provider) { double(:action_provider) } let(:reps) { Nanoc::Int::ItemRepRepo.new } let(:dependency_store) { Nanoc::Int::DependencyStore.new(dependency_store_objects) } let(:rule_memory_store) { Nanoc::Int::RuleMemoryStore.new } let(:checksum_store) { Nanoc::Int::ChecksumStore.new(objects: objects) } let(:dependency_store_objects) { [item] } before do allow(site).to receive(:code_snippets).and_return(code_snippets) allow(site).to receive(:config).and_return(config) end context 'CodeSnippetsModified' do let(:rule_class) { Nanoc::Int::OutdatednessRules::CodeSnippetsModified } context 'no snippets' do let(:code_snippets) { [] } it { is_expected.not_to be } end context 'only non-outdated snippets' do let(:code_snippet) { Nanoc::Int::CodeSnippet.new('asdf', 'lib/foo.md') } let(:code_snippets) { [code_snippet] } before { checksum_store.add(code_snippet) } it { is_expected.not_to be } end context 'only non-outdated snippets' do let(:code_snippet) { Nanoc::Int::CodeSnippet.new('asdf', 'lib/foo.md') } let(:code_snippet_old) { Nanoc::Int::CodeSnippet.new('aaaaaaaa', 'lib/foo.md') } let(:code_snippets) { [code_snippet] } before { checksum_store.add(code_snippet_old) } it { is_expected.to be } end end context 'ConfigurationModified' do let(:rule_class) { Nanoc::Int::OutdatednessRules::ConfigurationModified } context 'non-outdated' do let(:config) { Nanoc::Int::Configuration.new } before { checksum_store.add(config) } it { is_expected.not_to be } end context 'outdated' do let(:config) { Nanoc::Int::Configuration.new } let(:config_old) { Nanoc::Int::Configuration.new(hash: { foo: 125 }) } before { checksum_store.add(config_old) } it { is_expected.to be } end end context 'NotWritten' do let(:rule_class) { Nanoc::Int::OutdatednessRules::NotWritten } context 'no path' do before { item_rep.paths = {} } it { is_expected.not_to be } end context 'path' do let(:path) { 'foo.txt' } before { item_rep.raw_paths = { last: path } } context 'not written' do it { is_expected.to be } end context 'written' do before { File.write(path, 'hello') } it { is_expected.not_to be } end end end context 'ContentModified' do let(:rule_class) { Nanoc::Int::OutdatednessRules::ContentModified } context 'item' do let(:obj) { item } before { reps << item_rep } context 'no checksum available' do it { is_expected.to be } end context 'checksum available and same' do before { checksum_store.add(item) } it { is_expected.not_to be } end context 'checksum available, but content different' do let(:old_item) { Nanoc::Int::Item.new('other stuff!!!!', {}, '/foo.md') } before { checksum_store.add(old_item) } it { is_expected.to be } end context 'checksum available, but attributes different' do let(:old_item) { Nanoc::Int::Item.new('stuff', { greeting: 'hi' }, '/foo.md') } before { checksum_store.add(old_item) } it { is_expected.not_to be } end end context 'item rep' do let(:obj) { item_rep } context 'no checksum available' do it { is_expected.to be } end context 'checksum available and same' do before { checksum_store.add(item) } it { is_expected.not_to be } end context 'checksum available, but content different' do let(:old_item) { Nanoc::Int::Item.new('other stuff!!!!', {}, '/foo.md') } before { checksum_store.add(old_item) } it { is_expected.to be } end context 'checksum available, but attributes different' do let(:old_item) { Nanoc::Int::Item.new('stuff', { greeting: 'hi' }, '/foo.md') } before { checksum_store.add(old_item) } it { is_expected.not_to be } end end end context 'AttributesModified' do let(:rule_class) { Nanoc::Int::OutdatednessRules::AttributesModified } context 'item' do let(:obj) { item } before { reps << item_rep } context 'no checksum available' do it { is_expected.to be } end context 'checksum available and same' do before { checksum_store.add(item) } it { is_expected.not_to be } end context 'checksum available, but content different' do let(:old_item) { Nanoc::Int::Item.new('other stuff!!!!', {}, '/foo.md') } before { checksum_store.add(old_item) } it { is_expected.not_to be } end context 'checksum available, but attributes different' do let(:old_item) { Nanoc::Int::Item.new('stuff', { greeting: 'hi' }, '/foo.md') } before { checksum_store.add(old_item) } it { is_expected.to be } end end context 'item rep' do let(:obj) { item_rep } context 'no checksum available' do it { is_expected.to be } end context 'checksum available and same' do before { checksum_store.add(item) } it { is_expected.not_to be } end context 'checksum available, but content different' do let(:old_item) { Nanoc::Int::Item.new('other stuff!!!!', {}, '/foo.md') } before { checksum_store.add(old_item) } it { is_expected.not_to be } end context 'checksum available, but attributes different' do let(:old_item) { Nanoc::Int::Item.new('stuff', { greeting: 'hi' }, '/foo.md') } before { checksum_store.add(old_item) } it { is_expected.to be } end end end context 'RulesModified' do let(:rule_class) { Nanoc::Int::OutdatednessRules::RulesModified } let(:old_mem) do Nanoc::Int::RuleMemory.new(item_rep).tap do |mem| mem.add_filter(:erb, {}) end end before do rule_memory_store[item_rep] = old_mem.serialize allow(action_provider).to receive(:memory_for).with(item_rep).and_return(new_mem) end context 'memory is the same' do let(:new_mem) { old_mem } it { is_expected.not_to be } end context 'memory is different' do let(:new_mem) do Nanoc::Int::RuleMemory.new(item_rep).tap do |mem| mem.add_filter(:erb, {}) mem.add_filter(:donkey, {}) end end it { is_expected.to be } end end context 'PathsModified' do let(:rule_class) { Nanoc::Int::OutdatednessRules::PathsModified } before do allow(action_provider).to receive(:memory_for).with(item_rep).and_return(new_mem) end context 'old mem does not exist' do let(:new_mem) do Nanoc::Int::RuleMemory.new(item_rep).tap do |mem| mem.add_snapshot(:donkey, '/foo.md') mem.add_filter(:asdf, {}) end end it { is_expected.to be } end context 'old mem exists' do let(:old_mem) do Nanoc::Int::RuleMemory.new(item_rep).tap do |mem| mem.add_filter(:erb, {}) mem.add_snapshot(:donkey, '/foo.md') end end before do rule_memory_store[item_rep] = old_mem.serialize end context 'paths in memory are the same' do let(:new_mem) do Nanoc::Int::RuleMemory.new(item_rep).tap do |mem| mem.add_snapshot(:donkey, '/foo.md') mem.add_filter(:asdf, {}) end end it { is_expected.not_to be } end context 'paths in memory are different' do let(:new_mem) do Nanoc::Int::RuleMemory.new(item_rep).tap do |mem| mem.add_filter(:erb, {}) mem.add_snapshot(:donkey, '/foo.md') mem.add_filter(:donkey, {}) mem.add_snapshot(:giraffe, '/bar.md') end end it { is_expected.to be } end end end describe '#{Content,Attributes}Modified' do subject do # TODO: remove negation [ Nanoc::Int::OutdatednessRules::ContentModified, Nanoc::Int::OutdatednessRules::AttributesModified, ].map { |c| !c.instance.apply(new_obj, outdatedness_checker) } end let(:stored_obj) { raise 'override me' } let(:new_obj) { raise 'override me' } shared_examples 'a document' do let(:stored_obj) { klass.new('a', {}, '/foo.md') } let(:new_obj) { stored_obj } context 'no checksum data' do context 'not stored' do it { is_expected.to eql([false, false]) } end context 'stored' do before { checksum_store.add(stored_obj) } context 'but content changed afterwards' do let(:new_obj) { klass.new('aaaaaaaa', {}, '/foo.md') } it { is_expected.to eql([false, true]) } end context 'but attributes changed afterwards' do let(:new_obj) { klass.new('a', { animal: 'donkey' }, '/foo.md') } it { is_expected.to eql([true, false]) } end context 'and unchanged' do it { is_expected.to eql([true, true]) } end end end context 'checksum_data' do let(:stored_obj) { klass.new('a', {}, '/foo.md', checksum_data: 'cs-data') } let(:new_obj) { stored_obj } context 'not stored' do it { is_expected.to eql([false, false]) } end context 'stored' do before { checksum_store.add(stored_obj) } context 'but checksum data afterwards' do let(:new_obj) { klass.new('a', {}, '/foo.md', checksum_data: 'cs-data-new') } it { is_expected.to eql([false, false]) } end context 'and unchanged' do it { is_expected.to eql([true, true]) } end end end context 'content_checksum_data' do let(:stored_obj) { klass.new('a', {}, '/foo.md', content_checksum_data: 'cs-data') } let(:new_obj) { stored_obj } context 'not stored' do it { is_expected.to eql([false, false]) } end context 'stored' do before { checksum_store.add(stored_obj) } context 'but checksum data afterwards' do let(:new_obj) { klass.new('a', {}, '/foo.md', content_checksum_data: 'cs-data-new') } it { is_expected.to eql([false, true]) } end context 'and unchanged' do it { is_expected.to eql([true, true]) } end end end context 'attributes_checksum_data' do let(:stored_obj) { klass.new('a', {}, '/foo.md', attributes_checksum_data: 'cs-data') } let(:new_obj) { stored_obj } context 'not stored' do it { is_expected.to eql([false, false]) } end context 'stored' do before { checksum_store.add(stored_obj) } context 'but checksum data afterwards' do let(:new_obj) { klass.new('a', {}, '/foo.md', attributes_checksum_data: 'cs-data-new') } it { is_expected.to eql([true, false]) } end context 'and unchanged' do it { is_expected.to eql([true, true]) } end end end end context 'item' do let(:klass) { Nanoc::Int::Item } it_behaves_like 'a document' end context 'layout' do let(:klass) { Nanoc::Int::Layout } it_behaves_like 'a document' end # … end end end nanoc-4.4.7/spec/nanoc/base/repos/0000755000004100000410000000000013033443476016755 5ustar www-datawww-datananoc-4.4.7/spec/nanoc/base/repos/compiled_content_cache_spec.rb0000644000004100000410000000250713033443476024771 0ustar www-datawww-datadescribe Nanoc::Int::CompiledContentCache do let(:cache) { described_class.new(items: items) } let(:items) { [item] } let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo.md') } let(:item_rep) { Nanoc::Int::ItemRep.new(item, :default) } let(:other_item) { Nanoc::Int::Item.new('asdf', {}, '/sneaky.md') } let(:other_item_rep) { Nanoc::Int::ItemRep.new(other_item, :default) } let(:content) { Nanoc::Int::Content.create('omg') } it 'has no content by default' do expect(cache[item_rep]).to be_nil end context 'setting content on known item' do before { cache[item_rep] = { last: content } } it 'has content' do expect(cache[item_rep][:last].string).to eql('omg') end context 'after storing and loading' do before do cache.store cache.load end it 'has content' do expect(cache[item_rep][:last].string).to eql('omg') end end end context 'setting content on unknown item' do before { cache[other_item_rep] = { last: content } } it 'has content' do expect(cache[other_item_rep][:last].string).to eql('omg') end context 'after storing and loading' do before do cache.store cache.load end it 'has no content' do expect(cache[other_item_rep]).to be_nil end end end end nanoc-4.4.7/spec/nanoc/base/repos/checksum_store_spec.rb0000644000004100000410000000615513033443476023341 0ustar www-datawww-datadescribe Nanoc::Int::ChecksumStore do let(:store) { described_class.new(objects: objects) } let(:objects) { [item, code_snippet] } let(:item) { Nanoc::Int::Item.new('asdf', {}, '/foo.md') } let(:other_item) { Nanoc::Int::Item.new('asdf', {}, '/sneaky.md') } let(:code_snippet) { Nanoc::Int::CodeSnippet.new('def hi ; end', 'lib/foo.rb') } let(:other_code_snippet) { Nanoc::Int::CodeSnippet.new('def ho ; end', 'lib/bar.rb') } context 'nothing added' do it 'has no checksum' do expect(store[item]).to be_nil end it 'has no content checksum' do expect(store.content_checksum_for(item)).to be_nil end it 'has no attributes checksum' do expect(store.attributes_checksum_for(item)).to be_nil end end context 'setting content on known non-document' do before { store.add(code_snippet) } it 'has checksum' do expect(store[code_snippet]).not_to be_nil end it 'has no content checksum' do expect(store.content_checksum_for(code_snippet)).to be_nil end it 'has no attributes checksum' do expect(store.attributes_checksum_for(code_snippet)).to be_nil end context 'after storing and loading' do before do store.store store.load end it 'has checksum' do expect(store[code_snippet]).not_to be_nil end end end context 'setting content on unknown non-document' do before { store.add(other_code_snippet) } it 'has checksum' do expect(store[other_code_snippet]).not_to be_nil end it 'has no content checksum' do expect(store.content_checksum_for(other_code_snippet)).to be_nil end it 'has no attributes checksum' do expect(store.attributes_checksum_for(other_code_snippet)).to be_nil end context 'after storing and loading' do before do store.store store.load end it 'has no checksum' do expect(store[other_code_snippet]).to be_nil end end end context 'setting content on known item' do before { store.add(item) } it 'has checksum' do expect(store[item]).not_to be_nil end it 'has content checksum' do expect(store.content_checksum_for(item)).not_to be_nil end it 'has attributes checksum' do expect(store.attributes_checksum_for(item)).not_to be_nil end context 'after storing and loading' do before do store.store store.load end it 'has checksum' do expect(store[item]).not_to be_nil end end end context 'setting content on unknown item' do before { store.add(other_item) } it 'has checksum' do expect(store[other_item]).not_to be_nil end it 'has content checksum' do expect(store.content_checksum_for(other_item)).not_to be_nil end it 'has attributes checksum' do expect(store.attributes_checksum_for(other_item)).not_to be_nil end context 'after storing and loading' do before do store.store store.load end it 'has no checksum' do expect(store[other_item]).to be_nil end end end end nanoc-4.4.7/spec/nanoc/base/repos/dependency_store_spec.rb0000644000004100000410000001524513033443476023655 0ustar www-datawww-datadescribe Nanoc::Int::DependencyStore do let(:store) { described_class.new(objects) } let(:objects) do [obj_a, obj_b, obj_c] end let(:obj_a) { Nanoc::Int::Item.new('a', {}, '/a.md') } let(:obj_b) { Nanoc::Int::Item.new('b', {}, '/b.md') } let(:obj_c) { Nanoc::Int::Item.new('c', {}, '/c.md') } describe '#dependencies_causing_outdatedness_of' do context 'no dependencies' do it 'returns nothing for each' do expect(store.dependencies_causing_outdatedness_of(obj_a)).to be_empty expect(store.dependencies_causing_outdatedness_of(obj_b)).to be_empty expect(store.dependencies_causing_outdatedness_of(obj_c)).to be_empty end end context 'one dependency' do context 'no props' do before do # FIXME: weird argument order (obj_b depends on obj_a, not th other way around) store.record_dependency(obj_a, obj_b) end it 'returns one dependency' do deps = store.dependencies_causing_outdatedness_of(obj_a) expect(deps.size).to eql(1) end it 'returns dependency from b to a' do deps = store.dependencies_causing_outdatedness_of(obj_a) expect(deps[0].from).to eql(obj_b) expect(deps[0].to).to eql(obj_a) end it 'returns true for all props by default' do deps = store.dependencies_causing_outdatedness_of(obj_a) expect(deps[0].props.raw_content?).to eq(true) expect(deps[0].props.attributes?).to eq(true) expect(deps[0].props.compiled_content?).to eq(true) expect(deps[0].props.path?).to eq(true) end it 'returns nothing for the others' do expect(store.dependencies_causing_outdatedness_of(obj_b)).to be_empty expect(store.dependencies_causing_outdatedness_of(obj_c)).to be_empty end end context 'one prop' do before do # FIXME: weird argument order (obj_b depends on obj_a, not th other way around) store.record_dependency(obj_a, obj_b, compiled_content: true) end it 'returns false for all unspecified props' do deps = store.dependencies_causing_outdatedness_of(obj_a) expect(deps[0].props.raw_content?).to eq(false) expect(deps[0].props.attributes?).to eq(false) expect(deps[0].props.path?).to eq(false) end it 'returns the specified props' do deps = store.dependencies_causing_outdatedness_of(obj_a) expect(deps[0].props.compiled_content?).to eq(true) end end context 'two props' do before do # FIXME: weird argument order (obj_b depends on obj_a, not th other way around) store.record_dependency(obj_a, obj_b, compiled_content: true) store.record_dependency(obj_a, obj_b, attributes: true) end it 'returns false for all unspecified props' do deps = store.dependencies_causing_outdatedness_of(obj_a) expect(deps[0].props.raw_content?).to eq(false) expect(deps[0].props.path?).to eq(false) end it 'returns the specified props' do deps = store.dependencies_causing_outdatedness_of(obj_a) expect(deps[0].props.attributes?).to eq(true) expect(deps[0].props.compiled_content?).to eq(true) end end end context 'two dependency in a chain' do before do # FIXME: weird argument order (obj_b depends on obj_a, not th other way around) store.record_dependency(obj_a, obj_b) store.record_dependency(obj_b, obj_c) end it 'returns one dependency for object A' do deps = store.dependencies_causing_outdatedness_of(obj_a) expect(deps.size).to eql(1) expect(deps[0].from).to eql(obj_b) end it 'returns one dependency for object B' do deps = store.dependencies_causing_outdatedness_of(obj_b) expect(deps.size).to eql(1) expect(deps[0].from).to eql(obj_c) end it 'returns nothing for the others' do expect(store.dependencies_causing_outdatedness_of(obj_c)).to be_empty end end end describe 'reloading' do before do store.record_dependency(obj_a, obj_b, compiled_content: true) store.record_dependency(obj_a, obj_b, attributes: true) store.store store.objects = objects_after store.load end context 'no new objects' do let(:objects_after) { objects } it 'has the right dependencies for item A' do deps = store.dependencies_causing_outdatedness_of(obj_a) expect(deps.size).to eql(1) expect(deps[0].from).to eql(obj_b) expect(deps[0].to).to eql(obj_a) expect(deps[0].props.raw_content?).to eq(false) expect(deps[0].props.attributes?).to eq(true) expect(deps[0].props.compiled_content?).to eq(true) expect(deps[0].props.path?).to eq(false) end it 'has the right dependencies for item B' do deps = store.dependencies_causing_outdatedness_of(obj_b) expect(deps).to be_empty end it 'has the right dependencies for item C' do deps = store.dependencies_causing_outdatedness_of(obj_c) expect(deps).to be_empty end end context 'one new object' do let(:objects_after) do [obj_a, obj_b, obj_c, obj_d] end let(:obj_d) { Nanoc::Int::Item.new('d', {}, '/d.md') } it 'marks existing items as outdated' do expect(store.objects_causing_outdatedness_of(obj_a)).to eq([obj_d]) expect(store.objects_causing_outdatedness_of(obj_b)).to eq([obj_d]) expect(store.objects_causing_outdatedness_of(obj_c)).to eq([obj_d]) end it 'marks new items as outdated' do expect(store.objects_causing_outdatedness_of(obj_d)).to eq([obj_d]) end end context 'two new objects' do let(:objects_after) do [obj_a, obj_b, obj_c, obj_d, obj_e] end let(:obj_d) { Nanoc::Int::Item.new('d', {}, '/d.md') } let(:obj_e) { Nanoc::Int::Item.new('e', {}, '/e.md') } it 'marks existing items as outdated' do # Only one of obj D or E needed! expect(store.objects_causing_outdatedness_of(obj_a)).to eq([obj_d]).or eq([obj_e]) expect(store.objects_causing_outdatedness_of(obj_b)).to eq([obj_d]).or eq([obj_e]) expect(store.objects_causing_outdatedness_of(obj_c)).to eq([obj_d]).or eq([obj_e]) end it 'marks new items as outdated' do # Only one of obj D or E needed! expect(store.objects_causing_outdatedness_of(obj_d)).to eq([obj_d]).or eq([obj_e]) expect(store.objects_causing_outdatedness_of(obj_e)).to eq([obj_d]).or eq([obj_e]) end end end end nanoc-4.4.7/spec/nanoc/base/repos/site_loader_spec.rb0000644000004100000410000001477713033443476022626 0ustar www-datawww-datadescribe Nanoc::Int::SiteLoader do let(:loader) { described_class.new } describe '#new_empty' do subject { loader.new_empty } it 'has the default configuration' do expect(subject.config).to be_a(Nanoc::Int::Configuration) expect(subject.config[:index_filenames]).to eq(['index.html']) end it 'has no code snippets' do expect(subject.code_snippets).to be_empty end it 'has no items' do expect(subject.items).to be_empty end it 'has no layouts' do expect(subject.layouts).to be_empty end end describe '#new_with_config' do subject { loader.new_with_config(arg) } let(:arg) { { foo: 'bar' } } it 'has a slightly modified configuration' do expect(subject.config).to be_a(Nanoc::Int::Configuration) expect(subject.config[:index_filenames]).to eq(['index.html']) expect(subject.config[:foo]).to eq('bar') end it 'has no code snippets' do expect(subject.code_snippets).to be_empty end it 'has no items' do expect(subject.items).to be_empty end it 'has no layouts' do expect(subject.layouts).to be_empty end end describe '#new_from_cwd' do subject { loader.new_from_cwd } context 'no config file' do it 'errors' do expect { subject }.to raise_error( Nanoc::Int::ConfigLoader::NoConfigFileFoundError, ) end end shared_examples 'a directory with a config file' do it 'has the default configuration' do expect(subject.config).to be_a(Nanoc::Int::Configuration) expect(subject.config[:index_filenames]).to eq(['index.html']) expect(subject.config[:foo]).to eq('bar') end it 'has no code snippets' do expect(subject.code_snippets).to be_empty end it 'has no items' do expect(subject.items).to be_empty end it 'has no layouts' do expect(subject.layouts).to be_empty end context 'some items, layouts, and code snippets' do before do FileUtils.mkdir_p('lib') File.write('lib/foo.rb', '$spirit_animal = :donkey') FileUtils.mkdir_p('content') File.write('content/about.md', 'I am Denis!') FileUtils.mkdir_p('layouts') File.write('layouts/page.erb', '<%= yield %>') end it 'has a code snippet' do expect(subject.code_snippets.size).to eq(1) expect(subject.code_snippets[0].data).to eq('$spirit_animal = :donkey') end it 'has an item' do expect(subject.items.size).to eq(1) expect(subject.items['/about.md'].content).to be_a(Nanoc::Int::TextualContent) expect(subject.items['/about.md'].content.string).to eq('I am Denis!') expect(subject.items['/about.md'].attributes[:content_filename]) .to eq('content/about.md') expect(subject.items['/about.md'].attributes[:extension]) .to eq('md') expect(subject.items['/about.md'].attributes[:filename]) .to eq('content/about.md') expect(subject.items['/about.md'].attributes[:meta_filename]) .to be_nil expect(subject.items['/about.md'].attributes[:mtime]) .to be > Time.now - 5 expect(subject.items['/about.md'].identifier.to_s).to eq('/about.md') end it 'has a layout' do expect(subject.layouts.size).to eq(1) expect(subject.layouts['/page.erb'].content).to be_a(Nanoc::Int::TextualContent) expect(subject.layouts['/page.erb'].content.string).to eq('<%= yield %>') expect(subject.layouts['/page.erb'].attributes[:content_filename]) .to eq('layouts/page.erb') expect(subject.layouts['/page.erb'].attributes[:extension]) .to eq('erb') expect(subject.layouts['/page.erb'].attributes[:filename]) .to eq('layouts/page.erb') expect(subject.layouts['/page.erb'].attributes[:meta_filename]) .to be_nil expect(subject.layouts['/page.erb'].attributes[:mtime]) .to be > Time.now - 5 expect(subject.layouts['/page.erb'].identifier.to_s).to eq('/page.erb') end end end context 'nanoc.yaml config file' do before do File.write('nanoc.yaml', "---\nfoo: bar\n") end it_behaves_like 'a directory with a config file' end context 'config.yaml config file' do before do File.write('config.yaml', "---\nfoo: bar\n") end it_behaves_like 'a directory with a config file' end context 'configuration has non-existant data source' do before do File.write('nanoc.yaml', <<-EOS.gsub(/^ {10}/, '')) data_sources: - type: eenvaleed EOS end it 'raises an error' do expect { subject }.to raise_error(Nanoc::Int::Errors::UnknownDataSource) end end context 'environments defined' do before do File.write('nanoc.yaml', <<-EOS.gsub(/^ {10}/, '')) animal: donkey environments: staging: animal: giraffe EOS end before do expect(ENV).to receive(:fetch).with('NANOC_ENV', 'default').and_return('staging') end it 'does not load environment' do expect(subject.config[:animal]).to eq('giraffe') end end context 'code snippet with data source implementation' do before do FileUtils.mkdir_p('lib') File.write('lib/foo_data_source.rb', <<-EOS.gsub(/^ {10}/, '')) class FooDataSource < Nanoc::DataSource identifier :site_loader_spec_sample def items [ Nanoc::Int::Item.new( 'Generated content!', { generated: true }, '/generated.txt', ) ] end end EOS File.write('nanoc.yaml', <<-EOS.gsub(/^ {10}/, '')) data_sources: - type: site_loader_spec_sample EOS end it 'loads code snippets before items/layouts' do expect(subject.items.size).to eq(1) expect(subject.items['/generated.txt'].content).to be_a(Nanoc::Int::TextualContent) expect(subject.items['/generated.txt'].content.string).to eq('Generated content!') expect(subject.items['/generated.txt'].attributes).to eq(generated: true) expect(subject.items['/generated.txt'].identifier.to_s).to eq('/generated.txt') end end end end nanoc-4.4.7/spec/nanoc/base/repos/outdatedness_store_spec.rb0000644000004100000410000000404613033443476024236 0ustar www-datawww-datadescribe Nanoc::Int::OutdatednessStore do subject(:store) { described_class.new(site: site, reps: reps) } let(:site) { double(:site) } let(:reps) { Nanoc::Int::ItemRepRepo.new } let(:item) { Nanoc::Int::Item.new('foo', {}, '/foo.md') } let(:rep) { Nanoc::Int::ItemRep.new(item, :foo) } let(:site) do Nanoc::Int::Site.new( config: config, code_snippets: code_snippets, items: items, layouts: layouts, ) end let(:config) { Nanoc::Int::Configuration.new.with_defaults } let(:items) { [] } let(:layouts) { [] } let(:code_snippets) { [] } describe '#include?, #add and #remove' do subject { store.include?(rep) } context 'nothing added' do it { is_expected.not_to be } end context 'rep added' do before { store.add(rep) } it { is_expected.to be } end context 'rep added and removed' do before do store.add(rep) store.remove(rep) end it { is_expected.not_to be } end context 'rep added, removed, and added again' do before do store.add(rep) store.remove(rep) store.add(rep) end it { is_expected.to be } end end describe '#to_a' do subject { store.to_a } context 'nothing added' do it { is_expected.to be_empty } end context 'one rep added' do before { store.add(rep) } it { is_expected.to eql([rep]) } end end describe 'reloading' do subject do store.store store.load store.include?(rep) end context 'not added' do context 'rep part of new reps' do before { reps << rep } it { is_expected.not_to be } end context 'rep not part of new reps' do it { is_expected.not_to be } end end context 'added' do before { store.add(rep) } context 'rep part of new reps' do before { reps << rep } it { is_expected.to be } end context 'rep not part of new reps' do it { is_expected.not_to be } end end end end nanoc-4.4.7/spec/nanoc/base/repos/config_loader_spec.rb0000644000004100000410000001507713033443476023121 0ustar www-datawww-datadescribe Nanoc::Int::ConfigLoader do let(:loader) { described_class.new } describe '#new_from_cwd' do subject { loader.new_from_cwd } context 'no config file present' do it 'errors' do expect { subject }.to raise_error( Nanoc::Int::ConfigLoader::NoConfigFileFoundError, ) end end context 'config file present' do before do File.write('nanoc.yaml', YAML.dump(foo: 'bar')) end it 'returns a configuration' do expect(subject).to be_a(Nanoc::Int::Configuration) end it 'has the defaults' do expect(subject[:output_dir]).to eq('output') end it 'has the custom option' do expect(subject[:foo]).to eq('bar') end end context 'config file and parent present' do before do File.write('nanoc.yaml', YAML.dump(parent_config_file: 'parent.yaml')) File.write('parent.yaml', YAML.dump(foo: 'bar')) end it 'returns the configuration' do expect(subject).to be_a(Nanoc::Int::Configuration) end it 'has the defaults' do expect(subject[:output_dir]).to eq('output') end it 'has the custom option' do expect(subject[:foo]).to eq('bar') end it 'does not include parent config option' do expect(subject[:parent_config_file]).to be_nil end end context 'config file present, environment defined' do let(:active_env_name) { 'default' } let(:config) do { foo: 'bar', tofoo: 'bar', environments: { test: { foo: 'test-bar' }, default: { foo: 'default-bar' }, }, } end before do File.write('nanoc.yaml', YAML.dump(config)) end before do expect(ENV).to receive(:fetch).with('NANOC_ENV', 'default').and_return(active_env_name) end it 'returns the configuration' do expect(subject).to be_a(Nanoc::Int::Configuration) end it 'has option defined not within environments' do expect(subject[:tofoo]).to eq('bar') end context 'current env is test' do let(:active_env_name) { 'test' } it 'has the test environment custom option' do expect(subject[:foo]).to eq('test-bar') end end it 'has the default environment custom option' do expect(subject[:foo]).to eq('default-bar') end end end describe '.cwd_is_nanoc_site? + .config_filename_for_cwd' do context 'no config files' do it 'is not considered a nanoc site dir' do expect(described_class.cwd_is_nanoc_site?).to eq(false) expect(described_class.config_filename_for_cwd).to be_nil end end context 'nanoc.yaml config file' do before do File.write('nanoc.yaml', 'stuff') end it 'is considered a nanoc site dir' do expect(described_class.cwd_is_nanoc_site?).to eq(true) expect(described_class.config_filename_for_cwd).to eq(File.expand_path('nanoc.yaml')) end end context 'config.yaml config file' do before do File.write('config.yaml', 'stuff') end it 'is considered a nanoc site dir' do expect(described_class.cwd_is_nanoc_site?).to eq(true) expect(described_class.config_filename_for_cwd).to eq(File.expand_path('config.yaml')) end end end describe '#apply_parent_config' do subject { loader.apply_parent_config(config, processed_paths) } let(:config) { Nanoc::Int::Configuration.new(hash: { foo: 'bar' }) } let(:processed_paths) { ['nanoc.yaml'] } context 'no parent_config_file' do it 'returns self' do expect(subject).to eq(config) end end context 'parent config file is set' do let(:config) do Nanoc::Int::Configuration.new(hash: { parent_config_file: 'foo.yaml', foo: 'bar' }) end context 'parent config file is not present' do it 'errors' do expect { subject }.to raise_error( Nanoc::Int::ConfigLoader::NoParentConfigFileFoundError, ) end end context 'parent config file is present' do context 'parent-child cycle' do before do File.write('foo.yaml', 'parent_config_file: bar.yaml') File.write('bar.yaml', 'parent_config_file: foo.yaml') end it 'errors' do expect { subject }.to raise_error( Nanoc::Int::ConfigLoader::CyclicalConfigFileError, ) end end context 'self parent-child cycle' do before do File.write('foo.yaml', 'parent_config_file: foo.yaml') end it 'errors' do expect { subject }.to raise_error( Nanoc::Int::ConfigLoader::CyclicalConfigFileError, ) end end context 'no parent-child cycle' do before do File.write('foo.yaml', 'animal: giraffe') end it 'returns a configuration' do expect(subject).to be_a(Nanoc::Int::Configuration) end it 'has no defaults (added in #new_from_cwd only)' do expect(subject[:output_dir]).to be_nil end it 'inherits options from parent' do expect(subject[:animal]).to eq('giraffe') end it 'takes options from child' do expect(subject[:foo]).to eq('bar') end it 'does not include parent config option' do expect(subject[:parent_config_file]).to be_nil end end context 'long parent chain' do before do File.write('foo.yaml', "parrots: 43\nparent_config_file: bar.yaml\n") File.write('bar.yaml', "day_one: lasers\nslugs: false\n") end it 'returns a configuration' do expect(subject).to be_a(Nanoc::Int::Configuration) end it 'has no defaults (added in #new_from_cwd only)' do expect(subject[:output_dir]).to be_nil end it 'inherits options from grandparent' do expect(subject[:day_one]).to eq('lasers') expect(subject[:slugs]).to eq(false) end it 'inherits options from parent' do expect(subject[:parrots]).to eq(43) end it 'takes options from child' do expect(subject[:foo]).to eq('bar') end it 'does not include parent config option' do expect(subject[:parent_config_file]).to be_nil end end end end end end nanoc-4.4.7/spec/nanoc/base/compiler_spec.rb0000644000004100000410000001761113033443476021004 0ustar www-datawww-datadescribe Nanoc::Int::Compiler do let(:compiler) do described_class.new( site, compiled_content_cache: compiled_content_cache, checksum_store: checksum_store, rule_memory_store: rule_memory_store, action_provider: action_provider, dependency_store: dependency_store, outdatedness_checker: outdatedness_checker, reps: reps, outdatedness_store: outdatedness_store, ) end let(:checksum_store) { Nanoc::Int::ChecksumStore.new(objects: items) } let(:rule_memory_store) { Nanoc::Int::RuleMemoryStore.new } let(:dependency_store) { Nanoc::Int::DependencyStore.new(items.to_a) } let(:reps) { Nanoc::Int::ItemRepRepo.new } let(:outdatedness_checker) { double(:outdatedness_checker) } let(:outdatedness_store) { Nanoc::Int::OutdatednessStore.new(site: site, reps: reps) } let(:action_provider) { double(:action_provider) } let(:compiled_content_cache) { Nanoc::Int::CompiledContentCache.new(items: items) } let(:rep) { Nanoc::Int::ItemRep.new(item, :default) } let(:item) { Nanoc::Int::Item.new('<%= 1 + 2 %>', {}, '/hi.md') } let(:other_rep) { Nanoc::Int::ItemRep.new(other_item, :default) } let(:other_item) { Nanoc::Int::Item.new('other content', {}, '/other.md') } let(:site) do Nanoc::Int::Site.new( config: config, code_snippets: code_snippets, items: items, layouts: layouts, ) end let(:config) { Nanoc::Int::Configuration.new.with_defaults } let(:layouts) { [] } let(:code_snippets) { [] } let(:items) do Nanoc::Int::IdentifiableCollection.new(config).tap do |col| col << item col << other_item end end let(:memory) do actions = [ Nanoc::Int::ProcessingActions::Filter.new(:erb, {}), Nanoc::Int::ProcessingActions::Snapshot.new(:last, nil), ] Nanoc::Int::RuleMemory.new(nil, actions: actions) end before do reps << rep reps << other_rep reps.each do |rep| rep.snapshot_defs << Nanoc::Int::SnapshotDef.new(:last) end allow(outdatedness_checker).to receive(:outdated?).with(rep).and_return(true) allow(outdatedness_checker).to receive(:outdated?).with(other_rep).and_return(true) allow(action_provider).to receive(:memory_for).with(rep).and_return(memory) allow(action_provider).to receive(:memory_for).with(other_rep).and_return(memory) end describe '#compile_reps' do subject do compiler.send(:determine_outdatedness) compiler.send(:compile_reps) end before do allow(action_provider).to receive(:snapshots_defs_for).with(rep).and_return(snapshot_defs_for_rep) allow(action_provider).to receive(:snapshots_defs_for).with(other_rep).and_return(snapshot_defs_for_rep) end let(:snapshot_defs_for_rep) do [Nanoc::Int::SnapshotDef.new(:last)] end let(:snapshot_defs_for_other_rep) do [Nanoc::Int::SnapshotDef.new(:last)] end it 'compiles individual reps' do expect { subject }.to change { rep.snapshot_contents[:last].string } .from('<%= 1 + 2 %>') .to('3') end it 'removes the item rep from the outdatedness store' do expect(compiler.outdatedness_store.include?(rep)).not_to be expect { subject }.not_to change { compiler.outdatedness_store.include?(rep) } end context 'rep in outdatedness store' do before do compiler.outdatedness_store.add(rep) end it 'removes the item rep from the outdatedness store' do expect { subject }.to change { compiler.outdatedness_store.include?(rep) }.from(true).to(false) end end context 'exception' do let(:item) { Nanoc::Int::Item.new('<%= raise "lol" %>', {}, '/hi.md') } it 'wraps exception' do expect { subject }.to raise_error(Nanoc::Int::Errors::CompilationError) end it 'contains the right item rep in the wrapped exception' do expect { subject }.to raise_error do |err| expect(err.item_rep).to eql(rep) end end it 'contains the right wrapped exception' do expect { subject }.to raise_error do |err| expect(err.unwrap).to be_a(RuntimeError) expect(err.unwrap.message).to eq('lol') end end it 'adds the item rep to the outdatedness store' do expect { subject rescue nil }.to change { compiler.outdatedness_store.include?(rep) }.from(false).to(true) end context 'rep in outdatedness store' do before do compiler.outdatedness_store.add(rep) end it 'keeps the item rep in the outdatedness store' do expect(compiler.outdatedness_store.include?(rep)).to be expect { subject rescue nil }.not_to change { compiler.outdatedness_store.include?(rep) } end end end end describe '#compile_rep' do let(:stage) { compiler.send(:compile_reps_stage) } subject { stage.send(:compile_rep, rep, is_outdated: is_outdated) } let(:is_outdated) { true } it 'generates expected output' do expect(rep.snapshot_contents[:last].string).to eql(item.content.string) subject expect(rep.snapshot_contents[:last].string).to eql('3') end it 'generates notifications in the proper order' do expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:compilation_started, rep).ordered expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:filtering_started, rep, :erb).ordered expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:filtering_ended, rep, :erb).ordered expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:compilation_ended, rep).ordered subject end context 'interrupted compilation' do let(:item) { Nanoc::Int::Item.new('other=<%= @items["/other.*"].compiled_content %>', {}, '/hi.md') } before do expect(action_provider).to receive(:memory_for).with(other_rep).and_return(memory) end it 'generates expected output' do expect(rep.snapshot_contents[:last].string).to eql(item.content.string) expect { stage.send(:compile_rep, rep, is_outdated: true) } .to raise_error(Nanoc::Int::Errors::UnmetDependency) stage.send(:compile_rep, other_rep, is_outdated: true) stage.send(:compile_rep, rep, is_outdated: true) expect(rep.snapshot_contents[:last].string).to eql('other=other content') end it 'generates notifications in the proper order' do # rep 1 expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:compilation_started, rep).ordered expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:filtering_started, rep, :erb).ordered expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:dependency_created, item, other_item).ordered expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:compilation_suspended, rep, anything).ordered # rep 2 expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:compilation_started, other_rep).ordered expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:filtering_started, other_rep, :erb).ordered expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:filtering_ended, other_rep, :erb).ordered expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:compilation_ended, other_rep).ordered # rep 1 (again) expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:compilation_started, rep).ordered expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:filtering_ended, rep, :erb).ordered expect(Nanoc::Int::NotificationCenter).to receive(:post).with(:compilation_ended, rep).ordered expect { stage.send(:compile_rep, rep, is_outdated: true) } .to raise_error(Nanoc::Int::Errors::UnmetDependency) stage.send(:compile_rep, other_rep, is_outdated: true) stage.send(:compile_rep, rep, is_outdated: true) end end end end nanoc-4.4.7/spec/nanoc/filters/0000755000004100000410000000000013033443476016363 5ustar www-datawww-datananoc-4.4.7/spec/nanoc/filters/less_spec.rb0000644000004100000410000000674413033443476020703 0ustar www-datawww-datadescribe Nanoc::Filters::Less, site: true, stdio: true, v8: true do # These tests are high-level in order to interact well with the compiler. This is important for # this :less filter, because of the way it handles fibers. before do File.open('Rules', 'w') do |io| io.write "compile '/**/*.less' do\n" io.write " filter :less\n" io.write " write item.identifier.without_ext + '.css'\n" io.write "end\n" end end context 'one file' do let(:content_a) { 'p { color: red; }' } before do File.write('content/a.less', content_a) end it 'compiles a.less' do Nanoc::CLI.run(%w(compile)) expect(File.read('output/a.css')).to match(/^p\s*\{\s*color:\s*red;?\s*\}/) end context 'with compression' do let(:content_a) { '.foo { bar: a; } .bar { foo: b; }' } before do File.open('Rules', 'w') do |io| io.write "compile '/*.less' do\n" io.write " filter :less, compress: true\n" io.write " write item.identifier.without_ext + '.css'\n" io.write "end\n" end end it 'compiles and compresses a.less' do Nanoc::CLI.run(%w(compile)) expect(File.read('output/a.css')).to match(/^\.foo\{bar:a\}\n?\.bar\{foo:b\}/) end end end context 'two files' do let(:content_a) { '@import "b.less";' } let(:content_b) { 'p { color: red; }' } before do File.write('content/a.less', content_a) File.write('content/b.less', content_b) end it 'compiles a.less' do Nanoc::CLI.run(%w(compile)) expect(File.read('output/a.css')).to match(/^p\s*\{\s*color:\s*red;?\s*\}/) end it 'recompiles a.less if b.less has changed' do Nanoc::CLI.run(%w(compile)) File.write('content/b.less', 'p { color: blue; }') Nanoc::CLI.run(%w(compile)) expect(File.read('output/a.css')).to match(/^p\s*\{\s*color:\s*blue;?\s*\}/) end end context 'paths relative to site directory' do let(:content_a) { '@import "content/foo/bar/imported_file.less";' } let(:content_b) { 'p { color: red; }' } before do FileUtils.mkdir_p('content/foo/bar') File.write('content/a.less', content_a) File.write('content/foo/bar/imported_file.less', content_b) end it 'compiles a.less' do Nanoc::CLI.run(%w(compile)) expect(File.read('output/a.css')).to match(/^p\s*\{\s*color:\s*red;?\s*\}/) end it 'recompiles a.less if b.less has changed' do Nanoc::CLI.run(%w(compile)) File.write('content/foo/bar/imported_file.less', 'p { color: blue; }') Nanoc::CLI.run(%w(compile)) expect(File.read('output/a.css')).to match(/^p\s*\{\s*color:\s*blue;?\s*\}/) end end context 'paths relative to current file' do let(:content_a) { '@import "bar/imported_file.less";' } let(:content_b) { 'p { color: red; }' } before do FileUtils.mkdir_p('content/foo/bar') File.write('content/foo/a.less', content_a) File.write('content/foo/bar/imported_file.less', content_b) end it 'compiles a.less' do Nanoc::CLI.run(%w(compile)) expect(File.read('output/foo/a.css')).to match(/^p\s*\{\s*color:\s*red;?\s*\}/) end it 'recompiles a.less if b.less has changed' do Nanoc::CLI.run(%w(compile)) File.write('content/foo/bar/imported_file.less', 'p { color: blue; }') Nanoc::CLI.run(%w(compile)) expect(File.read('output/foo/a.css')).to match(/^p\s*\{\s*color:\s*blue;?\s*\}/) end end end nanoc-4.4.7/spec/nanoc/filters/colorize_syntax/0000755000004100000410000000000013033443476021617 5ustar www-datawww-datananoc-4.4.7/spec/nanoc/filters/colorize_syntax/rouge_spec.rb0000644000004100000410000001270413033443476024303 0ustar www-datawww-datarequire 'rouge' describe Nanoc::Filters::ColorizeSyntax, filter: true, rouge: true do subject { filter.setup_and_run(input, default_colorizer: :rouge, rouge: params) } let(:filter) { ::Nanoc::Filters::ColorizeSyntax.new } let(:params) { {} } let(:wrap) { false } let(:css_class) { 'highlight' } let(:input) do <<-EOS.freeze before 

  def foo
  end
after EOS end let(:output) do <<-EOS before 
  def foo
  end
after EOS end context 'with Rouge' do context 'with 1.x', if: Rouge.version < '2' do context 'with default options' do it { is_expected.to eql output } end context 'with pygments wrapper' do let(:wrap) { true } let(:params) { super().merge(wrap: wrap) } it { is_expected.to eql output } context 'with css_class' do let(:css_class) { 'nanoc' } let(:params) { super().merge(css_class: css_class) } it { is_expected.to eql output } end end context 'with line number' do let(:line_numbers) { true } let(:params) { super().merge(line_numbers: line_numbers) } let(:output) do <<-EOS before 


1
2


  def foo
  end
after EOS end it { is_expected.to eql output } end end context 'with 2.x', if: Rouge.version >= '2' do context 'with default options' do it { is_expected.to eql output } end context 'with legacy' do let(:legacy) { true } let(:params) { super().merge(legacy: legacy) } it { is_expected.to eql output } context 'with pygments wrapper' do let(:wrap) { true } let(:params) { super().merge(wrap: wrap) } it { is_expected.to eql output } context 'with css_class' do let(:css_class) { 'nanoc' } let(:params) { super().merge(css_class: css_class) } it { is_expected.to eql output } end end context 'with line number' do let(:line_numbers) { true } let(:params) { super().merge(line_numbers: line_numbers) } let(:output) do <<-EOS before 


1
2



  def foo
  end
after EOS end it { is_expected.to eql output } end end context 'with formater' do let(:params) { super().merge(formatter: formatter) } context 'with inline' do let(:formatter) { Rouge::Formatters::HTMLInline.new(theme) } context 'with github theme' do let(:theme) { Rouge::Themes::Github.new } let(:output) do <<-EOS before 
  def foo
  end
after EOS end it { is_expected.to eql output } end context 'with colorful theme' do let(:theme) { Rouge::Themes::Colorful.new } let(:output) do <<-EOS before 
  def foo
  end
after EOS end it { is_expected.to eql output } end end context 'with linewise' do let(:formatter) { Rouge::Formatters::HTMLLinewise.new(Rouge::Formatters::HTML.new) } let(:output) do <<-EOS before 
  def foo



  end
after EOS end it { is_expected.to eql output } end context 'with pygments' do let(:wrap) { true } let(:css_class) { 'codehilite' } let(:formatter) { Rouge::Formatters::HTMLPygments.new(Rouge::Formatters::HTML.new) } it { is_expected.to eql output } end context 'with table' do let(:formatter) { Rouge::Formatters::HTMLTable.new(Rouge::Formatters::HTML.new) } let(:output) do <<-EOS before 


1
2



  def foo
  end
after EOS end it { is_expected.to eql output } end end end end end nanoc-4.4.7/spec/nanoc/extra/0000755000004100000410000000000013033443476016036 5ustar www-datawww-datananoc-4.4.7/spec/nanoc/extra/parallel_collection_spec.rb0000644000004100000410000000425713033443476023414 0ustar www-datawww-datadescribe Nanoc::Extra::ParallelCollection do subject(:col) { described_class.new(wrapped, parallelism: parallelism) } let(:wrapped) { [1, 2, 3, 4, 5] } let(:parallelism) { 5 } describe '#each' do subject do col.each do |e| sleep 0.1 out << e end end let!(:out) { [] } it 'is fast' do expect { subject }.to finish_in_under(0.25).seconds end it 'is correct' do expect { subject }.to change { out.sort }.from([]).to([1, 2, 3, 4, 5]) end it 'does not leave threads lingering' do expect { subject }.not_to change { Thread.list.size } end context 'errors' do subject do col.each do |e| if e == 1 sleep 0.02 raise 'ugh' else sleep 0.1 out << e end end end let(:parallelism) { 3 } it 'raises' do expect { subject }.to raise_error(RuntimeError, 'ugh') end it 'aborts early' do expect { subject rescue nil }.to change { out.sort }.from([]).to([2, 3]) end end context 'low parallelism' do let(:parallelism) { 1 } it 'is not fast' do expect { subject }.not_to finish_in_under(0.5).seconds end end end describe '#map' do subject do col.map do |e| sleep 0.1 e * 10 end end it 'is fast' do expect { subject }.to finish_in_under(0.25).seconds end it 'does not leave threads lingering' do expect { subject }.not_to change { Thread.list.size } end it 'is correct' do expect(subject.sort).to eq([10, 20, 30, 40, 50]) end context 'errors' do subject do col.each do |e| if e == 1 sleep 0.02 raise 'ugh' else sleep 0.1 e * 10 end end end let(:parallelism) { 3 } it 'raises' do expect { subject }.to raise_error(RuntimeError, 'ugh') end end context 'low parallelism' do let(:parallelism) { 1 } it 'is not fast' do expect { subject }.not_to finish_in_under(0.5).seconds end end end end nanoc-4.4.7/spec/nanoc/regressions/0000755000004100000410000000000013033443476017256 5ustar www-datawww-datananoc-4.4.7/spec/nanoc/regressions/gh_767_spec.rb0000644000004100000410000000074513033443476021624 0ustar www-datawww-datadescribe 'GH-767', site: true do before do File.write('content/donkey.md', 'Compiled content donkey!') File.write('Rules', <') File.write('nanoc.yaml', <http://example.com/foo/}) expect(contents).to match(%r{2015-03-02}) end it 'updates the sitemap' do Nanoc::CLI.run(%w(compile)) File.write('content/foo.txt', 'foo 2') FileUtils.touch('content/foo.txt', mtime: Time.parse('2016-04-03 10:00:00Z')) Nanoc::CLI.run(%w(compile)) expect(File.file?('output/sitemap.xml')).to be contents = File.read('output/sitemap.xml') expect(contents).to match(%r{http://example.com/foo/}) expect(contents).to match(%r{2016-04-03}) end end nanoc-4.4.7/spec/nanoc/regressions/gh_970b_spec.rb0000644000004100000410000000273013033443476021756 0ustar www-datawww-datadescribe 'GH-970 (show-data)', site: true, stdio: true do before do File.write('content/foo.md', 'foo') File.write('content/bar.md', '<%= @items["/foo.*"].compiled_content %>') File.write('Rules', <') File.write('content/bar.txt', 'foo=<%= @items["/foo.*"].compiled_content %>') File.write('layouts/default.erb', '*<%= yield %>*') File.write('Rules', <!') File.write('content/items-view.md', 'Frozen? <%= @items.frozen? %>!') File.write('Rules', <<%= raise "boom" %>') expect { Nanoc::CLI.run(%w(compile)) }.to raise_error(Nanoc::Int::Errors::CompilationError) expect(File.read('output/foo.md')).to eql('I am foo!') File.write('content/bar.md', '[<%= @items["/foo.*"].compiled_content %>]') Nanoc::CLI.run(%w(compile)) expect(File.read('output/foo.md')).to eql('I am foo!') expect(File.read('output/bar.md')).to eql('[I am foo!]') end end nanoc-4.4.7/spec/nanoc/regressions/gh_970a_spec.rb0000644000004100000410000000056213033443476021756 0ustar www-datawww-datadescribe 'GH-970 (show-rules)', site: true, stdio: true do before do File.write('content/foo.md', 'foo') File.write('Rules', <]') File.open('nanoc.yaml', 'w') do |io| io << 'string_pattern_type: legacy' << "\n" io << 'data_sources:' << "\n" io << ' -' << "\n" io << ' type: filesystem' << "\n" io << ' identifier_type: legacy' << "\n" end File.write('Rules', <') File.write('Rules', < - <%= Time.now.to_f %>", ) File.write('Rules', <') File.write('Rules', <') Nanoc::CLI.run(%w(compile)) expect(File.read('output/hello.html')).to include('donkeys?') end end nanoc-4.4.7/spec/nanoc/regressions/gh_833_spec.rb0000644000004100000410000000045613033443476021615 0ustar www-datawww-datadescribe 'GH-833', site: true, stdio: true do before do File.write('content/foo.md', 'stuff') File.write('Rules', <]') File.write('content/bar.md', 'I am bar!') File.write('lib/stuff.rb', < :binary def run(content, params = {}) File.write(output_filename, content) end end EOS File.write('Rules', <root') File.write('content/bar.md', 'bar root') File.write('content/bar-copy.md', '<%= @items["/bar.*"].compiled_content(snapshot: :last) %>') File.write('Rules', <root') # Path is not relativized expect(File.read('output/bar-copy.html')).to eq('bar root') end end nanoc-4.4.7/spec/nanoc/regressions/gh_937_spec.rb0000644000004100000410000000130313033443476021612 0ustar www-datawww-datadescribe 'GH-937', site: true, stdio: true do before do File.write('content/style.sass', ".test\n color: red") File.write( 'nanoc.yaml', "sass_style: compact\nenvironments:\n staging:\n sass_style: expanded", ) File.write('Rules', <]') File.write('content/bar.md', 'I am bar!') File.write('Rules', <]') File.write('Rules', <<% raise "boom" %>') File.write('Rules', <') expect { Nanoc::CLI.run(%w(compile --verbose --debug)) rescue nil } .to output(/skip.*output\/foo\.html/).to_stdout expect { Nanoc::CLI.run(%w(show-data --no-color)) } .to(output(/^item \/foo\.md, rep default:\n is not outdated/).to_stdout) expect { Nanoc::CLI.run(%w(show-data --no-color)) } .to(output(/^item \/bar\.md, rep default:\n is outdated: /).to_stdout) end end nanoc-4.4.7/spec/nanoc/integration/outdatedness_integration_spec.rb0000644000004100000410000001573413033443476025714 0ustar www-datawww-datadescribe 'Outdatedness integration', site: true, stdio: true do context 'only attribute dependency' do let(:time) { Time.now } before do File.write('content/foo.md', "---\ntitle: hello\n---\n\nfoo") File.write('content/bar.md', '<%= @items["/foo.*"][:title] %>') FileUtils.touch('content/foo.md', mtime: time) FileUtils.touch('content/bar.md', mtime: time) File.write('Rules', <') File.write('Rules', < / <%= @items["/foo.*"][:title] %>') File.write('Rules', < [:erb, {}], } end it { is_expected.to be_nil } end context 'one matching rule' do let(:mapping) do { '/foo.*' => [:erb, {}], } end it 'is the single one' do expect(subject).to eq([:erb, {}]) end end context 'multiple matching rules' do let(:mapping) do { '/foo.*' => [:erb, {}], '/*' => [:haml, {}], } end it 'is the first one' do expect(subject).to eq([:erb, {}]) end end end end nanoc-4.4.7/spec/nanoc/rule_dsl/rule_context_spec.rb0000644000004100000410000001372413033443476022605 0ustar www-datawww-datadescribe(Nanoc::RuleDSL::RuleContext) do subject(:rule_context) do described_class.new(rep: rep, site: site, executor: executor, view_context: view_context) end let(:item_identifier) { Nanoc::Identifier.new('/foo.md') } let(:item) { Nanoc::Int::Item.new('content', {}, item_identifier) } let(:config) { Nanoc::Int::Configuration.new } let(:items) { Nanoc::Int::IdentifiableCollection.new(config) } let(:layouts) { Nanoc::Int::IdentifiableCollection.new(config) } let(:rep) { double(:rep, item: item) } let(:site) { double(:site, items: items, layouts: layouts, config: config) } let(:executor) { double(:executor) } let(:reps) { double(:reps) } let(:compilation_context) { double(:compilation_context) } let(:view_context) { Nanoc::ViewContext.new(reps: reps, items: items, dependency_tracker: dependency_tracker, compilation_context: compilation_context) } let(:dependency_tracker) { double(:dependency_tracker) } describe '#initialize' do it 'wraps objects in view classes' do expect(subject.rep.class).to eql(Nanoc::ItemRepView) expect(subject.item.class).to eql(Nanoc::ItemWithoutRepsView) expect(subject.config.class).to eql(Nanoc::ConfigView) expect(subject.layouts.class).to eql(Nanoc::LayoutCollectionView) expect(subject.items.class).to eql(Nanoc::ItemCollectionWithoutRepsView) end it 'contains the right objects' do expect(rule_context.rep.unwrap).to eql(rep) expect(rule_context.item.unwrap).to eql(item) expect(rule_context.config.unwrap).to eql(config) expect(rule_context.layouts.unwrap).to eql(layouts) expect(rule_context.items.unwrap).to eql(items) end end describe '#item' do subject { rule_context.item } it 'is a view without reps access' do expect(subject.class).to eql(Nanoc::ItemWithoutRepsView) end it 'contains the right item' do expect(subject.unwrap).to eql(item) end context 'with legacy identifier and children/parent' do let(:item_identifier) { Nanoc::Identifier.new('/foo/', type: :legacy) } let(:parent_identifier) { Nanoc::Identifier.new('/', type: :legacy) } let(:parent) { Nanoc::Int::Item.new('parent', {}, parent_identifier) } let(:child_identifier) { Nanoc::Identifier.new('/foo/bar/', type: :legacy) } let(:child) { Nanoc::Int::Item.new('child', {}, child_identifier) } before do items << item items << parent items << child end it 'has a parent' do expect(subject.parent.unwrap).to eql(parent) end it 'wraps the parent in a view without reps access' do expect(subject.parent.class).to eql(Nanoc::ItemWithoutRepsView) expect(subject.parent).not_to respond_to(:compiled_content) expect(subject.parent).not_to respond_to(:path) expect(subject.parent).not_to respond_to(:reps) end it 'has children' do expect(subject.children.map(&:unwrap)).to eql([child]) end it 'wraps the children in a view without reps access' do expect(subject.children.map(&:class)).to eql([Nanoc::ItemWithoutRepsView]) expect(subject.children[0]).not_to respond_to(:compiled_content) expect(subject.children[0]).not_to respond_to(:path) expect(subject.children[0]).not_to respond_to(:reps) end end end describe '#items' do subject { rule_context.items } let(:item_identifier) { Nanoc::Identifier.new('/foo/', type: :legacy) } let(:parent_identifier) { Nanoc::Identifier.new('/', type: :legacy) } let(:parent) { Nanoc::Int::Item.new('parent', {}, parent_identifier) } let(:child_identifier) { Nanoc::Identifier.new('/foo/bar/', type: :legacy) } let(:child) { Nanoc::Int::Item.new('child', {}, child_identifier) } before do items << item items << parent items << child end it 'is a view without reps access' do expect(subject.class).to eql(Nanoc::ItemCollectionWithoutRepsView) end it 'contains all items' do expect(subject.unwrap).to match_array([item, parent, child]) end it 'provides no rep access' do expect(subject['/']).not_to be_nil expect(subject['/']).not_to respond_to(:compiled_content) expect(subject['/']).not_to respond_to(:path) expect(subject['/']).not_to respond_to(:reps) expect(subject['/foo/']).not_to be_nil expect(subject['/foo/']).not_to respond_to(:compiled_content) expect(subject['/foo/']).not_to respond_to(:path) expect(subject['/foo/']).not_to respond_to(:reps) expect(subject['/foo/bar/']).not_to be_nil expect(subject['/foo/bar/']).not_to respond_to(:compiled_content) expect(subject['/foo/bar/']).not_to respond_to(:path) expect(subject['/foo/bar/']).not_to respond_to(:reps) end end describe '#filter' do subject { rule_context.filter(filter_name, filter_args) } let(:filter_name) { :donkey } let(:filter_args) { { color: 'grey' } } it 'makes a request to the executor' do expect(executor).to receive(:filter).with(filter_name, filter_args) subject end end describe '#layout' do subject { rule_context.layout(layout_identifier, extra_filter_args) } let(:layout_identifier) { '/default.*' } let(:extra_filter_args) { { color: 'grey' } } it 'makes a request to the executor' do expect(executor).to receive(:layout).with(layout_identifier, extra_filter_args) subject end end describe '#snapshot' do subject { rule_context.snapshot(snapshot_name, path: path) } let(:snapshot_name) { :for_snippet } let(:path) { '/foo.html' } it 'makes a request to the executor' do expect(executor).to receive(:snapshot).with(:for_snippet, path: '/foo.html') subject end end describe '#write' do subject { rule_context.write(path) } let(:path) { '/foo.html' } it 'makes a request to the executor' do expect(executor).to receive(:snapshot).with(:last, path: '/foo.html') subject end end end nanoc-4.4.7/spec/nanoc/rule_dsl/rule_memory_calculator_spec.rb0000644000004100000410000002047613033443476024644 0ustar www-datawww-datadescribe(Nanoc::RuleDSL::RuleMemoryCalculator) do subject(:rule_memory_calculator) do described_class.new(site: site, rules_collection: rules_collection) end let(:rules_collection) { Nanoc::RuleDSL::RulesCollection.new } let(:site) { double(:site) } describe '#[]' do subject { rule_memory_calculator[obj] } context 'with item rep' do let(:obj) { Nanoc::Int::ItemRep.new(item, :csv) } let(:item) { Nanoc::Int::Item.new('content', {}, Nanoc::Identifier.from('/list.md')) } let(:config) { Nanoc::Int::Configuration.new.with_defaults } let(:items) { Nanoc::Int::IdentifiableCollection.new(config) } let(:layouts) { Nanoc::Int::IdentifiableCollection.new(config) } let(:site) { double(:site, items: items, layouts: layouts, config: config, compiler: compiler) } let(:compiler) { double(:compiler, compilation_context: compilation_context) } let(:compilation_context) { double(:compilation_context) } let(:view_context) { double(:view_context) } before do expect(compilation_context).to receive(:create_view_context).and_return(view_context) end context 'no rules exist' do it 'raises error' do error = Nanoc::RuleDSL::RuleMemoryCalculator::NoRuleMemoryForItemRepException expect { subject }.to raise_error(error) end end context 'rules exist' do before do rules_proc = proc do filter :erb, speed: :over_9000 layout '/default.*' filter :typohero end rule = Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/list.*'), :csv, rules_proc) rules_collection.add_item_compilation_rule(rule) end example do subject expect(subject[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot) expect(subject[0].snapshot_name).to eql(:raw) expect(subject[0].path).to be_nil expect(subject[1]).to be_a(Nanoc::Int::ProcessingActions::Filter) expect(subject[1].filter_name).to eql(:erb) expect(subject[1].params).to eql(speed: :over_9000) expect(subject[2]).to be_a(Nanoc::Int::ProcessingActions::Snapshot) expect(subject[2].snapshot_name).to eql(:pre) expect(subject[2].path).to be_nil expect(subject[3]).to be_a(Nanoc::Int::ProcessingActions::Layout) expect(subject[3].layout_identifier).to eql('/default.*') expect(subject[3].params).to be_nil expect(subject[4]).to be_a(Nanoc::Int::ProcessingActions::Filter) expect(subject[4].filter_name).to eql(:typohero) expect(subject[4].params).to eql({}) expect(subject[5]).to be_a(Nanoc::Int::ProcessingActions::Snapshot) expect(subject[5].snapshot_name).to eql(:post) expect(subject[5].path).to be_nil expect(subject[6]).to be_a(Nanoc::Int::ProcessingActions::Snapshot) expect(subject[6].snapshot_name).to eql(:last) expect(subject[6].path).to be_nil expect(subject.size).to eql(7) end end context 'no routing rule exists' do before do # Add compilation rule compilation_rule = Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/list.*'), :csv, proc {}) rules_collection.add_item_compilation_rule(compilation_rule) end example do subject expect(subject[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot) expect(subject[0].snapshot_name).to eql(:raw) expect(subject[0].path).to be_nil expect(subject[1]).to be_a(Nanoc::Int::ProcessingActions::Snapshot) expect(subject[1].snapshot_name).to eql(:last) expect(subject[1].path).to be_nil expect(subject.size).to eql(2) end end context 'routing rule exists' do before do # Add compilation rule compilation_rule = Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/list.*'), :csv, proc {}) rules_collection.add_item_compilation_rule(compilation_rule) # Add routing rule routing_rule = Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/list.*'), :csv, proc { '/foo.md' }, snapshot_name: :last) rules_collection.add_item_routing_rule(routing_rule) end example do subject expect(subject[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot) expect(subject[0].snapshot_name).to eql(:raw) expect(subject[0].path).to be_nil expect(subject[1]).to be_a(Nanoc::Int::ProcessingActions::Snapshot) expect(subject[1].snapshot_name).to eql(:last) expect(subject[1].path).to eq('/foo.md') expect(subject.size).to eql(2) end end context 'routing rule for other rep exists' do before do # Add compilation rule compilation_rule = Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/list.*'), :csv, proc {}) rules_collection.add_item_compilation_rule(compilation_rule) # Add routing rule routing_rule = Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/list.*'), :abc, proc { '/foo.md' }, snapshot_name: :last) rules_collection.add_item_routing_rule(routing_rule) end example do subject expect(subject[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot) expect(subject[0].snapshot_name).to eql(:raw) expect(subject[0].path).to be_nil expect(subject[1]).to be_a(Nanoc::Int::ProcessingActions::Snapshot) expect(subject[1].snapshot_name).to eql(:last) expect(subject[1].path).to be_nil expect(subject.size).to eql(2) end end end context 'with layout' do let(:obj) { Nanoc::Int::Layout.new('content', {}, '/default.erb') } context 'no rules exist' do it 'raises error' do error = Nanoc::RuleDSL::RuleMemoryCalculator::NoRuleMemoryForLayoutException expect { subject }.to raise_error(error) end end context 'rule exists' do before do pat = Nanoc::Int::Pattern.from('/*.erb') rules_collection.layout_filter_mapping[pat] = [:erb, { x: 123 }] end it 'contains memory for the rule' do expect(subject.size).to eql(1) expect(subject[0]).to be_a(Nanoc::Int::ProcessingActions::Filter) expect(subject[0].filter_name).to eql(:erb) expect(subject[0].params).to eql(x: 123) end end end context 'with something else' do let(:obj) { :donkey } it 'errors' do error = Nanoc::RuleDSL::RuleMemoryCalculator::UnsupportedObjectTypeException expect { subject }.to raise_error(error) end end end describe '#snapshots_defs_for' do subject { rule_memory_calculator.snapshots_defs_for(rep) } let(:rep) { Nanoc::Int::ItemRep.new(item, :csv) } let(:item) { Nanoc::Int::Item.new('content', {}, Nanoc::Identifier.from('/list.md')) } let(:config) { Nanoc::Int::Configuration.new.with_defaults } let(:items) { Nanoc::Int::IdentifiableCollection.new(config) } let(:layouts) { Nanoc::Int::IdentifiableCollection.new(config) } let(:site) { double(:site, items: items, layouts: layouts, config: config, compiler: compiler) } let(:compiler) { double(:compiler, compilation_context: compilation_context) } let(:compilation_context) { double(:compilation_context) } let(:view_context) { double(:view_context) } before do rules_proc = proc do filter :erb, speed: :over_9000 layout '/default.*' filter :typohero end rule = Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/list.*'), :csv, rules_proc) rules_collection.add_item_compilation_rule(rule) expect(compilation_context).to receive(:create_view_context).and_return(view_context) end example do expect(subject[0]).to be_a(Nanoc::Int::SnapshotDef) expect(subject[0].name).to eql(:raw) expect(subject[1]).to be_a(Nanoc::Int::SnapshotDef) expect(subject[1].name).to eql(:pre) expect(subject[2]).to be_a(Nanoc::Int::SnapshotDef) expect(subject[2].name).to eql(:post) expect(subject[3]).to be_a(Nanoc::Int::SnapshotDef) expect(subject[3].name).to eql(:last) expect(subject.size).to eql(4) end end end nanoc-4.4.7/spec/nanoc/rule_dsl/recording_executor_spec.rb0000644000004100000410000001121613033443476023756 0ustar www-datawww-datadescribe Nanoc::RuleDSL::RecordingExecutor do let(:executor) { described_class.new(rule_memory) } let(:rule_memory) { Nanoc::Int::RuleMemory.new(rep) } let(:rep) { double(:rep) } describe '#filter' do it 'records filter call without arguments' do executor.filter(:erb) expect(rule_memory.size).to eql(1) expect(rule_memory[0]).to be_a(Nanoc::Int::ProcessingActions::Filter) expect(rule_memory[0].filter_name).to eql(:erb) expect(rule_memory[0].params).to eql({}) end it 'records filter call with arguments' do executor.filter(:erb, x: 123) expect(rule_memory.size).to eql(1) expect(rule_memory[0]).to be_a(Nanoc::Int::ProcessingActions::Filter) expect(rule_memory[0].filter_name).to eql(:erb) expect(rule_memory[0].params).to eql(x: 123) end end describe '#layout' do it 'records layout call without arguments' do executor.layout('/default.*') expect(rule_memory.size).to eql(2) expect(rule_memory[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot) expect(rule_memory[0].snapshot_name).to eql(:pre) expect(rule_memory[0].path).to be_nil expect(rule_memory[1]).to be_a(Nanoc::Int::ProcessingActions::Layout) expect(rule_memory[1].layout_identifier).to eql('/default.*') expect(rule_memory[1].params).to eql({}) end it 'records layout call with arguments' do executor.layout('/default.*', donkey: 123) expect(rule_memory.size).to eql(2) expect(rule_memory[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot) expect(rule_memory[0].snapshot_name).to eql(:pre) expect(rule_memory[0].path).to be_nil expect(rule_memory[1]).to be_a(Nanoc::Int::ProcessingActions::Layout) expect(rule_memory[1].layout_identifier).to eql('/default.*') expect(rule_memory[1].params).to eql(donkey: 123) end it 'fails when passed a symbol' do expect { executor.layout(:default, donkey: 123) }.to raise_error(ArgumentError) end end describe '#snapshot' do context 'snapshot already exists' do before do executor.snapshot(:foo) end it 'raises when creating same snapshot' do expect { executor.snapshot(:foo) } .to raise_error(Nanoc::Int::Errors::CannotCreateMultipleSnapshotsWithSameName) end end context 'no arguments' do subject { executor.snapshot(:foo) } it 'records' do subject expect(rule_memory.size).to eql(1) expect(rule_memory[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot) expect(rule_memory[0].snapshot_name).to eql(:foo) expect(rule_memory[0].path).to be_nil end end context 'final argument' do subject { executor.snapshot(:foo, path: path) } let(:path) { nil } context 'routing rule does not exist' do context 'no explicit path given' do it 'records' do subject expect(rule_memory.size).to eql(1) expect(rule_memory[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot) expect(rule_memory[0].snapshot_name).to eql(:foo) expect(rule_memory[0].path).to be_nil end end context 'explicit path given as string' do let(:path) { '/routed-foo.html' } it 'records' do subject expect(rule_memory.size).to eql(1) expect(rule_memory[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot) expect(rule_memory[0].snapshot_name).to eql(:foo) expect(rule_memory[0].path).to eql('/routed-foo.html') end end context 'explicit path given as identifier' do let(:path) { Nanoc::Identifier.from('/routed-foo.html') } it 'records' do subject expect(rule_memory.size).to eql(1) expect(rule_memory[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot) expect(rule_memory[0].snapshot_name).to eql(:foo) expect(rule_memory[0].path).to eql('/routed-foo.html') end end end end it 'raises when given unknown arguments' do expect { executor.snapshot(:foo, animal: 'giraffe') } .to raise_error(ArgumentError) end it 'can create multiple snapshots with different names' do executor.snapshot(:foo) executor.snapshot(:bar) expect(rule_memory.size).to eql(2) expect(rule_memory[0]).to be_a(Nanoc::Int::ProcessingActions::Snapshot) expect(rule_memory[0].snapshot_name).to eql(:foo) expect(rule_memory[1]).to be_a(Nanoc::Int::ProcessingActions::Snapshot) expect(rule_memory[1].snapshot_name).to eql(:bar) end end end nanoc-4.4.7/spec/nanoc/cli/0000755000004100000410000000000013033443476015462 5ustar www-datawww-datananoc-4.4.7/spec/nanoc/cli/commands/0000755000004100000410000000000013033443476017263 5ustar www-datawww-datananoc-4.4.7/spec/nanoc/cli/commands/compile/0000755000004100000410000000000013033443476020713 5ustar www-datawww-datananoc-4.4.7/spec/nanoc/cli/commands/compile/file_action_printer_spec.rb0000644000004100000410000000452513033443476026277 0ustar www-datawww-datadescribe Nanoc::CLI::Commands::Compile::FileActionPrinter, stdio: true do let(:listener) { described_class.new(reps: reps) } before { Timecop.freeze(Time.local(2008, 1, 2, 14, 5, 0)) } after { Timecop.return } let(:reps) do Nanoc::Int::ItemRepRepo.new.tap do |reps| reps << rep end end let(:item) { Nanoc::Int::Item.new('<%= 1 + 2 %>', {}, '/hi.md') } let(:rep) do Nanoc::Int::ItemRep.new(item, :default).tap do |rep| rep.raw_paths = { default: '/hi.html' } end end it 'records from compilation_started to rep_written' do listener.start Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0)) Nanoc::Int::NotificationCenter.post(:compilation_started, rep) Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1)) expect { Nanoc::Int::NotificationCenter.post(:rep_written, rep, '/foo.html', true, true) } .to output(/create.*\[1\.00s\]/).to_stdout end it 'stops listening after #stop' do listener.start listener.stop Nanoc::Int::NotificationCenter.post(:compilation_started, rep) expect { Nanoc::Int::NotificationCenter.post(:rep_written, rep, '/foo.html', true, true) } .not_to output(/create/).to_stdout end it 'records from compilation_started over compilation_suspended to rep_written' do listener.start Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0)) Nanoc::Int::NotificationCenter.post(:compilation_started, rep) Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1)) Nanoc::Int::NotificationCenter.post(:compilation_suspended, rep, :__irrelevant__) Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 3)) Nanoc::Int::NotificationCenter.post(:compilation_started, rep) Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 6)) expect { Nanoc::Int::NotificationCenter.post(:rep_written, rep, '/foo.html', true, true) } .to output(/create.*\[4\.00s\]/).to_stdout end context 'log level = high' do before { listener.start } before { Nanoc::CLI::Logger.instance.level = :high } it 'prints skipped (uncompiled) reps' do expect { listener.stop } .not_to output(/skip/).to_stdout end end context 'log level = low' do before { listener.start } before { Nanoc::CLI::Logger.instance.level = :low } it 'prints nothing' do expect { listener.stop } .to output(/skip.*\/hi\.html/).to_stdout end end end nanoc-4.4.7/spec/nanoc/cli/commands/compile/timing_recorder_spec.rb0000644000004100000410000000472413033443476025435 0ustar www-datawww-datadescribe Nanoc::CLI::Commands::Compile::TimingRecorder, stdio: true do let(:listener) { described_class.new(reps: reps) } before { Timecop.freeze(Time.local(2008, 1, 2, 14, 5, 0)) } after { Timecop.return } let(:reps) do Nanoc::Int::ItemRepRepo.new.tap do |reps| reps << rep end end let(:item) { Nanoc::Int::Item.new('<%= 1 + 2 %>', {}, '/hi.md') } let(:rep) do Nanoc::Int::ItemRep.new(item, :default).tap do |rep| rep.raw_paths = { default: '/hi.html' } end end it 'records single from filtering_started to filtering_ended' do listener.start Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0)) Nanoc::Int::NotificationCenter.post(:filtering_started, rep, :erb) Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1)) Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :erb) expect { listener.stop } .to output(/^erb \| 1 1\.00s 1\.00s 1\.00s 1\.00s$/).to_stdout end it 'records multiple from filtering_started to filtering_ended' do listener.start Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0)) Nanoc::Int::NotificationCenter.post(:filtering_started, rep, :erb) Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1)) Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :erb) Timecop.freeze(Time.local(2008, 9, 1, 10, 14, 1)) Nanoc::Int::NotificationCenter.post(:filtering_started, rep, :erb) Timecop.freeze(Time.local(2008, 9, 1, 10, 14, 3)) Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :erb) expect { listener.stop } .to output(/^erb \| 2 1\.00s 1\.50s 2\.00s 3\.00s$/).to_stdout end it 'records single from filtering_started over compilation_{suspended,started} to filtering_ended' do listener.start Nanoc::Int::NotificationCenter.post(:compilation_started, rep) Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 0)) Nanoc::Int::NotificationCenter.post(:filtering_started, rep, :erb) Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 1)) Nanoc::Int::NotificationCenter.post(:compilation_suspended, rep, :__anything__) Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 3)) Nanoc::Int::NotificationCenter.post(:compilation_started, rep) Timecop.freeze(Time.local(2008, 9, 1, 10, 5, 7)) Nanoc::Int::NotificationCenter.post(:filtering_ended, rep, :erb) # FIXME: wrong count (should be 1, not 2) expect { listener.stop } .to output(/^erb \| 2 1\.00s 2\.50s 4\.00s 5\.00s$/).to_stdout end end nanoc-4.4.7/spec/nanoc/cli/commands/show_rules_spec.rb0000644000004100000410000000633313033443476023021 0ustar www-datawww-datadescribe Nanoc::CLI::Commands::ShowRules, stdio: true do describe '#run' do subject { runner.run } let(:runner) do described_class.new(options, arguments, command).tap do |runner| runner.site = site end end let(:options) { {} } let(:arguments) { [] } let(:command) { double(:command) } let(:site) do double( :site, items: items, layouts: layouts, compiler: compiler, ) end let(:items) do Nanoc::Int::IdentifiableCollection.new(config).tap do |ic| ic << Nanoc::Int::Item.new('About Me', {}, '/about.md') ic << Nanoc::Int::Item.new('About My Dog', {}, '/dog.md') ic << Nanoc::Int::Item.new('Raw Data', {}, '/other.dat') end end let(:reps) do Nanoc::Int::ItemRepRepo.new.tap do |reps| reps << Nanoc::Int::ItemRep.new(items['/about.md'], :default) reps << Nanoc::Int::ItemRep.new(items['/about.md'], :text) reps << Nanoc::Int::ItemRep.new(items['/dog.md'], :default) reps << Nanoc::Int::ItemRep.new(items['/dog.md'], :text) reps << Nanoc::Int::ItemRep.new(items['/other.dat'], :default) end end let(:layouts) do Nanoc::Int::IdentifiableCollection.new(config).tap do |ic| ic << Nanoc::Int::Layout.new('Default', {}, '/default.erb') ic << Nanoc::Int::Layout.new('Article', {}, '/article.haml') ic << Nanoc::Int::Layout.new('Other', {}, '/other.xyzzy') end end let(:config) { Nanoc::Int::Configuration.new } let(:action_provider) { double(:action_provider, rules_collection: rules_collection) } let(:compiler) { double(:compiler, action_provider: action_provider, reps: reps) } let(:rules_collection) do Nanoc::RuleDSL::RulesCollection.new.tap do |rc| rc.add_item_compilation_rule( Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/dog.*'), :default, proc {}), ) rc.add_item_compilation_rule( Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/*.md'), :default, proc {}), ) rc.add_item_compilation_rule( Nanoc::RuleDSL::Rule.new(Nanoc::Int::Pattern.from('/**/*'), :text, proc {}), ) rc.layout_filter_mapping[Nanoc::Int::Pattern.from('/*.haml')] = [:haml, {}] rc.layout_filter_mapping[Nanoc::Int::Pattern.from('/*.erb')] = [:erb, {}] end end let(:expected_out) do <<-EOS \e[1m\e[33mItem /about.md\e[0m: Rep default: /*.md Rep text: /**/* \e[1m\e[33mItem /dog.md\e[0m: Rep default: /dog.* Rep text: /**/* \e[1m\e[33mItem /other.dat\e[0m: Rep default: (none) \e[1m\e[33mLayout /article.haml\e[0m: /*.haml \e[1m\e[33mLayout /default.erb\e[0m: /*.erb \e[1m\e[33mLayout /other.xyzzy\e[0m: (none) EOS .gsub(/^ {8}/, '') end before do expect(compiler).to receive(:build_reps).once end it 'writes item and layout rules to stdout' do expect { subject }.to output(expected_out).to_stdout end it 'writes status informaion to stderr' do expect { subject }.to output("Loading site… done\n").to_stderr end end end nanoc-4.4.7/spec/nanoc/cli/commands/compile_spec.rb0000644000004100000410000000222713033443476022255 0ustar www-datawww-datadescribe Nanoc::CLI::Commands::Compile::Listener do let(:klass) do Class.new(described_class) do attr_reader :started attr_reader :stopped def initialize @started = false @stopped = false end def start @started = true end def stop @stopped = true end end end subject { klass.new } it 'starts' do subject.start expect(subject.started).to be end it 'stops' do subject.start subject.stop expect(subject.stopped).to be end it 'starts safely' do subject.start_safely expect(subject.started).to be end it 'stops safely' do subject.start_safely subject.stop_safely expect(subject.stopped).to be end context 'listener that does not start or stop properly' do let(:klass) do Class.new(described_class) do def start raise 'boom' end def stop raise 'boom' end end end it 'raises on start, but not stop' do expect { subject.start_safely }.to raise_error(RuntimeError) expect { subject.stop_safely }.not_to raise_error end end end nanoc-4.4.7/spec/nanoc/cli/commands/deploy_spec.rb0000644000004100000410000002161413033443476022122 0ustar www-datawww-datadescribe Nanoc::CLI::Commands::Shell, site: true, stdio: true do describe '#run' do let(:config) { {} } before do # Prevent double-loading expect(Nanoc::CLI).to receive(:setup) File.write('nanoc.yaml', YAML.dump(config)) end shared_examples 'no effective deploy' do it 'does not write any files' do expect { run rescue nil }.not_to change { Dir['remote/*'] } expect(Dir['remote/*']).to be_empty end end shared_examples 'effective deploy' do it 'writes files' do expect { run }.to change { Dir['remote/*'] }.from([]).to(['remote/success.txt']) expect(File.read('remote/success.txt')).to eql('hurrah') end end shared_examples 'attempted/effective deploy' do context 'no checks' do include_examples 'effective deploy' end context 'checks fail' do before do File.write( 'Checks', "check :donkey do\n" \ " add_issue('things are broken', subject: 'success.txt')\n" \ "end\n" \ "\n" \ "deploy_check :donkey\n", ) end include_examples 'no effective deploy' context 'checks disabled' do context '--no-check' do let(:command) { super() + ['--no-check'] } include_examples 'effective deploy' end context '--Ck' do let(:command) { super() + ['-C'] } include_examples 'effective deploy' end end end context 'checks pass' do before do File.write( 'Checks', "check :donkey do\n" \ "end\n" \ "\n" \ "deploy_check :donkey\n", ) end include_examples 'effective deploy' end end describe 'listing deployers' do shared_examples 'lists all deployers' do let(:run) { Nanoc::CLI.run(command) } it 'lists all deployers' do expect { run }.to output(/Available deployers:\n fog\n rsync/).to_stdout end include_examples 'no effective deploy' end context '--list-deployers' do let(:command) { %w(deploy --list-deployers) } include_examples 'lists all deployers' end context '-D' do let(:command) { %w(deploy -D) } include_examples 'lists all deployers' end end describe 'listing deployment configurations' do shared_examples 'lists all deployment configurations' do let(:run) { Nanoc::CLI.run(command) } context 'no deployment configurations' do let(:config) { { donkeys: 'lots' } } it 'says nothing is found' do expect { run }.to output(/No deployment configurations./).to_stdout end include_examples 'no effective deploy' end context 'some deployment configurations' do let(:config) do { deploy: { production: { kind: 'rsync', dst: 'remote', }, staging: { kind: 'rsync', dst: 'remote', }, }, } end it 'says some targets are found' do expect { run }.to output(/Available deployment configurations:\n production\n staging/).to_stdout end include_examples 'no effective deploy' end end context '--list' do let(:command) { %w(deploy --list) } include_examples 'lists all deployment configurations' end context '-L' do let(:command) { %w(deploy -L) } include_examples 'lists all deployment configurations' end end describe 'deploying' do let(:run) { Nanoc::CLI.run(command) } let(:command) { %w(deploy) } before do FileUtils.mkdir_p('output') FileUtils.mkdir_p('remote') File.write('output/success.txt', 'hurrah') end shared_examples 'missing kind warning' do it 'warns about missing kind' do expect { run }.to output(/Warning: The specified deploy target does not have a kind attribute. Assuming rsync./).to_stderr end end context 'no deploy configs' do it 'errors' do expect { run }.to raise_error( Nanoc::Int::Errors::GenericTrivial, 'The site has no deployment configurations.', ) end include_examples 'no effective deploy' context 'configuration created in preprocessor' do before do File.write( 'Rules', "preprocess do\n" \ " @config[:deploy] = {\n" \ " default: { dst: 'remote' },\n" \ " }\n" \ "end\n\n" + File.read('Rules'), ) end include_examples 'attempted/effective deploy' end end context 'some deploy configs' do let(:config) do { deploy: { irrelevant: { kind: 'rsync', dst: 'remote', }, }, } end context 'default target' do context 'requested deploy config does not exist' do it 'errors' do expect { run }.to raise_error( Nanoc::Int::Errors::GenericTrivial, 'The site has no deployment configuration named `default`.', ) end include_examples 'no effective deploy' end context 'requested deploy config exists' do let(:config) do { deploy: { default: { kind: 'rsync', dst: 'remote', }, }, } end include_examples 'attempted/effective deploy' context 'dry run' do let(:command) { super() + ['--dry-run'] } include_examples 'no effective deploy' end end context 'requested deploy config exists, but has no kind' do let(:config) do { deploy: { default: { dst: 'remote', }, }, } end include_examples 'attempted/effective deploy' include_examples 'missing kind warning' context 'dry run' do let(:command) { super() + ['--dry-run'] } include_examples 'no effective deploy' end end end shared_examples 'deploy with non-default target' do context 'requested deploy config does not exist' do it 'errors' do expect { run }.to raise_error( Nanoc::Int::Errors::GenericTrivial, 'The site has no deployment configuration named `production`.', ) end include_examples 'no effective deploy' end context 'requested deploy config exists' do let(:config) do { deploy: { production: { kind: 'rsync', dst: 'remote', }, }, } end include_examples 'attempted/effective deploy' context 'dry run' do let(:command) { (super() + ['--dry-run']) } include_examples 'no effective deploy' end end context 'requested deploy config exists, but has no kind' do let(:config) do { deploy: { production: { dst: 'remote', }, }, } end include_examples 'attempted/effective deploy' include_examples 'missing kind warning' context 'dry run' do let(:command) { (super() + ['--dry-run']) } include_examples 'no effective deploy' end end end context 'non-default target, specified as argument' do let(:command) { %w(deploy production) } include_examples 'deploy with non-default target' end context 'non-default target, specified as option (--target)' do let(:command) { %w(deploy --target production) } include_examples 'deploy with non-default target' end context 'multiple targets specified' do let(:command) { %w(deploy --target staging production) } it 'errors' do expect { run }.to raise_error( Nanoc::Int::Errors::GenericTrivial, 'Only one deployment target can be specified on the command line.', ) end end end end end end nanoc-4.4.7/spec/nanoc/cli/commands/shell_spec.rb0000644000004100000410000000304413033443476021732 0ustar www-datawww-datadescribe Nanoc::CLI::Commands::Shell, site: true, stdio: true do describe '#run' do before do # Prevent double-loading expect(Nanoc::CLI).to receive(:setup) end it 'can be invoked' do context = Object.new allow(Nanoc::Int::Context).to receive(:new).with(anything).and_return(context) expect(context).to receive(:pry) Nanoc::CLI.run(['shell']) end end describe '#env_for_site' do subject { described_class.env_for_site(site) } before do File.write('content/hello.md', 'Hello!') File.write('layouts/default.erb', 'MY SITE!<%= yield %>') end let(:site) do Nanoc::Int::SiteLoader.new.new_from_cwd end it 'returns views' do expect(subject[:items]).to be_a(Nanoc::ItemCollectionWithRepsView) expect(subject[:layouts]).to be_a(Nanoc::LayoutCollectionView) expect(subject[:config]).to be_a(Nanoc::ConfigView) end it 'returns correct items' do expect(subject[:items].size).to eq(1) expect(subject[:items].first.identifier.to_s).to eq('/hello.md') end it 'returns correct layouts' do expect(subject[:layouts].size).to eq(1) expect(subject[:layouts].first.identifier.to_s).to eq('/default.erb') end it 'returns items with reps' do expect(subject[:items].first.reps).not_to be_nil expect(subject[:items].first.reps.first.name).to eq(:default) end it 'returns items with rep paths' do expect(subject[:items].first.reps.first.path).to eq('/hello.md') end end end nanoc-4.4.7/spec/nanoc/cli/commands/view_spec.rb0000644000004100000410000000350713033443476021601 0ustar www-datawww-datarequire 'net/http' describe Nanoc::CLI::Commands::View, site: true, stdio: true do describe '#run' do def run_nanoc_cmd(cmd) pid = fork { Nanoc::CLI.run(cmd) } # Wait for server to start up 20.times do |i| begin Net::HTTP.get('127.0.0.1', '/', 50_385) rescue Errno::ECONNREFUSED, Errno::ECONNRESET sleep(0.1 * 1.2**i) retry end break end yield ensure Process.kill('TERM', pid) end context 'default configuration' do it 'serves /index.html as /' do File.write('output/index.html', 'Hello there! Nanoc loves you! <3') run_nanoc_cmd(['view', '--port', '50385']) do expect(Net::HTTP.get('127.0.0.1', '/', 50_385)).to eql('Hello there! Nanoc loves you! <3') end end it 'does not serve /index.xhtml as /' do File.write('output/index.xhtml', 'Hello there! Nanoc loves you! <3') run_nanoc_cmd(['view', '--port', '50385']) do expect(Net::HTTP.get('127.0.0.1', '/', 50_385)).to eql("File not found: /\n") end end end context 'index_filenames including index.xhtml' do before do File.write('nanoc.yaml', 'index_filenames: [index.xhtml]') end it 'serves /index.xhtml as /' do File.write('output/index.xhtml', 'Hello there! Nanoc loves you! <3') run_nanoc_cmd(['view', '--port', '50385']) do expect(Net::HTTP.get('127.0.0.1', '/', 50_385)).to eql('Hello there! Nanoc loves you! <3') end end end it 'does not serve other files as /' do File.write('output/index.html666', 'Hello there! Nanoc loves you! <3') run_nanoc_cmd(['view', '--port', '50385']) do expect(Net::HTTP.get('127.0.0.1', '/', 50_385)).to eql("File not found: /\n") end end end end nanoc-4.4.7/spec/nanoc/cli/commands/show_data_spec.rb0000644000004100000410000001013313033443476022571 0ustar www-datawww-datadescribe Nanoc::CLI::Commands::ShowData, stdio: true do describe '#print_item_dependencies' do subject { runner.send(:print_item_dependencies, items, dependency_store) } let(:runner) do described_class.new(options, arguments, command) end let(:options) { {} } let(:arguments) { [] } let(:command) { double(:command) } let(:items) do Nanoc::Int::IdentifiableCollection.new(config).tap do |ic| ic << item_about ic << item_dog ic << item_other end end let(:item_about) { Nanoc::Int::Item.new('About Me', {}, '/about.md') } let(:item_dog) { Nanoc::Int::Item.new('About My Dog', {}, '/dog.md') } let(:item_other) { Nanoc::Int::Item.new('Raw Data', {}, '/other.dat') } let(:config) { Nanoc::Int::Configuration.new } let(:dependency_store) do Nanoc::Int::DependencyStore.new(objects) end let(:objects) do items.to_a + layouts.to_a end let(:layouts) do Nanoc::Int::IdentifiableCollection.new(config).tap do |ic| end end it 'prints a legend' do expect { subject }.to output(%r{Item dependencies =+\n\nLegend:}).to_stdout end context 'no dependencies' do it 'outputs no dependencies for /about.md' do expect { subject }.to output(%r{^item /about.md depends on:\n \(nothing\)$}m).to_stdout end it 'outputs no dependencies for /dog.md' do expect { subject }.to output(%r{^item /dog.md depends on:\n \(nothing\)$}m).to_stdout end it 'outputs no dependencies for /other.dat' do expect { subject }.to output(%r{^item /other.dat depends on:\n \(nothing\)$}m).to_stdout end end context 'dependency (without props) from about to dog' do before do dependency_store.record_dependency(item_dog, item_about) end it 'outputs no dependencies for /about.md' do expect { subject }.to output(%r{^item /about.md depends on:\n \(nothing\)$}m).to_stdout end it 'outputs dependencies for /dog.md' do expect { subject }.to output(%r{^item /dog.md depends on:\n \[ item \] \(racp\) /about.md$}m).to_stdout end it 'outputs no dependencies for /other.dat' do expect { subject }.to output(%r{^item /other.dat depends on:\n \(nothing\)$}m).to_stdout end end context 'dependency (with raw_content prop) from about to dog' do before do dependency_store.record_dependency(item_dog, item_about, raw_content: true) end it 'outputs dependencies for /dog.md' do expect { subject }.to output(%r{^item /dog.md depends on:\n \[ item \] \(r___\) /about.md$}m).to_stdout end end context 'dependency (with attributes prop) from about to dog' do before do dependency_store.record_dependency(item_dog, item_about, attributes: true) end it 'outputs dependencies for /dog.md' do expect { subject }.to output(%r{^item /dog.md depends on:\n \[ item \] \(_a__\) /about.md$}m).to_stdout end end context 'dependency (with compiled_content prop) from about to dog' do before do dependency_store.record_dependency(item_dog, item_about, compiled_content: true) end it 'outputs dependencies for /dog.md' do expect { subject }.to output(%r{^item /dog.md depends on:\n \[ item \] \(__c_\) /about.md$}m).to_stdout end end context 'dependency (with path prop) from about to dog' do before do dependency_store.record_dependency(item_dog, item_about, path: true) end it 'outputs dependencies for /dog.md' do expect { subject }.to output(%r{^item /dog.md depends on:\n \[ item \] \(___p\) /about.md$}m).to_stdout end end context 'dependency (with multiple props) from about to dog' do before do dependency_store.record_dependency(item_dog, item_about, attributes: true, raw_content: true) end it 'outputs dependencies for /dog.md' do expect { subject }.to output(%r{^item /dog.md depends on:\n \[ item \] \(ra__\) /about.md$}m).to_stdout end end end end nanoc-4.4.7/spec/nanoc/helpers/0000755000004100000410000000000013033443476016355 5ustar www-datawww-datananoc-4.4.7/spec/nanoc/helpers/child_parent_spec.rb0000644000004100000410000000576713033443476022367 0ustar www-datawww-datadescribe Nanoc::Helpers::ChildParent, helper: true do describe '#children_of' do subject { helper.children_of(item) } let(:item) { ctx.create_item('some content', {}, identifier) } context 'legacy identifier' do let(:identifier) { Nanoc::Identifier.new('/foo/', type: :legacy) } let!(:child_item) do ctx.create_item('abc', {}, Nanoc::Identifier.new('/foo/a/', type: :legacy)) end let!(:grandchild_item) do ctx.create_item('def', {}, Nanoc::Identifier.new('/foo/a/b/', type: :legacy)) end let!(:sibling_item) do ctx.create_item('xyz', {}, Nanoc::Identifier.new('/bar/', type: :legacy)) end it 'returns only direct children' do expect(subject).to eql([child_item]) end end context 'full identifier' do let(:identifier) { Nanoc::Identifier.new('/foo.md', type: :full) } let!(:child_item) do ctx.create_item('abc', {}, Nanoc::Identifier.new('/foo/a.md', type: :full)) end let!(:grandchild_item) do ctx.create_item('def', {}, Nanoc::Identifier.new('/foo/a/b.md', type: :full)) end let!(:sibling_item) do ctx.create_item('xyz', {}, Nanoc::Identifier.new('/bar.md', type: :full)) end let!(:index_child_item) do ctx.create_item('xyz', {}, Nanoc::Identifier.new('/foo/a/index.md', type: :full)) end it 'returns only direct children' do expect(subject).to eql([child_item]) end end end describe '#parent_of' do subject { helper.parent_of(item) } let(:item) { ctx.create_item('some content', {}, identifier) } context 'legacy identifier' do let(:identifier) { Nanoc::Identifier.new('/foo/bar/', type: :legacy) } let!(:parent_item) do ctx.create_item('abc', {}, Nanoc::Identifier.new('/foo/', type: :legacy)) end let!(:sibling_item) do ctx.create_item('def', {}, Nanoc::Identifier.new('/foo/qux/', type: :legacy)) end let!(:child_item) do ctx.create_item('xyz', {}, Nanoc::Identifier.new('/foo/bar/asdf/', type: :legacy)) end let!(:grandparent_item) do ctx.create_item('opq', {}, Nanoc::Identifier.new('/', type: :legacy)) end it 'returns parent' do expect(subject).to eql(parent_item) end end context 'full identifier' do let(:identifier) { Nanoc::Identifier.new('/foo/bar.md', type: :full) } let!(:parent_item) do ctx.create_item('abc', {}, Nanoc::Identifier.new('/foo.md', type: :full)) end let!(:sibling_item) do ctx.create_item('def', {}, Nanoc::Identifier.new('/foo/qux.md', type: :full)) end let!(:child_item) do ctx.create_item('xyz', {}, Nanoc::Identifier.new('/foo/bar/asdf.md', type: :full)) end let!(:grandparent_item) do ctx.create_item('opq', {}, Nanoc::Identifier.new('/index.md', type: :full)) end it 'returns parent' do expect(subject).to eql(parent_item) end end end end nanoc-4.4.7/spec/nanoc/helpers/text_spec.rb0000644000004100000410000000247713033443476020712 0ustar www-datawww-datadescribe Nanoc::Helpers::Text, helper: true do describe '#excerptize' do subject { helper.excerptize(string, params) } let(:string) { 'Foo bar baz quux meow woof' } let(:params) { {} } context 'no params' do it 'takes 25 characters' do expect(subject).to eql('Foo bar baz quux meow ...') end end context 'perfect fit' do let(:params) { { length: 26 } } it 'does not truncate' do expect(subject).to eql('Foo bar baz quux meow woof') end end context 'long length' do let(:params) { { length: 27 } } it 'does not truncate' do expect(subject).to eql('Foo bar baz quux meow woof') end end context 'short length' do let(:params) { { length: 3 } } it 'truncates' do expect(subject).to eql('...') end end context 'length shorter than omission' do let(:params) { { length: 2 } } it 'truncates, disregarding length' do expect(subject).to eql('...') end end context 'custom omission' do let(:params) { { omission: '[continued]' } } it 'uses custom omission string' do expect(subject).to eql('Foo bar baz qu[continued]') end end end describe '#strip_html' do # TODO: test this… or get rid of it (it’s bad!) end end nanoc-4.4.7/spec/nanoc/helpers/rendering_spec.rb0000644000004100000410000000776513033443476021710 0ustar www-datawww-datadescribe Nanoc::Helpers::Rendering, helper: true do describe '#render' do subject { helper.instance_eval { render('/partial.erb') } } let(:rule_memory_for_layout) do [Nanoc::Int::ProcessingActions::Filter.new(:erb, {})] end let(:layout_view) do ctx.create_layout(layout_content, {}, layout_identifier) end let(:layout) do layout_view.unwrap end before do ctx.update_rule_memory(layout, rule_memory_for_layout) end context 'legacy identifier' do let(:layout_identifier) { Nanoc::Identifier.new('/partial/', type: :legacy) } context 'cleaned identifier' do subject { helper.instance_eval { render('/partial/') } } context 'layout without instructions' do let(:layout_content) { 'blah' } it { is_expected.to eql('blah') } it 'tracks proper dependencies' do expect(ctx.dependency_tracker).to receive(:enter) .with(layout, raw_content: true, attributes: false, compiled_content: false, path: false) subject end end context 'layout with instructions' do let(:layout_content) { 'blah <%= @layout.identifier %>' } it { is_expected.to eql('blah /partial/') } end end context 'non-cleaned identifier' do subject { helper.instance_eval { render('/partial') } } context 'layout without instructions' do let(:layout_content) { 'blah' } it { is_expected.to eql('blah') } end context 'layout with instructions' do let(:layout_content) { 'blah <%= @layout.identifier %>' } it { is_expected.to eql('blah /partial/') } end end end context 'full-style identifier' do let(:layout_identifier) { Nanoc::Identifier.new('/partial.erb') } context 'layout without instructions' do let(:layout_content) { 'blah' } it { is_expected.to eql('blah') } end context 'layout with instructions' do let(:layout_content) { 'blah <%= @layout.identifier %>' } it { is_expected.to eql('blah /partial.erb') } end context 'printing wrapped layout class' do let(:layout_content) { 'blah <%= @layout.class %>' } it { is_expected.to eql('blah Nanoc::LayoutView') } end context 'printing unwrapped layout class' do let(:layout_content) { 'blah <%= @layout.unwrap.class %>' } it { is_expected.to eql('blah Nanoc::Int::Layout') } end context 'unknown layout' do subject { helper.instance_eval { render('/unknown.erb') } } let(:layout_content) { 'blah' } it 'raises' do expect { subject }.to raise_error(Nanoc::Int::Errors::UnknownLayout) end end context 'layout with unknown filter' do let(:rule_memory_for_layout) do [Nanoc::Int::ProcessingActions::Filter.new(:donkey, {})] end let(:layout_content) { 'blah' } it 'raises' do expect { subject }.to raise_error(Nanoc::Int::Errors::UnknownFilter) end end context 'layout without filter' do let(:rule_memory_for_layout) do [Nanoc::Int::ProcessingActions::Filter.new(nil, {})] end let(:layout_content) { 'blah' } it 'raises' do expect { subject }.to raise_error(Nanoc::Int::Errors::CannotDetermineFilter) end end context 'with block' do subject do helper.instance_eval do render('/partial.erb') { _erbout << 'extra content' } end end before do ctx.erbout << '[erbout-before]' end let(:layout_content) { '[partial-before]<%= yield %>[partial-after]' } it 'returns an empty string' do expect(subject).to eql('') end it 'modifies erbout' do subject expect(ctx.erbout).to eql('[erbout-before][partial-before]extra content[partial-after]') end end end end end nanoc-4.4.7/spec/nanoc/helpers/link_to_spec.rb0000644000004100000410000001701713033443476021361 0ustar www-datawww-datadescribe Nanoc::Helpers::LinkTo, helper: true do describe '#link_to' do subject { helper.link_to(text, target, attributes) } let(:text) { 'Text' } let(:target) { raise 'override me' } let(:attributes) { {} } context 'with string path' do let(:target) { '/foo/' } it { is_expected.to eql('Text') } context 'with attributes' do let(:attributes) { { title: 'Donkey' } } it { is_expected.to eql('Text') } end context 'special HTML characters in text' do let(:text) { 'Foo & Bar' } it { is_expected.to eql('Foo & Bar') } # Not escaped! end context 'special HTML characters in URL' do let(:target) { '/r&d/' } it { is_expected.to eql('Text') } end context 'special HTML characters in attribute' do let(:attributes) { { title: 'Research & Development' } } it { is_expected.to eql('Text') } end end context 'with rep' do let(:item) { ctx.create_item('content', {}, '/target/') } let(:target) { ctx.create_rep(item, '/target.html') } it { is_expected.to eql('Text') } end context 'with item' do let(:target) { ctx.create_item('content', {}, '/target/') } before do ctx.create_rep(target, '/target.html') end it { is_expected.to eql('Text') } end context 'with nil' do let(:target) { nil } it 'raises' do expect { subject }.to raise_error(ArgumentError) end end context 'with something else' do let(:target) { :donkey } it 'raises' do expect { subject }.to raise_error(ArgumentError) end end context 'with nil path' do let(:item) { ctx.create_item('content', {}, '/target/') } let(:target) { ctx.create_rep(item, nil) } it 'raises' do expect { subject }.to raise_error(RuntimeError) end end end describe '#link_to_unless_current' do subject { helper.link_to_unless_current(text, target, attributes) } let(:text) { 'Text' } let(:target) { raise 'override me' } let(:attributes) { {} } context 'with string path' do let(:target) { '/target.html' } context 'current' do before do ctx.item = ctx.create_item('content', {}, '/target.md') ctx.item_rep = ctx.create_rep(ctx.item, '/target.html') end it { is_expected.to eql('Text') } end context 'no item rep present' do it { is_expected.to eql('Text') } end context 'item rep present, but not current' do before do ctx.item = ctx.create_item('content', {}, '/other.md') ctx.item_rep = ctx.create_rep(ctx.item, '/other.html') end it { is_expected.to eql('Text') } end end context 'with rep' do before do ctx.item = ctx.create_item('content', {}, '/target.md') ctx.item_rep = ctx.create_rep(ctx.item, '/target.html') end let(:some_item) { ctx.create_item('content', {}, '/other.md') } let(:some_item_rep) { ctx.create_rep(some_item, '/other.html') } context 'current' do let(:target) { ctx.item_rep } it { is_expected.to eql('Text') } end context 'no item rep present' do let(:target) { some_item_rep } before do ctx.item = nil ctx.item_rep = nil end it { is_expected.to eql('Text') } end context 'item rep present, but not current' do let(:target) { some_item_rep } it { is_expected.to eql('Text') } end end context 'with item' do before do ctx.item = ctx.create_item('content', {}, '/target.md') ctx.item_rep = ctx.create_rep(ctx.item, '/target.html') end let!(:some_item) { ctx.create_item('content', {}, '/other.md') } let!(:some_item_rep) { ctx.create_rep(some_item, '/other.html') } context 'current' do let(:target) { ctx.item } it { is_expected.to eql('Text') } end context 'no item rep present' do let(:target) { some_item } before do ctx.item = nil ctx.item_rep = nil end it { is_expected.to eql('Text') } end context 'item rep present, but not current' do let(:target) { some_item } it { is_expected.to eql('Text') } end end end describe '#relative_path_to' do subject { helper.relative_path_to(target) } before do ctx.item = ctx.create_item('content', {}, '/foo/self.md') ctx.item_rep = ctx.create_rep(ctx.item, self_path) end context 'current item rep has non-nil path' do let(:self_path) { '/foo/self.html' } context 'to string path' do context 'to relative path' do let(:target) { 'bar/target.html' } it 'errors' do # TODO: Might make sense to allow this case (and return the path itself) expect { subject }.to raise_error(ArgumentError) end end context 'to path without trailing slash' do let(:target) { '/bar/target.html' } it { is_expected.to eql('../bar/target.html') } end context 'to path with trailing slash' do let(:target) { '/bar/target/' } it { is_expected.to eql('../bar/target/') } end context 'to Windows/UNC path (forward slashes)' do let(:target) { '//foo' } it { is_expected.to eql('//foo') } end context 'to Windows/UNC path (backslashes)' do let(:target) { '\\\\foo' } it { is_expected.to eql('\\\\foo') } end end context 'to rep' do let(:target) { ctx.create_rep(ctx.item, '/bar/target.html') } it { is_expected.to eql('../bar/target.html') } context 'to self' do let(:target) { ctx.item_rep } context 'self is a filename' do it { is_expected.to eql('self.html') } end context 'self is a directory' do let(:self_path) { '/foo/self/' } it { is_expected.to eql('./') } end end end context 'to item' do let(:target) { ctx.create_item('content', {}, '/bar/target.md') } before do ctx.create_rep(target, '/bar/target.html') end it { is_expected.to eql('../bar/target.html') } context 'to self' do let(:target) { ctx.item } context 'self is a filename' do it { is_expected.to eql('self.html') } end context 'self is a directory' do let(:self_path) { '/foo/self/' } it { is_expected.to eql('./') } end end end context 'to nil path' do let(:target) { ctx.create_rep(ctx.item, nil) } it 'raises' do expect { subject }.to raise_error(RuntimeError) end end end context 'current item rep has nil path' do let(:self_path) { nil } let(:target) { '/bar/target.html' } it 'errors' do expect { subject }.to raise_error(RuntimeError) end end end end nanoc-4.4.7/spec/nanoc/helpers/blogging_spec.rb0000644000004100000410000001336713033443476021516 0ustar www-datawww-datadescribe Nanoc::Helpers::Blogging, helper: true do before do allow(ctx.dependency_tracker).to receive(:enter) allow(ctx.dependency_tracker).to receive(:exit) end describe '#articles' do subject { helper.articles } before do ctx.create_item('blah', { kind: 'item' }, '/0/') ctx.create_item('blah blah', { kind: 'article' }, '/1/') ctx.create_item('blah blah blah', { kind: 'article' }, '/2/') end it 'returns the two articles' do expect(subject.map(&:identifier)).to match_array(['/1/', '/2/']) end end describe '#sorted_articles' do subject { helper.sorted_articles } before do attrs = { kind: 'item' } ctx.create_item('blah', attrs, '/0/') attrs = { kind: 'article', created_at: (Date.today - 1).to_s } ctx.create_item('blah blah', attrs, '/1/') attrs = { kind: 'article', created_at: (Time.now - 500).to_s } ctx.create_item('blah blah blah', attrs, '/2/') end it 'returns the two articles in descending order' do expect(subject.map(&:identifier)).to eq(['/2/', '/1/']) end end describe '#url_for' do subject { helper.url_for(ctx.items['/stuff/']) } let(:item_attributes) { {} } before do item = ctx.create_item('Stuff', item_attributes, '/stuff/') ctx.create_rep(item, '/rep/path/stuff.html') ctx.config[:base_url] = base_url end context 'without base_url' do let(:base_url) { nil } it 'raises' do expect { subject }.to raise_error(Nanoc::Error) end end context 'with base_url' do let(:base_url) { 'http://url.base' } context 'with custom_url_in_feed' do let(:item_attributes) do { custom_url_in_feed: 'http://example.com/stuff.html' } end it 'returns custom URL' do expect(subject).to eql('http://example.com/stuff.html') end end context 'without custom_url_in_feed' do context 'with custom_path_in_feed' do let(:item_attributes) do { custom_path_in_feed: '/stuff.html' } end it 'returns base URL + custom path' do expect(subject).to eql('http://url.base/stuff.html') end end context 'without custom_path_in_feed' do it 'returns base URL + path' do expect(subject).to eql('http://url.base/rep/path/stuff.html') end end end end end describe '#feed_url' do subject { helper.feed_url } let(:item_attributes) { {} } before do ctx.item = ctx.create_item('Feed', item_attributes, '/feed/') ctx.create_rep(ctx.item, '/feed.xml') ctx.config[:base_url] = base_url end context 'without base_url' do let(:base_url) { nil } it 'raises' do expect { subject }.to raise_error(Nanoc::Error) end end context 'with base_url' do let(:base_url) { 'http://url.base' } context 'with feed_url' do let(:item_attributes) do { feed_url: 'http://custom.feed.url/feed.rss' } end it 'returns custom URL' do expect(subject).to eql('http://custom.feed.url/feed.rss') end end context 'without feed_url' do it 'returns base URL + path' do expect(subject).to eql('http://url.base/feed.xml') end end end end describe '#attribute_to_time' do subject { helper.attribute_to_time(arg) } let(:noon_s) { 1_446_903_076 } let(:beginning_of_day_s) { 1_446_854_400 } let(:around_noon_local) { Time.at(noon_s - Time.at(noon_s).utc_offset) } let(:around_noon_utc) { Time.at(noon_s) } let(:beginning_of_day_utc) { Time.at(beginning_of_day_s) } context 'with Time instance' do let(:arg) { around_noon_utc } it { is_expected.to eql(around_noon_utc) } end context 'with Date instance' do let(:arg) { Date.new(2015, 11, 7) } it { is_expected.to eql(beginning_of_day_utc) } end context 'with DateTime instance' do let(:arg) { DateTime.new(2015, 11, 7, 13, 31, 16) } it { is_expected.to eql(around_noon_utc) } end context 'with string' do let(:arg) { '2015-11-7 13:31:16' } it { is_expected.to eql(around_noon_local) } end end describe '#atom_tag_for' do subject { helper.atom_tag_for(ctx.items['/stuff/']) } let(:item_attributes) { { created_at: '2015-05-19 12:34:56' } } let(:item_rep_path) { '/stuff.xml' } let(:base_url) { 'http://url.base' } before do item = ctx.create_item('Stuff', item_attributes, '/stuff/') ctx.create_rep(item, item_rep_path) ctx.config[:base_url] = base_url end context 'item with path' do let(:item_rep_path) { '/stuff.xml' } it { is_expected.to eql('tag:url.base,2015-05-19:/stuff.xml') } end context 'item without path' do let(:item_rep_path) { nil } it { is_expected.to eql('tag:url.base,2015-05-19:/stuff/') } end context 'bare URL without subdir' do let(:base_url) { 'http://url.base' } it { is_expected.to eql('tag:url.base,2015-05-19:/stuff.xml') } end context 'bare URL with subdir' do let(:base_url) { 'http://url.base/sub' } it { is_expected.to eql('tag:url.base,2015-05-19:/sub/stuff.xml') } end context 'created_at is date' do let(:item_attributes) do { created_at: Date.parse('2015-05-19 12:34:56') } end it { is_expected.to eql('tag:url.base,2015-05-19:/stuff.xml') } end context 'created_at is time' do let(:item_attributes) do { created_at: Time.parse('2015-05-19 12:34:56') } end it { is_expected.to eql('tag:url.base,2015-05-19:/stuff.xml') } end # TODO: handle missing base_dir # TODO: handle missing created_at end end nanoc-4.4.7/spec/nanoc/helpers/html_escape_spec.rb0000644000004100000410000000160513033443476022202 0ustar www-datawww-datadescribe Nanoc::Helpers::HTMLEscape, helper: true do describe '#html_escape' do subject { helper.html_escape(string) } context 'given strings to escape' do let(:string) { '< > & "' } it { is_expected.to eql('< > & "') } end context 'given a block' do let!(:_erbout) { 'moo' } it 'adds escaped content to _erbout' do helper.html_escape { _erbout << '

Stuff!

' } expect(_erbout).to eql('moo<h1>Stuff!</h1>') end end context 'given no argument nor block' do subject { helper.html_escape } it 'raises' do expect { subject }.to raise_error(RuntimeError) end end context 'given argument that is not a string' do let(:string) { 1 } it 'raises an ArgumentError' do expect { subject }.to raise_error(ArgumentError) end end end end nanoc-4.4.7/spec/nanoc/helpers/filtering_spec.rb0000644000004100000410000000343213033443476021701 0ustar www-datawww-datadescribe Nanoc::Helpers::Filtering, helper: true do describe '#filter' do before do ctx.item = ctx.create_item('some content', { title: 'Hello!' }, '/about.md') ctx.item_rep = ctx.create_rep(ctx.item, '/about.html') end let(:content) do "A<% filter :erb do %><%%= 'X' %><% end %>B" end subject { ::ERB.new(content).result(helper.get_binding) } context 'basic case' do it { is_expected.to eql('AXB') } it 'notifies' do ns = Set.new Nanoc::Int::NotificationCenter.on(:filtering_started) { ns << :filtering_started } Nanoc::Int::NotificationCenter.on(:filtering_ended) { ns << :filtering_ended } subject expect(ns).to include(:filtering_started) expect(ns).to include(:filtering_ended) end end context 'with assigns' do let(:content) do 'A<% filter :erb do %><%%= @item[:title] %><% end %>B' end it { is_expected.to eql('AHello!B') } end context 'unknonwn filter name' do let(:content) do 'A<% filter :donkey do %>X<% end %>B' end it 'errors' do expect { subject }.to raise_error(Nanoc::Int::Errors::UnknownFilter) end end context 'with locals' do let(:content) do "A<% filter :erb, locals: { sheep: 'baah' } do %><%%= @sheep %><% end %>B" end it { is_expected.to eql('AbaahB') } end context 'with Haml' do let(:content) do "%p Foo.\n" \ "- filter(:erb) do\n" \ " <%= 'abc' + 'xyz' %>\n" \ "%p Bar.\n" end before do require 'haml' end subject { ::Haml::Engine.new(content).render(helper.get_binding) } it { is_expected.to match(%r{^

Foo.

\s*abcxyz\s*

Bar.

$}) } end end end nanoc-4.4.7/spec/nanoc/helpers/tagging_spec.rb0000644000004100000410000000576113033443476021345 0ustar www-datawww-datadescribe Nanoc::Helpers::Tagging, helper: true do describe '#tags_for' do subject { helper.tags_for(item, params) } let(:item) { ctx.items['/me.*'] } let(:params) { {} } let(:item_attributes) { {} } before do ctx.create_item('content', item_attributes, '/me.md') end context 'no tags' do let(:item_attributes) { {} } it { is_expected.to eql('(none)') } end context 'nil tag list' do let(:item_attributes) { { tags: nil } } it { is_expected.to eql('(none)') } end context 'empty tag list' do let(:item_attributes) { { tags: [] } } it { is_expected.to eql('(none)') } end context 'no tags, and custom none text' do let(:item_attributes) { {} } let(:params) { { none_text: 'no tags for you, fool' } } it { is_expected.to eql('no tags for you, fool') } end context 'one tag' do let(:item_attributes) { { tags: %w(donkey) } } context 'implicit base_url' do it { is_expected.to eql('donkey') } end context 'explicit nil base_url' do let(:params) { { base_url: nil } } it { is_expected.to eql('donkey') } end context 'explicit other base_url' do let(:params) { { base_url: 'http://nanoc.ws/tag/' } } it { is_expected.to eql('') } end end context 'two tags' do let(:item_attributes) { { tags: %w(donkey giraffe) } } it { is_expected.to eql('donkey, giraffe') } end context 'three tags' do let(:item_attributes) { { tags: %w(donkey giraffe zebra) } } it { is_expected.to eql('donkey, giraffe, zebra') } context 'custom separator' do let(:item_attributes) { { tags: %w(donkey giraffe zebra) } } let(:params) { { separator: ' / ' } } it { is_expected.to eql('donkey / giraffe / zebra') } end end end describe '#items_with_tag' do subject { helper.items_with_tag(tag) } before do ctx.create_item('item 1', { tags: [:foo] }, '/item1.md') ctx.create_item('item 2', { tags: [:bar] }, '/item2.md') ctx.create_item('item 3', { tags: [:foo, :bar] }, '/item3.md') ctx.create_item('item 4', { tags: nil }, '/item4.md') ctx.create_item('item 5', {}, '/item5.md') end context 'tag that exists' do let(:tag) { :foo } it { is_expected.to contain_exactly(ctx.items['/item1.md'], ctx.items['/item3.md']) } end context 'tag that does not exists' do let(:tag) { :other } it { is_expected.to be_empty } end end describe '#link_for_tag' do subject { helper.link_for_tag(tag, base_url) } let(:tag) { 'foo' } let(:base_url) { 'http://nanoc.ws/tag/' } it { is_expected.to eql('') } context 'tag with special HTML characters' do let(:tag) { 'R&D' } it { is_expected.to eql('') } end end end nanoc-4.4.7/spec/nanoc/helpers/breadcrumbs_spec.rb0000644000004100000410000001025513033443476022210 0ustar www-datawww-datadescribe Nanoc::Helpers::Breadcrumbs, helper: true do before do allow(ctx.dependency_tracker).to receive(:enter) allow(ctx.dependency_tracker).to receive(:exit) end describe '#breadcrumbs_trail' do subject { helper.breadcrumbs_trail } context 'legacy identifiers' do context 'root' do before do ctx.create_item('root', {}, Nanoc::Identifier.new('/', type: :legacy)) ctx.item = ctx.items['/'] end it 'returns an array with the item' do expect(subject).to eql([ctx.items['/']]) end end context 'root and direct child' do before do ctx.create_item('child', {}, Nanoc::Identifier.new('/foo/', type: :legacy)) ctx.create_item('root', {}, Nanoc::Identifier.new('/', type: :legacy)) ctx.item = ctx.items['/foo/'] end it 'returns an array with the items' do expect(subject).to eql([ctx.items['/'], ctx.items['/foo/']]) end end context 'root, child and grandchild' do before do ctx.create_item('grandchild', {}, Nanoc::Identifier.new('/foo/bar/', type: :legacy)) ctx.create_item('child', {}, Nanoc::Identifier.new('/foo/', type: :legacy)) ctx.create_item('root', {}, Nanoc::Identifier.new('/', type: :legacy)) ctx.item = ctx.items['/foo/bar/'] end it 'returns an array with the items' do expect(subject).to eql([ctx.items['/'], ctx.items['/foo/'], ctx.items['/foo/bar/']]) end end context 'root, missing child and grandchild' do before do ctx.create_item('grandchild', {}, Nanoc::Identifier.new('/foo/bar/', type: :legacy)) ctx.create_item('root', {}, Nanoc::Identifier.new('/', type: :legacy)) ctx.item = ctx.items['/foo/bar/'] end it 'returns an array with the items' do expect(subject).to eql([ctx.items['/'], nil, ctx.items['/foo/bar/']]) end end end context 'non-legacy identifiers' do context 'root' do before do ctx.create_item('root', {}, Nanoc::Identifier.new('/index.md')) ctx.item = ctx.items['/index.md'] end it 'returns an array with the item' do expect(subject).to eql([ctx.items['/index.md']]) end end context 'root and direct child' do before do ctx.create_item('child', {}, Nanoc::Identifier.new('/foo.md')) ctx.create_item('root', {}, Nanoc::Identifier.new('/index.md')) ctx.item = ctx.items['/foo.md'] end it 'returns an array with the items' do expect(subject).to eql([ctx.items['/index.md'], ctx.items['/foo.md']]) end end context 'root, child and grandchild' do before do ctx.create_item('grandchild', {}, Nanoc::Identifier.new('/foo/bar.md')) ctx.create_item('child', {}, Nanoc::Identifier.new('/foo.md')) ctx.create_item('root', {}, Nanoc::Identifier.new('/index.md')) ctx.item = ctx.items['/foo/bar.md'] end it 'returns an array with the items' do expect(subject).to eql([ctx.items['/index.md'], ctx.items['/foo.md'], ctx.items['/foo/bar.md']]) end end context 'root, missing child and grandchild' do before do ctx.create_item('grandchild', {}, Nanoc::Identifier.new('/foo/bar.md')) ctx.create_item('root', {}, Nanoc::Identifier.new('/index.md')) ctx.item = ctx.items['/foo/bar.md'] end it 'returns an array with the items' do expect(subject).to eql([ctx.items['/index.md'], nil, ctx.items['/foo/bar.md']]) end end context 'index.md child' do # No special handling of non-root index.* files. before do ctx.create_item('grandchild', {}, Nanoc::Identifier.new('/foo/index.md')) ctx.create_item('root', {}, Nanoc::Identifier.new('/index.md')) ctx.item = ctx.items['/foo/index.md'] end it 'returns an array with the items' do expect(subject).to eql([ctx.items['/index.md'], nil, ctx.items['/foo/index.md']]) end end end end end nanoc-4.4.7/spec/nanoc/helpers/capturing_spec.rb0000644000004100000410000001304713033443476021715 0ustar www-datawww-datadescribe Nanoc::Helpers::Capturing, helper: true do describe '#content_for' do before do ctx.item = ctx.create_item('some content', {}, '/about.md') ctx.create_rep(ctx.item, '/about.html') end describe 'with name + block' do let(:_erbout) { 'existing content' } context 'only name given' do subject { helper.content_for(:foo) { _erbout << 'foo' } } it 'stores snapshot content' do subject expect(ctx.item.reps[:default].unwrap.snapshot_contents[:__capture_foo].string).to eql('foo') end end context 'name and params given' do subject { helper.content_for(:foo, params) { _erbout << 'foo' } } let(:params) { raise 'overwrite me' } context 'no existing behavior specified' do let(:params) { {} } it 'errors after two times' do helper.content_for(:foo, params) { _erbout << 'foo' } expect { helper.content_for(:foo, params) { _erbout << 'bar' } }.to raise_error(RuntimeError) end end context 'existing behavior is :overwrite' do let(:params) { { existing: :overwrite } } it 'overwrites' do helper.content_for(:foo, params) { _erbout << 'foo' } helper.content_for(:foo, params) { _erbout << 'bar' } expect(ctx.item.reps[:default].unwrap.snapshot_contents[:__capture_foo].string).to eql('bar') end end context 'existing behavior is :append' do let(:params) { { existing: :append } } it 'appends' do helper.content_for(:foo, params) { _erbout << 'foo' } helper.content_for(:foo, params) { _erbout << 'bar' } expect(ctx.item.reps[:default].unwrap.snapshot_contents[:__capture_foo].string).to eql('foobar') end end context 'existing behavior is :error' do let(:params) { { existing: :error } } it 'errors after two times' do helper.content_for(:foo, params) { _erbout << 'foo' } expect { helper.content_for(:foo, params) { _erbout << 'bar' } }.to raise_error(RuntimeError) end end context 'existing behavior is :something else' do let(:params) { { existing: :donkey } } it 'errors' do expect { subject }.to raise_error(ArgumentError) end end end end describe 'with item + name' do subject { helper.content_for(item, :foo) } let(:_erbout) { 'existing content' } context 'requesting for same item' do let(:item) { ctx.item } context 'nothing captured' do it { is_expected.to be_nil } end context 'something captured' do before do helper.content_for(:foo) { _erbout << 'I have been captured!' } end it { is_expected.to eql('I have been captured!') } end end context 'requesting for other item' do let(:item) { ctx.items['/other.md'] } before do item = ctx.create_item('other content', {}, '/other.md') ctx.create_rep(item, '/other.html') end context 'other item is not yet compiled' do it 'raises an unmet dependency error' do expect(ctx.dependency_tracker).to receive(:bounce).with(item.unwrap, compiled_content: true) expect { subject }.to raise_error(FiberError) end end context 'other item is compiled' do before do item.reps[:default].unwrap.compiled = true item.reps[:default].unwrap.snapshot_contents[:__capture_foo] = Nanoc::Int::TextualContent.new('other captured foo') end it 'returns the captured content' do expect(ctx.dependency_tracker).to receive(:bounce).with(item.unwrap, compiled_content: true) expect(subject).to eql('other captured foo') end end end end end describe '#capture' do context 'with string' do let(:_erbout) { 'existing content' } subject { helper.capture { _erbout << 'new content' } } it 'returns the appended content' do expect(subject).to eql('new content') end it 'does not modify _erbout' do expect { subject }.not_to change { _erbout } end end context 'with array' do let(:_erbout) { ['existing content'] } shared_examples 'returns properly joined output' do subject { helper.capture { _erbout << %w(new _ content) } } it 'returns the appended content, joined' do expect(subject).to eql('new_content') end it 'does not modify _erbout' do expect { subject }.not_to change { _erbout.join('') } end end context 'default output field separator' do include_examples 'returns properly joined output' end context 'output field separator set to ,' do around do |ex| orig_output_field_separator = $OUTPUT_FIELD_SEPARATOR $OUTPUT_FIELD_SEPARATOR = ',' ex.run $OUTPUT_FIELD_SEPARATOR = orig_output_field_separator end include_examples 'returns properly joined output' end context 'output field separator set to nothing' do around do |ex| orig_output_field_separator = $OUTPUT_FIELD_SEPARATOR $OUTPUT_FIELD_SEPARATOR = '' ex.run $OUTPUT_FIELD_SEPARATOR = orig_output_field_separator end include_examples 'returns properly joined output' end end end end nanoc-4.4.7/spec/nanoc/data_sources/0000755000004100000410000000000013033443476017367 5ustar www-datawww-datananoc-4.4.7/spec/nanoc/data_sources/filesystem_spec.rb0000644000004100000410000000366613033443476023125 0ustar www-datawww-datadescribe Nanoc::DataSources::Filesystem do let(:data_source) { Nanoc::DataSources::Filesystem.new(site.config, nil, nil, params) } let(:params) { {} } let(:site) { Nanoc::Int::SiteLoader.new.new_empty } before { Timecop.freeze(now) } after { Timecop.return } let(:now) { Time.local(2008, 1, 2, 14, 5, 0) } describe '#load_objects' do subject { data_source.send(:load_objects, 'foo', klass) } let(:klass) { raise 'override me' } context 'items' do let(:klass) { Nanoc::Int::Item } context 'no files' do it 'loads nothing' do expect(subject).to be_empty end end context 'one regular file' do before do FileUtils.mkdir_p('foo') File.write('foo/bar.html', "---\nnum: 1\n---\ntest 1") FileUtils.touch('foo/bar.html', mtime: now) end let(:expected_attributes) do { content_filename: 'foo/bar.html', extension: 'html', filename: 'foo/bar.html', meta_filename: nil, mtime: now, num: 1, } end it 'loads that file' do expect(subject.size).to eq(1) expect(subject[0].content.string).to eq('test 1') expect(subject[0].attributes).to eq(expected_attributes) expect(subject[0].identifier).to eq(Nanoc::Identifier.new('/bar/')) expect(subject[0].checksum_data).to be_nil expect(subject[0].content_checksum_data).to eq('test 1') end it 'has the right attributes checksum data' do cs = YAML.load(subject[0].attributes_checksum_data) expect(cs[:attributes]).to eq("num: 1\n") expect(cs[:extra_attributes]).to eq( filename: 'foo/bar.html', content_filename: 'foo/bar.html', meta_filename: nil, extension: 'html', mtime: now, ) end end end end end nanoc-4.4.7/spec/contributors_spec.rb0000644000004100000410000000116213033443476017711 0ustar www-datawww-datadescribe 'list of contributors in README', chdir: false do let(:contributors_in_readme) do File.readlines('README.md').last.chomp("\n").split(', ') end let(:contributors_in_release_notes) do File.read('NEWS.md').scan(/\[[^\]]+\]$/).map { |s| s[1..-2].split(', ') }.flatten end it 'should include everyone mentioned in NEWS.md' do diff = (contributors_in_release_notes - contributors_in_readme).uniq.sort expect(diff).to be_empty, "some contributors are missing from the README: #{diff.join(', ')}" end it 'should be sorted' do expect(contributors_in_readme).to be_humanly_sorted end end nanoc-4.4.7/lib/0000755000004100000410000000000013033443476013431 5ustar www-datawww-datananoc-4.4.7/lib/nanoc.rb0000644000004100000410000000250113033443476015052 0ustar www-datawww-datamodule Nanoc # @return [String] A string containing information about this Nanoc version # and its environment (Ruby engine and version, Rubygems version if any). # # @api private def self.version_information gem_info = defined?(Gem) ? "with RubyGems #{Gem::VERSION}" : 'without RubyGems' engine = defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby' res = '' res << "Nanoc #{Nanoc::VERSION} © 2007-2017 Denis Defreyne.\n" res << "Running #{engine} #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) on #{RUBY_PLATFORM} #{gem_info}.\n" res end # @return [Boolean] True if the current platform is Windows, false otherwise. # # @api private def self.on_windows? RUBY_PLATFORM =~ /windows|bccwin|cygwin|djgpp|mingw|mswin|wince/i end end # Load external dependencies require 'hamster' require 'ref' # Load general requirements require 'digest' require 'enumerator' require 'fiber' require 'fileutils' require 'forwardable' require 'pathname' require 'pstore' require 'set' require 'singleton' require 'tempfile' require 'thread' require 'time' require 'yaml' require 'English' # Load Nanoc require 'nanoc/version' require 'nanoc/base' require 'nanoc/checking' require 'nanoc/deploying' require 'nanoc/extra' require 'nanoc/data_sources' require 'nanoc/filters' require 'nanoc/helpers' require 'nanoc/rule_dsl' nanoc-4.4.7/lib/nanoc/0000755000004100000410000000000013033443476014527 5ustar www-datawww-datananoc-4.4.7/lib/nanoc/base/0000755000004100000410000000000013033443476015441 5ustar www-datawww-datananoc-4.4.7/lib/nanoc/base/core_ext.rb0000644000004100000410000000022313033443476017573 0ustar www-datawww-datarequire 'nanoc/base/core_ext/array' require 'nanoc/base/core_ext/hash' require 'nanoc/base/core_ext/pathname' require 'nanoc/base/core_ext/string' nanoc-4.4.7/lib/nanoc/base/views/0000755000004100000410000000000013033443476016576 5ustar www-datawww-datananoc-4.4.7/lib/nanoc/base/views/item_rep_view.rb0000644000004100000410000000441213033443476021762 0ustar www-datawww-datamodule Nanoc class ItemRepView < ::Nanoc::View # @api private def initialize(item_rep, context) super(context) @item_rep = item_rep end # @api private def unwrap @item_rep end # @see Object#== def ==(other) other.respond_to?(:item) && other.respond_to?(:name) && item == other.item && name == other.name end # @see Object#eql? def eql?(other) other.is_a?(self.class) && item.eql?(other.item) && name.eql?(other.name) end # @see Object#hash def hash self.class.hash ^ item.identifier.hash ^ name.hash end # @return [Symbol] def name @item_rep.name end # Returns the compiled content. # # @param [String] snapshot The name of the snapshot from which to # fetch the compiled content. By default, the returned compiled content # will be the content compiled right before the first layout call (if # any). # # @return [String] The content at the given snapshot. def compiled_content(snapshot: nil) @context.dependency_tracker.bounce(unwrap.item, compiled_content: true) @item_rep.compiled_content(snapshot: snapshot) end # Returns the item rep’s path, as used when being linked to. It starts # with a slash and it is relative to the output directory. It does not # include the path to the output directory. It will not include the # filename if the filename is an index filename. # # @param [Symbol] snapshot The snapshot for which the path should be # returned. # # @return [String] The item rep’s path. def path(snapshot: :last) @context.dependency_tracker.bounce(unwrap.item, path: true) @item_rep.path(snapshot: snapshot) end # Returns the item that this item rep belongs to. # # @return [Nanoc::ItemWithRepsView] def item Nanoc::ItemWithRepsView.new(@item_rep.item, @context) end # @api private def raw_path(snapshot: :last) @context.dependency_tracker.bounce(unwrap.item, path: true) @item_rep.raw_path(snapshot: snapshot) end # @api private def binary? @item_rep.binary? end def inspect "<#{self.class} item.identifier=#{item.identifier} name=#{name}>" end end end nanoc-4.4.7/lib/nanoc/base/views/config_view.rb0000644000004100000410000000141613033443476021424 0ustar www-datawww-datamodule Nanoc class ConfigView < ::Nanoc::View # @api private NONE = Object.new.freeze # @api private def initialize(config, context) super(context) @config = config end # @api private def unwrap @config end # @see Hash#fetch def fetch(key, fallback = NONE, &_block) @config.fetch(key) do if !fallback.equal?(NONE) fallback elsif block_given? yield(key) else raise KeyError, "key not found: #{key.inspect}" end end end # @see Hash#key? def key?(key) @config.key?(key) end # @see Hash#[] def [](key) @config[key] end # @see Hash#each def each(&block) @config.each(&block) end end end nanoc-4.4.7/lib/nanoc/base/views/mixins/0000755000004100000410000000000013033443476020105 5ustar www-datawww-datananoc-4.4.7/lib/nanoc/base/views/mixins/document_view_mixin.rb0000644000004100000410000000337413033443476024515 0ustar www-datawww-datamodule Nanoc module DocumentViewMixin # @api private NONE = Object.new.freeze # @api private def initialize(document, context) super(context) @document = document end # @api private def unwrap @document end # @see Object#== def ==(other) other.respond_to?(:identifier) && identifier == other.identifier end # @see Object#eql? def eql?(other) other.is_a?(self.class) && identifier.eql?(other.identifier) end # @see Object#hash def hash self.class.hash ^ identifier.hash end # @return [Nanoc::Identifier] def identifier unwrap.identifier end # @see Hash#[] def [](key) @context.dependency_tracker.bounce(unwrap, attributes: true) unwrap.attributes[key] end # @return [Hash] def attributes @context.dependency_tracker.bounce(unwrap, attributes: true) unwrap.attributes end # @see Hash#fetch def fetch(key, fallback = NONE, &_block) @context.dependency_tracker.bounce(unwrap, attributes: true) if unwrap.attributes.key?(key) unwrap.attributes[key] elsif !fallback.equal?(NONE) fallback elsif block_given? yield(key) else raise KeyError, "key not found: #{key.inspect}" end end # @see Hash#key? def key?(key) @context.dependency_tracker.bounce(unwrap, attributes: true) unwrap.attributes.key?(key) end # @api private def reference unwrap.reference end # @api private def raw_content @context.dependency_tracker.bounce(unwrap, raw_content: true) unwrap.content.string end def inspect "<#{self.class} identifier=#{unwrap.identifier}>" end end end nanoc-4.4.7/lib/nanoc/base/views/mixins/mutable_document_view_mixin.rb0000644000004100000410000000230213033443476026214 0ustar www-datawww-datamodule Nanoc module MutableDocumentViewMixin # @api private class DisallowedAttributeValueError < Nanoc::Error attr_reader :value def initialize(value) @value = value end def message "The #{value.class} cannot be stored inside an attribute. Store its identifier instead." end end # Sets the value for the given attribute. # # @param [Symbol] key # # @see Hash#[]= def []=(key, value) disallowed_value_classes = Set.new([ Nanoc::Int::Item, Nanoc::Int::Layout, Nanoc::ItemWithRepsView, Nanoc::LayoutView, ]) if disallowed_value_classes.include?(value.class) raise DisallowedAttributeValueError.new(value) end unwrap.attributes[key] = value end # Sets the identifier to the given argument. # # @param [String, Nanoc::Identifier] arg def identifier=(arg) unwrap.identifier = Nanoc::Identifier.from(arg) end # Updates the attributes based on the given hash. # # @param [Hash] hash # # @return [self] def update_attributes(hash) hash.each { |k, v| unwrap.attributes[k] = v } self end end end nanoc-4.4.7/lib/nanoc/base/views/mixins/with_reps_view_mixin.rb0000644000004100000410000000315113033443476024674 0ustar www-datawww-datamodule Nanoc module WithRepsViewMixin # Returns the compiled content. # # @param [String] rep The name of the representation # from which the compiled content should be fetched. By default, the # compiled content will be fetched from the default representation. # # @param [String] snapshot The name of the snapshot from which to # fetch the compiled content. By default, the returned compiled content # will be the content compiled right before the first layout call (if # any). # # @return [String] The content of the given rep at the given snapshot. def compiled_content(rep: :default, snapshot: nil) reps.fetch(rep).compiled_content(snapshot: snapshot) end # Returns the item path, as used when being linked to. It starts # with a slash and it is relative to the output directory. It does not # include the path to the output directory. It will not include the # filename if the filename is an index filename. # # @param [String] rep The name of the representation # from which the path should be fetched. By default, the path will be # fetched from the default representation. # # @param [Symbol] snapshot The snapshot for which the # path should be returned. # # @return [String] The item’s path. def path(rep: :default, snapshot: :last) reps.fetch(rep).path(snapshot: snapshot) end # Returns the representations of this item. # # @return [Nanoc::ItemRepCollectionView] def reps Nanoc::ItemRepCollectionView.new(@context.reps[unwrap], @context) end end end nanoc-4.4.7/lib/nanoc/base/views/item_with_reps_view.rb0000644000004100000410000000016413033443476023200 0ustar www-datawww-datamodule Nanoc class ItemWithRepsView < ::Nanoc::ItemWithoutRepsView include Nanoc::WithRepsViewMixin end end nanoc-4.4.7/lib/nanoc/base/views/layout_collection_view.rb0000644000004100000410000000024013033443476023701 0ustar www-datawww-datamodule Nanoc class LayoutCollectionView < ::Nanoc::IdentifiableCollectionView # @api private def view_class Nanoc::LayoutView end end end nanoc-4.4.7/lib/nanoc/base/views/mutable_config_view.rb0000644000004100000410000000035013033443476023131 0ustar www-datawww-datamodule Nanoc class MutableConfigView < Nanoc::ConfigView # Sets the value for the given attribute. # # @param [Symbol] key # # @see Hash#[]= def []=(key, value) @config[key] = value end end end nanoc-4.4.7/lib/nanoc/base/views/mutable_layout_collection_view.rb0000644000004100000410000000120713033443476025416 0ustar www-datawww-datamodule Nanoc class MutableLayoutCollectionView < Nanoc::MutableIdentifiableCollectionView # @api private def view_class Nanoc::MutableLayoutView end # Creates a new layout and adds it to the site’s collection of layouts. # # @param [String] content The layout content. # # @param [Hash] attributes A hash containing this layout's attributes. # # @param [Nanoc::Identifier, String] identifier This layout's identifier. # # @return [self] def create(content, attributes, identifier) @objects << Nanoc::Int::Layout.new(content, attributes, identifier) self end end end nanoc-4.4.7/lib/nanoc/base/views/layout_view.rb0000644000004100000410000000013713033443476021473 0ustar www-datawww-datamodule Nanoc class LayoutView < ::Nanoc::View include Nanoc::DocumentViewMixin end end nanoc-4.4.7/lib/nanoc/base/views/mutable_item_view.rb0000644000004100000410000000017013033443476022622 0ustar www-datawww-datamodule Nanoc class MutableItemView < Nanoc::ItemWithoutRepsView include Nanoc::MutableDocumentViewMixin end end nanoc-4.4.7/lib/nanoc/base/views/post_compile_item_view.rb0000644000004100000410000000054213033443476023671 0ustar www-datawww-datamodule Nanoc class PostCompileItemView < Nanoc::ItemWithRepsView def reps Nanoc::PostCompileItemRepCollectionView.new(@context.reps[unwrap], @context) end # @deprecated Use {#modified_reps} instead def modified modified_reps end def modified_reps reps.select { |rep| rep.unwrap.modified? } end end end nanoc-4.4.7/lib/nanoc/base/views/item_collection_with_reps_view.rb0000644000004100000410000000025413033443476025413 0ustar www-datawww-datamodule Nanoc class ItemCollectionWithRepsView < ::Nanoc::IdentifiableCollectionView # @api private def view_class Nanoc::ItemWithRepsView end end end nanoc-4.4.7/lib/nanoc/base/views/item_without_reps_view.rb0000644000004100000410000000301713033443476023730 0ustar www-datawww-datamodule Nanoc class ItemWithoutRepsView < ::Nanoc::View include Nanoc::DocumentViewMixin # Returns the children of this item. For items with identifiers that have # extensions, returns an empty collection. # # @return [Enumerable] def children unless unwrap.identifier.legacy? raise Nanoc::Int::Errors::CannotGetParentOrChildrenOfNonLegacyItem.new(unwrap.identifier) end children_pattern = Nanoc::Int::Pattern.from(unwrap.identifier.to_s + '*/') children = @context.items.select { |i| children_pattern.match?(i.identifier) } children.map { |i| self.class.new(i, @context) }.freeze end # Returns the parent of this item, if one exists. For items with identifiers # that have extensions, returns nil. # # @return [Nanoc::ItemWithRepsView] if the item has a parent # # @return [nil] if the item has no parent def parent unless unwrap.identifier.legacy? raise Nanoc::Int::Errors::CannotGetParentOrChildrenOfNonLegacyItem.new(unwrap.identifier) end parent_identifier = '/' + unwrap.identifier.components[0..-2].join('/') + '/' parent_identifier = '/' if parent_identifier == '//' parent = @context.items[parent_identifier] parent && self.class.new(parent, @context) end # @return [Boolean] True if the item is binary, false otherwise def binary? unwrap.content.binary? end # @api private def raw_filename unwrap.content.filename end end end nanoc-4.4.7/lib/nanoc/base/views/mutable_layout_view.rb0000644000004100000410000000016113033443476023201 0ustar www-datawww-datamodule Nanoc class MutableLayoutView < Nanoc::LayoutView include Nanoc::MutableDocumentViewMixin end end nanoc-4.4.7/lib/nanoc/base/views/view.rb0000644000004100000410000000072513033443476020101 0ustar www-datawww-datamodule Nanoc class View # @api private def initialize(context) @context = context end # @api private def _context @context end # @api private def unwrap raise NotImplementedError end # True if the wrapped object is frozen; false otherwise. # # @return [Boolean] # # @see Object#frozen? def frozen? unwrap.frozen? end def inspect "<#{self.class}>" end end end nanoc-4.4.7/lib/nanoc/base/views/identifiable_collection_view.rb0000644000004100000410000000333513033443476025013 0ustar www-datawww-datamodule Nanoc class IdentifiableCollectionView < ::Nanoc::View include Enumerable # @api private def initialize(objects, context) super(context) @objects = objects end # @api private def unwrap @objects end # @abstract # # @api private def view_class raise NotImplementedError end # Calls the given block once for each object, passing that object as a parameter. # # @yieldparam [#identifier] object # # @yieldreturn [void] # # @return [self] def each @objects.each { |i| yield view_class.new(i, @context) } self end # @return [Integer] def size @objects.size end # Finds all objects whose identifier matches the given argument. # # @param [String, Regex] arg # # @return [Enumerable] def find_all(arg) pat = Nanoc::Int::Pattern.from(arg) select { |i| pat.match?(i.identifier) } end # @overload [](string) # # Finds the object whose identifier matches the given string. # # If the glob syntax is enabled, the string can be a glob, in which case # this method finds the first object that matches the given glob. # # @param [String] string # # @return [nil] if no object matches the string # # @return [#identifier] if an object was found # # @overload [](regex) # # Finds the object whose identifier matches the given regular expression. # # @param [Regex] regex # # @return [nil] if no object matches the regex # # @return [#identifier] if an object was found def [](arg) res = @objects[arg] res && view_class.new(res, @context) end end end nanoc-4.4.7/lib/nanoc/base/views/post_compile_item_collection_view.rb0000644000004100000410000000026013033443476026101 0ustar www-datawww-datamodule Nanoc class PostCompileItemCollectionView < Nanoc::IdentifiableCollectionView # @api private def view_class Nanoc::PostCompileItemView end end end nanoc-4.4.7/lib/nanoc/base/views/view_context.rb0000644000004100000410000000062013033443476021637 0ustar www-datawww-datamodule Nanoc # @api private class ViewContext attr_reader :reps attr_reader :items attr_reader :dependency_tracker attr_reader :compilation_context def initialize(reps:, items:, dependency_tracker:, compilation_context:) @reps = reps @items = items @dependency_tracker = dependency_tracker @compilation_context = compilation_context end end end nanoc-4.4.7/lib/nanoc/base/views/mutable_item_collection_view.rb0000644000004100000410000000203513033443476025037 0ustar www-datawww-datamodule Nanoc class MutableItemCollectionView < Nanoc::MutableIdentifiableCollectionView # @api private def view_class Nanoc::MutableItemView end # Creates a new item and adds it to the site’s collection of items. # # @param [String] content The uncompiled item content (if it is a textual # item) or the path to the filename containing the content (if it is a # binary item). # # @param [Hash] attributes A hash containing this item's attributes. # # @param [Nanoc::Identifier, String] identifier This item's identifier. # # @param [Boolean] binary Whether or not this item is binary # # @param [String] filename Absolute path to the file # containing this content (if any) # # @return [self] def create(content, attributes, identifier, binary: false, filename: nil) content = Nanoc::Int::Content.create(content, binary: binary, filename: filename) @objects << Nanoc::Int::Item.new(content, attributes, identifier) self end end end nanoc-4.4.7/lib/nanoc/base/views/item_collection_without_reps_view.rb0000644000004100000410000000026213033443476026142 0ustar www-datawww-datamodule Nanoc class ItemCollectionWithoutRepsView < ::Nanoc::IdentifiableCollectionView # @api private def view_class Nanoc::ItemWithoutRepsView end end end nanoc-4.4.7/lib/nanoc/base/views/post_compile_item_rep_view.rb0000644000004100000410000000112013033443476024530 0ustar www-datawww-datamodule Nanoc class PostCompileItemRepView < ::Nanoc::ItemRepView def compiled_content(snapshot: nil) if unwrap.binary? raise Nanoc::Int::Errors::CannotGetCompiledContentOfBinaryItem.new(unwrap) end snapshot_contents = @context.compilation_context.compiled_content_cache[unwrap] snapshot_name = snapshot || (snapshot_contents[:pre] ? :pre : :last) if snapshot_contents[snapshot_name] snapshot_contents[snapshot_name].string else raise Nanoc::Int::Errors::NoSuchSnapshot.new(unwrap, snapshot_name) end end end end nanoc-4.4.7/lib/nanoc/base/views/mutable_identifiable_collection_view.rb0000644000004100000410000000060413033443476026520 0ustar www-datawww-datamodule Nanoc class MutableIdentifiableCollectionView < Nanoc::IdentifiableCollectionView # Deletes every object for which the block evaluates to true. # # @yieldparam [#identifier] object # # @yieldreturn [Boolean] # # @return [self] def delete_if(&_block) @objects.delete_if { |o| yield(view_class.new(o, @context)) } self end end end nanoc-4.4.7/lib/nanoc/base/views/post_compile_item_rep_collection_view.rb0000644000004100000410000000026113033443476026750 0ustar www-datawww-datamodule Nanoc class PostCompileItemRepCollectionView < Nanoc::ItemRepCollectionView # @api private def view_class Nanoc::PostCompileItemRepView end end end nanoc-4.4.7/lib/nanoc/base/views/item_rep_collection_view.rb0000644000004100000410000000411113033443476024171 0ustar www-datawww-datamodule Nanoc class ItemRepCollectionView < ::Nanoc::View include Enumerable class NoSuchItemRepError < ::Nanoc::Error def initialize(rep_name) super("No rep named #{rep_name.inspect} was found.") end end # @api private def initialize(item_reps, context) super(context) @item_reps = item_reps end # @api private def unwrap @item_reps end # @api private def view_class Nanoc::ItemRepView end def to_ary @item_reps.map { |ir| view_class.new(ir, @context) } end # Calls the given block once for each item rep, passing that item rep as a parameter. # # @yieldparam [Object] item rep view # # @yieldreturn [void] # # @return [self] def each @item_reps.each { |ir| yield view_class.new(ir, @context) } self end # @return [Integer] def size @item_reps.size end # Return the item rep with the given name, or nil if no item rep exists. # # @param [Symbol] rep_name # # @return [nil] if no item rep with the given name was found # # @return [Nanoc::ItemRepView] if an item rep with the given name was found def [](rep_name) case rep_name when Symbol res = @item_reps.find { |ir| ir.name == rep_name } res && view_class.new(res, @context) when Fixnum raise ArgumentError, "expected ItemRepCollectionView#[] to be called with a symbol (you likely want `.reps[:default]` rather than `.reps[#{rep_name}]`)" else raise ArgumentError, 'expected ItemRepCollectionView#[] to be called with a symbol' end end # Return the item rep with the given name, or raises an exception if there # is no rep with the given name. # # @param [Symbol] rep_name # # @return [Nanoc::ItemRepView] # # @raise if no rep was found def fetch(rep_name) res = @item_reps.find { |ir| ir.name == rep_name } if res view_class.new(res, @context) else raise NoSuchItemRepError.new(rep_name) end end end end nanoc-4.4.7/lib/nanoc/base/core_ext/0000755000004100000410000000000013033443476017251 5ustar www-datawww-datananoc-4.4.7/lib/nanoc/base/core_ext/string.rb0000644000004100000410000000046713033443476021113 0ustar www-datawww-data# @api private module Nanoc::StringExtensions # Transforms string into an actual identifier # # @return [String] The identifier generated from the receiver def __nanoc_cleaned_identifier "/#{self}/".gsub(/^\/+|\/+$/, '/') end end # @api private class String include Nanoc::StringExtensions end nanoc-4.4.7/lib/nanoc/base/core_ext/hash.rb0000644000004100000410000000230113033443476020515 0ustar www-datawww-data# @api private module Nanoc::HashExtensions # Returns a new hash where all keys are recursively converted to symbols by # calling {Nanoc::ArrayExtensions#__nanoc_symbolize_keys_recursively} or # {Nanoc::HashExtensions#__nanoc_symbolize_keys_recursively}. # # @return [Hash] The converted hash def __nanoc_symbolize_keys_recursively hash = {} each_pair do |key, value| new_key = key.respond_to?(:to_sym) ? key.to_sym : key new_value = value.respond_to?(:__nanoc_symbolize_keys_recursively) ? value.__nanoc_symbolize_keys_recursively : value hash[new_key] = new_value end hash end # Freezes the contents of the hash, as well as all hash values. The hash # values will be frozen using {#__nanoc_freeze_recursively} if they respond to # that message, or #freeze if they do not. # # @see Array#__nanoc_freeze_recursively # # @return [void] def __nanoc_freeze_recursively return if frozen? freeze each_pair do |_key, value| if value.respond_to?(:__nanoc_freeze_recursively) value.__nanoc_freeze_recursively else value.freeze end end end end # @api private class Hash include Nanoc::HashExtensions end nanoc-4.4.7/lib/nanoc/base/core_ext/array.rb0000644000004100000410000000215213033443476020714 0ustar www-datawww-data# @api private module Nanoc::ArrayExtensions # Returns a new array where all items' keys are recursively converted to # symbols by calling {Nanoc::ArrayExtensions#__nanoc_symbolize_keys_recursively} or # {Nanoc::HashExtensions#__nanoc_symbolize_keys_recursively}. # # @return [Array] The converted array def __nanoc_symbolize_keys_recursively array = [] each do |element| array << (element.respond_to?(:__nanoc_symbolize_keys_recursively) ? element.__nanoc_symbolize_keys_recursively : element) end array end # Freezes the contents of the array, as well as all array elements. The # array elements will be frozen using {#__nanoc_freeze_recursively} if they respond # to that message, or #freeze if they do not. # # @see Hash#__nanoc_freeze_recursively # # @return [void] def __nanoc_freeze_recursively return if frozen? freeze each do |value| if value.respond_to?(:__nanoc_freeze_recursively) value.__nanoc_freeze_recursively else value.freeze end end end end # @api private class Array include Nanoc::ArrayExtensions end nanoc-4.4.7/lib/nanoc/base/core_ext/pathname.rb0000644000004100000410000000017313033443476021374 0ustar www-datawww-data# @api private module Nanoc::PathnameExtensions end # @api private class Pathname include Nanoc::PathnameExtensions end nanoc-4.4.7/lib/nanoc/base/plugin_registry.rb0000644000004100000410000001556113033443476021224 0ustar www-datawww-datamodule Nanoc::Int # The class responsible for keeping track of all loaded plugins, such as # filters ({Nanoc::Filter}) and data sources ({Nanoc::DataSource}). # # @api private class PluginRegistry extend Nanoc::Int::Memoization # A module that contains class methods for plugins. It provides functions # for setting identifiers, registering plugins and finding plugins. Plugin # classes should extend this module. module PluginMethods # @overload identifiers(*identifiers) # # Sets the identifiers for this plugin. # # @param [Array] identifiers A list of identifiers to assign to # this plugin. # # @return [void] # # @overload identifiers # # @return [Array] The identifiers for this plugin def identifiers(*identifiers) if identifiers.empty? registry = Nanoc::Int::PluginRegistry.instance registry.identifiers_of(registry.root_class_of(self), self) else register(self, *identifiers) end end # @overload identifier(identifier) # # Sets the identifier for this plugin. # # @param [Symbol] identifier An identifier to assign to this plugin. # # @return [void] # # @overload identifier # # @return [Symbol] The first identifier for this plugin def identifier(identifier = nil) if identifier identifiers(identifier) else registry = Nanoc::Int::PluginRegistry.instance registry.identifiers_of(registry.root_class_of(self), self).first end end # Registers the given class as a plugin with the given identifier. # # @param [Class, String] class_or_name The class to register, or a # string containing the class name to register. # # @param [Array] identifiers A list of identifiers to assign to # this plugin. # # @return [void] def register(class_or_name, *identifiers) registry = Nanoc::Int::PluginRegistry.instance root = registry.root_class_of(self) registry.register(root, class_or_name, *identifiers) end # @return [Hash] All plugins of this type, with keys # being the identifiers and values the plugin classes def all Nanoc::Int::PluginRegistry.instance.find_all(self) end # Returns the plugin with the given name (identifier) # # @param [String] name The name of the plugin class to find # # @return [Class] The plugin class with the given name def named(name) Nanoc::Int::PluginRegistry.instance.find(self, name) end end # Returns the shared {PluginRegistry} instance, creating it if none exists # yet. # # @return [Nanoc::Int::PluginRegistry] The shared plugin registry def self.instance @instance ||= new end # Creates a new plugin registry. This should usually not be necessary; it # is recommended to use the shared instance (obtained from # {Nanoc::Int::PluginRegistry.instance}). def initialize @identifiers_to_classes = {} @classes_to_identifiers = {} end # Registers the given class as a plugin. # # @param [Class] superclass The superclass of the plugin. For example: # {Nanoc::Filter}. # # @param [Class, String] class_or_name The class to register. This can be # a string, in which case it will be automatically converted to a proper # class at lookup. For example: `Nanoc::Filters::ERB`, # `"Nanoc::Filters::Haml"`. # # @param [Symbol] identifiers One or more symbols identifying the class. # For example: `:haml`, :`erb`. # # @return [void] def register(superclass, class_or_name, *identifiers) @identifiers_to_classes[superclass] ||= {} @classes_to_identifiers[superclass] ||= {} identifiers.each do |identifier| @identifiers_to_classes[superclass][identifier.to_sym] = class_or_name (@classes_to_identifiers[superclass][name_for_class(class_or_name)] ||= []) << identifier.to_sym end end # @param [Class] superclass The superclass of the plugin. For example: # {Nanoc::Filter}. # # @param [Class] klass The class to get the identifiers for. # # @return [Array] An array of identifiers for the given class def identifiers_of(superclass, klass) (@classes_to_identifiers[superclass] || {})[name_for_class(klass)] || [] end # Finds the plugin that is a subclass of the given class and has the given # name. # # @param [Class] klass The class of the plugin to return # # @param [Symbol] name The name of the plugin to return # # @return [Class, nil] The plugin with the given name def find(klass, name) @identifiers_to_classes[klass] ||= {} resolve(@identifiers_to_classes[klass][name.to_sym], klass) end # Returns all plugins of the given class. # # @param [Class] klass The class of the plugin to return # # @return [Enumerable] A collection of class plugins def find_all(klass) @identifiers_to_classes[klass] ||= {} res = {} @identifiers_to_classes[klass].each_pair { |k, v| res[k] = resolve(v, k) } res end # @param [Class] subclass # # @return [Class] # # @api private def root_class_of(subclass) root_class = subclass root_class = root_class.superclass while root_class.superclass.respond_to?(:register) root_class end # Returns a list of all plugins. The returned list of plugins is an array # with array elements in the following format: # # { :class => ..., :superclass => ..., :identifiers => ... } # # @return [Array] A list of all plugins in the format described def all plugins = [] @identifiers_to_classes.each_pair do |superclass, submap| submap.each_pair do |identifier, klass| # Find existing plugin existing_plugin = plugins.find do |p| p[:class] == klass && p[:superclass] == superclass end if existing_plugin # Add identifier to existing plugin existing_plugin[:identifiers] << identifier existing_plugin[:identifiers] = existing_plugin[:identifiers].sort_by(&:to_s) else # Create new plugin plugins << { class: klass, superclass: superclass, identifiers: [identifier], } end end end plugins end protected def resolve(class_or_name, _klass) if class_or_name.is_a?(String) Kernel.const_get(class_or_name) else class_or_name end end memoize :resolve def name_for_class(klass) klass.to_s.sub(/^(::)?/, '::') end end end nanoc-4.4.7/lib/nanoc/base/repos.rb0000644000004100000410000000062113033443476017115 0ustar www-datawww-datarequire_relative 'repos/store' require_relative 'repos/checksum_store' require_relative 'repos/compiled_content_cache' require_relative 'repos/config_loader' require_relative 'repos/data_source' require_relative 'repos/dependency_store' require_relative 'repos/item_rep_repo' require_relative 'repos/outdatedness_store' require_relative 'repos/rule_memory_store' require_relative 'repos/site_loader' nanoc-4.4.7/lib/nanoc/base/errors.rb0000644000004100000410000002226713033443476017313 0ustar www-datawww-datamodule Nanoc::Int # Module that contains all Nanoc-specific errors. # # @api private module Errors Generic = ::Nanoc::Error # Generic trivial error. Superclass for all Nanoc-specific errors that are # considered "trivial", i.e. errors that do not require a full crash report. class GenericTrivial < Generic end # Error that is raised when compilation of an item rep fails. The # underlying error is available by calling `#unwrap`. class CompilationError < Generic attr_reader :item_rep def initialize(wrapped, item_rep) @wrapped = wrapped @item_rep = item_rep end def unwrap @wrapped end end # Error that is raised when a site is loaded that uses a data source with # an unknown identifier. class UnknownDataSource < Generic # @param [String] data_source_name The data source name for which no # data source could be found def initialize(data_source_name) super("The data source specified in the site’s configuration file, “#{data_source_name}”, does not exist.") end end # Error that is raised during site compilation when an item uses a layout # that is not present in the site. class UnknownLayout < Generic # @param [String] layout_identifier The layout identifier for which no # layout could be found def initialize(layout_identifier) super("The site does not have a layout with identifier “#{layout_identifier}”.") end end # Error that is raised during site compilation when an item uses a filter # that is not known. class UnknownFilter < Generic # @param [Symbol] filter_name The filter name for which no filter could # be found def initialize(filter_name) super("The requested filter, “#{filter_name}”, does not exist.") end end # Error that is raised during site compilation when a layout is compiled # for which the filter cannot be determined. This is similar to the # {UnknownFilter} error, but specific for filters for layouts. class CannotDetermineFilter < Generic # @param [String] layout_identifier The identifier of the layout for # which the filter could not be determined def initialize(layout_identifier) super("The filter to be used for the “#{layout_identifier}” layout could not be determined. Make sure the layout does have a filter.") end end # Error that is raised during site compilation when an item (directly or # indirectly) includes its own item content, leading to endless recursion. class RecursiveCompilation < Generic # @param [Array] reps A list of item representations # that mutually depend on each other def initialize(reps) list = reps.map(&:inspect).join("\n") super("The site cannot be compiled because the following items mutually depend on each other:\n#{list}.") end end # Error that is raised when no rules file can be found in the current # working directory. class NoRulesFileFound < Generic def initialize super('This site does not have a rules file, which is required for Nanoc sites.') end end # Error that is raised when no compilation rule that can be applied to the # current item can be found. class NoMatchingCompilationRuleFound < Generic # @param [Nanoc::Int::Item] item The item for which no compilation rule # could be found def initialize(item) super("No compilation rules were found for the “#{item.identifier}” item.") end end # Error that is raised when no routing rule that can be applied to the # current item can be found. class NoMatchingRoutingRuleFound < Generic # @param [Nanoc::Int::ItemRep] rep The item repiresentation for which no # routing rule could be found def initialize(rep) super("No routing rules were found for the “#{rep.item.identifier}” item (rep “#{rep.name}”).") end end # Error that is raised when an rep cannot be compiled because it depends # on other representations. class UnmetDependency < Generic # @return [Nanoc::Int::ItemRep] The item representation that cannot yet be # compiled attr_reader :rep # @param [Nanoc::Int::ItemRep] rep The item representation that cannot yet be # compiled def initialize(rep) @rep = rep super("The current item cannot be compiled yet because of an unmet dependency on the “#{rep.item.identifier}” item (rep “#{rep.name}”).") end end # Error that is raised when a binary item is attempted to be laid out. class CannotLayoutBinaryItem < Generic # @param [Nanoc::Int::ItemRep] rep The item representation that was attempted # to be laid out def initialize(rep) super("The “{rep.item.identifier}” item (rep “#{rep.name}”) cannot be laid out because it is a binary item. If you are getting this error for an item that should be textual instead of binary, make sure that its extension is included in the text_extensions array in the site configuration.") end end # Error that is raised when a textual filter is attempted to be applied to # a binary item representation. class CannotUseTextualFilter < Generic # @param [Nanoc::Int::ItemRep] rep The item representation that was # attempted to be filtered # # @param [Class] filter_class The filter class that was used def initialize(rep, filter_class) super("The “#{filter_class.inspect}” filter cannot be used to filter the “#{rep.item.identifier}” item (rep “#{rep.name}”), because textual filters cannot be used on binary items.") end end # Error that is raised when a binary filter is attempted to be applied to # a textual item representation. class CannotUseBinaryFilter < Generic # @param [Nanoc::Int::ItemRep] rep The item representation that was # attempted to be filtered # # @param [Class] filter_class The filter class that was used def initialize(rep, filter_class) super("The “#{filter_class.inspect}” filter cannot be used to filter the “#{rep.item.identifier}” item (rep “#{rep.name}”), because binary filters cannot be used on textual items. If you are getting this error for an item that should be textual instead of binary, make sure that its extension is included in the text_extensions array in the site configuration.") end end # Error that is raised when the compiled content at a non-existing snapshot # is requested. class NoSuchSnapshot < Generic # @return [Nanoc::Int::ItemRep] The item rep from which the compiled content # was requested attr_reader :item_rep # @return [Symbol] The requested snapshot attr_reader :snapshot # @param [Nanoc::Int::ItemRep] item_rep The item rep from which the compiled # content was requested # # @param [Symbol] snapshot The requested snapshot def initialize(item_rep, snapshot) @item_rep = item_rep @snapshot = snapshot super("The “#{item_rep.inspect}” item rep does not have a snapshot “#{snapshot.inspect}”") end end # Error that is raised when a snapshot with an existing name is made. class CannotCreateMultipleSnapshotsWithSameName < Generic # @param [Nanoc::Int::ItemRep] rep The item representation for which a # snapshot was attempted to be made # # @param [Symbol] snapshot The name of the snapshot that was attempted to # be made def initialize(rep, snapshot) super("Attempted to create a snapshot with a duplicate name #{snapshot.inspect} for the item rep “#{rep.inspect}”") end end # Error that is raised when the compiled content of a binary item is attempted to be accessed. class CannotGetCompiledContentOfBinaryItem < Generic # @param [Nanoc::Int::ItemRep] rep The binary item representation whose compiled content was attempted to be accessed def initialize(rep) super("You cannot access the compiled content of a binary item representation (but you can access the path). The offending item rep is #{rep.inspect}.") end end # Error that is raised when multiple items or layouts with the same identifier exist. class DuplicateIdentifier < Generic def initialize(identifier, type) super("There are multiple #{type}s with the #{identifier} identifier.") end end # Error that is raised when attempting to call #parent or #children on an item with a legacy identifier. class CannotGetParentOrChildrenOfNonLegacyItem < Generic def initialize(identifier) super("You cannot get the parent or children of an item that has a “full” identifier (#{identifier}). Getting the parent or children of an item is only possible for items that have a legacy identifier.") end end class UndefinedFilterForLayout < Generic def initialize(layout) super("There is no filter defined for the layout #{layout.identifier}") end end class InternalInconsistency < Generic end end end nanoc-4.4.7/lib/nanoc/base/entities/0000755000004100000410000000000013033443476017265 5ustar www-datawww-datananoc-4.4.7/lib/nanoc/base/entities/code_snippet.rb0000644000004100000410000000227513033443476022274 0ustar www-datawww-datamodule Nanoc::Int # Nanoc::Int::CodeSnippet represent a piece of custom code of a Nanoc site. # # @api private class CodeSnippet include Nanoc::Int::ContractsSupport # A string containing the actual code in this code snippet. # # @return [String] attr_reader :data # The filename corresponding to this code snippet. # # @return [String] attr_reader :filename contract String, String => C::Any # Creates a new code snippet. # # @param [String] data The raw source code which will be executed before # compilation # # @param [String] filename The filename corresponding to this code snippet def initialize(data, filename) @data = data @filename = filename end contract C::None => nil # Loads the code by executing it. # # @return [void] def load eval(@data, TOPLEVEL_BINDING, @filename) nil end # Returns an object that can be used for uniquely identifying objects. # # @return [Object] An unique reference to this object def reference [:code_snippet, filename] end def inspect "<#{self.class} filename=\"#{filename}\">" end end end nanoc-4.4.7/lib/nanoc/base/entities/identifiable_collection.rb0000644000004100000410000000366713033443476024460 0ustar www-datawww-datamodule Nanoc::Int # @api private class IdentifiableCollection include Nanoc::Int::ContractsSupport include Enumerable extend Forwardable def_delegator :@objects, :each def_delegator :@objects, :size def_delegator :@objects, :<< def_delegator :@objects, :concat contract C::Or[Hash, C::Named['Nanoc::Int::Configuration']] => C::Any def initialize(config) @config = config @objects = [] end contract C::None => self def freeze @objects.freeze @objects.each(&:freeze) build_mapping super end contract C::Any => C::Maybe[C::RespondTo[:identifier]] def [](arg) case arg when Nanoc::Identifier object_with_identifier(arg) when String object_with_identifier(arg) || object_matching_glob(arg) when Regexp @objects.find { |i| i.identifier.to_s =~ arg } else raise ArgumentError, "don’t know how to fetch objects by #{arg.inspect}" end end contract C::None => C::ArrayOf[C::RespondTo[:identifier]] def to_a @objects end contract C::None => C::Bool def empty? @objects.empty? end contract C::Func[C::RespondTo[:identifier] => C::Bool] => self def delete_if(&block) @objects.delete_if(&block) self end protected def object_with_identifier(identifier) if frozen? @mapping[identifier.to_s] else @objects.find { |i| i.identifier == identifier } end end def object_matching_glob(glob) if use_globs? pat = Nanoc::Int::Pattern.from(glob) @objects.find { |i| pat.match?(i.identifier) } else nil end end def build_mapping @mapping = {} @objects.each do |object| @mapping[object.identifier.to_s] = object end @mapping.freeze end def use_globs? @config[:string_pattern_type] == 'glob' end end end nanoc-4.4.7/lib/nanoc/base/entities/configuration.rb0000644000004100000410000001005413033443476022461 0ustar www-datawww-datamodule Nanoc::Int # Represents the site configuration. # # @api private class Configuration include Nanoc::Int::ContractsSupport NONE = Object.new.freeze # The default configuration for a data source. A data source's # configuration overrides these options. DEFAULT_DATA_SOURCE_CONFIG = { type: 'filesystem', items_root: '/', layouts_root: '/', config: {}, identifier_type: 'full', }.freeze # The default configuration for a site. A site's configuration overrides # these options: when a {Nanoc::Int::Site} is created with a configuration # that lacks some options, the default value will be taken from # `DEFAULT_CONFIG`. DEFAULT_CONFIG = { text_extensions: %w(adoc asciidoc atom css erb haml htm html js less markdown md php rb sass scss txt xhtml xml coffee hb handlebars mustache ms slim rdoc).sort, lib_dirs: %w(lib), commands_dirs: %w(commands), output_dir: 'output', data_sources: [{}], index_filenames: ['index.html'], enable_output_diff: false, prune: { auto_prune: false, exclude: ['.git', '.hg', '.svn', 'CVS'] }, string_pattern_type: 'glob', }.freeze # @return [String, nil] The active environment for the configuration attr_reader :env_name # Configuration environments property key ENVIRONMENTS_CONFIG_KEY = :environments NANOC_ENV = 'NANOC_ENV'.freeze NANOC_ENV_DEFAULT = 'default'.freeze contract C::KeywordArgs[hash: C::Optional[Hash], env_name: C::Maybe[String]] => C::Any # Creates a new configuration with the given hash. # # @param [Hash] hash The actual configuration hash # @param [String, nil] env_name The active environment for this configuration def initialize(hash: {}, env_name: nil) @env_name = env_name @wrapped = hash.__nanoc_symbolize_keys_recursively end contract C::None => self def with_defaults new_wrapped = DEFAULT_CONFIG.merge(@wrapped) new_wrapped[:data_sources] = new_wrapped[:data_sources].map do |ds| DEFAULT_DATA_SOURCE_CONFIG.merge(ds) end self.class.new(hash: new_wrapped) end def with_environment return self unless @wrapped.key?(ENVIRONMENTS_CONFIG_KEY) # Set active environment env_name = @env_name || ENV.fetch(NANOC_ENV, NANOC_ENV_DEFAULT) # Load given environment configuration env_config = @wrapped[ENVIRONMENTS_CONFIG_KEY].fetch(env_name.to_sym, {}) self.class.new(hash: @wrapped, env_name: env_name).merge(env_config) end contract C::None => Hash def to_h @wrapped end contract C::Any => C::Bool def key?(key) @wrapped.key?(key) end contract C::Any => C::Any def [](key) @wrapped[key] end contract C::Any, C::Maybe[C::Any], C::Maybe[C::Func[C::None => C::Any]] => C::Any def fetch(key, fallback = NONE, &_block) @wrapped.fetch(key) do if !fallback.equal?(NONE) fallback elsif block_given? yield(key) else raise KeyError, "key not found: #{key.inspect}" end end end contract C::Any, C::Any => C::Any def []=(key, value) @wrapped[key] = value end contract C::Or[Hash, self] => self def merge(hash) self.class.new(hash: @wrapped.merge(hash.to_h), env_name: @env_name) end contract C::Any => self def without(key) self.class.new(hash: @wrapped.reject { |k, _v| k == key }, env_name: @env_name) end contract C::Any => self def update(hash) @wrapped.update(hash) self end contract C::Func[C::Any, C::Any => C::Any] => self def each @wrapped.each { |k, v| yield(k, v) } self end contract C::None => self def freeze super @wrapped.__nanoc_freeze_recursively self end # Returns an object that can be used for uniquely identifying objects. # # @return [Object] An unique reference to this object def reference :config end def inspect "<#{self.class}>" end end end nanoc-4.4.7/lib/nanoc/base/entities/props.rb0000644000004100000410000000353713033443476020765 0ustar www-datawww-datamodule Nanoc::Int # @api private class Props include Nanoc::Int::ContractsSupport contract C::KeywordArgs[raw_content: C::Optional[C::Bool], attributes: C::Optional[C::Bool], compiled_content: C::Optional[C::Bool], path: C::Optional[C::Bool]] => C::Any def initialize(raw_content: false, attributes: false, compiled_content: false, path: false) @raw_content = raw_content @attributes = attributes @compiled_content = compiled_content @path = path end contract C::None => String def inspect ''.tap do |s| s << 'Props(' s << (raw_content? ? 'r' : '_') s << (attributes? ? 'a' : '_') s << (compiled_content? ? 'c' : '_') s << (path? ? 'p' : '_') s << ')' end end contract C::None => C::Bool def raw_content? @raw_content end contract C::None => C::Bool def attributes? @attributes end contract C::None => C::Bool def compiled_content? @compiled_content end contract C::None => C::Bool def path? @path end contract Nanoc::Int::Props => Nanoc::Int::Props def merge(other) Props.new( raw_content: raw_content? || other.raw_content?, attributes: attributes? || other.attributes?, compiled_content: compiled_content? || other.compiled_content?, path: path? || other.path?, ) end contract C::None => Set def active Set.new.tap do |pr| pr << :raw_content if raw_content? pr << :attributes if attributes? pr << :compiled_content if compiled_content? pr << :path if path? end end contract C::None => Hash def to_h { raw_content: raw_content?, attributes: attributes?, compiled_content: compiled_content?, path: path?, } end end end nanoc-4.4.7/lib/nanoc/base/entities/pattern.rb0000644000004100000410000000334713033443476021276 0ustar www-datawww-datamodule Nanoc::Int # @api private class Pattern include Nanoc::Int::ContractsSupport contract C::Any => self def self.from(obj) case obj when Nanoc::Int::StringPattern, Nanoc::Int::RegexpPattern obj when String Nanoc::Int::StringPattern.new(obj) when Regexp Nanoc::Int::RegexpPattern.new(obj) else raise ArgumentError, "Do not know how to convert `#{obj.inspect}` into a Nanoc::Pattern" end end def initialize(_obj) raise NotImplementedError end def match?(_identifier) raise NotImplementedError end def captures(_identifier) raise NotImplementedError end end # @api private class StringPattern < Pattern MATCH_OPTS = File::FNM_PATHNAME | File::FNM_EXTGLOB contract String => C::Any def initialize(string) @string = string end contract C::Or[Nanoc::Identifier, String] => C::Bool def match?(identifier) File.fnmatch(@string, identifier.to_s, MATCH_OPTS) end contract C::Or[Nanoc::Identifier, String] => nil def captures(_identifier) nil end contract C::None => String def to_s @string end end # @api private class RegexpPattern < Pattern contract Regexp => C::Any def initialize(regexp) @regexp = regexp end contract C::Or[Nanoc::Identifier, String] => C::Bool def match?(identifier) (identifier.to_s =~ @regexp) != nil end contract C::Or[Nanoc::Identifier, String] => C::Maybe[C::ArrayOf[String]] def captures(identifier) matches = @regexp.match(identifier.to_s) matches && matches.captures end contract C::None => String def to_s @regexp.to_s end end end nanoc-4.4.7/lib/nanoc/base/entities/context.rb0000644000004100000410000000300213033443476021271 0ustar www-datawww-datamodule Nanoc::Int # Provides a context and a binding for use in filters such as the ERB and # Haml ones. # # @api private class Context # Creates a new context based off the contents of the hash. # # Each pair in the hash will be converted to an instance variable and an # instance method. For example, passing the hash `{ :foo => 'bar' }` will # cause `@foo` to have the value `"bar"`, and the instance method `#foo` # to return the same value `"bar"`. # # @param [Hash] hash A list of key-value pairs to make available # # @example Defining a context and accessing values # # context = Nanoc::Int::Context.new( # :name => 'Max Payne', # :location => 'in a cheap motel' # ) # context.instance_eval do # "I am #{name} and I am hiding #{@location}." # end # # => "I am Max Payne and I am hiding in a cheap motel." def initialize(hash) metaclass = class << self; self; end hash.each_pair do |key, value| instance_variable_set('@' + key.to_s, value) metaclass.send(:define_method, key) { value } end end # Returns a binding for this instance. # # @return [Binding] A binding for this instance # rubocop:disable Style/AccessorMethodName def get_binding binding end # rubocop:enable Style/AccessorMethodName def include(mod) metaclass = class << self; self; end metaclass.instance_eval { include(mod) } end end end nanoc-4.4.7/lib/nanoc/base/entities/dependency.rb0000644000004100000410000000144013033443476021727 0ustar www-datawww-datamodule Nanoc::Int # @api private # A dependency between two items/layouts. class Dependency include Nanoc::Int::ContractsSupport contract C::None => C::Maybe[C::Or[Nanoc::Int::Item, Nanoc::Int::Layout]] attr_reader :from contract C::None => C::Maybe[C::Or[Nanoc::Int::Item, Nanoc::Int::Layout]] attr_reader :to contract C::None => Nanoc::Int::Props attr_reader :props contract C::Maybe[C::Or[Nanoc::Int::Item, Nanoc::Int::Layout]], C::Maybe[C::Or[Nanoc::Int::Item, Nanoc::Int::Layout]], Nanoc::Int::Props => C::Any def initialize(from, to, props) @from = from @to = to @props = props end contract C::None => String def inspect "Dependency(#{@from.inspect} -> #{@to.inspect}, #{@props.inspect})" end end end nanoc-4.4.7/lib/nanoc/base/entities/item.rb0000644000004100000410000000046013033443476020550 0ustar www-datawww-datamodule Nanoc::Int # @api private class Item < ::Nanoc::Int::Document # Returns an object that can be used for uniquely identifying objects. # # @api private # # @return [Object] An unique reference to this object def reference [:item, identifier.to_s] end end end nanoc-4.4.7/lib/nanoc/base/entities/outdatedness_status.rb0000644000004100000410000000072713033443476023725 0ustar www-datawww-datamodule Nanoc::Int # @api private class OutdatednessStatus attr_reader :reasons attr_reader :props def initialize(reasons: [], props: Props.new) @reasons = reasons @props = props end def useful_to_apply?(rule) (rule.instance.reason.props.active - @props.active).any? end def update(reason) self.class.new( reasons: @reasons + [reason], props: @props.merge(reason.props), ) end end end nanoc-4.4.7/lib/nanoc/base/entities/lazy_value.rb0000644000004100000410000000206313033443476021766 0ustar www-datawww-datamodule Nanoc::Int # Holds a value that might be generated lazily. # # @api private class LazyValue include Nanoc::Int::ContractsSupport # @param [Object, Proc] value_or_proc A value or a proc to generate the value def initialize(value_or_proc) @value = { raw: value_or_proc } end # @return [Object] The value, generated when needed def value if @value.key?(:raw) value = @value.delete(:raw) @value[:final] = value.respond_to?(:call) ? value.call : value @value.__nanoc_freeze_recursively if frozen? end @value[:final] end contract C::Func[C::Any => C::Any] => self # Returns a new lazy value that will apply the given transformation when the value is requested. # # @yield resolved value # # @return [Nanoc::Int::LazyValue] def map Nanoc::Int::LazyValue.new(-> { yield(value) }) end contract C::None => self # @return [void] def freeze super @value.__nanoc_freeze_recursively unless @value[:raw] self end end end nanoc-4.4.7/lib/nanoc/base/entities/document.rb0000644000004100000410000000517313033443476021436 0ustar www-datawww-datamodule Nanoc module Int # @api private class Document include Nanoc::Int::ContractsSupport # @return [Nanoc::Int::Content] attr_accessor :content # @return [Hash] def attributes @attributes.value end # @return [Nanoc::Identifier] attr_accessor :identifier # @return [String, nil] attr_accessor :checksum_data # @return [String, nil] attr_accessor :content_checksum_data # @return [String, nil] attr_accessor :attributes_checksum_data c_content = C::Or[String, Nanoc::Int::Content] c_attributes = C::Or[Hash, Proc] c_identifier = C::Or[String, Nanoc::Identifier] c_checksum_data = C::KeywordArgs[ checksum_data: C::Optional[C::Maybe[String]], content_checksum_data: C::Optional[C::Maybe[String]], attributes_checksum_data: C::Optional[C::Maybe[String]], ] contract c_content, c_attributes, c_identifier, c_checksum_data => C::Any # @param [String, Nanoc::Int::Content] content # # @param [Hash, Proc] attributes # # @param [String, Nanoc::Identifier] identifier # # @param [String, nil] checksum_data # # @param [String, nil] content_checksum_data # # @param [String, nil] attributes_checksum_data def initialize(content, attributes, identifier, checksum_data: nil, content_checksum_data: nil, attributes_checksum_data: nil) @content = Nanoc::Int::Content.create(content) @attributes = Nanoc::Int::LazyValue.new(attributes).map(&:__nanoc_symbolize_keys_recursively) @identifier = Nanoc::Identifier.from(identifier) @checksum_data = checksum_data @content_checksum_data = content_checksum_data @attributes_checksum_data = attributes_checksum_data end contract C::None => self # @return [void] def freeze super @content.freeze @attributes.freeze self end contract C::None => String # @abstract # # @return Unique reference to this object def reference raise NotImplementedError end contract C::None => String def inspect "<#{self.class} identifier=\"#{identifier}\">" end contract C::None => C::Num def hash self.class.hash ^ identifier.hash end contract C::Any => C::Bool def ==(other) other.respond_to?(:identifier) && identifier == other.identifier end contract C::Any => C::Bool def eql?(other) other.is_a?(self.class) && identifier == other.identifier end end end end nanoc-4.4.7/lib/nanoc/base/entities/processing_action.rb0000644000004100000410000000072013033443476023322 0ustar www-datawww-datamodule Nanoc::Int class ProcessingAction def serialize raise NotImplementedError.new('Nanoc::ProcessingAction subclasses must implement #serialize and #to_s') end def to_s raise NotImplementedError.new('Nanoc::ProcessingAction subclasses must implement #serialize and #to_s') end def inspect format( '<%s %s>', self.class.to_s, serialize[1..-1].map(&:inspect).join(', '), ) end end end nanoc-4.4.7/lib/nanoc/base/entities/outdatedness_reasons.rb0000644000004100000410000000436013033443476024051 0ustar www-datawww-datamodule Nanoc::Int # Module that contains all outdatedness reasons. # # @api private module OutdatednessReasons # A generic outdatedness reason. An outdatedness reason is basically a # descriptive message that explains why a given object is outdated. class Generic # @return [String] A descriptive message for this outdatedness reason attr_reader :message # @return [Nanoc::Int::Props] attr_reader :props # @param [String] message The descriptive message for this outdatedness # reason def initialize(message, props = Nanoc::Int::Props.new) @message = message @props = props end end CodeSnippetsModified = Generic.new( 'The code snippets have been modified since the last time the site was compiled.', Props.new(raw_content: true, attributes: true, compiled_content: true, path: true), ) ConfigurationModified = Generic.new( 'The site configuration has been modified since the last time the site was compiled.', Props.new(raw_content: true, attributes: true, compiled_content: true, path: true), ) DependenciesOutdated = Generic.new( 'This item uses content or attributes that have changed since the last time the site was compiled.', ) NotWritten = Generic.new( 'This item representation has not yet been written to the output directory (but it does have a path).', Props.new(raw_content: true, attributes: true, compiled_content: true, path: true), ) RulesModified = Generic.new( 'The rules file has been modified since the last time the site was compiled.', Props.new(compiled_content: true, path: true), ) ContentModified = Generic.new( 'The content of this item has been modified since the last time the site was compiled.', Props.new(raw_content: true, compiled_content: true), ) AttributesModified = Generic.new( 'The attributes of this item have been modified since the last time the site was compiled.', Props.new(attributes: true, compiled_content: true), ) PathsModified = Generic.new( 'One or more output paths of this item have been modified since the last time the site was compiled.', Props.new(path: true), ) end end nanoc-4.4.7/lib/nanoc/base/entities/site.rb0000644000004100000410000000273513033443476020565 0ustar www-datawww-datamodule Nanoc::Int # @api private class Site include Nanoc::Int::ContractsSupport attr_accessor :compiler contract C::KeywordArgs[config: Nanoc::Int::Configuration, code_snippets: C::IterOf[Nanoc::Int::CodeSnippet], items: C::IterOf[Nanoc::Int::Item], layouts: C::IterOf[Nanoc::Int::Layout]] => C::Any def initialize(config:, code_snippets:, items:, layouts:) @config = config @code_snippets = code_snippets @items = items @layouts = layouts ensure_identifier_uniqueness(@items, 'item') ensure_identifier_uniqueness(@layouts, 'layout') end contract C::None => self def compile compiler.run_all self end contract C::None => C::Named['Nanoc::Int::Compiler'] def compiler @compiler ||= Nanoc::Int::CompilerLoader.new.load(self) end attr_reader :code_snippets attr_reader :config attr_reader :items attr_reader :layouts contract C::None => self def freeze config.freeze items.freeze layouts.freeze code_snippets.__nanoc_freeze_recursively self end contract C::IterOf[C::Or[Nanoc::Int::Item, Nanoc::Int::Layout]], String => self def ensure_identifier_uniqueness(objects, type) seen = Set.new objects.each do |obj| if seen.include?(obj.identifier) raise Nanoc::Int::Errors::DuplicateIdentifier.new(obj.identifier, type) end seen << obj.identifier end self end end end nanoc-4.4.7/lib/nanoc/base/entities/snapshot_def.rb0000644000004100000410000000034113033443476022265 0ustar www-datawww-datamodule Nanoc module Int class SnapshotDef include Nanoc::Int::ContractsSupport attr_reader :name contract Symbol => C::Any def initialize(name) @name = name end end end end nanoc-4.4.7/lib/nanoc/base/entities/identifier.rb0000644000004100000410000001100613033443476021732 0ustar www-datawww-datamodule Nanoc class Identifier include Comparable include Nanoc::Int::ContractsSupport # @api private class InvalidIdentifierError < ::Nanoc::Error def initialize(string) super("Invalid identifier (does not start with a slash): #{string.inspect}") end end # @api private class InvalidTypeError < ::Nanoc::Error def initialize(type) super("Invalid type for identifier: #{type.inspect} (can be :full or :legacy)") end end # @api private class InvalidPrefixError < ::Nanoc::Error def initialize(string) super("Invalid prefix (does not start with a slash): #{string.inspect}") end end # @api private class UnsupportedLegacyOperationError < ::Nanoc::Error def initialize super('Cannot use this method on legacy identifiers') end end # @api private class NonCoercibleObjectError < ::Nanoc::Error def initialize(obj) super("#{obj.inspect} cannot be converted into a Nanoc::Identifier") end end contract C::Any => self def self.from(obj) case obj when Nanoc::Identifier obj when String Nanoc::Identifier.new(obj) else raise NonCoercibleObjectError.new(obj) end end contract String, C::KeywordArgs[type: C::Optional[Symbol]] => C::Any def initialize(string, type: :full) @type = type case @type when :legacy @string = "/#{string}/".gsub(/^\/+|\/+$/, '/').freeze when :full if string !~ /\A\// raise InvalidIdentifierError.new(string) end @string = string.dup.freeze else raise InvalidTypeError.new(@type) end end contract C::Any => C::Bool def ==(other) case other when Nanoc::Identifier, String to_s == other.to_s else false end end contract C::Any => C::Bool def eql?(other) other.is_a?(self.class) && to_s == other.to_s end contract C::None => C::Num def hash self.class.hash ^ to_s.hash end contract C::Any => C::Maybe[C::Num] def =~(other) Nanoc::Int::Pattern.from(other).match?(to_s) ? 0 : nil end contract C::Any => C::Num def <=>(other) to_s <=> other.to_s end contract C::None => C::Bool # Whether or not this is a full identifier (i.e.includes the extension). def full? @type == :full end contract C::None => C::Bool # Whether or not this is a legacy identifier (i.e. does not include the extension). def legacy? @type == :legacy end contract C::None => String # @return [String] def chop to_s.chop end contract String => String # @return [String] def +(other) to_s + other end contract String => self # @return [Nanoc::Identifier] def prefix(string) if string !~ /\A\// raise InvalidPrefixError.new(string) end Nanoc::Identifier.new(string.sub(/\/+\z/, '') + @string, type: @type) end contract C::None => String # The identifier, as string, with the last extension removed def without_ext unless full? raise UnsupportedLegacyOperationError end extname = File.extname(@string) if !extname.empty? @string[0..-extname.size - 1] else @string end end contract C::None => C::Maybe[String] # The extension, without a leading dot def ext unless full? raise UnsupportedLegacyOperationError end s = File.extname(@string) s && s[1..-1] end contract C::None => String # The identifier, as string, with all extensions removed def without_exts extname = exts.join('.') if !extname.empty? @string[0..-extname.size - 2] else @string end end contract C::None => C::ArrayOf[String] # The list of extensions, without a leading dot def exts unless full? raise UnsupportedLegacyOperationError end s = File.basename(@string) s ? s.split('.', -1).drop(1) : [] end contract C::None => C::ArrayOf[String] def components res = to_s.split('/') if res.empty? [] else res[1..-1] end end contract C::None => String def to_s @string end contract C::None => String def to_str @string end contract C::None => String def inspect "" end end end nanoc-4.4.7/lib/nanoc/base/entities/layout.rb0000644000004100000410000000021313033443476021123 0ustar www-datawww-datamodule Nanoc::Int # @api private class Layout < ::Nanoc::Int::Document def reference [:layout, identifier] end end end nanoc-4.4.7/lib/nanoc/base/entities/item_rep.rb0000644000004100000410000000770313033443476021425 0ustar www-datawww-datamodule Nanoc::Int # @api private class ItemRep include Nanoc::Int::ContractsSupport # @return [Hash] attr_accessor :snapshot_contents # @return [Boolean] attr_accessor :compiled alias compiled? compiled # @return [Hash] attr_accessor :raw_paths # @return [Hash] attr_accessor :paths # @return [Nanoc::Int::Item] attr_reader :item # @return [Symbol] attr_reader :name # @return [Enumerable C::Any # @param [Nanoc::Int::Item] item # # @param [Symbol] name def initialize(item, name) # Set primary attributes @item = item @name = name # Set default attributes @raw_paths = {} @paths = {} @snapshot_defs = [] @snapshot_contents = { last: @item.content } # Reset flags @compiled = false end contract C::None => C::Bool def binary? @snapshot_contents[:last].binary? end contract C::KeywordArgs[snapshot: C::Optional[C::Maybe[Symbol]]] => String # Returns the compiled content from a given snapshot. # # @param [Symbol] snapshot The name of the snapshot from which to # fetch the compiled content. By default, the returned compiled content # will be the content compiled right before the first layout call (if # any). # # @return [String] The compiled content at the given snapshot (or the # default snapshot if no snapshot is specified) def compiled_content(snapshot: nil) # Get name of last pre-layout snapshot snapshot_name = snapshot || (@snapshot_contents[:pre] ? :pre : :last) # Check existance of snapshot snapshot_def = snapshot_defs.reverse.find { |sd| sd.name == snapshot_name } unless snapshot_def raise Nanoc::Int::Errors::NoSuchSnapshot.new(self, snapshot_name) end # Verify snapshot is usable stopped_moving = snapshot_name != :last || compiled? is_usable_snapshot = @snapshot_contents[snapshot_name] && stopped_moving unless is_usable_snapshot Fiber.yield(Nanoc::Int::Errors::UnmetDependency.new(self)) return compiled_content(snapshot: snapshot) end # Verify snapshot is not binary snapshot_content = @snapshot_contents[snapshot_name] if snapshot_content.binary? raise Nanoc::Int::Errors::CannotGetCompiledContentOfBinaryItem.new(self) end snapshot_content.string end contract C::KeywordArgs[snapshot: C::Optional[Symbol]] => C::Maybe[String] # Returns the item rep’s raw path. It includes the path to the output # directory and the full filename. # # @param [Symbol] snapshot The snapshot for which the path should be # returned # # @return [String] The item rep’s path def raw_path(snapshot: :last) @raw_paths[snapshot] end contract C::KeywordArgs[snapshot: C::Optional[Symbol]] => C::Maybe[String] # Returns the item rep’s path, as used when being linked to. It starts # with a slash and it is relative to the output directory. It does not # include the path to the output directory. It will not include the # filename if the filename is an index filename. # # @param [Symbol] snapshot The snapshot for which the path should be # returned # # @return [String] The item rep’s path def path(snapshot: :last) @paths[snapshot] end # Returns an object that can be used for uniquely identifying objects. # # @api private # # @return [Object] An unique reference to this object def reference [:item_rep, item.identifier, name] end def inspect "<#{self.class} name=\"#{name}\" raw_path=\"#{raw_path}\" item.identifier=\"#{item.identifier}\">" end end end nanoc-4.4.7/lib/nanoc/base/entities/rule_memory.rb0000644000004100000410000000417713033443476022162 0ustar www-datawww-datamodule Nanoc::Int class RuleMemory include Nanoc::Int::ContractsSupport include Enumerable def initialize(item_rep, actions: []) @item_rep = item_rep @actions = actions end contract C::None => Numeric def size @actions.size end contract Numeric => C::Maybe[Nanoc::Int::ProcessingAction] def [](idx) @actions[idx] end contract Symbol, Hash => self def add_filter(filter_name, params) @actions << Nanoc::Int::ProcessingActions::Filter.new(filter_name, params) self end contract String, C::Maybe[Hash] => self def add_layout(layout_identifier, params) @actions << Nanoc::Int::ProcessingActions::Layout.new(layout_identifier, params) self end contract Symbol, C::Maybe[String] => self def add_snapshot(snapshot_name, path) will_add_snapshot(snapshot_name) @actions << Nanoc::Int::ProcessingActions::Snapshot.new(snapshot_name, path) self end contract C::None => C::ArrayOf[Nanoc::Int::ProcessingAction] def snapshot_actions @actions.select { |a| a.is_a?(Nanoc::Int::ProcessingActions::Snapshot) } end contract C::None => C::Bool def any_layouts? @actions.any? { |a| a.is_a?(Nanoc::Int::ProcessingActions::Layout) } end contract C::None => Hash def paths snapshot_actions.each_with_object({}) do |action, paths| paths[action.snapshot_name] = action.path end end # TODO: Add contract def serialize to_a.map(&:serialize) end contract C::Func[Nanoc::Int::ProcessingAction => C::Any] => self def each @actions.each { |a| yield(a) } self end contract C::Func[Nanoc::Int::ProcessingAction => C::Any] => self def map self.class.new( @item_rep, actions: @actions.map { |a| yield(a) }, ) end private def will_add_snapshot(name) @_snapshot_names ||= Set.new if @_snapshot_names.include?(name) raise Nanoc::Int::Errors::CannotCreateMultipleSnapshotsWithSameName.new(@item_rep, name) else @_snapshot_names << name end end end end nanoc-4.4.7/lib/nanoc/base/entities/processing_actions.rb0000644000004100000410000000021113033443476023500 0ustar www-datawww-datarequire_relative 'processing_actions/filter' require_relative 'processing_actions/layout' require_relative 'processing_actions/snapshot' nanoc-4.4.7/lib/nanoc/base/entities/directed_graph.rb0000644000004100000410000001563013033443476022563 0ustar www-datawww-datamodule Nanoc::Int # Represents a directed graph. It is used by the dependency tracker for # storing and querying dependencies between items. # # @example Creating and using a directed graph # # # Create a graph with three vertices # graph = Nanoc::Int::DirectedGraph.new(%w( a b c d )) # # # Add edges # graph.add_edge('a', 'b') # graph.add_edge('b', 'c') # graph.add_edge('c', 'd') # # # Get (direct) predecessors # graph.direct_predecessors_of('d').sort # # => %w( c ) # graph.predecessors_of('d').sort # # => %w( a b c ) # # # Modify edges # graph.delete_edge('a', 'b') # # # Get (direct) predecessors again # graph.direct_predecessors_of('d').sort # # => %w( c ) # graph.predecessors_of('d').sort # # => %w( b c ) # # @api private class DirectedGraph # @group Creating a graph # Creates a new directed graph with the given vertices. def initialize(vertices) @vertices = {} vertices.each_with_index do |v, i| @vertices[v] = i end @from_graph = {} @to_graph = {} @edge_props = {} @roots = Set.new(@vertices.keys) invalidate_caches end # @group Modifying the graph # Adds an edge from the first vertex to the second vertex. # # @param from Vertex where the edge should start # # @param to Vertex where the edge should end # # @return [void] def add_edge(from, to, props: nil) add_vertex(from) add_vertex(to) @from_graph[from] ||= Set.new @from_graph[from] << to @to_graph[to] ||= Set.new @to_graph[to] << from if props @edge_props[[from, to]] = props end @roots.delete(to) invalidate_caches end # Removes the edge from the first vertex to the second vertex. If the # edge does not exist, nothing is done. # # @param from Start vertex of the edge # # @param to End vertex of the edge # # @return [void] def delete_edge(from, to) @from_graph[from] ||= Set.new @from_graph[from].delete(to) @to_graph[to] ||= Set.new @to_graph[to].delete(from) @edge_props.delete([from, to]) @roots.add(to) if @to_graph[to].empty? invalidate_caches end # Adds the given vertex to the graph. # # @param v The vertex to add to the graph # # @return [void] def add_vertex(v) return if @vertices.key?(v) @vertices[v] = @vertices.size @roots << v end # Deletes all edges coming from the given vertex. # # @param from Vertex from which all edges should be removed # # @return [void] def delete_edges_from(from) return if @from_graph[from].nil? @from_graph[from].each do |to| @to_graph[to].delete(from) @edge_props.delete([from, to]) @roots.add(to) if @to_graph[to].empty? end @from_graph.delete(from) end # Deletes all edges going to the given vertex. # # @param to Vertex to which all edges should be removed # # @return [void] def delete_edges_to(to) return if @to_graph[to].nil? @to_graph[to].each do |from| @from_graph[from].delete(to) @edge_props.delete([from, to]) end @to_graph.delete(to) @roots.add(to) end # Removes the given vertex from the graph. # # @param v Vertex to remove from the graph # # @return [void] def delete_vertex(v) delete_edges_to(v) delete_edges_from(v) @vertices.delete(v) @roots.delete(v) end # @group Querying the graph # Returns the direct predecessors of the given vertex, i.e. the vertices # x where there is an edge from x to the given vertex y. # # @param to The vertex of which the predecessors should be calculated # # @return [Array] Direct predecessors of the given vertex def direct_predecessors_of(to) @to_graph[to].to_a end # Returns the direct successors of the given vertex, i.e. the vertices y # where there is an edge from the given vertex x to y. # # @param from The vertex of which the successors should be calculated # # @return [Array] Direct successors of the given vertex def direct_successors_of(from) @from_graph[from].to_a end # Returns the predecessors of the given vertex, i.e. the vertices x for # which there is a path from x to the given vertex y. # # @param to The vertex of which the predecessors should be calculated # # @return [Array] Predecessors of the given vertex def predecessors_of(to) @predecessors[to] ||= recursively_find_vertices(to, :direct_predecessors_of) end # Returns the successors of the given vertex, i.e. the vertices y for # which there is a path from the given vertex x to y. # # @param from The vertex of which the successors should be calculated # # @return [Array] Successors of the given vertex def successors_of(from) @successors[from] ||= recursively_find_vertices(from, :direct_successors_of) end def props_for(from, to) @edge_props[[from, to]] end # @return [Array] The list of all vertices in this graph. def vertices @vertices.keys.sort_by { |v| @vertices[v] } end # Returns an array of tuples representing the edges. The result of this # method may take a while to compute and should be cached if possible. # # @return [Array] The list of all edges in this graph. def edges result = [] @vertices.each_pair do |v1, i1| direct_successors_of(v1).map { |v2| [@vertices[v2], v2] }.each do |i2, v2| result << [i1, i2, @edge_props[[v1, v2]]] end end result end # Returns all root vertices, i.e. vertices where no edge points to. # # @return [Set] The set of all root vertices in this graph. def roots @roots end private # Invalidates cached data. This method should be called when the internal # graph representation is changed. def invalidate_caches @predecessors = {} @successors = {} end # Recursively finds vertices, starting at the vertex start, using the # given method, which should be a symbol to a method that takes a vertex # and returns related vertices (e.g. predecessors, successors). def recursively_find_vertices(start, method) all_vertices = Set.new processed_vertices = Set.new unprocessed_vertices = [start] until unprocessed_vertices.empty? # Get next unprocessed vertex vertex = unprocessed_vertices.pop next if processed_vertices.include?(vertex) processed_vertices << vertex # Add predecessors of this vertex send(method, vertex).each do |v| all_vertices << v unless all_vertices.include?(v) unprocessed_vertices << v end end all_vertices.to_a end end end nanoc-4.4.7/lib/nanoc/base/entities/content.rb0000644000004100000410000000541013033443476021264 0ustar www-datawww-datamodule Nanoc module Int # Abstract content. # # The filename is the full filename on the default filesystem. It can be # nil. It is used by filters such as Sass, which look up items on the # filesystem. # # @abstract # # @api private class Content include Nanoc::Int::ContractsSupport # @return [String, nil] attr_reader :filename contract C::Maybe[String] => C::Any # @param [String, nil] filename def initialize(filename) if filename && Pathname.new(filename).relative? raise ArgumentError, 'Content filename is not absolute' end @filename = filename end contract C::None => self def freeze super @filename.freeze self end contract C::Or[Nanoc::Int::Content, String, Proc], C::KeywordArgs[binary: C::Optional[C::Bool], filename: C::Optional[C::Maybe[String]]] => self # @param [Nanoc::Int::Content, String, Proc] content The uncompiled item # content (if it is textual content) or the path to the filename # containing the content (if this is binary content). # # @param [Boolean] binary Whether or not this item is binary # # @param [String] filename Absolute path to the file containing this # content (if any) def self.create(content, binary: false, filename: nil) if content.nil? raise ArgumentError, 'Cannot create nil content' elsif content.is_a?(Nanoc::Int::Content) content elsif binary Nanoc::Int::BinaryContent.new(content) else Nanoc::Int::TextualContent.new(content, filename: filename) end end # @abstract # # @return [Boolean] def binary? raise NotImplementedError end end # @api private class TextualContent < Content contract C::None => String # @return [String] def string @string.value end contract C::Or[String, Proc], C::KeywordArgs[filename: C::Optional[C::Maybe[String]]] => C::Any def initialize(string, filename: nil) super(filename) @string = Nanoc::Int::LazyValue.new(string) end contract C::None => self def freeze super @string.freeze self end contract C::None => C::Bool def binary? false end # TODO: Add contract def marshal_dump [filename, string] end # TODO: Add contract def marshal_load(array) @filename = array[0] @string = Nanoc::Int::LazyValue.new(array[1]) end end # @api private class BinaryContent < Content contract C::None => C::Bool def binary? true end end end end nanoc-4.4.7/lib/nanoc/base/entities/processing_actions/0000755000004100000410000000000013033443476023161 5ustar www-datawww-datananoc-4.4.7/lib/nanoc/base/entities/processing_actions/snapshot.rb0000644000004100000410000000116013033443476025343 0ustar www-datawww-datamodule Nanoc::Int::ProcessingActions class Snapshot < Nanoc::Int::ProcessingAction # snapshot :before_layout # snapshot :before_layout, path: '/about.md' attr_reader :snapshot_name attr_reader :path def initialize(snapshot_name, path) @snapshot_name = snapshot_name @path = path end def serialize [:snapshot, @snapshot_name, true, @path] end NONE = Object.new def copy(path: NONE) self.class.new(@snapshot_name, path.equal?(NONE) ? @path : path) end def to_s "snapshot #{@snapshot_name.inspect}, path: #{@path.inspect}" end end end nanoc-4.4.7/lib/nanoc/base/entities/processing_actions/filter.rb0000644000004100000410000000073613033443476025001 0ustar www-datawww-datamodule Nanoc::Int::ProcessingActions class Filter < Nanoc::Int::ProcessingAction # filter :foo # filter :foo, params attr_reader :filter_name attr_reader :params def initialize(filter_name, params) @filter_name = filter_name @params = params end def serialize [:filter, @filter_name, Nanoc::Int::Checksummer.calc(@params)] end def to_s "filter #{@filter_name.inspect}, #{@params.inspect}" end end end nanoc-4.4.7/lib/nanoc/base/entities/processing_actions/layout.rb0000644000004100000410000000101113033443476025014 0ustar www-datawww-datamodule Nanoc::Int::ProcessingActions class Layout < Nanoc::Int::ProcessingAction # layout '/foo.erb' # layout '/foo.erb', params attr_reader :layout_identifier attr_reader :params def initialize(layout_identifier, params) @layout_identifier = layout_identifier @params = params end def serialize [:layout, @layout_identifier, Nanoc::Int::Checksummer.calc(@params)] end def to_s "layout #{@layout_identifier.inspect}, #{@params.inspect}" end end end nanoc-4.4.7/lib/nanoc/base/services/0000755000004100000410000000000013033443476017264 5ustar www-datawww-datananoc-4.4.7/lib/nanoc/base/services/outdatedness_rules.rb0000644000004100000410000000651213033443476023531 0ustar www-datawww-datamodule Nanoc::Int # @api private module OutdatednessRules class CodeSnippetsModified < OutdatednessRule extend Nanoc::Int::Memoization include Nanoc::Int::ContractsSupport def reason Nanoc::Int::OutdatednessReasons::CodeSnippetsModified end def apply(_obj, outdatedness_checker) any_snippets_modified?(outdatedness_checker) end private def any_snippets_modified?(outdatedness_checker) outdatedness_checker.site.code_snippets.any? do |cs| ch_old = outdatedness_checker.checksum_store[cs] ch_new = Nanoc::Int::Checksummer.calc(cs) ch_old != ch_new end end memoize :any_snippets_modified? end class ConfigurationModified < OutdatednessRule extend Nanoc::Int::Memoization def reason Nanoc::Int::OutdatednessReasons::ConfigurationModified end def apply(_obj, outdatedness_checker) config_modified?(outdatedness_checker) end private def config_modified?(outdatedness_checker) obj = outdatedness_checker.site.config ch_old = outdatedness_checker.checksum_store[obj] ch_new = Nanoc::Int::Checksummer.calc(obj) ch_old != ch_new end memoize :config_modified? end class NotWritten < OutdatednessRule def reason Nanoc::Int::OutdatednessReasons::NotWritten end def apply(obj, _outdatedness_checker) # FIXME: check all paths (for all snapshots) obj.raw_path && !File.file?(obj.raw_path) end end class ContentModified < OutdatednessRule def reason Nanoc::Int::OutdatednessReasons::ContentModified end def apply(obj, outdatedness_checker) obj = obj.item if obj.is_a?(Nanoc::Int::ItemRep) ch_old = outdatedness_checker.checksum_store.content_checksum_for(obj) ch_new = Nanoc::Int::Checksummer.calc_for_content_of(obj) ch_old != ch_new end end class AttributesModified < OutdatednessRule def reason Nanoc::Int::OutdatednessReasons::AttributesModified end def apply(obj, outdatedness_checker) obj = obj.item if obj.is_a?(Nanoc::Int::ItemRep) ch_old = outdatedness_checker.checksum_store.attributes_checksum_for(obj) ch_new = Nanoc::Int::Checksummer.calc_for_attributes_of(obj) ch_old != ch_new end end class RulesModified < OutdatednessRule def reason Nanoc::Int::OutdatednessReasons::RulesModified end def apply(obj, outdatedness_checker) mem_old = outdatedness_checker.rule_memory_store[obj] mem_new = outdatedness_checker.action_provider.memory_for(obj).serialize !mem_old.eql?(mem_new) end end class PathsModified < OutdatednessRule def reason Nanoc::Int::OutdatednessReasons::PathsModified end def apply(obj, outdatedness_checker) # FIXME: Prefer to not work on serialised version mem_old = outdatedness_checker.rule_memory_store[obj] mem_new = outdatedness_checker.action_provider.memory_for(obj).serialize return true if mem_old.nil? paths_old = mem_old.select { |pa| pa[0] == :snapshot } paths_new = mem_new.select { |pa| pa[0] == :snapshot } paths_old != paths_new end end end end nanoc-4.4.7/lib/nanoc/base/services/item_rep_selector.rb0000644000004100000410000000225713033443476023323 0ustar www-datawww-datamodule Nanoc::Int # Yields item reps to compile. # # @api private class ItemRepSelector def initialize(reps) @reps = reps end def each graph = Nanoc::Int::DirectedGraph.new(@reps) loop do break if graph.roots.empty? rep = graph.roots.each { |e| break e } begin yield(rep) graph.delete_vertex(rep) rescue => e handle_error(e, rep, graph) end end # Check whether everything was compiled unless graph.vertices.empty? raise Nanoc::Int::Errors::RecursiveCompilation.new(graph.vertices) end end def handle_error(e, rep, graph) actual_error = if e.is_a?(Nanoc::Int::Errors::CompilationError) e.unwrap else e end if actual_error.is_a?(Nanoc::Int::Errors::UnmetDependency) handle_dependency_error(actual_error, rep, graph) else raise(e) end end def handle_dependency_error(e, rep, graph) other_rep = e.rep graph.add_edge(other_rep, rep) unless graph.vertices.include?(other_rep) graph.add_vertex(other_rep) end end end end nanoc-4.4.7/lib/nanoc/base/services/outdatedness_checker.rb0000644000004100000410000001423713033443476024006 0ustar www-datawww-datamodule Nanoc::Int # Responsible for determining whether an item or a layout is outdated. # # @api private class OutdatednessChecker class Basic extend Nanoc::Int::Memoization include Nanoc::Int::ContractsSupport Rules = Nanoc::Int::OutdatednessRules RULES_FOR_ITEM_REP = [ Rules::RulesModified, Rules::PathsModified, Rules::ContentModified, Rules::AttributesModified, Rules::NotWritten, Rules::CodeSnippetsModified, Rules::ConfigurationModified, ].freeze RULES_FOR_LAYOUT = [ Rules::RulesModified, Rules::ContentModified, Rules::AttributesModified, ].freeze contract C::KeywordArgs[outdatedness_checker: OutdatednessChecker, reps: Nanoc::Int::ItemRepRepo] => C::Any def initialize(outdatedness_checker:, reps:) @outdatedness_checker = outdatedness_checker @reps = reps end contract C::Or[Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout] => C::Maybe[OutdatednessStatus] def outdatedness_status_for(obj) case obj when Nanoc::Int::ItemRep apply_rules(RULES_FOR_ITEM_REP, obj) when Nanoc::Int::Item apply_rules_multi(RULES_FOR_ITEM_REP, @reps[obj]) when Nanoc::Int::Layout apply_rules(RULES_FOR_LAYOUT, obj) else raise Nanoc::Int::Errors::InternalInconsistency, "do not know how to check outdatedness of #{obj.inspect}" end end memoize :outdatedness_status_for private contract C::ArrayOf[Class], C::Or[Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout], OutdatednessStatus => C::Maybe[OutdatednessStatus] def apply_rules(rules, obj, status = OutdatednessStatus.new) rules.inject(status) do |acc, rule| if !acc.useful_to_apply?(rule) acc elsif rule.instance.apply(obj, @outdatedness_checker) acc.update(rule.instance.reason) else acc end end end contract C::ArrayOf[Class], C::ArrayOf[C::Or[Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout]] => C::Maybe[OutdatednessStatus] def apply_rules_multi(rules, objs) objs.inject(OutdatednessStatus.new) { |acc, elem| apply_rules(rules, elem, acc) } end end extend Nanoc::Int::Memoization include Nanoc::Int::ContractsSupport attr_reader :checksum_store attr_reader :dependency_store attr_reader :rule_memory_store attr_reader :action_provider attr_reader :site Reasons = Nanoc::Int::OutdatednessReasons # FIXME: Replace C::Any with proper types contract C::KeywordArgs[site: Nanoc::Int::Site, checksum_store: Nanoc::Int::ChecksumStore, dependency_store: Nanoc::Int::DependencyStore, rule_memory_store: Nanoc::Int::RuleMemoryStore, action_provider: C::Any, reps: Nanoc::Int::ItemRepRepo] => C::Any def initialize(site:, checksum_store:, dependency_store:, rule_memory_store:, action_provider:, reps:) @site = site @checksum_store = checksum_store @dependency_store = dependency_store @rule_memory_store = rule_memory_store @action_provider = action_provider @reps = reps @objects_outdated_due_to_dependencies = {} end contract C::Or[Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout] => C::Bool # Checks whether the given object is outdated and therefore needs to be # recompiled. # # @param [Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout] obj The object # whose outdatedness should be checked. # # @return [Boolean] true if the object is outdated, false otherwise def outdated?(obj) !outdatedness_reason_for(obj).nil? end contract C::Or[Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout] => C::Maybe[Reasons::Generic] # Calculates the reason why the given object is outdated. # # @param [Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout] obj The object # whose outdatedness reason should be calculated. # # @return [Reasons::Generic, nil] The reason why the # given object is outdated, or nil if the object is not outdated. def outdatedness_reason_for(obj) reason = basic_outdatedness_reason_for(obj) if reason.nil? && outdated_due_to_dependencies?(obj) reason = Reasons::DependenciesOutdated end reason end memoize :outdatedness_reason_for private contract C::None => Basic def basic @_basic ||= Basic.new(outdatedness_checker: self, reps: @reps) end contract C::Or[Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout] => C::Maybe[Reasons::Generic] def basic_outdatedness_reason_for(obj) # FIXME: Stop using this; it is no longer accurate, as there can be >1 reasons basic.outdatedness_status_for(obj).reasons.first end contract C::Or[Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout], Hamster::Set => C::Bool def outdated_due_to_dependencies?(obj, processed = Hamster::Set.new) # Convert from rep to item if necessary obj = obj.item if obj.is_a?(Nanoc::Int::ItemRep) # Get from cache if @objects_outdated_due_to_dependencies.key?(obj) return @objects_outdated_due_to_dependencies[obj] end # Check processed # Don’t return true; the false will be or’ed into a true if there # really is a dependency that is causing outdatedness. return false if processed.include?(obj) # Calculate is_outdated = dependency_store.dependencies_causing_outdatedness_of(obj).any? do |dep| dependency_causes_outdatedness?(dep) || (dep.props.compiled_content? && outdated_due_to_dependencies?(dep.from, processed.merge([obj]))) end # Cache @objects_outdated_due_to_dependencies[obj] = is_outdated # Done is_outdated end contract Nanoc::Int::Dependency => C::Bool def dependency_causes_outdatedness?(dependency) return true if dependency.from.nil? status = basic.outdatedness_status_for(dependency.from) (status.props.active & dependency.props.active).any? end end end nanoc-4.4.7/lib/nanoc/base/services/outdatedness_rule.rb0000644000004100000410000000105013033443476023336 0ustar www-datawww-datamodule Nanoc::Int # @api private class OutdatednessRule include Nanoc::Int::ContractsSupport include Singleton def apply(_obj, _outdatedness_checker) raise NotImplementedError.new('Nanoc::Int::OutdatednessRule subclasses must implement ##reason, and #apply') end contract C::None => String def inspect "#{self.class.name}(#{reason})" end # TODO: remove def reason raise NotImplementedError.new('Nanoc::Int::OutdatednessRule subclasses must implement ##reason, and #apply') end end end nanoc-4.4.7/lib/nanoc/base/services/item_rep_builder.rb0000644000004100000410000000113413033443476023122 0ustar www-datawww-datamodule Nanoc::Int # @api private class ItemRepBuilder attr_reader :reps def initialize(site, action_provider, reps) @site = site @action_provider = action_provider @reps = reps end def run @site.items.each do |item| @action_provider.rep_names_for(item).each do |rep_name| @reps << Nanoc::Int::ItemRep.new(item, rep_name) end end Nanoc::Int::ItemRepRouter.new(@reps, @action_provider, @site).run @reps.each do |rep| rep.snapshot_defs = @action_provider.snapshots_defs_for(rep) end end end end nanoc-4.4.7/lib/nanoc/base/services/filter.rb0000644000004100000410000001513313033443476021101 0ustar www-datawww-datamodule Nanoc # Nanoc::Filter is responsible for filtering items. It is the superclass # for all textual filters. # # A filter instance should only be used once. Filters should not be reused # since they store state. # # When creating a filter with a hash containing assigned variables, those # variables will be made available in the `@assigns` instance variable and # the {#assigns} method. The assigns itself will also be available as # instance variables and instance methods. # # @example Accessing assigns in different ways # # filter = SomeFilter.new({ :foo => 'bar' }) # filter.instance_eval { @assigns[:foo] } # # => 'bar' # filter.instance_eval { assigns[:foo] } # # => 'bar' # filter.instance_eval { @foo } # # => 'bar' # filter.instance_eval { foo } # # => 'bar' # # @abstract Subclass and override {#run} to implement a custom filter. class Filter < Nanoc::Int::Context # @api private TMP_BINARY_ITEMS_DIR = 'binary_items'.freeze # A hash containing variables that will be made available during # filtering. # # @return [Hash] # # @api private attr_reader :assigns extend Nanoc::Int::PluginRegistry::PluginMethods class << self def define(ident, &block) filter_class = Class.new(::Nanoc::Filter) { identifier(ident) } filter_class.send(:define_method, :run) do |content, params| instance_exec(content, params, &block) end end # Sets the new type for the filter. The type can be `:binary` (default) # or `:text`. The given argument can either be a symbol indicating both # “from” and “to” types, or a hash where the only key is the “from” type # and the only value is the “to” type. # # @example Specifying a text-to-text filter # # type :text # # @example Specifying a text-to-binary filter # # type :text => :binary # # @param [Symbol, Hash] arg The new type of this filter # # @return [void] def type(arg) if arg.is_a?(Hash) @from = arg.keys[0] @to = arg.values[0] else @from = arg @to = arg end end # @return [Boolean] True if this filter can be applied to binary item # representations, false otherwise # # @api private def from_binary? (@from || :text) == :binary end # @return [Boolean] True if this filter results in a binary item # representation, false otherwise # # @api private def to_binary? (@to || :text) == :binary end # @overload requires(*requires) # Sets the required libraries for this filter. # @param [Array] requires A list of library names that are required # @return [void] # @overload requires # Returns the required libraries for this filter. # @return [Enumerable] This filter’s list of library names that are required def requires(*requires) if requires.any? @requires = requires else @requires || [] end end # Requires the filter’s required library if necessary. # # @return [void] # # @api private def setup @setup ||= begin requires.each { |r| require r } true end end end # Creates a new filter that has access to the given assigns. # # @param [Hash] hash A hash containing variables that should be made # available during filtering. # # @api private def initialize(hash = {}) @assigns = hash super end # Sets up the filter and runs the filter. This method passes its arguments # to {#run} unchanged and returns the return value from {#run}. # # @see #run # # @api private def setup_and_run(*args) self.class.setup run(*args) end # Runs the filter on the given content or filename. # # @abstract # # @param [String] content_or_filename The unprocessed content that should # be filtered (if the item is a textual item) or the path to the file # that should be filtered (if the item is a binary item) # # @param [Hash] params A hash containing parameters. Filter subclasses can # use these parameters to allow modifying the filter's behaviour. # # @return [String, void] If the filter output binary content, the return # value is undefined; if the filter outputs textual content, the return # value will be the filtered content. def run(content_or_filename, params = {}) # rubocop:disable Lint/UnusedMethodArgument raise NotImplementedError.new('Nanoc::Filter subclasses must implement #run') end # Returns a filename that is used to write data to. This method is only # used on binary items. When running a binary filter on a file, the # resulting file must end up in the location returned by this method. # # The returned filename will be absolute, so it is safe to change to # another directory inside the filter. # # @return [String] The output filename def output_filename @output_filename ||= Nanoc::Int::TempFilenameFactory.instance.create(TMP_BINARY_ITEMS_DIR) end # Returns the filename associated with the item that is being filtered. # It is in the format `item (rep )`. # # @return [String] The filename # # @api private def filename if assigns[:layout] "layout #{assigns[:layout].identifier}" elsif assigns[:item] "item #{assigns[:item].identifier} (rep #{assigns[:item_rep].name})" else '?' end end # @api private def on_main_fiber(&block) Fiber.yield(block) end # Creates a dependency from the item that is currently being filtered onto # the given collection of items. In other words, require the given items # to be compiled first before this items is processed. # # @return [void] def depend_on(items) orig_items = items items = items.map { |i| i.is_a?(Nanoc::ItemWithRepsView) ? i.unwrap : i } # Notify dependency_tracker = @assigns[:item]._context.dependency_tracker items.each { |item| dependency_tracker.bounce(item, compiled_content: true) } # Raise unmet dependency error if necessary items.each do |item| rep = orig_items.sample._context.reps[item].find { |r| !r.compiled? } Fiber.yield(Nanoc::Int::Errors::UnmetDependency.new(rep)) if rep end end end end nanoc-4.4.7/lib/nanoc/base/services/item_rep_writer.rb0000644000004100000410000000227313033443476023015 0ustar www-datawww-datamodule Nanoc::Int # @api private class ItemRepWriter TMP_TEXT_ITEMS_DIR = 'text_items'.freeze def write(item_rep, snapshot_name) raw_path = item_rep.raw_path(snapshot: snapshot_name) return unless raw_path # Create parent directory FileUtils.mkdir_p(File.dirname(raw_path)) # Check if file will be created is_created = !File.file?(raw_path) # Notify Nanoc::Int::NotificationCenter.post( :will_write_rep, item_rep, raw_path ) content = item_rep.snapshot_contents[snapshot_name] if content.binary? temp_path = content.filename else temp_path = temp_filename File.write(temp_path, content.string) end # Check whether content was modified is_modified = is_created || !FileUtils.identical?(raw_path, temp_path) # Write FileUtils.cp(temp_path, raw_path) if is_modified item_rep.modified = is_modified # Notify Nanoc::Int::NotificationCenter.post( :rep_written, item_rep, raw_path, is_created, is_modified ) end def temp_filename Nanoc::Int::TempFilenameFactory.instance.create(TMP_TEXT_ITEMS_DIR) end end end nanoc-4.4.7/lib/nanoc/base/services/notification_center.rb0000644000004100000410000000534213033443476023643 0ustar www-datawww-datamodule Nanoc::Int # Provides a way to send notifications between objects. It allows blocks # associated with a certain notification name to be registered; these blocks # will be called when the notification with the given name is posted. # # It is a slightly different implementation of the Observer pattern; the # table of subscribers is not stored in the observable object itself, but in # the notification center. # # @api private class NotificationCenter class << self # Adds the given block to the list of blocks that should be called when # the notification with the given name is received. # # @param [String, Symbol] name The name of the notification that will # cause the given block to be called. # # @param [String, Symbol, nil] id An identifier for the block. This is # only used to be able to remove the block (using the remove method) # later. Can be nil, but this is not recommended because it prevents # the given notification block from being unregistered. # # @yield [*args] Will be executed with the arguments passed to {.post} # # @return [void] def on(name, id = nil, &block) initialize_if_necessary(name) # Add observer @notifications[name] << { id: id, block: block } end # Posts a notification with the given name and the given arguments. # # @param [String, Symbol] name The name of the notification that should # be posted. # # @param args Arguments that wil be passed to the blocks handling the # notification. # # @return [void] def post(name, *args) initialize_if_necessary(name) # Notify all observers @notifications[name].each do |observer| observer[:block].call(*args) end end # Removes the block with the given identifier from the list of blocks # that should be called when the notification with the given name is # posted. # # @param [String, Symbol] name The name of the notification that should # no longer be registered. # # @param [String, Symbol] id The identifier of the block that should be # removed. # # @return [void] def remove(name, id) initialize_if_necessary(name) # Remove relevant observers @notifications[name].reject! { |i| i[:id] == id } end # @api private # # @return [void] def reset @notifications = nil end private def initialize_if_necessary(name) @notifications ||= {} # name => observers dictionary @notifications[name] ||= [] # list of observers end end end end nanoc-4.4.7/lib/nanoc/base/services/compiler_loader.rb0000644000004100000410000000320113033443476022745 0ustar www-datawww-datamodule Nanoc::Int # @api private class CompilerLoader def load(site, action_provider: nil) rule_memory_store = Nanoc::Int::RuleMemoryStore.new(env_name: site.config.env_name) dependency_store = Nanoc::Int::DependencyStore.new(site.items.to_a + site.layouts.to_a, env_name: site.config.env_name) objects = site.items.to_a + site.layouts.to_a + site.code_snippets + [site.config] checksum_store = Nanoc::Int::ChecksumStore.new(site: site, objects: objects) item_rep_repo = Nanoc::Int::ItemRepRepo.new action_provider ||= Nanoc::Int::ActionProvider.named(:rule_dsl).for(site) outdatedness_store = Nanoc::Int::OutdatednessStore.new(site: site, reps: item_rep_repo) outdatedness_checker = Nanoc::Int::OutdatednessChecker.new( site: site, checksum_store: checksum_store, dependency_store: dependency_store, rule_memory_store: rule_memory_store, action_provider: action_provider, reps: item_rep_repo, ) compiled_content_cache = Nanoc::Int::CompiledContentCache.new( env_name: site.config.env_name, items: site.items, ) params = { compiled_content_cache: compiled_content_cache, checksum_store: checksum_store, rule_memory_store: rule_memory_store, dependency_store: dependency_store, outdatedness_checker: outdatedness_checker, reps: item_rep_repo, action_provider: action_provider, outdatedness_store: outdatedness_store, } Nanoc::Int::Compiler.new(site, params) end end end nanoc-4.4.7/lib/nanoc/base/services/compiler.rb0000644000004100000410000003655413033443476021440 0ustar www-datawww-datamodule Nanoc::Int # Responsible for compiling a site’s item representations. # # The compilation process makes use of notifications (see # {Nanoc::Int::NotificationCenter}) to track dependencies between items, # layouts, etc. The following notifications are used: # # * `compilation_started` — indicates that the compiler has started # compiling this item representation. Has one argument: the item # representation itself. Only one item can be compiled at a given moment; # therefore, it is not possible to get two consecutive # `compilation_started` notifications without also getting a # `compilation_ended` notification in between them. # # * `compilation_ended` — indicates that the compiler has finished compiling # this item representation (either successfully or with failure). Has one # argument: the item representation itself. # # @api private class Compiler # Provides common functionality for accesing “context” of an item that is being compiled. class CompilationContext def initialize(action_provider:, reps:, site:, compiled_content_cache:) @action_provider = action_provider @reps = reps @site = site @compiled_content_cache = compiled_content_cache end def filter_name_and_args_for_layout(layout) mem = @action_provider.memory_for(layout) if mem.nil? || mem.size != 1 || !mem[0].is_a?(Nanoc::Int::ProcessingActions::Filter) raise Nanoc::Int::Errors::UndefinedFilterForLayout.new(layout) end [mem[0].filter_name, mem[0].params] end def create_view_context(dependency_tracker) Nanoc::ViewContext.new( reps: @reps, items: @site.items, dependency_tracker: dependency_tracker, compilation_context: self, ) end def assigns_for(rep, dependency_tracker) content_or_filename_assigns = if rep.binary? { filename: rep.snapshot_contents[:last].filename } else { content: rep.snapshot_contents[:last].string } end view_context = create_view_context(dependency_tracker) content_or_filename_assigns.merge( item: Nanoc::ItemWithRepsView.new(rep.item, view_context), rep: Nanoc::ItemRepView.new(rep, view_context), item_rep: Nanoc::ItemRepView.new(rep, view_context), items: Nanoc::ItemCollectionWithRepsView.new(@site.items, view_context), layouts: Nanoc::LayoutCollectionView.new(@site.layouts, view_context), config: Nanoc::ConfigView.new(@site.config, view_context), ) end def site @site end def compiled_content_cache @compiled_content_cache end end # All phases for the compilation of a single item rep. Phases will be repeated for every rep. module Phases # Provides functionality for (re)calculating the content of an item rep, without caching or # outdatedness checking. class Recalculate include Nanoc::Int::ContractsSupport def initialize(action_provider:, dependency_store:, compilation_context:) @action_provider = action_provider @dependency_store = dependency_store @compilation_context = compilation_context end contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => C::Any def run(rep, is_outdated:) # rubocop:disable Lint/UnusedMethodArgument dependency_tracker = Nanoc::Int::DependencyTracker.new(@dependency_store) dependency_tracker.enter(rep.item) executor = Nanoc::Int::Executor.new(rep, @compilation_context, dependency_tracker) @action_provider.memory_for(rep).each do |action| case action when Nanoc::Int::ProcessingActions::Filter executor.filter(action.filter_name, action.params) when Nanoc::Int::ProcessingActions::Layout executor.layout(action.layout_identifier, action.params) when Nanoc::Int::ProcessingActions::Snapshot executor.snapshot(action.snapshot_name) else raise Nanoc::Int::Errors::InternalInconsistency, "unknown action #{action.inspect}" end end ensure dependency_tracker.exit end end # Provides functionality for (re)calculating the content of an item rep, with caching or # outdatedness checking. Delegates to s::Recalculate if outdated or no cache available. class Cache include Nanoc::Int::ContractsSupport def initialize(compiled_content_cache:, wrapped:) @compiled_content_cache = compiled_content_cache @wrapped = wrapped end contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => C::Any def run(rep, is_outdated:) if can_reuse_content_for_rep?(rep, is_outdated: is_outdated) Nanoc::Int::NotificationCenter.post(:cached_content_used, rep) rep.snapshot_contents = @compiled_content_cache[rep] else @wrapped.run(rep, is_outdated: is_outdated) end rep.compiled = true @compiled_content_cache[rep] = rep.snapshot_contents end contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => C::Bool def can_reuse_content_for_rep?(rep, is_outdated:) !is_outdated && !@compiled_content_cache[rep].nil? end end # Provides functionality for suspending and resuming item rep compilation (using fibers). class Resume include Nanoc::Int::ContractsSupport def initialize(wrapped:) @wrapped = wrapped end contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => C::Any def run(rep, is_outdated:) fiber = fiber_for(rep, is_outdated: is_outdated) while fiber.alive? Nanoc::Int::NotificationCenter.post(:compilation_started, rep) res = fiber.resume case res when Nanoc::Int::Errors::UnmetDependency Nanoc::Int::NotificationCenter.post(:compilation_suspended, rep, res) raise(res) when Proc fiber.resume(res.call) else # TODO: raise end end Nanoc::Int::NotificationCenter.post(:compilation_ended, rep) end private contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => Fiber def fiber_for(rep, is_outdated:) @fibers ||= {} @fibers[rep] ||= Fiber.new do @wrapped.run(rep, is_outdated: is_outdated) @fibers.delete(rep) end @fibers[rep] end end class Write include Nanoc::Int::ContractsSupport def initialize(wrapped:) @wrapped = wrapped end contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => C::Any def run(rep, is_outdated:) @wrapped.run(rep, is_outdated: is_outdated) rep.snapshot_defs.each do |sdef| ItemRepWriter.new.write(rep, sdef.name) end end end class MarkDone include Nanoc::Int::ContractsSupport def initialize(wrapped:, outdatedness_store:) @wrapped = wrapped @outdatedness_store = outdatedness_store end contract Nanoc::Int::ItemRep, C::KeywordArgs[is_outdated: C::Bool] => C::Any def run(rep, is_outdated:) @wrapped.run(rep, is_outdated: is_outdated) @outdatedness_store.remove(rep) end end end module Stages class Preprocess def initialize(action_provider:, site:, dependency_store:, checksum_store:) @action_provider = action_provider @site = site @dependency_store = dependency_store @checksum_store = checksum_store end def run @action_provider.preprocess(@site) @dependency_store.objects = @site.items.to_a + @site.layouts.to_a @checksum_store.objects = @site.items.to_a + @site.layouts.to_a + @site.code_snippets + [@site.config] @site.freeze end end class Prune def initialize(config:, reps:) @config = config @reps = reps end def run if @config[:prune][:auto_prune] Nanoc::Pruner.new(@config, @reps, exclude: prune_config_exclude).run end end private def prune_config @config[:prune] || {} end def prune_config_exclude prune_config[:exclude] || {} end end class DetermineOutdatedness def initialize(reps:, outdatedness_checker:, outdatedness_store:) @reps = reps @outdatedness_checker = outdatedness_checker @outdatedness_store = outdatedness_store end def run outdated_reps_tmp = @reps.select do |r| @outdatedness_store.include?(r) || @outdatedness_checker.outdated?(r) end outdated_items = outdated_reps_tmp.map(&:item).uniq outdated_reps = Set.new(outdated_items.flat_map { |i| @reps[i] }) outdated_reps.each { |r| @outdatedness_store.add(r) } yield(outdated_items) end end class CompileReps def initialize(outdatedness_store:, dependency_store:, action_provider:, compilation_context:, compiled_content_cache:) @outdatedness_store = outdatedness_store @dependency_store = dependency_store @action_provider = action_provider @compilation_context = compilation_context @compiled_content_cache = compiled_content_cache end def run selector = Nanoc::Int::ItemRepSelector.new(@outdatedness_store.to_a) selector.each do |rep| handle_errors_while(rep) { compile_rep(rep, is_outdated: @outdatedness_store.include?(rep)) } end ensure @outdatedness_store.store @compiled_content_cache.store end private def handle_errors_while(item_rep) yield rescue => e raise Nanoc::Int::Errors::CompilationError.new(e, item_rep) end def compile_rep(rep, is_outdated:) item_rep_compiler.run(rep, is_outdated: is_outdated) end def item_rep_compiler @_item_rep_compiler ||= begin recalculate_phase = Phases::Recalculate.new( action_provider: @action_provider, dependency_store: @dependency_store, compilation_context: @compilation_context, ) cache_phase = Phases::Cache.new( compiled_content_cache: @compiled_content_cache, wrapped: recalculate_phase, ) resume_phase = Phases::Resume.new( wrapped: cache_phase, ) write_phase = Phases::Write.new( wrapped: resume_phase, ) mark_done_phase = Phases::MarkDone.new( wrapped: write_phase, outdatedness_store: @outdatedness_store, ) mark_done_phase end end end end include Nanoc::Int::ContractsSupport # @api private attr_reader :site # @api private attr_reader :compiled_content_cache # @api private attr_reader :checksum_store # @api private attr_reader :rule_memory_store # @api private attr_reader :action_provider # @api private attr_reader :dependency_store # @api private attr_reader :outdatedness_checker # @api private attr_reader :reps # @api private attr_reader :outdatedness_store def initialize(site, compiled_content_cache:, checksum_store:, rule_memory_store:, action_provider:, dependency_store:, outdatedness_checker:, reps:, outdatedness_store:) @site = site @compiled_content_cache = compiled_content_cache @checksum_store = checksum_store @rule_memory_store = rule_memory_store @dependency_store = dependency_store @outdatedness_checker = outdatedness_checker @reps = reps @action_provider = action_provider @outdatedness_store = outdatedness_store end def run_all preprocess_stage.run build_reps prune_stage.run load_stores determine_outdatedness forget_dependencies_if_needed store compile_reps store_output_state @action_provider.postprocess(@site, @reps) ensure Nanoc::Int::TempFilenameFactory.instance.cleanup( Nanoc::Filter::TMP_BINARY_ITEMS_DIR, ) Nanoc::Int::TempFilenameFactory.instance.cleanup( Nanoc::Int::ItemRepWriter::TMP_TEXT_ITEMS_DIR, ) end def load_stores stores.each(&:load) end # TODO: rename to store_preprocessed_state def store # Calculate rule memory (@reps.to_a + @site.layouts.to_a).each do |obj| rule_memory_store[obj] = action_provider.memory_for(obj).serialize end # Calculate checksums objects_to_checksum = site.items.to_a + site.layouts.to_a + site.code_snippets + [site.config] objects_to_checksum.each { |obj| checksum_store.add(obj) } # Store checksum_store.store rule_memory_store.store end def store_output_state @dependency_store.store end def build_reps builder = Nanoc::Int::ItemRepBuilder.new( site, action_provider, @reps ) builder.run end def compilation_context @_compilation_context ||= CompilationContext.new( action_provider: action_provider, reps: @reps, site: @site, compiled_content_cache: compiled_content_cache, ) end private def preprocess_stage @_preprocess_stage ||= Stages::Preprocess.new( action_provider: action_provider, site: site, dependency_store: dependency_store, checksum_store: checksum_store, ) end def prune_stage @_prune_stage ||= Stages::Prune.new( config: site.config, reps: reps, ) end def determine_outdatedness_stage @_determine_outdatedness_stage ||= Stages::DetermineOutdatedness.new( reps: reps, outdatedness_checker: outdatedness_checker, outdatedness_store: outdatedness_store, ) end def compile_reps_stage @_compile_reps_stage ||= Stages::CompileReps.new( outdatedness_store: @outdatedness_store, dependency_store: @dependency_store, action_provider: action_provider, compilation_context: compilation_context, compiled_content_cache: compiled_content_cache, ) end def determine_outdatedness determine_outdatedness_stage.run do |outdated_items| @outdated_items = outdated_items end end def forget_dependencies_if_needed @outdated_items.each { |i| @dependency_store.forget_dependencies_for(i) } end def compile_reps compile_reps_stage.run end # Returns all stores that can load/store data that can be used for # compilation. def stores [ checksum_store, compiled_content_cache, @dependency_store, rule_memory_store, @outdatedness_store, ] end end end nanoc-4.4.7/lib/nanoc/base/services/item_rep_router.rb0000644000004100000410000000354413033443476023023 0ustar www-datawww-datamodule Nanoc::Int # Assigns paths to reps. # # @api private class ItemRepRouter class IdenticalRoutesError < ::Nanoc::Error def initialize(output_path, rep_a, rep_b) super("The item representations #{rep_a.inspect} and #{rep_b.inspect} are both routed to #{output_path}.") end end class RouteWithoutSlashError < ::Nanoc::Error def initialize(output_path, rep) super("The item representation #{rep.inspect} is routed to #{output_path}, which does not start with a slash, as required.") end end def initialize(reps, action_provider, site) @reps = reps @action_provider = action_provider @site = site end def run paths_to_reps = {} @reps.each do |rep| @action_provider.paths_for(rep).each do |snapshot_name, path| route_rep(rep, path, snapshot_name, paths_to_reps) end end end def route_rep(rep, path, snapshot_name, paths_to_reps) basic_path = path return if basic_path.nil? basic_path = basic_path.encode('UTF-8') unless basic_path.start_with?('/') raise RouteWithoutSlashError.new(basic_path, rep) end # Check for duplicate paths if paths_to_reps.key?(basic_path) raise IdenticalRoutesError.new(basic_path, paths_to_reps[basic_path], rep) else paths_to_reps[basic_path] = rep end rep.raw_paths[snapshot_name] = @site.config[:output_dir] + basic_path rep.paths[snapshot_name] = strip_index_filename(basic_path) end def strip_index_filename(basic_path) @site.config[:index_filenames].each do |index_filename| slashed_index_filename = '/' + index_filename if basic_path.end_with?(slashed_index_filename) return basic_path[0..-index_filename.length - 1] end end basic_path end end end nanoc-4.4.7/lib/nanoc/base/services/checksummer.rb0000644000004100000410000001502713033443476022124 0ustar www-datawww-datamodule Nanoc::Int # Creates checksums for given objects. # # A checksum is a string, such as “mL+TaqNsEeiPkWloPgCtAofT1yg=”, that is used # to determine whether a piece of data has changed. # # @api private class Checksummer class VerboseDigest def initialize @str = '' end def update(str) @str << str end def to_s @str end end class CompactDigest def initialize @digest = Digest::SHA1.new end def update(str) @digest.update(str) end def to_s @digest.base64digest end end class << self # @param obj The object to create a checksum for # # @return [String] The digest def calc(obj, digest_class = CompactDigest) digest = digest_class.new update(obj, digest) digest.to_s end def calc_for_content_of(obj) obj.content_checksum_data || obj.checksum_data || Nanoc::Int::Checksummer.calc(obj.content) end def calc_for_attributes_of(obj) obj.attributes_checksum_data || obj.checksum_data || Nanoc::Int::Checksummer.calc(obj.attributes) end private def update(obj, digest, visited = Hamster::Set.new) digest.update(obj.class.to_s) if visited.include?(obj) digest.update('') else digest.update('<') behavior_for(obj).update(obj, digest) { |o| update(o, digest, visited.add(obj)) } digest.update('>') end end def behavior_for(obj) case obj when String, Symbol, Numeric RawUpdateBehavior when Pathname PathnameUpdateBehavior when Nanoc::Int::BinaryContent BinaryContentUpdateBehavior when Array, Nanoc::Int::IdentifiableCollection ArrayUpdateBehavior when Hash, Nanoc::Int::Configuration HashUpdateBehavior when Nanoc::Int::Item, Nanoc::Int::Layout DocumentUpdateBehavior when Nanoc::Int::ItemRep ItemRepUpdateBehavior when NilClass, TrueClass, FalseClass NoUpdateBehavior when Time ToIToSUpdateBehavior when Nanoc::Identifier ToSUpdateBehavior when Nanoc::RuleDSL::RulesCollection, Nanoc::Int::CodeSnippet DataUpdateBehavior when Nanoc::Int::TextualContent StringUpdateBehavior when Nanoc::View UnwrapUpdateBehavior when Nanoc::RuleDSL::RuleContext RuleContextUpdateBehavior when Nanoc::Int::Context ContextUpdateBehavior else RescueUpdateBehavior end end end class UpdateBehavior def self.update(_obj, _digest) raise NotImpementedError end end class RuleContextUpdateBehavior < UpdateBehavior def self.update(obj, digest) digest.update('item=') yield(obj.item) digest.update(',rep=') yield(obj.rep) digest.update(',items=') yield(obj.items) digest.update(',layouts=') yield(obj.layouts) digest.update(',config=') yield(obj.config) end end class ContextUpdateBehavior < UpdateBehavior def self.update(obj, digest) obj.instance_variables.each do |var| digest.update(var.to_s) digest.update('=') yield(obj.instance_variable_get(var)) digest.update(',') end end end class RawUpdateBehavior < UpdateBehavior def self.update(obj, digest) digest.update(obj.to_s) end end class ToSUpdateBehavior < UpdateBehavior def self.update(obj, _digest) yield(obj.to_s) end end class ToIToSUpdateBehavior < UpdateBehavior def self.update(obj, digest) digest.update(obj.to_i.to_s) end end class StringUpdateBehavior < UpdateBehavior def self.update(obj, _digest) yield(obj.string) end end class DataUpdateBehavior < UpdateBehavior def self.update(obj, _digest) yield(obj.data) end end class NoUpdateBehavior < UpdateBehavior def self.update(_obj, _digest); end end class UnwrapUpdateBehavior < UpdateBehavior def self.update(obj, _digest) yield(obj.unwrap) end end class ArrayUpdateBehavior < UpdateBehavior def self.update(obj, digest) obj.each do |el| yield(el) digest.update(',') end end end class HashUpdateBehavior < UpdateBehavior def self.update(obj, digest) obj.each do |key, value| yield(key) digest.update('=') yield(value) digest.update(',') end end end class DocumentUpdateBehavior < UpdateBehavior def self.update(obj, digest) if obj.checksum_data digest.update('checksum_data=' + obj.checksum_data) else if obj.content_checksum_data digest.update('content_checksum_data=' + obj.content_checksum_data) else digest.update('content=') yield(obj.content) end if obj.attributes_checksum_data digest.update(',attributes_checksum_data=' + obj.attributes_checksum_data) else digest.update(',attributes=') yield(obj.attributes) end digest.update(',identifier=') yield(obj.identifier) end end end class ItemRepUpdateBehavior < UpdateBehavior def self.update(obj, digest) digest.update('item=') yield(obj.item) digest.update(',name=') yield(obj.name) end end class PathnameUpdateBehavior < UpdateBehavior def self.update(obj, digest) filename = obj.to_s if File.exist?(filename) stat = File.stat(filename) digest.update(stat.size.to_s + '-' + stat.mtime.to_i.to_s) else digest.update('???') end end end class BinaryContentUpdateBehavior < UpdateBehavior def self.update(obj, _digest) yield(Pathname.new(obj.filename)) end end class RescueUpdateBehavior < UpdateBehavior def self.update(obj, digest) if obj.class.to_s == 'Sass::Importers::Filesystem' digest.update('root=') digest.update(obj.root) return end data = begin Marshal.dump(obj) rescue obj.inspect end digest.update(data) end end end end nanoc-4.4.7/lib/nanoc/base/services/action_provider.rb0000644000004100000410000000070413033443476023001 0ustar www-datawww-datamodule Nanoc::Int # @private class ActionProvider extend Nanoc::Int::PluginRegistry::PluginMethods def self.for(_site) raise NotImplementedError end def rep_names_for(_item) raise NotImplementedError end def memory_for(_rep) raise NotImplementedError end def snapshots_defs_for(_rep) raise NotImplementedError end def paths_for(rep) memory_for(rep).paths end end end nanoc-4.4.7/lib/nanoc/base/services/pruner.rb0000644000004100000410000000534713033443476021135 0ustar www-datawww-datarequire 'find' module Nanoc # Responsible for finding and deleting files in the site’s output directory # that are not managed by Nanoc. # # @api private class Pruner # @param [Nanoc::Int::Configuration] config # # @param [Nanoc::Int::ItemRepRepo] reps # # @param [Boolean] dry_run true if the files to be deleted # should only be printed instead of actually deleted, false if the files # should actually be deleted. # # @param [Enumerable] exclude def initialize(config, reps, dry_run: false, exclude: []) @config = config @reps = reps @dry_run = dry_run @exclude = Set.new(exclude) end # Prunes all output files not managed by Nanoc. # # @return [void] def run return unless File.directory?(@config[:output_dir]) compiled_files = @reps.flat_map { |r| r.raw_paths.values }.compact present_files, present_dirs = files_and_dirs_in(@config[:output_dir] + '/') remove_stray_files(present_files, compiled_files) remove_empty_directories(present_dirs) end def exclude?(component) @exclude.include?(component) end # @param [String] filename The filename to check # # @return [Boolean] true if the given file is excluded, false otherwise def filename_excluded?(filename) pathname = Pathname.new(filename) @exclude.any? { |e| pathname.__nanoc_include_component?(e) } end # @api private def remove_stray_files(present_files, compiled_files) (present_files - compiled_files).each do |f| delete_file(f) unless exclude?(f) end end # @api private def remove_empty_directories(present_dirs) present_dirs.reverse_each do |dir| next if Dir.foreach(dir) { |n| break true if n !~ /\A\.\.?\z/ } next if exclude?(dir) delete_dir(dir) end end # @api private def files_and_dirs_in(dir) present_files = [] present_dirs = [] Find.find(dir) do |f| basename = File.basename(f) case File.ftype(f) when 'file'.freeze unless exclude?(basename) present_files << f end when 'directory'.freeze if exclude?(basename) Find.prune else present_dirs << f end end end [present_files, present_dirs] end protected def delete_file(file) log_delete_and_run(file) { FileUtils.rm(file) } end def delete_dir(dir) log_delete_and_run(dir) { Dir.rmdir(dir) } end def log_delete_and_run(thing) if @dry_run puts thing else Nanoc::CLI::Logger.instance.file(:high, :delete, thing) yield end end end end nanoc-4.4.7/lib/nanoc/base/services/executor.rb0000644000004100000410000001041013033443476021443 0ustar www-datawww-datamodule Nanoc module Int class Executor class OutputNotWrittenError < ::Nanoc::Error def initialize(filter_name, output_filename) super("The #{filter_name.inspect} filter did not write anything to the required output file, #{output_filename}.") end end def initialize(rep, compilation_context, dependency_tracker) @rep = rep @compilation_context = compilation_context @dependency_tracker = dependency_tracker end def filter(filter_name, filter_args = {}) filter = filter_for_filtering(@rep, filter_name) begin Nanoc::Int::NotificationCenter.post(:filtering_started, @rep, filter_name) # Run filter last = @rep.snapshot_contents[:last] source = @rep.binary? ? last.filename : last.string filter_args.freeze result = filter.setup_and_run(source, filter_args) @rep.snapshot_contents[:last] = if filter.class.to_binary? Nanoc::Int::BinaryContent.new(filter.output_filename).tap(&:freeze) else Nanoc::Int::TextualContent.new(result).tap(&:freeze) end # Check whether file was written if filter.class.to_binary? && !File.file?(filter.output_filename) raise OutputNotWrittenError.new(filter_name, filter.output_filename) end ensure Nanoc::Int::NotificationCenter.post(:filtering_ended, @rep, filter_name) end end def layout(layout_identifier, extra_filter_args = nil) layout = find_layout(layout_identifier) filter_name, filter_args = *@compilation_context.filter_name_and_args_for_layout(layout) if filter_name.nil? raise Nanoc::Int::Errors::Generic, "Cannot find rule for layout matching #{layout_identifier}" end filter_args = filter_args.merge(extra_filter_args || {}) filter_args.freeze # Check whether item can be laid out raise Nanoc::Int::Errors::CannotLayoutBinaryItem.new(@rep) if @rep.binary? # Create filter klass = Nanoc::Filter.named(filter_name) raise Nanoc::Int::Errors::UnknownFilter.new(filter_name) if klass.nil? view_context = @compilation_context.create_view_context(@dependency_tracker) layout_view = Nanoc::LayoutView.new(layout, view_context) filter = klass.new(assigns_for(@rep).merge(layout: layout_view)) # Visit @dependency_tracker.bounce(layout, raw_content: true) begin Nanoc::Int::NotificationCenter.post(:filtering_started, @rep, filter_name) # Layout content = layout.content arg = content.binary? ? content.filename : content.string res = filter.setup_and_run(arg, filter_args) @rep.snapshot_contents[:last] = Nanoc::Int::TextualContent.new(res).tap(&:freeze) ensure Nanoc::Int::NotificationCenter.post(:filtering_ended, @rep, filter_name) end end def snapshot(snapshot_name) @rep.snapshot_contents[snapshot_name] = @rep.snapshot_contents[:last] end def assigns_for(rep) @compilation_context.assigns_for(rep, @dependency_tracker) end def layouts @compilation_context.site.layouts end def find_layout(arg) req_id = arg.__nanoc_cleaned_identifier layout = layouts.find { |l| l.identifier == req_id } return layout if layout if use_globs? pat = Nanoc::Int::Pattern.from(arg) layout = layouts.find { |l| pat.match?(l.identifier) } return layout if layout end raise Nanoc::Int::Errors::UnknownLayout.new(arg) end def filter_for_filtering(rep, filter_name) klass = Nanoc::Filter.named(filter_name) raise Nanoc::Int::Errors::UnknownFilter.new(filter_name) if klass.nil? if klass.from_binary? && !rep.binary? raise Nanoc::Int::Errors::CannotUseBinaryFilter.new(rep, klass) elsif !klass.from_binary? && rep.binary? raise Nanoc::Int::Errors::CannotUseTextualFilter.new(rep, klass) end klass.new(assigns_for(rep)) end def use_globs? @compilation_context.site.config[:string_pattern_type] == 'glob' end end end end nanoc-4.4.7/lib/nanoc/base/services/temp_filename_factory.rb0000644000004100000410000000234413033443476024150 0ustar www-datawww-datarequire 'tmpdir' module Nanoc::Int # @api private class TempFilenameFactory # @return [String] The root directory for all temporary filenames attr_reader :root_dir # @return [Nanoc::Int::TempFilenameFactory] A common instance def self.instance @instance ||= new end def initialize @counts = {} @root_dir = Dir.mktmpdir('nanoc') end # @param [String] prefix A string prefix to include in the temporary # filename, often the type of filename being provided. # # @return [String] A new unused filename def create(prefix) count = @counts.fetch(prefix, 0) @counts[prefix] = count + 1 dirname = File.join(@root_dir, prefix) filename = File.join(@root_dir, prefix, count.to_s) FileUtils.mkdir_p(dirname) filename end # @param [String] prefix A string prefix that indicates which temporary # filenames should be deleted. # # @return [void] def cleanup(prefix) path = File.join(@root_dir, prefix) if File.exist?(path) FileUtils.rm_rf(path) end @counts.delete(prefix) if @counts.empty? && File.directory?(@root_dir) FileUtils.rm_rf(@root_dir) end end end end nanoc-4.4.7/lib/nanoc/base/services/dependency_tracker.rb0000644000004100000410000000324713033443476023450 0ustar www-datawww-datamodule Nanoc::Int # @api private class DependencyTracker include Nanoc::Int::ContractsSupport C_OBJ = C::Or[Nanoc::Int::Item, Nanoc::Int::Layout] C_ARGS = C::KeywordArgs[raw_content: C::Optional[C::Bool], attributes: C::Optional[C::Bool], compiled_content: C::Optional[C::Bool], path: C::Optional[C::Bool]] class Null include Nanoc::Int::ContractsSupport contract C_OBJ, C_ARGS => C::Any def enter(_obj, raw_content: false, attributes: false, compiled_content: false, path: false); end contract C_OBJ => C::Any def exit; end contract C_OBJ, C_ARGS => C::Any def bounce(_obj, raw_content: false, attributes: false, compiled_content: false, path: false); end end def initialize(dependency_store) @dependency_store = dependency_store @stack = [] end contract C_OBJ, C_ARGS => C::Any def enter(obj, raw_content: false, attributes: false, compiled_content: false, path: false) unless @stack.empty? Nanoc::Int::NotificationCenter.post(:dependency_created, @stack.last, obj) @dependency_store.record_dependency( @stack.last, obj, raw_content: raw_content, attributes: attributes, compiled_content: compiled_content, path: path, ) end @stack.push(obj) end contract C_OBJ => C::Any def exit @stack.pop end contract C_OBJ, C_ARGS => C::Any def bounce(obj, raw_content: false, attributes: false, compiled_content: false, path: false) enter(obj, raw_content: raw_content, attributes: attributes, compiled_content: compiled_content, path: path) exit end end end nanoc-4.4.7/lib/nanoc/base/views.rb0000644000004100000410000000232413033443476017124 0ustar www-datawww-datarequire_relative 'views/mixins/document_view_mixin' require_relative 'views/mixins/mutable_document_view_mixin' require_relative 'views/mixins/with_reps_view_mixin' require_relative 'views/view' require_relative 'views/view_context' require_relative 'views/config_view' require_relative 'views/identifiable_collection_view' require_relative 'views/item_without_reps_view' require_relative 'views/item_with_reps_view' require_relative 'views/item_collection_with_reps_view' require_relative 'views/item_collection_without_reps_view' require_relative 'views/item_rep_view' require_relative 'views/item_rep_collection_view' require_relative 'views/layout_view' require_relative 'views/layout_collection_view' require_relative 'views/mutable_config_view' require_relative 'views/mutable_identifiable_collection_view' require_relative 'views/mutable_item_view' require_relative 'views/mutable_item_collection_view' require_relative 'views/mutable_layout_view' require_relative 'views/mutable_layout_collection_view' require_relative 'views/post_compile_item_view' require_relative 'views/post_compile_item_collection_view' require_relative 'views/post_compile_item_rep_view' require_relative 'views/post_compile_item_rep_collection_view' nanoc-4.4.7/lib/nanoc/base/memoization.rb0000644000004100000410000000446613033443476020333 0ustar www-datawww-datarequire 'weakref' module Nanoc::Int # Adds support for memoizing functions. # # @api private module Memoization class Wrapper attr_reader :ref def initialize(ref) @ref = ref end def inspect obj = @ref.object if obj obj.inspect else '' end end end class Value attr_reader :value def initialize(value) @value = value end end NONE = Object.new # Memoizes the method with the given name. The modified method will cache # the results of the original method, so that calling a method twice with # the same arguments will short-circuit and return the cached results # immediately. # # Memoization assumes that the current object as well as the function # arguments are immutable. Mutating the object or the arguments will not # cause memoized methods to recalculate their results. There is no way to # un-memoize a result, and calculation results will remain in memory even # if they are no longer needed. # # @example A fast fib function due to memoization # # class FibFast # # extend Nanoc::Int::Memoization # # def run(n) # if n == 0 # 0 # elsif n == 1 # 1 # else # run(n-1) + run(n-2) # end # end # memoize :run # # end # # @param [Symbol, String] method_name The name of the method to memoize # # @return [void] def memoize(method_name) original_method_name = '__nonmemoized_' + method_name.to_s alias_method original_method_name, method_name define_method(method_name) do |*args| @__memoization_cache ||= {} @__memoization_cache[method_name] ||= {} method_cache = @__memoization_cache[method_name] value = NONE if method_cache.key?(args) object = method_cache[args].ref.object value = object ? object.value : NONE end if value.equal?(NONE) send(original_method_name, *args).tap do |r| method_cache[args] = Wrapper.new(Ref::SoftReference.new(Value.new(r))) end else value end end end end end nanoc-4.4.7/lib/nanoc/base/services.rb0000644000004100000410000000134313033443476017612 0ustar www-datawww-datarequire_relative 'services/action_provider' require_relative 'services/checksummer' require_relative 'services/compiler' require_relative 'services/compiler_loader' require_relative 'services/dependency_tracker' require_relative 'services/executor' require_relative 'services/filter' require_relative 'services/item_rep_builder' require_relative 'services/item_rep_router' require_relative 'services/item_rep_selector' require_relative 'services/item_rep_writer' require_relative 'services/notification_center' require_relative 'services/pruner' require_relative 'services/temp_filename_factory' require_relative 'services/outdatedness_rule' require_relative 'services/outdatedness_rules' require_relative 'services/outdatedness_checker' nanoc-4.4.7/lib/nanoc/base/repos/0000755000004100000410000000000013033443476016571 5ustar www-datawww-datananoc-4.4.7/lib/nanoc/base/repos/compiled_content_cache.rb0000644000004100000410000000336413033443476023575 0ustar www-datawww-datamodule Nanoc::Int # Represents a cache than can be used to store already compiled content, # to prevent it from being needlessly recompiled. # # @api private class CompiledContentCache < ::Nanoc::Int::Store include Nanoc::Int::ContractsSupport contract C::KeywordArgs[env_name: C::Maybe[String], items: C::IterOf[Nanoc::Int::Item]] => C::Any def initialize(env_name: nil, items:) super(Nanoc::Int::Store.tmp_path_for(env_name: env_name, store_name: 'compiled_content'), 2) @items = items @cache = {} end contract Nanoc::Int::ItemRep => C::Maybe[C::HashOf[Symbol => Nanoc::Int::Content]] # Returns the cached compiled content for the given item representation. # # This cached compiled content is a hash where the keys are the snapshot # names. and the values the compiled content at the given snapshot. def [](rep) item_cache = @cache[rep.item.identifier] || {} item_cache[rep.name] end contract Nanoc::Int::ItemRep, C::HashOf[Symbol => Nanoc::Int::Content] => self # Sets the compiled content for the given representation. # # This cached compiled content is a hash where the keys are the snapshot # names. and the values the compiled content at the given snapshot. def []=(rep, content) @cache[rep.item.identifier] ||= {} @cache[rep.item.identifier][rep.name] = content self end protected def data @cache end def data=(new_data) @cache = {} item_identifiers = Set.new(@items.map(&:identifier)) new_data.each_pair do |item_identifier, content_per_rep| if item_identifiers.include?(item_identifier) @cache[item_identifier] ||= content_per_rep end end end end end nanoc-4.4.7/lib/nanoc/base/repos/item_rep_repo.rb0000644000004100000410000000073513033443476021754 0ustar www-datawww-datamodule Nanoc::Int # Stores item reps (in memory). # # @api private class ItemRepRepo include Enumerable def initialize @reps = [] @reps_by_item = {} end def <<(rep) @reps << rep @reps_by_item[rep.item] ||= [] @reps_by_item[rep.item] << rep end def to_a @reps end def each(&block) @reps.each(&block) self end def [](item) @reps_by_item.fetch(item, []) end end end nanoc-4.4.7/lib/nanoc/base/repos/outdatedness_store.rb0000644000004100000410000000222213033443476023032 0ustar www-datawww-datamodule Nanoc::Int # @api private class OutdatednessStore < ::Nanoc::Int::Store include Nanoc::Int::ContractsSupport contract C::KeywordArgs[site: C::Maybe[Nanoc::Int::Site], reps: Nanoc::Int::ItemRepRepo] => C::Any def initialize(site: nil, reps:) super(Nanoc::Int::Store.tmp_path_for(env_name: (site.config.env_name if site), store_name: 'outdatedness'), 1) @outdated_reps = Set.new @all_reps = reps end contract Nanoc::Int::ItemRep => C::Bool def include?(obj) @outdated_reps.include?(obj) end contract Nanoc::Int::ItemRep => self def add(obj) @outdated_reps << obj self end contract Nanoc::Int::ItemRep => self def remove(obj) @outdated_reps.delete(obj) self end contract C::None => C::ArrayOf[Nanoc::Int::ItemRep] def to_a @outdated_reps.to_a end protected def data @outdated_reps.map(&:reference) end def data=(new_data) outdated_refs = Set.new(new_data) all_reps = Set.new(@all_reps) @outdated_reps = Set.new(all_reps.select { |rep| outdated_refs.include?(rep.reference) }) end end end nanoc-4.4.7/lib/nanoc/base/repos/site_loader.rb0000644000004100000410000000455213033443476021416 0ustar www-datawww-datamodule Nanoc::Int class SiteLoader def new_empty site_from_config(Nanoc::Int::Configuration.new.with_defaults) end def new_with_config(hash) site_from_config(Nanoc::Int::Configuration.new(hash: hash).with_defaults) end def new_from_cwd site_from_config(Nanoc::Int::ConfigLoader.new.new_from_cwd) end # @return [Boolean] def self.cwd_is_nanoc_site? Nanoc::Int::ConfigLoader.cwd_is_nanoc_site? end private def site_from_config(config) code_snippets = code_snippets_from_config(config) code_snippets.each(&:load) items = Nanoc::Int::IdentifiableCollection.new(config) layouts = Nanoc::Int::IdentifiableCollection.new(config) with_data_sources(config) do |data_sources| data_sources.each do |ds| items_in_ds = ds.items layouts_in_ds = ds.layouts items_in_ds.each { |i| i.identifier = i.identifier.prefix(ds.items_root) } layouts_in_ds.each { |l| l.identifier = l.identifier.prefix(ds.layouts_root) } items.concat(items_in_ds) layouts.concat(layouts_in_ds) end end Nanoc::Int::Site.new( config: config, code_snippets: code_snippets, items: items, layouts: layouts, ) end def with_data_sources(config, &_block) data_sources = create_data_sources(config) begin data_sources.each(&:use) yield(data_sources) ensure data_sources.each(&:unuse) end end def create_data_sources(config) config[:data_sources].map do |data_source_hash| # Get data source class data_source_class = Nanoc::DataSource.named(data_source_hash[:type]) if data_source_class.nil? raise Nanoc::Int::Errors::UnknownDataSource.new(data_source_hash[:type]) end # Create data source data_source_class.new( config, data_source_hash[:items_root], data_source_hash[:layouts_root], data_source_hash.merge(data_source_hash[:config] || {}), ) end end def code_snippets_from_config(config) config[:lib_dirs].flat_map do |lib| Dir["#{lib}/**/*.rb"].sort.map do |filename| Nanoc::Int::CodeSnippet.new( File.read(filename), filename, ) end end end end end nanoc-4.4.7/lib/nanoc/base/repos/checksum_store.rb0000644000004100000410000000337113033443476022140 0ustar www-datawww-datamodule Nanoc::Int # Stores checksums for objects in order to be able to detect whether a file # has changed since the last site compilation. # # @api private class ChecksumStore < ::Nanoc::Int::Store include Nanoc::Int::ContractsSupport attr_accessor :objects c_obj = C::Or[Nanoc::Int::Item, Nanoc::Int::Layout, Nanoc::Int::Configuration, Nanoc::Int::CodeSnippet] contract C::KeywordArgs[site: C::Maybe[Nanoc::Int::Site], objects: C::IterOf[c_obj]] => C::Any def initialize(site: nil, objects:) super(Nanoc::Int::Store.tmp_path_for(env_name: (site.config.env_name if site), store_name: 'checksums'), 1) @objects = objects @checksums = {} end contract c_obj => C::Maybe[String] def [](obj) @checksums[obj.reference] end contract c_obj => self def add(obj) if obj.is_a?(Nanoc::Int::Document) @checksums[[obj.reference, :content]] = Nanoc::Int::Checksummer.calc_for_content_of(obj) @checksums[[obj.reference, :attributes]] = Nanoc::Int::Checksummer.calc_for_attributes_of(obj) end @checksums[obj.reference] = Nanoc::Int::Checksummer.calc(obj) self end contract c_obj => C::Maybe[String] def content_checksum_for(obj) @checksums[[obj.reference, :content]] end contract c_obj => C::Maybe[String] def attributes_checksum_for(obj) @checksums[[obj.reference, :attributes]] end protected def data @checksums end def data=(new_data) references = Set.new(@objects.map(&:reference)) @checksums = {} new_data.each_pair do |key, checksum| if references.include?(key) || references.include?(key.first) @checksums[key] = checksum end end end end end nanoc-4.4.7/lib/nanoc/base/repos/data_source.rb0000644000004100000410000001471013033443476021412 0ustar www-datawww-datamodule Nanoc # Responsible for loading site data. It is the (abstract) superclass for all # data sources. Subclasses must at least implement the data reading methods # ({#items} and {#layouts}). # # Apart from the methods for loading and storing data, there are the {#up} # and {#down} methods for bringing up and tearing down the connection to the # data source. These should be overridden in subclasses. The {#loading} # method wraps {#up} and {#down}. {#loading} is a convenience method for the # more low-level methods {#use} and {#unuse}, which respectively increment # and decrement the reference count; when the reference count goes from 0 to # 1, the data source will be loaded ({#up} will be called) and when the # reference count goes from 1 to 0, the data source will be unloaded # ({#down} will be called). # # @abstract Subclasses should at least implement {#items} and {#layouts}. class DataSource # @return [String] The root path where items returned by this data source # should be mounted. attr_reader :items_root # @return [String] The root path where layouts returned by this data # source should be mounted. attr_reader :layouts_root # @return [Hash] The configuration for this data source. For example, # online data sources could contain authentication details. attr_reader :config extend Nanoc::Int::PluginRegistry::PluginMethods def initialize(site_config, items_root, layouts_root, config) @site_config = site_config @items_root = items_root @layouts_root = layouts_root @config = config || {} @references = 0 end # Loads the data source when necessary (calling {#up}), yields, and # unloads (using {#down}) the data source when it is not being used # elsewhere. All data source queries and data manipulations should be # wrapped in a {#loading} block; it ensures that the data source is loaded # when necessary and makes sure the data source does not get unloaded # while it is still being used elsewhere. # # @return [void] def loading use yield ensure unuse end # Marks the data source as used by the caller. # # Calling this method increases the internal reference count. When the # data source is used for the first time (first {#use} call), the data # source will be loaded ({#up} will be called). # # @return [void] def use up if @references.zero? @references += 1 end # Marks the data source as unused by the caller. # # Calling this method decreases the internal reference count. When the # reference count reaches zero, i.e. when the data source is not used any # more, the data source will be unloaded ({#down} will be called). # # @return [void] def unuse @references -= 1 down if @references.zero? end # Brings up the connection to the data. Depending on the way data is # stored, this may not be necessary. This is the ideal place to connect to # the database, for example. # # Subclasses may override this method, but are not required to do so; the # default implementation simply does nothing. # # @return [void] def up; end # Brings down the connection to the data. This method should undo the # effects of the {#up} method. For example, a database connection # established in {#up} should be closed in this method. # # Subclasses may override this method, but are not required to do so; the # default implementation simply does nothing. # # @return [void] def down; end # Returns the collection of items (represented by {Nanoc::Int::Item}) in # this site. The default implementation simply returns an empty array. # # Subclasses should not prepend `items_root` to the item's identifiers, as # this will be done automatically. # # Subclasses may override this method, but are not required to do so; the # default implementation simply does nothing. # # @return [Enumerable] The collection of items def items [] end # Returns the collection of layouts (represented by {Nanoc::Int::Layout}) in # this site. The default implementation simply returns an empty array. # # Subclasses should prepend `layout_root` to the layout's identifiers, # since this is not done automatically. # # Subclasses may override this method, but are not required to do so; the # default implementation simply does nothing. # # @return [Enumerable] The collection of layouts def layouts [] end # Creates a new in-memory item instance. This is intended for use within # the {#items} method. # # @param [String, Proc] content The uncompiled item content # (if it is a textual item) or the path to the filename containing the # content (if it is a binary item). # # @param [Hash, Proc] attributes A hash containing this item's attributes. # # @param [String] identifier This item's identifier. # # @param [Boolean] binary Whether or not this item is binary # # @param [String, nil] checksum_data # # @param [String, nil] content_checksum_data # # @param [String, nil] attributes_checksum_data def new_item(content, attributes, identifier, binary: false, checksum_data: nil, content_checksum_data: nil, attributes_checksum_data: nil) content = Nanoc::Int::Content.create(content, binary: binary) Nanoc::Int::Item.new(content, attributes, identifier, checksum_data: checksum_data, content_checksum_data: content_checksum_data, attributes_checksum_data: attributes_checksum_data) end # Creates a new in-memory layout instance. This is intended for use within # the {#layouts} method. # # @param [String] raw_content The raw content of this layout. # # @param [Hash] attributes A hash containing this layout's attributes. # # @param [String] identifier This layout's identifier. # # @param [String, nil] checksum_data # # @param [String, nil] content_checksum_data # # @param [String, nil] attributes_checksum_data def new_layout(raw_content, attributes, identifier, checksum_data: nil, content_checksum_data: nil, attributes_checksum_data: nil) Nanoc::Int::Layout.new(raw_content, attributes, identifier, checksum_data: checksum_data, content_checksum_data: content_checksum_data, attributes_checksum_data: attributes_checksum_data) end end end nanoc-4.4.7/lib/nanoc/base/repos/rule_memory_store.rb0000644000004100000410000000216013033443476022670 0ustar www-datawww-datamodule Nanoc::Int # Stores rule memories for objects that can be run through a rule (item # representations and layouts). # # @api private class RuleMemoryStore < ::Nanoc::Int::Store def initialize(env_name: nil) super(Nanoc::Int::Store.tmp_path_for(env_name: env_name, store_name: 'rule_memory'), 1) @rule_memories = {} end # @param [Nanoc::Int::ItemRep, Nanoc::Int::Layout] obj The item representation or # the layout to get the rule memory for # # @return [Array] The rule memory for the given object def [](obj) @rule_memories[obj.reference] end # @param [Nanoc::Int::ItemRep, Nanoc::Int::Layout] obj The item representation or # the layout to set the rule memory for # # @param [Array] rule_memory The new rule memory to be stored # # @return [void] def []=(obj, rule_memory) @rule_memories[obj.reference] = rule_memory end protected # @see Nanoc::Int::Store#data def data @rule_memories end # @see Nanoc::Int::Store#data= def data=(new_data) @rule_memories = new_data end end end nanoc-4.4.7/lib/nanoc/base/repos/dependency_store.rb0000644000004100000410000001165613033443476022461 0ustar www-datawww-datamodule Nanoc::Int # @api private class DependencyStore < ::Nanoc::Int::Store include Nanoc::Int::ContractsSupport # @return [Array] attr_accessor :objects # @param [Array] objects def initialize(objects, env_name: nil) super(Nanoc::Int::Store.tmp_path_for(env_name: env_name, store_name: 'dependencies'), 4) @objects = objects @new_objects = [] @graph = Nanoc::Int::DirectedGraph.new([nil] + @objects) end contract C::Or[Nanoc::Int::Item, Nanoc::Int::ItemRep, Nanoc::Int::Layout] => C::ArrayOf[Nanoc::Int::Dependency] def dependencies_causing_outdatedness_of(object) objects_causing_outdatedness_of(object).map do |other_object| props = props_for(other_object, object) Nanoc::Int::Dependency.new( other_object, object, Nanoc::Int::Props.new( raw_content: props.fetch(:raw_content, false), attributes: props.fetch(:attributes, false), compiled_content: props.fetch(:compiled_content, false), path: props.fetch(:path, false), ), ) end end # Returns the direct dependencies for the given object. # # The direct dependencies of the given object include the items and # layouts that, when outdated will cause the given object to be marked as # outdated. Indirect dependencies will not be returned (e.g. if A depends # on B which depends on C, then the direct dependencies of A do not # include C). # # The direct predecessors can include nil, which indicates an item that is # no longer present in the site. # # @param [Nanoc::Int::Item, Nanoc::Int::Layout] object The object for # which to fetch the direct predecessors # # @return [Array] The direct # predecessors of # the given object def objects_causing_outdatedness_of(object) if @new_objects.any? [@new_objects.first] else @graph.direct_predecessors_of(object) end end contract C::Maybe[C::Or[Nanoc::Int::Item, Nanoc::Int::Layout]], C::Maybe[C::Or[Nanoc::Int::Item, Nanoc::Int::Layout]], C::KeywordArgs[raw_content: C::Optional[C::Bool], attributes: C::Optional[C::Bool], compiled_content: C::Optional[C::Bool], path: C::Optional[C::Bool]] => C::Any # Records a dependency from `src` to `dst` in the dependency graph. When # `dst` is oudated, `src` will also become outdated. # # @param [Nanoc::Int::Item, Nanoc::Int::Layout] src The source of the dependency, # i.e. the object that will become outdated if dst is outdated # # @param [Nanoc::Int::Item, Nanoc::Int::Layout] dst The destination of the # dependency, i.e. the object that will cause the source to become # outdated if the destination is outdated # # @return [void] def record_dependency(src, dst, raw_content: false, attributes: false, compiled_content: false, path: false) existing_props = Nanoc::Int::Props.new(@graph.props_for(dst, src) || {}) new_props = Nanoc::Int::Props.new(raw_content: raw_content, attributes: attributes, compiled_content: compiled_content, path: path) props = existing_props.merge(new_props) # Warning! dst and src are *reversed* here! @graph.add_edge(dst, src, props: props.to_h) unless src == dst end # Empties the list of dependencies for the given object. This is necessary # before recompiling the given object, because otherwise old dependencies # will stick around and new dependencies will appear twice. This function # removes all incoming edges for the given vertex. # # @param [Nanoc::Int::Item, Nanoc::Int::Layout] object The object for which to # forget all dependencies # # @return [void] def forget_dependencies_for(object) @graph.delete_edges_to(object) end protected def props_for(a, b) props = @graph.props_for(a, b) || {} if props.values.any? { |v| v } props else { raw_content: true, attributes: true, compiled_content: true, path: true } end end def data { edges: @graph.edges, vertices: @graph.vertices.map { |obj| obj && obj.reference }, } end def data=(new_data) # Create new graph @graph = Nanoc::Int::DirectedGraph.new([nil] + @objects) # Load vertices previous_objects = new_data[:vertices].map do |reference| @objects.find { |obj| reference == obj.reference } end # Load edges new_data[:edges].each do |edge| from_index, to_index, props = *edge from = from_index && previous_objects[from_index] to = to_index && previous_objects[to_index] @graph.add_edge(from, to, props: props) end # Record dependency from all items on new items @new_objects = @objects - previous_objects end end end nanoc-4.4.7/lib/nanoc/base/repos/store.rb0000644000004100000410000000613513033443476020257 0ustar www-datawww-datamodule Nanoc::Int # An abstract superclass for classes that need to store data to the # filesystem, such as checksums, cached compiled content and dependency # graphs. # # Each store has a version number. When attempting to load data from a store # that has an incompatible version number, no data will be loaded, but # {#version_mismatch_detected} will be called. # # @abstract Subclasses must implement {#data} and {#data=}, and may # implement {#no_data_found} and {#version_mismatch_detected}. # # @api private class Store include Nanoc::Int::ContractsSupport # @return [String] The name of the file where data will be loaded from and # stored to. attr_reader :filename # @return [Numeric] The version number corresponding to the file format # the data is in. When the file format changes, the version number # should be incremented. attr_reader :version # Creates a new store for the given filename. # # @param [String] filename The name of the file where data will be loaded # from and stored to. # # @param [Numeric] version The version number corresponding to the file # format the data is in. When the file format changes, the version # number should be incremented. def initialize(filename, version) @filename = filename @version = version end # Logic for building tmp path from active environment and store name # @api private contract C::KeywordArgs[env_name: C::Maybe[String], store_name: String] => String def self.tmp_path_for(env_name:, store_name:) File.join('tmp', env_name.to_s, store_name) end # @group Loading and storing data # @return The data that should be written to the disk # # @abstract This method must be implemented by the subclass. def data raise NotImplementedError.new('Nanoc::Int::Store subclasses must implement #data and #data=') end # @param new_data The data that has been loaded from the disk # # @abstract This method must be implemented by the subclass. # # @return [void] def data=(new_data) # rubocop:disable Lint/UnusedMethodArgument raise NotImplementedError.new('Nanoc::Int::Store subclasses must implement #data and #data=') end # Loads the data from the filesystem into memory. This method will set the # loaded data using the {#data=} method. # # @return [void] def load return unless File.file?(filename) begin pstore.transaction do return if pstore[:version] != version self.data = pstore[:data] end rescue FileUtils.rm_f(filename) load end end # Stores the data contained in memory to the filesystem. This method will # use the {#data} method to fetch the data that should be written. # # @return [void] def store FileUtils.mkdir_p(File.dirname(filename)) pstore.transaction do pstore[:data] = data pstore[:version] = version end end private def pstore @pstore ||= PStore.new(filename) end end end nanoc-4.4.7/lib/nanoc/base/repos/config_loader.rb0000644000004100000410000000403313033443476021711 0ustar www-datawww-datamodule Nanoc::Int # @api private class ConfigLoader class NoConfigFileFoundError < ::Nanoc::Error def initialize super('No configuration file found') end end class NoParentConfigFileFoundError < ::Nanoc::Error def initialize(filename) super("There is no parent configuration file at #{filename}") end end class CyclicalConfigFileError < ::Nanoc::Error def initialize(filename) super("The parent configuration file at #{filename} includes one of its descendants") end end # @return [Boolean] def self.cwd_is_nanoc_site? !config_filename_for_cwd.nil? end # @return [String] def self.config_filename_for_cwd filenames = %w(nanoc.yaml config.yaml) candidate = filenames.find { |f| File.file?(f) } candidate && File.expand_path(candidate) end def new_from_cwd # Determine path filename = self.class.config_filename_for_cwd raise NoConfigFileFoundError if filename.nil? # Read config = apply_parent_config( Nanoc::Int::Configuration.new(hash: YAML.load_file(filename)), [filename], ).with_defaults # Load environment config.with_environment end # @api private def apply_parent_config(config, processed_paths = []) parent_path = config[:parent_config_file] return config if parent_path.nil? # Get absolute path parent_path = File.absolute_path(parent_path, File.dirname(processed_paths.last)) unless File.file?(parent_path) raise NoParentConfigFileFoundError.new(parent_path) end # Check recursion if processed_paths.include?(parent_path) raise CyclicalConfigFileError.new(parent_path) end # Load parent_config = Nanoc::Int::Configuration.new(hash: YAML.load_file(parent_path)) full_parent_config = apply_parent_config(parent_config, processed_paths + [parent_path]) full_parent_config.merge(config.without(:parent_config_file)) end end end nanoc-4.4.7/lib/nanoc/base/feature.rb0000644000004100000410000000453113033443476017424 0ustar www-datawww-datamodule Nanoc # @api private # # @example Defining a feature and checking its enabledness # # Nanoc::Feature.define('environments', version: '4.3') # Nanoc::Feaure.enabled?(Nanoc::Feature::ENVIRONMENTS) # module Feature # Defines a new feature with the given name, experimental in the given # version. The feature will be made available as a constant with the same # name, in uppercase, on the Nanoc::Feature module. # # @example Defining Nanoc::Feature::ENVIRONMENTS # # Nanoc::Feature.define('environments', version: '4.3') # # @param name The name of the feature # # @param version The minor version in which the feature is considered # experimental. # # @return [void] def self.define(name, version:) repo[name] = version const_set(name.upcase, name) end # Undefines the feature with the given name. For testing purposes only. # # @param name The name of the feature # # @return [void] # # @private def self.undefine(name) repo.delete(name) remove_const(name.upcase) end # @param [String] feature_name # # @return [Boolean] Whether or not the feature with the given name is enabled def self.enabled?(feature_name) enabled_features.include?(feature_name) || enabled_features.include?('all') end # @api private def self.enable(feature_name) raise ArgumentError, 'no block given' unless block_given? if enabled?(feature_name) yield else begin enabled_features << feature_name yield ensure enabled_features.delete(feature_name) end end end # @api private def self.reset_caches @enabled_features = nil end # @api private def self.enabled_features @enabled_features ||= Set.new(ENV.fetch('NANOC_FEATURES', '').split(',')) end # @api private def self.repo @repo ||= {} end # @return [Enumerable] Names of features that still exist, but # should not be considered as experimental in the current version of # Nanoc. def self.all_outdated repo.keys.reject do |name| version = repo[name] Nanoc::VERSION.start_with?(version) end end end end Nanoc::Feature.define('profiler', version: '4.4') nanoc-4.4.7/lib/nanoc/base/entities.rb0000644000004100000410000000156613033443476017622 0ustar www-datawww-datarequire_relative 'entities/context' require_relative 'entities/directed_graph' require_relative 'entities/identifier' require_relative 'entities/content' require_relative 'entities/processing_action' require_relative 'entities/processing_actions' require_relative 'entities/code_snippet' require_relative 'entities/configuration' require_relative 'entities/lazy_value' require_relative 'entities/document' require_relative 'entities/identifiable_collection' require_relative 'entities/item' require_relative 'entities/item_rep' require_relative 'entities/layout' require_relative 'entities/pattern' require_relative 'entities/props' require_relative 'entities/rule_memory' require_relative 'entities/site' require_relative 'entities/snapshot_def' require_relative 'entities/outdatedness_status' require_relative 'entities/outdatedness_reasons' require_relative 'entities/dependency' nanoc-4.4.7/lib/nanoc/base/contracts_support.rb0000644000004100000410000000533413033443476021567 0ustar www-datawww-datarequire 'singleton' module Nanoc::Int # @api private module ContractsSupport class Ignorer include Singleton # rubocop:disable Style/MethodMissing def method_missing(*_args) self end # rubocop:enable Style/MethodMissing def respond_to_missing?(*_args) true end end module DisabledContracts Any = Ignorer.instance Bool = Ignorer.instance Num = Ignorer.instance KeywordArgs = Ignorer.instance Optional = Ignorer.instance Maybe = Ignorer.instance None = Ignorer.instance ArrayOf = Ignorer.instance Or = Ignorer.instance Func = Ignorer.instance RespondTo = Ignorer.instance Named = Ignorer.instance IterOf = Ignorer.instance HashOf = Ignorer.instance def contract(*args); end end module EnabledContracts class AbstractContract def self.[](*vals) new(*vals) end end class Named < AbstractContract def initialize(name) @name = name end def valid?(val) val.is_a?(Kernel.const_get(@name)) end def inspect "#{self.class}(#{@name})" end end class IterOf < AbstractContract def initialize(contract) @contract = contract end def valid?(val) val.respond_to?(:each) && val.all? { |v| Contract.valid?(v, @contract) } end def inspect "#{self.class}(#{@contract})" end end def contract(*args) Contract(*args) end end def self.setup_once @_contracts_support__setup ||= false return @_contracts_support__should_enable if @_contracts_support__setup @_contracts_support__setup = true contracts_loadable = begin require 'contracts' true rescue LoadError false end @_contracts_support__should_enable = contracts_loadable && !ENV.key?('DISABLE_CONTRACTS') if @_contracts_support__should_enable # FIXME: ugly ::Contracts.const_set('Named', EnabledContracts::Named) ::Contracts.const_set('IterOf', EnabledContracts::IterOf) end @_contracts_support__should_enable end def self.included(base) should_enable = setup_once if should_enable unless base.include?(::Contracts::Core) base.include(::Contracts::Core) base.extend(EnabledContracts) base.const_set('C', ::Contracts) end else base.extend(DisabledContracts) base.const_set('C', DisabledContracts) end end end end nanoc-4.4.7/lib/nanoc/base/error.rb0000644000004100000410000000016413033443476017120 0ustar www-datawww-datamodule Nanoc # Generic error. Superclass for all Nanoc-specific errors. class Error < ::StandardError end end nanoc-4.4.7/lib/nanoc/deploying.rb0000644000004100000410000000020313033443476017041 0ustar www-datawww-datamodule Nanoc # @api private module Deploying end end require 'nanoc/deploying/deployer' require 'nanoc/deploying/deployers' nanoc-4.4.7/lib/nanoc/filters/0000755000004100000410000000000013033443476016177 5ustar www-datawww-datananoc-4.4.7/lib/nanoc/filters/markaby.rb0000644000004100000410000000067613033443476020163 0ustar www-datawww-datamodule Nanoc::Filters # @api private class Markaby < Nanoc::Filter requires 'markaby' # Runs the content through [Markaby](http://markaby.github.io/). # This method takes no options. # # @param [String] content The content to filter # # @return [String] The filtered content def run(content, _params = {}) # Get result ::Markaby::Builder.new(assigns).instance_eval(content).to_s end end end nanoc-4.4.7/lib/nanoc/filters/redcarpet.rb0000644000004100000410000000523013033443476020475 0ustar www-datawww-datamodule Nanoc::Filters # @api private class Redcarpet < Nanoc::Filter requires 'redcarpet' # Runs the content through [Redcarpet](https://github.com/vmg/redcarpet). # This method optionally takes processing options to pass on to Redcarpet. # # @overload run(content, params={}) # # For Redcarpet 1.x # # @param [String] content The content to filter # # @option params [Array] :options ([]) A list of options to pass on to # Redcarpet # # @return [String] The filtered content # # @overload run(content, params={}) # # For Redcarpet 2.x # # @param [String] content The content to filter # # @option params [Hash] :options ({}) A list of options to pass on to # Redcarpet itself (not the renderer) # # @option params [::Redcarpet::Render::Base] :renderer # (::Redcarpet::Render::HTML) The class of the renderer to use # # @option params [Hash] :renderer_options ({}) A list of options to pass # on to the Redcarpet renderer # # @option params [Boolean] :with_toc (false) A boolean to request a table # of contents # # @return [String] The filtered content def run(content, params = {}) if ::Redcarpet::VERSION > '2' options = params.fetch(:options, {}) renderer_class = params.fetch(:renderer, ::Redcarpet::Render::HTML) renderer_options = params.fetch(:renderer_options, {}) with_toc = params.fetch(:with_toc, false) if options.is_a?(Array) warn 'WARNING: You are passing an array of options to the :redcarpet filter, but Redcarpet 2.x expects a hash instead. This will likely fail.' end # Setup TOC if with_toc unless renderer_class <= ::Redcarpet::Render::HTML raise "Unexpected renderer: #{renderer_class}" end # `with_toc` implies `with_toc_data` for the HTML renderer renderer_options[:with_toc_data] = true end # Create renderer renderer = if renderer_class == ::Redcarpet::Render::HTML_TOC renderer_class.new else renderer_class.new(renderer_options) end # Render if with_toc renderer_toc = ::Redcarpet::Render::HTML_TOC.new toc = ::Redcarpet::Markdown.new(renderer_toc, options).render(content) body = ::Redcarpet::Markdown.new(renderer, options).render(content) toc + body else ::Redcarpet::Markdown.new(renderer, options).render(content) end end end end end nanoc-4.4.7/lib/nanoc/filters/rdiscount.rb0000644000004100000410000000101213033443476020530 0ustar www-datawww-datamodule Nanoc::Filters # @api private class RDiscount < Nanoc::Filter requires 'rdiscount' # Runs the content through [RDiscount](http://github.com/rtomayko/rdiscount). # # @option params [Array] :extensions ([]) A list of RDiscount extensions # # @param [String] content The content to filter # # @return [String] The filtered content def run(content, params = {}) extensions = params[:extensions] || [] ::RDiscount.new(content, *extensions).to_html end end end nanoc-4.4.7/lib/nanoc/filters/less.rb0000644000004100000410000000442313033443476017475 0ustar www-datawww-datamodule Nanoc::Filters # @api private class Less < Nanoc::Filter requires 'less' # Runs the content through [LESS](http://lesscss.org/). # This method takes no options. # # @param [String] content The content to filter # # @return [String] The filtered content def run(content, params = {}) # Create dependencies imported_filenames = imported_filenames_from(content) imported_items = imported_filenames_to_items(imported_filenames) depend_on(imported_items) # Add filename to load path paths = [File.dirname(@item[:content_filename])] on_main_fiber do parser = ::Less::Parser.new(paths: paths) parser.parse(content).to_css(params) end end def imported_filenames_from(content) imports = [] imports.concat(content.scan(/^@import\s+(["'])([^\1]+?)\1;/)) imports.concat(content.scan(/^@import\s+url\((["']?)([^)]+?)\1\);/)) imports.map { |i| i[1] =~ /\.(less|css)$/ ? i[1] : i[1] + '.less' } end def imported_filenames_to_items(imported_filenames) item_dir_path = Pathname.new(@item[:content_filename]).dirname.realpath cwd = Pathname.pwd # FIXME: ugly (get site dir instead) imported_filenames.map do |filename| full_paths = Set.new imported_pathname = Pathname.new(filename) full_paths << find_file(imported_pathname, item_dir_path) full_paths << find_file(imported_pathname, cwd) # Find matching item @items.find do |i| next if i[:content_filename].nil? item_path = Pathname.new(i[:content_filename]).realpath full_paths.any? { |fp| fp == item_path } end end.compact end # @param [Pathname] pathname Pathname of the file to find. Can be relative or absolute. # # @param [Pathname] root_pathname Directory pathname from which the search will start. # # @return [String, nil] A string containing the full path if a file is found, otherwise nil. def find_file(pathname, root_pathname) absolute_pathname = if pathname.relative? root_pathname + pathname else pathname end if absolute_pathname.exist? absolute_pathname.realpath else nil end end end end nanoc-4.4.7/lib/nanoc/filters/bluecloth.rb0000644000004100000410000000064313033443476020510 0ustar www-datawww-datamodule Nanoc::Filters # @api private class BlueCloth < Nanoc::Filter requires 'bluecloth' # Runs the content through [BlueCloth](http://deveiate.org/projects/BlueCloth). # This method takes no options. # # @param [String] content The content to filter # # @return [String] The filtered content def run(content, _params = {}) ::BlueCloth.new(content).to_html end end end nanoc-4.4.7/lib/nanoc/filters/coffeescript.rb0000644000004100000410000000067513033443476021210 0ustar www-datawww-datamodule Nanoc::Filters # @api private class CoffeeScript < Nanoc::Filter requires 'coffee-script' # Runs the content through [CoffeeScript](http://coffeescript.org/). # This method takes no options. # # @param [String] content The CoffeeScript content to turn into JavaScript # # @return [String] The resulting JavaScript def run(content, _params = {}) ::CoffeeScript.compile(content) end end end nanoc-4.4.7/lib/nanoc/filters/redcloth.rb0000644000004100000410000000306013033443476020327 0ustar www-datawww-datamodule Nanoc::Filters # @api private class RedCloth < Nanoc::Filter requires 'redcloth' # Runs the content through [RedCloth](http://redcloth.org/). This method # takes the following options: # # * `:filter_class` # * `:filter_html` # * `:filter_ids` # * `:filter_style` # * `:hard_breaks` # * `:lite_mode` # * `:no_span_caps` # * `:sanitize_htm` # # Each of these options sets the corresponding attribute on the `RedCloth` # instance. For example, when the `:hard_breaks => false` option is passed # to this filter, the filter will call `r.hard_breaks = false` (with `r` # being the `RedCloth` instance). # # @param [String] content The content to filter # # @return [String] The filtered content def run(content, params = {}) # Create formatter r = ::RedCloth.new(content) # Set options r.filter_classes = params[:filter_classes] if params.key?(:filter_classes) r.filter_html = params[:filter_html] if params.key?(:filter_html) r.filter_ids = params[:filter_ids] if params.key?(:filter_ids) r.filter_styles = params[:filter_styles] if params.key?(:filter_styles) r.hard_breaks = params[:hard_breaks] if params.key?(:hard_breaks) r.lite_mode = params[:lite_mode] if params.key?(:lite_mode) r.no_span_caps = params[:no_span_caps] if params.key?(:no_span_caps) r.sanitize_html = params[:sanitize_html] if params.key?(:sanitize_html) # Get result r.to_html end end end nanoc-4.4.7/lib/nanoc/filters/sass.rb0000644000004100000410000000223113033443476017473 0ustar www-datawww-datamodule Nanoc::Filters # @api private class Sass < Nanoc::Filter requires 'sass', 'nanoc/filters/sass/sass_filesystem_importer' # Runs the content through [Sass](http://sass-lang.com/). # Parameters passed to this filter will be passed on to Sass. # # @param [String] content The content to filter # # @return [String] The filtered content def run(content, params = {}) options = params.merge( nanoc_current_filter: self, filename: @item && @item.raw_filename, ) engine = ::Sass::Engine.new(content, options) engine.render end def self.item_filename_map_for_config(config, items) @item_filename_map ||= {} @item_filename_map[config] ||= {}.tap do |map| items.each do |item| if item.raw_filename path = Pathname.new(item.raw_filename).realpath.to_s map[path] = item end end end end def imported_filename_to_item(filename) realpath = Pathname.new(filename).realpath.to_s map = self.class.item_filename_map_for_config(@config, @items) map[realpath] end end end nanoc-4.4.7/lib/nanoc/filters/xsl.rb0000644000004100000410000000275413033443476017342 0ustar www-datawww-datamodule Nanoc::Filters # @api private class XSL < Nanoc::Filter requires 'nokogiri' # Runs the item content through an [XSLT](http://www.w3.org/TR/xslt) # stylesheet using [Nokogiri](http://nokogiri.org/). # # This filter can only be run for layouts, because it will need both the # XML to convert (= the item content) as well as the XSLT stylesheet (= # the layout content). # # Additional parameters can be passed to the layout call. These parameters # will be turned into `xsl:param` elements. # # @example Invoking the filter as a layout # # compile '/reports/*/' do # layout 'xsl-report' # end # # layout 'xsl-report', :xsl, :awesome => 'definitely' # # @param [String] _content Ignored. As the filter can be run only as a # layout, the value of the `:content` parameter passed to the class at # initialization is used as the content to transform. # # @param [Hash] params The parameters that will be stored in corresponding # `xsl:param` elements. # # @return [String] The transformed content def run(_content, params = {}) Nanoc::Extra::JRubyNokogiriWarner.check_and_warn if assigns[:layout].nil? raise 'The XSL filter can only be run as a layout' end xml = ::Nokogiri::XML(assigns[:content]) xsl = ::Nokogiri::XSLT(assigns[:layout].raw_content) xsl.apply_to(xml, ::Nokogiri::XSLT.quote_params(params)) end end end nanoc-4.4.7/lib/nanoc/filters/mustache.rb0000644000004100000410000000074513033443476020343 0ustar www-datawww-datamodule Nanoc::Filters # @api private class Mustache < Nanoc::Filter requires 'mustache' # Runs the content through # [Mustache](http://github.com/defunkt/mustache). This method takes no # options. # # @param [String] content The content to filter # # @return [String] The filtered content def run(content, _params = {}) context = item.attributes.merge(yield: assigns[:content]) ::Mustache.render(content, context) end end end nanoc-4.4.7/lib/nanoc/filters/handlebars.rb0000644000004100000410000000150113033443476020624 0ustar www-datawww-datamodule Nanoc::Filters # @api private class Handlebars < Nanoc::Filter requires 'handlebars' # Runs the content through # [Handlebars](http://handlebarsjs.com/) using # [Handlebars.rb](https://github.com/cowboyd/handlebars.rb). # This method takes no options. # # @param [String] content The content to filter # # @return [String] The filtered content def run(content, _params = {}) context = item.attributes.dup context[:item] = assigns[:item].attributes context[:config] = assigns[:config] context[:yield] = assigns[:content] if assigns.key?(:layout) context[:layout] = assigns[:layout].attributes end handlebars = ::Handlebars::Context.new template = handlebars.compile(content) template.call(context) end end end nanoc-4.4.7/lib/nanoc/filters/typogruby.rb0000644000004100000410000000066013033443476020572 0ustar www-datawww-datamodule Nanoc::Filters # @api private class Typogruby < Nanoc::Filter requires 'typogruby' # Runs the content through [Typogruby](http://avdgaag.github.com/typogruby/). # This method takes no options. # # @param [String] content The content to filter # # @return [String] The filtered content def run(content, _params = {}) # Get result ::Typogruby.improve(content) end end end nanoc-4.4.7/lib/nanoc/filters/relativize_paths.rb0000644000004100000410000001017213033443476022102 0ustar www-datawww-datamodule Nanoc::Filters # @api private class RelativizePaths < Nanoc::Filter require 'nanoc/helpers/link_to' include Nanoc::Helpers::LinkTo SELECTORS = ['*/@href', '*/@src', 'object/@data', 'param[@name="movie"]/@content', 'form/@action', 'comment()'].freeze # Relativizes all paths in the given content, which can be HTML, XHTML, XML # or CSS. This filter is quite useful if a site needs to be hosted in a # subdirectory instead of a subdomain. In HTML, all `href` and `src` # attributes will be relativized. In CSS, all `url()` references will be # relativized. # # @param [String] content The content to filter # # @option params [Symbol] :type The type of content to filter; can be # `:html`, `:xhtml`, `:xml` or `:css`. # # @option params [Array] :select The XPath expressions that matches the # nodes to modify. This param is useful only for the `:html`, `:xml` and # `:xhtml` types. # # @option params [Hash] :namespaces The pairs `prefix => uri` to define # any namespace you want to use in the XPath expressions. This param # is useful only for the `:xml` and `:xhtml` types. # # @return [String] The filtered content def run(content, params = {}) Nanoc::Extra::JRubyNokogiriWarner.check_and_warn # Set assigns so helper function can be used @item_rep = assigns[:item_rep] if @item_rep.nil? # Filter case params[:type] when :css relativize_css(content) when :html, :xml, :xhtml relativize_html_like(content, params) else raise 'The relativize_paths needs to know the type of content to ' \ 'process. Pass a :type to the filter call (:html for HTML, ' \ ':xhtml for XHTML, :xml for XML, or :css for CSS).' end end protected def relativize_css(content) # FIXME: parse CSS the proper way using csspool or something content.gsub(/url\((['"]?)(\/(?:[^\/].*?)?)\1\)/) do quote = Regexp.last_match[1] path = Regexp.last_match[2] 'url(' + quote + relative_path_to(path) + quote + ')' end end def relativize_html_like(content, params) selectors = params.fetch(:select, SELECTORS) namespaces = params.fetch(:namespaces, {}) type = params.fetch(:type) require 'nokogiri' case type when :html klass = ::Nokogiri::HTML when :xml klass = ::Nokogiri::XML when :xhtml klass = ::Nokogiri::XML # FIXME: cleanup because it is ugly # this cleans the XHTML namespace to process fragments and full # documents in the same way. At least, Nokogiri adds this namespace # if detects the `html` element. content = content.sub(%r{(]+)xmlns="http://www.w3.org/1999/xhtml"}, '\1') end nokogiri_process(content, selectors, namespaces, klass, type) end def nokogiri_process(content, selectors, namespaces, klass, type) # Ensure that all prefixes are strings namespaces = namespaces.reduce({}) { |new, (prefix, uri)| new.merge(prefix.to_s => uri) } doc = content =~ /]/ ? klass.parse(content) : klass.fragment(content) selectors.map { |sel| "descendant-or-self::#{sel}" }.each do |selector| doc.xpath(selector, namespaces).each do |node| if node.name == 'comment' nokogiri_process_comment(node, doc, selectors, namespaces, klass, type) elsif path_is_relativizable?(node.content) node.content = relative_path_to(node.content) end end end doc.send("to_#{type}") end def nokogiri_process_comment(node, doc, selectors, namespaces, klass, type) content = node.content.dup.sub(%r{^(\s*\[.+?\]>\s*)(.+?)(\s* { assigns[:content] } : nil assigns_binding = context.get_binding(&proc) # Get result safe_level = params[:safe_level] trim_mode = params[:trim_mode] erb = ::ERB.new(content, safe_level, trim_mode) erb.filename = filename erb.result(assigns_binding) end end end nanoc-4.4.7/lib/nanoc/filters/rainpress.rb0000644000004100000410000000070713033443476020536 0ustar www-datawww-datamodule Nanoc::Filters # @api private class Rainpress < Nanoc::Filter requires 'rainpress' # Runs the content through [Rainpress](http://code.google.com/p/rainpress/). # Parameters passed to this filter will be passed on to Rainpress. # # @param [String] content The content to filter # # @return [String] The filtered content def run(content, params = {}) ::Rainpress.compress(content, params) end end end nanoc-4.4.7/lib/nanoc/filters/sass/0000755000004100000410000000000013033443476017150 5ustar www-datawww-datananoc-4.4.7/lib/nanoc/filters/sass/sass_filesystem_importer.rb0000644000004100000410000000102013033443476024624 0ustar www-datawww-data# @api private class ::Sass::Importers::Filesystem alias _orig_find _find def _find(dir, name, options) # Find filename full_filename, _syntax = ::Sass::Util.destructure(find_real_file(dir, name, options)) return nil if full_filename.nil? # Create dependency filter = options[:nanoc_current_filter] if filter item = filter.imported_filename_to_item(full_filename) filter.depend_on([item]) unless item.nil? end # Call original _find _orig_find(dir, name, options) end end nanoc-4.4.7/lib/nanoc/filters/rdoc.rb0000644000004100000410000000101113033443476017444 0ustar www-datawww-datamodule Nanoc::Filters # @api private class RDoc < Nanoc::Filter requires 'rdoc' # Runs the content through [RDoc::Markup](http://docs.seattlerb.org/rdoc/RDoc/Markup.html). # This method takes no options. # # @param [String] content The content to filter # # @return [String] The filtered content def run(content, _params = {}) options = ::RDoc::Options.new to_html = ::RDoc::Markup::ToHtml.new(options) ::RDoc::Markup.new.convert(content, to_html) end end end nanoc-4.4.7/lib/nanoc/filters/asciidoc.rb0000644000004100000410000000102713033443476020302 0ustar www-datawww-datamodule Nanoc::Filters # @api private class AsciiDoc < Nanoc::Filter # Runs the content through [AsciiDoc](http://www.methods.co.nz/asciidoc/). # This method takes no options. # # @param [String] content The content to filter # # @return [String] The filtered content def run(content, _params = {}) stdout = StringIO.new stderr = $stderr piper = Nanoc::Extra::Piper.new(stdout: stdout, stderr: stderr) piper.run(%w(asciidoc -o - -), content) stdout.string end end end nanoc-4.4.7/lib/nanoc/filters/haml.rb0000644000004100000410000000125013033443476017443 0ustar www-datawww-datamodule Nanoc::Filters # @api private class Haml < Nanoc::Filter requires 'haml' # Runs the content through [Haml](http://haml-lang.com/). # Parameters passed to this filter will be passed on to Haml. # # @param [String] content The content to filter # # @return [String] The filtered content def run(content, params = {}) # Get options options = params.merge(filename: filename) # Create context context = ::Nanoc::Int::Context.new(assigns) # Get result proc = assigns[:content] ? -> { assigns[:content] } : nil ::Haml::Engine.new(content, options).render(context, assigns, &proc) end end end nanoc-4.4.7/lib/nanoc/filters/colorize_syntax.rb0000644000004100000410000003204413033443476021763 0ustar www-datawww-datamodule Nanoc::Filters # @api private class ColorizeSyntax < Nanoc::Filter requires 'nokogiri', 'stringio', 'open3' # The default colorizer to use for a language if the colorizer for that # language is not overridden. DEFAULT_COLORIZER = :coderay # Syntax-highlights code blocks in the given content. Code blocks should # be enclosed in `pre` elements that contain a `code` element. The code # element should have an indication of the language the code is in. There # are two possible ways of adding such an indication: # # 1. A HTML class starting with `language-` and followed by the # code language, as specified by HTML5. For example, ``. # # 2. A comment on the very first line of the code block in the format # `#!language` where `language` is the language the code is in. For # example, `#!ruby`. # # Options for individual colorizers will be taken from the {#run} # options’ value for the given colorizer. For example, if the filter is # invoked with a `:coderay => coderay_options_hash` option, the # `coderay_options_hash` hash will be passed to the CodeRay colorizer. # # Currently, the following colorizers are supported: # # * `:coderay` for [Coderay](http://coderay.rubychan.de/) # * `:pygmentize` for [pygmentize](http://pygments.org/docs/cmdline/), the # command-line frontend for [Pygments](http://pygments.org/) # * `:pygmentsrb` for [pygments.rb](https://github.com/tmm1/pygments.rb), # a Ruby interface for [Pygments](http://pygments.org/) # * `:simon_highlight` for [Highlight](http://www.andre-simon.de/doku/highlight/en/highlight.html) # * `:rouge` for [Rouge](https://github.com/jayferd/rouge/) # # Additional colorizer implementations are welcome! # # @example Using a class to indicate type of code be highlighted # # 

    #     def foo
    #       "asdf"
    #     end
    #
# # @example Using a comment to indicate type of code be highlighted # # 

    #     #!ruby
    #     def foo
    #       "asdf"
    #     end
    #
# # @example Invoking the filter with custom parameters # # filter :colorize_syntax, # :colorizers => { :ruby => :coderay }, # :coderay => { :line_numbers => :list } # # @param [String] content The content to filter # # @option params [Symbol] :default_colorizer (DEFAULT_COLORIZER) The # default colorizer, i.e. the colorizer that will be used when the # colorizer is not overriden for a specific language. # # @option params [Symbol] :syntax (:html) The syntax to use, which can be # `:html`, `:xml` or `:xhtml`, the latter two being the same. # # @option params [Hash] :colorizers ({}) A hash containing # a mapping of programming languages (symbols, not strings) onto # colorizers (symbols). # # @option params [Boolean] :outside_pre (false) `true` if the colorizer # should be applied on `code` elements outside `pre` elements, false # if only `code` elements inside` pre` elements should be colorized. # # @option params [Symbol] :is_fullpage (false) Whether to treat the input # as a full HTML page or a page fragment. When true, HTML boilerplate # such as the doctype, `html`, `head` and `body` elements will be added. # # @return [String] The filtered content def run(content, params = {}) Nanoc::Extra::JRubyNokogiriWarner.check_and_warn # Take colorizers from parameters @colorizers = Hash.new(params[:default_colorizer] || DEFAULT_COLORIZER) (params[:colorizers] || {}).each_pair do |language, colorizer| @colorizers[language] = colorizer end # Determine syntax (HTML or XML) syntax = params[:syntax] || :html case syntax when :html klass = Nokogiri::HTML when :xml, :xhtml klass = Nokogiri::XML else raise "unknown syntax: #{syntax.inspect} (expected :html or :xml)" end # Colorize doc = parse(content, klass, params.fetch(:is_fullpage, false)) selector = params[:outside_pre] ? 'code' : 'pre > code' doc.css(selector).each do |element| # Get language has_class = false language = nil if element['class'] # Get language from class match = element['class'].match(/(^| )language-([^ ]+)/) language = match[2] if match has_class = true if language else # Get language from comment line match = element.inner_text.strip.split[0].match(/^#!([^\/][^\n]*)$/) language = match[1] if match element.content = element.content.sub(/^#!([^\/][^\n]*)$\n/, '') if language end # Give up if there is no hope left next if language.nil? # Highlight raw = strip(element.inner_text) highlighted_code = highlight(raw, language, params) element.children = Nokogiri::HTML.fragment(strip(highlighted_code), 'utf-8') # Add language-something class unless has_class klass = element['class'] || '' klass << ' ' unless [' ', nil].include?(klass[-1, 1]) klass << "language-#{language}" element['class'] = klass end highlight_postprocess(language, element.parent) end method = "to_#{syntax}".to_sym doc.send(method, encoding: 'UTF-8') end # Parses the given content using the given class. This method also handles # an issue with Nokogiri on JRuby causing “cannot modify frozen string” # errors. # # @param [String] content The content to parse # # @param [Class] klass The Nokogiri parser class (either Nokogiri::HTML # or Nokogiri::XML) # # @param [Boolean] is_fullpage true if the given content is a full page, # false if it is a fragment def parse(content, klass, is_fullpage) if is_fullpage klass.parse(content, nil, 'UTF-8') else klass.fragment(content) end rescue => e if e.message =~ /can't modify frozen string/ parse(content.dup, klass, is_fullpage) else raise e end end # Runs the code through [CodeRay](http://coderay.rubychan.de/). # # @param [String] code The code to colorize # # @param [String] language The language the code is written in # # @param [Hash] params Parameters to pass on to CodeRay # # @return [String] The colorized output def coderay(code, language, params = {}) require 'coderay' ::CodeRay.scan(code, language).html(params) end # Returns the input itself, not performing any code highlighting. # # @param [String] code The code to colorize # # @param [String] language The language the code is written in (unused) # # @return [String] The colorized output, which is identical to the input # in this case def dummy(code, language, params = {}) # rubocop:disable Lint/UnusedMethodArgument code end # Runs the content through [pygmentize](http://pygments.org/docs/cmdline/), # the command-line frontend for [Pygments](http://pygments.org/). # # @param [String] code The code to colorize # # @param [String] language The language the code is written in # # @option params [String, Symbol] :encoding The encoding of the code block # # @return [String] The colorized output def pygmentize(code, language, params = {}) check_availability('pygmentize', '-V') params[:encoding] ||= 'utf-8' params[:nowrap] ||= 'True' cmd = ['pygmentize', '-l', language, '-f', 'html'] cmd << '-O' << params.map { |k, v| "#{k}=#{v}" }.join(',') unless params.empty? stdout = StringIO.new stderr = $stderr piper = Nanoc::Extra::Piper.new(stdout: stdout, stderr: stderr) piper.run(cmd, code) stdout.string end # Runs the content through [Pygments](http://pygments.org/) via # [pygments.rb](https://github.com/tmm1/pygments.rb). # # @param [String] code The code to colorize # # @param [String] language The language the code is written in # # @return [String] The colorized output def pygmentsrb(code, language, params = {}) require 'pygments' args = params.dup args[:lexer] ||= language args[:options] ||= {} args[:options][:encoding] ||= 'utf-8' args[:options][:nowrap] ||= 'True' Pygments.highlight(code, args) end SIMON_HIGHLIGHT_OPT_MAP = { wrap: '-W', include_style: '-I', line_numbers: '-l', }.freeze # Runs the content through [Highlight](http://www.andre-simon.de/doku/highlight/en/highlight.html). # # @param [String] code The code to colorize # # @param [String] language The language the code is written in # # @option params [String] :style The style to use # # @return [String] The colorized output def simon_highlight(code, language, params = {}) check_availability('highlight', '--version') cmd = ['highlight', '--syntax', language, '--fragment'] params.each do |key, _value| if SIMON_HIGHLIGHT_OPT_MAP[key] cmd << SIMON_HIGHLIGHT_OPT_MAP[key] else # TODO: allow passing other options case key when :style cmd << '--style' << params[:style] end end end stdout = StringIO.new stderr = $stderr piper = Nanoc::Extra::Piper.new(stdout: stdout, stderr: stderr) piper.run(cmd, code) stdout.string end # Wraps the element in
def coderay_postprocess(_language, element) # Skip if we're a free return if element.parent.nil? #
div_inner = Nokogiri::XML::Node.new('div', element.document) div_inner['class'] = 'code' div_inner.children = element.dup #
div_outer = Nokogiri::XML::Node.new('div', element.document) div_outer['class'] = 'CodeRay' div_outer.children = div_inner # orig element element.swap div_outer end # Runs the content through [Rouge](https://github.com/jayferd/rouge/. # # @param [String] code The code to colorize # # @param [String] language The language the code is written in # # @return [String] The colorized output def rouge(code, language, params = {}) require 'rouge' if Rouge.version < '2' || params.fetch(:legacy, false) # Rouge 1.x or Rouge 2.x legacy options formatter_options = { css_class: params.fetch(:css_class, 'highlight'), inline_theme: params.fetch(:inline_theme, nil), line_numbers: params.fetch(:line_numbers, false), start_line: params.fetch(:start_line, 1), wrap: params.fetch(:wrap, false), } formatter_cls = Rouge::Formatters.const_get(Rouge.version < '2' ? 'HTML' : 'HTMLLegacy') formatter = formatter_cls.new(formatter_options) else formatter = params.fetch(:formatter, Rouge::Formatters::HTML.new) end lexer = Rouge::Lexer.find_fancy(language, code) || Rouge::Lexers::PlainText formatter.format(lexer.lex(code)) end # Removes the double wrapping. # # Before: # # 

    #
    # After:
    #
    #   

    def rouge_postprocess(_language, element)
      return if element.name != 'pre'

      code1 = element.xpath('code').first
      return if code1.nil?

      pre = code1.xpath('pre').first
      return if pre.nil?

      code2 = pre.xpath('code').first
      return if code2.nil?

      code1.inner_html = code2.inner_html
      code1['class'] = [code1['class'], pre['class']].compact.join(' ')
    end

    protected

    KNOWN_COLORIZERS = [:coderay, :dummy, :pygmentize, :pygmentsrb, :simon_highlight, :rouge].freeze

    # Removes the first blank lines and any whitespace at the end.
    def strip(s)
      s.lines.drop_while { |line| line.strip.empty? }.join.rstrip
    end

    def highlight(code, language, params = {})
      colorizer = @colorizers[language.to_sym]
      if KNOWN_COLORIZERS.include?(colorizer)
        send(colorizer, code, language, params[colorizer] || {})
      else
        raise "I don’t know how to highlight code using the “#{colorizer}” colorizer"
      end
    end

    def highlight_postprocess(language, element)
      colorizer = @colorizers[language.to_sym]
      if KNOWN_COLORIZERS.include?(colorizer)
        sym = (colorizer.to_s + '_postprocess').to_sym
        if respond_to?(sym)
          send(sym, language, element)
        end
      else
        raise "I don’t know how to highlight code using the “#{colorizer}” colorizer"
      end
    end

    def check_availability(*cmd)
      piper = Nanoc::Extra::Piper.new(stdout: StringIO.new, stderr: StringIO.new)
      piper.run(cmd, nil)
    end
  end
end
nanoc-4.4.7/lib/nanoc/filters/pandoc.rb0000644000004100000410000000222013033443476017764 0ustar  www-datawww-datamodule Nanoc::Filters
  # @api private
  class Pandoc < Nanoc::Filter
    requires 'pandoc-ruby'

    # Runs the content through [Pandoc](http://johnmacfarlane.net/pandoc/)
    # using [PandocRuby](https://github.com/alphabetum/pandoc-ruby).
    #
    # Arguments can be passed to PandocRuby in two ways:
    #
    # * Use the `:args` option. This approach is more flexible, since it
    #   allows passing an array instead of a hash.
    #
    # * Pass the arguments directly to the filter. With this approach, only
    #   hashes can be passed, which is more limiting than the `:args` approach.
    #
    # The `:args` approach is recommended.
    #
    # @example Passing arguments using `:arg`
    #
    #     filter :pandoc, args: [:s, {:f => :markdown, :to => :html}, 'no-wrap', :toc]
    #
    # @example Passing arguments not using `:arg`
    #
    #     filter :pandoc, :f => :markdown, :to => :html
    #
    # @param [String] content The content to filter
    #
    # @return [String] The filtered content
    def run(content, params = {})
      args = params.key?(:args) ? params[:args] : params

      PandocRuby.convert(content, *args)
    end
  end
end
nanoc-4.4.7/lib/nanoc/filters/kramdown.rb0000644000004100000410000000166713033443476020360 0ustar  www-datawww-datamodule Nanoc::Filters
  # @api private
  class Kramdown < Nanoc::Filter
    requires 'kramdown'

    # Runs the content through [Kramdown](http://kramdown.gettalong.org/).
    # Parameters passed to this filter will be passed on to Kramdown.
    #
    # @param [String] content The content to filter
    #
    # @return [String] The filtered content
    def run(content, params = {})
      params = params.dup
      warning_filters = params.delete(:warning_filters)
      document = ::Kramdown::Document.new(content, params)

      if warning_filters
        r = Regexp.union(warning_filters)
        warnings = document.warnings.reject { |warning| r =~ warning }
      else
        warnings = document.warnings
      end

      if warnings.any?
        $stderr.puts "kramdown warning(s) for #{@item_rep.inspect}"
        warnings.each do |warning|
          $stderr.puts "  #{warning}"
        end
      end

      document.to_html
    end
  end
end
nanoc-4.4.7/lib/nanoc/filters/erubis.rb0000644000004100000410000000172213033443476020017 0ustar  www-datawww-datamodule Nanoc::Filters
  # @api private
  class Erubis < Nanoc::Filter
    requires 'erubis'

    # The same as `::Erubis::Eruby` but adds `_erbout` as an alias for the
    # `_buf` variable, making it compatible with Nanoc’s helpers that rely
    # on `_erbout`, such as {Nanoc::Helpers::Capturing}.
    class ErubisWithErbout < ::Erubis::Eruby
      include ::Erubis::ErboutEnhancer
    end

    # Runs the content through [Erubis](http://www.kuwata-lab.com/erubis/).
    # This method takes no options.
    #
    # @param [String] content The content to filter
    #
    # @return [String] The filtered content
    def run(content, _params = {})
      # Create context
      context = ::Nanoc::Int::Context.new(assigns)

      # Get binding
      proc = assigns[:content] ? -> { assigns[:content] } : nil
      assigns_binding = context.get_binding(&proc)

      # Get result
      ErubisWithErbout.new(content, filename: filename).result(assigns_binding)
    end
  end
end
nanoc-4.4.7/lib/nanoc/filters/slim.rb0000644000004100000410000000125213033443476017470 0ustar  www-datawww-datamodule Nanoc::Filters
  # @api private
  class Slim < Nanoc::Filter
    requires 'slim'

    # Runs the content through [Slim](http://slim-lang.com/).
    # This method takes no options.
    #
    # @param [String] content The content to filter
    #
    # @return [String] The filtered content
    def run(content, params = {})
      params = {
        disable_capture: true, # Capture managed by Nanoc
        buffer: '_erbout', # Force slim to output to the buffer used by Nanoc
      }.merge params

      # Create context
      context = ::Nanoc::Int::Context.new(assigns)

      ::Slim::Template.new(params) { content }.render(context) { assigns[:content] }
    end
  end
end
nanoc-4.4.7/lib/nanoc/filters/yui_compressor.rb0000644000004100000410000000112113033443476021601 0ustar  www-datawww-datamodule Nanoc::Filters
  # @api private
  class YUICompressor < Nanoc::Filter
    requires 'yuicompressor'

    # Compress Javascript or CSS using [YUICompressor](http://rubydoc.info/gems/yuicompressor).
    # This method optionally takes options to pass directly to the
    # YUICompressor gem.
    #
    # @param [String] content JavaScript or CSS input
    #
    # @param [Hash] params Options passed to YUICompressor
    #
    # @return [String] Compressed but equivalent JavaScript or CSS
    def run(content, params = {})
      ::YUICompressor.compress(content, params)
    end
  end
end
nanoc-4.4.7/lib/nanoc/filters/rubypants.rb0000644000004100000410000000066313033443476020560 0ustar  www-datawww-datamodule Nanoc::Filters
  # @api private
  class RubyPants < Nanoc::Filter
    requires 'rubypants'

    # Runs the content through [RubyPants](http://rubydoc.info/gems/rubypants/).
    # This method takes no options.
    #
    # @param [String] content The content to filter
    #
    # @return [String] The filtered content
    def run(content, _params = {})
      # Get result
      ::RubyPants.new(content).to_html
    end
  end
end
nanoc-4.4.7/lib/nanoc/filters/maruku.rb0000644000004100000410000000071513033443476020033 0ustar  www-datawww-datamodule Nanoc::Filters
  # @api private
  class Maruku < Nanoc::Filter
    requires 'maruku'

    # Runs the content through [Maruku](https://github.com/bhollis/maruku/).
    # Parameters passed to this filter will be passed on to Maruku.
    #
    # @param [String] content The content to filter
    #
    # @return [String] The filtered content
    def run(content, params = {})
      # Get result
      ::Maruku.new(content, params).to_html
    end
  end
end
nanoc-4.4.7/lib/nanoc/filters/uglify_js.rb0000644000004100000410000000110313033443476020512 0ustar  www-datawww-datamodule Nanoc::Filters
  # @api private
  class UglifyJS < Nanoc::Filter
    requires 'uglifier'

    # Runs the content through [UglifyJS](https://github.com/mishoo/UglifyJS2/).
    # This method optionally takes options to pass directly to Uglifier.
    #
    # @param [String] content The content to filter
    #
    # @option params [Array] :options ([]) A list of options to pass on to Uglifier
    #
    # @return [String] The filtered content
    def run(content, params = {})
      # Add filename to load path
      Uglifier.new(params).compile(content)
    end
  end
end
nanoc-4.4.7/lib/nanoc/filters.rb0000644000004100000410000000661113033443476016530 0ustar  www-datawww-data# @api private
module Nanoc::Filters
  autoload 'AsciiDoc',        'nanoc/filters/asciidoc'
  autoload 'BlueCloth',       'nanoc/filters/bluecloth'
  autoload 'ColorizeSyntax',  'nanoc/filters/colorize_syntax'
  autoload 'CoffeeScript',    'nanoc/filters/coffeescript'
  autoload 'ERB',             'nanoc/filters/erb'
  autoload 'Erubis',          'nanoc/filters/erubis'
  autoload 'Haml',            'nanoc/filters/haml'
  autoload 'Handlebars',      'nanoc/filters/handlebars'
  autoload 'Kramdown',        'nanoc/filters/kramdown'
  autoload 'Less',            'nanoc/filters/less'
  autoload 'Markaby',         'nanoc/filters/markaby'
  autoload 'Maruku',          'nanoc/filters/maruku'
  autoload 'Mustache',        'nanoc/filters/mustache'
  autoload 'Pandoc',          'nanoc/filters/pandoc'
  autoload 'Rainpress',       'nanoc/filters/rainpress'
  autoload 'RDiscount',       'nanoc/filters/rdiscount'
  autoload 'RDoc',            'nanoc/filters/rdoc'
  autoload 'Redcarpet',       'nanoc/filters/redcarpet'
  autoload 'RedCloth',        'nanoc/filters/redcloth'
  autoload 'RelativizePaths', 'nanoc/filters/relativize_paths'
  autoload 'RubyPants',       'nanoc/filters/rubypants'
  autoload 'Sass',            'nanoc/filters/sass'
  autoload 'Slim',            'nanoc/filters/slim'
  autoload 'Typogruby',       'nanoc/filters/typogruby'
  autoload 'UglifyJS',        'nanoc/filters/uglify_js'
  autoload 'XSL',             'nanoc/filters/xsl'
  autoload 'YUICompressor',   'nanoc/filters/yui_compressor'

  Nanoc::Filter.register '::Nanoc::Filters::AsciiDoc',        :asciidoc
  Nanoc::Filter.register '::Nanoc::Filters::BlueCloth',       :bluecloth
  Nanoc::Filter.register '::Nanoc::Filters::ColorizeSyntax',  :colorize_syntax
  Nanoc::Filter.register '::Nanoc::Filters::CoffeeScript',    :coffeescript
  Nanoc::Filter.register '::Nanoc::Filters::ERB',             :erb
  Nanoc::Filter.register '::Nanoc::Filters::Erubis',          :erubis
  Nanoc::Filter.register '::Nanoc::Filters::Haml',            :haml
  Nanoc::Filter.register '::Nanoc::Filters::Handlebars',      :handlebars
  Nanoc::Filter.register '::Nanoc::Filters::Kramdown',        :kramdown
  Nanoc::Filter.register '::Nanoc::Filters::Less',            :less
  Nanoc::Filter.register '::Nanoc::Filters::Markaby',         :markaby
  Nanoc::Filter.register '::Nanoc::Filters::Maruku',          :maruku
  Nanoc::Filter.register '::Nanoc::Filters::Mustache',        :mustache
  Nanoc::Filter.register '::Nanoc::Filters::Pandoc',          :pandoc
  Nanoc::Filter.register '::Nanoc::Filters::Rainpress',       :rainpress
  Nanoc::Filter.register '::Nanoc::Filters::RDiscount',       :rdiscount
  Nanoc::Filter.register '::Nanoc::Filters::RDoc',            :rdoc
  Nanoc::Filter.register '::Nanoc::Filters::Redcarpet',       :redcarpet
  Nanoc::Filter.register '::Nanoc::Filters::RedCloth',        :redcloth
  Nanoc::Filter.register '::Nanoc::Filters::RelativizePaths', :relativize_paths
  Nanoc::Filter.register '::Nanoc::Filters::RubyPants',       :rubypants
  Nanoc::Filter.register '::Nanoc::Filters::Sass',            :sass
  Nanoc::Filter.register '::Nanoc::Filters::Slim',            :slim
  Nanoc::Filter.register '::Nanoc::Filters::Typogruby',       :typogruby
  Nanoc::Filter.register '::Nanoc::Filters::UglifyJS',        :uglify_js
  Nanoc::Filter.register '::Nanoc::Filters::XSL',             :xsl
  Nanoc::Filter.register '::Nanoc::Filters::YUICompressor',   :yui_compressor
end
nanoc-4.4.7/lib/nanoc/checking.rb0000644000004100000410000000042513033443476016630 0ustar  www-datawww-datamodule Nanoc
  # @api private
  module Checking
    autoload 'Check',  'nanoc/checking/check'
    autoload 'DSL',    'nanoc/checking/dsl'
    autoload 'Runner', 'nanoc/checking/runner.rb'
    autoload 'Issue',  'nanoc/checking/issue'
  end
end

require 'nanoc/checking/checks'
nanoc-4.4.7/lib/nanoc/spec.rb0000644000004100000410000001256513033443476016017 0ustar  www-datawww-datamodule Nanoc
  # @api private
  module Spec
    class HelperContext
      # @return [Nanoc::Int::DependencyTracker]
      attr_reader :dependency_tracker

      attr_reader :erbout

      # @param [Module] mod The helper module to create a context for
      def initialize(mod)
        @mod = mod

        @erbout = ''
        @rule_memory = {}
        @config = Nanoc::Int::Configuration.new.with_defaults
        @reps = Nanoc::Int::ItemRepRepo.new
        @items = Nanoc::Int::IdentifiableCollection.new(@config)
        @layouts = Nanoc::Int::IdentifiableCollection.new(@config)
        @dependency_tracker = Nanoc::Int::DependencyTracker.new(Object.new)
      end

      # Creates a new item and adds it to the site’s collection of items.
      #
      # @param [String] content The uncompiled item content
      #
      # @param [Hash] attributes A hash containing this item's attributes
      #
      # @param [Nanoc::Identifier, String] identifier This item's identifier
      #
      # @return [Nanoc::ItemWithRepsView] A view for the newly created item
      def create_item(content, attributes, identifier)
        item = Nanoc::Int::Item.new(content, attributes, identifier)
        @items << item
        Nanoc::ItemWithRepsView.new(item, view_context)
      end

      # Creates a new layout and adds it to the site’s collection of layouts.
      #
      # @param [String] content The raw layout content
      #
      # @param [Hash] attributes A hash containing this layout's attributes
      #
      # @param [Nanoc::Identifier, String] identifier This layout's identifier
      #
      # @return [Nanoc::ItemWithRepsView] A view for the newly created layout
      def create_layout(content, attributes, identifier)
        layout = Nanoc::Int::Layout.new(content, attributes, identifier)
        @layouts << layout
        Nanoc::LayoutView.new(layout, view_context)
      end

      # Creates a new representation for the given item.
      #
      # @param [Nanoc::ItemWithRepsView] item The item to create a represetation for
      #
      # @param [String] path The path of the `:last` snapshot of this item representation
      # @param [Symbol] rep The rep name to create
      def create_rep(item, path, rep = :default)
        rep = Nanoc::Int::ItemRep.new(item.unwrap, rep)
        rep.paths[:last] = path
        @reps << rep
        Nanoc::ItemRepView.new(rep, view_context)
      end

      # @return [Object] An object that includes the helper functions
      def helper
        mod = @mod
        klass = Class.new(Nanoc::Int::Context) { include mod }
        klass.new(assigns)
      end

      def item=(item)
        @item = item ? item.unwrap : nil
      end

      def item_rep=(item_rep)
        @item_rep = item_rep ? item_rep.unwrap : nil
      end

      # @return [Nanoc::MutableConfigView]
      def config
        assigns[:config]
      end

      # @return [Nanoc::ItemWithRepsView, nil]
      def item
        assigns[:item]
      end

      # @return [Nanoc::ItemRepView, nil]
      def item_rep
        assigns[:item_rep]
      end

      # @return [Nanoc::ItemCollectionWithRepsView]
      def items
        assigns[:items]
      end

      # @return [Nanoc::LayoutCollectionView]
      def layouts
        assigns[:layouts]
      end

      def rule_memory_for(obj)
        @rule_memory.fetch(obj, [])
      end

      def update_rule_memory(obj, memory)
        @rule_memory[obj] = memory
      end

      private

      def view_context
        Nanoc::ViewContext.new(
          reps: @reps,
          items: @items,
          dependency_tracker: @dependency_tracker,
          compilation_context: new_site.compiler.compilation_context,
        )
      end

      def new_action_provider
        Class.new(Nanoc::Int::ActionProvider) do
          def self.for(_context)
            raise NotImplementedError
          end

          def initialize(context)
            @context = context
          end

          def rep_names_for(_item)
            [:default]
          end

          def memory_for(obj)
            @context.rule_memory_for(obj)
          end

          def snapshots_defs_for(_rep)
            [Nanoc::Int::SnapshotDef.new(:last)]
          end
        end.new(self)
      end

      def new_compiler_for(site)
        Nanoc::Int::CompilerLoader.new.load(site, action_provider: new_action_provider)
      end

      def new_site
        site = Nanoc::Int::Site.new(
          config: @config,
          code_snippets: [],
          items: @items,
          layouts: @layouts,
        )
        site.compiler = new_compiler_for(site)
        site
      end

      def assigns
        site = Nanoc::Int::Site.new(
          config: @config,
          code_snippets: [],
          items: @items,
          layouts: @layouts,
        )
        site.compiler = new_compiler_for(site)

        {
          config: Nanoc::MutableConfigView.new(@config, view_context),
          item_rep: @item_rep ? Nanoc::ItemRepView.new(@item_rep, view_context) : nil,
          item: @item ? Nanoc::ItemWithRepsView.new(@item, view_context) : nil,
          items: Nanoc::ItemCollectionWithRepsView.new(@items, view_context),
          layouts: Nanoc::LayoutCollectionView.new(@layouts, view_context),
          _erbout: @erbout,
        }
      end
    end

    module HelperHelper
      def ctx
        @_ctx ||= HelperContext.new(described_class)
      end

      def helper
        @_helper ||= ctx.helper
      end
    end
  end
end
nanoc-4.4.7/lib/nanoc/cli.rb0000644000004100000410000001347413033443476015634 0ustar  www-datawww-databegin
  require 'cri'
rescue LoadError => e
  $stderr.puts e
  $stderr.puts "If you are using a Gemfile, make sure that the Gemfile contains Nanoc ('gem \"nanoc\"')."
  exit 1
end

# @api private
module Nanoc::CLI
  module Commands
  end

  autoload 'ANSIStringColorizer', 'nanoc/cli/ansi_string_colorizer'
  autoload 'Logger',              'nanoc/cli/logger'
  autoload 'CommandRunner',       'nanoc/cli/command_runner'
  autoload 'CleaningStream',      'nanoc/cli/cleaning_stream'
  autoload 'StreamCleaners',      'nanoc/cli/stream_cleaners'
  autoload 'ErrorHandler',        'nanoc/cli/error_handler'

  # @return [Boolean] true if debug output is enabled, false if not
  def self.debug?
    @debug || false
  end

  # @param [Boolean] boolean true if debug output should be enabled,
  #   false if it should not
  #
  # @return [void]
  def self.debug=(boolean)
    @debug = boolean
  end

  # Invokes the Nanoc command-line tool with the given arguments.
  #
  # @param [Array] args An array of command-line arguments
  #
  # @return [void]
  def self.run(args)
    Nanoc::CLI::ErrorHandler.handle_while do
      setup
      root_command.run(args)
    end
  end

  # @return [Cri::Command] The root command, i.e. the command-line tool itself
  def self.root_command
    @root_command
  end

  # Adds the given command to the collection of available commands.
  #
  # @param [Cri::Command] cmd The command to add
  #
  # @return [void]
  def self.add_command(cmd)
    root_command.add_command(cmd)
  end

  # Schedules the given block to be executed after the CLI has been set up.
  #
  # @return [void]
  def self.after_setup(&block)
    # TODO: decide what should happen if the CLI is already set up
    add_after_setup_proc(block)
  end

  protected

  # Makes the command-line interface ready for use.
  #
  # @return [void]
  def self.setup
    setup_cleaning_streams
    setup_commands
    load_custom_commands
    after_setup_procs.each(&:call)
  end

  # Sets up the root command and base subcommands.
  #
  # @return [void]
  def self.setup_commands
    # Reinit
    @root_command = nil

    # Add root command
    filename = File.dirname(__FILE__) + '/cli/commands/nanoc.rb'
    @root_command = load_command_at(filename)

    # Add help command
    help_cmd = Cri::Command.new_basic_help
    add_command(help_cmd)

    # Add other commands
    cmd_filenames = Dir[File.dirname(__FILE__) + '/cli/commands/*.rb']
    cmd_filenames.each do |cmd_filename|
      next if File.basename(cmd_filename, '.rb') == 'nanoc'
      cmd = load_command_at(cmd_filename)
      add_command(cmd)
    end

    if defined?(Bundler)
      # Discover external commands through Bundler
      begin
        Bundler.require(:nanoc)
      rescue Bundler::GemfileNotFound
        # When running nanoc with Bundler being defined but
        # no gemfile being present (rubygems automatically loads
        # Bundler when executing from command line), don't crash.
      end
    end
  end

  # Loads site-specific commands.
  #
  # @return [void]
  def self.load_custom_commands
    if Nanoc::Int::SiteLoader.cwd_is_nanoc_site?
      config = Nanoc::Int::ConfigLoader.new.new_from_cwd
      config[:commands_dirs].each do |path|
        load_commands_at(path)
      end
    end
  end

  def self.load_commands_at(path)
    recursive_contents_of(path).each do |filename|
      # Create command
      command = Nanoc::CLI.load_command_at(filename)

      # Get supercommand
      pieces = filename.gsub(/^#{path}\/|\.rb$/, '').split('/')
      pieces = pieces[0, pieces.size - 1] || []
      root = Nanoc::CLI.root_command
      supercommand = pieces.reduce(root) do |cmd, piece|
        cmd.nil? ? nil : cmd.command_named(piece)
      end

      # Add to supercommand
      if supercommand.nil?
        raise "Cannot load command at #{filename} because its supercommand cannot be found"
      end
      supercommand.add_command(command)
    end
  end

  # Loads the command in the file with the given filename.
  #
  # @param [String] filename The name of the file that contains the command
  #
  # @return [Cri::Command] The loaded command
  def self.load_command_at(filename, command_name = nil)
    # Load
    code = File.read(filename, encoding: 'UTF-8')
    cmd = Cri::Command.define(code, filename)

    # Set name
    command_name ||= File.basename(filename, '.rb')
    cmd.modify { name command_name }

    # Done
    cmd
  end

  # @return [Array] The directory contents
  def self.recursive_contents_of(path)
    return [] unless File.directory?(path)
    files, dirs = *Dir[path + '/*'].sort.partition { |e| File.file?(e) }
    dirs.each { |d| files.concat recursive_contents_of(d) }
    files
  end

  # Wraps the given stream in a cleaning stream. The cleaning streams will
  # have the proper stream cleaners configured.
  #
  # @param [IO] io The stream to wrap
  #
  # @return [::Nanoc::CLI::CleaningStream]
  def self.wrap_in_cleaning_stream(io)
    cio = ::Nanoc::CLI::CleaningStream.new(io)

    unless enable_utf8?(io)
      cio.add_stream_cleaner(Nanoc::CLI::StreamCleaners::UTF8)
    end

    unless enable_ansi_colors?(io)
      cio.add_stream_cleaner(Nanoc::CLI::StreamCleaners::ANSIColors)
    end

    cio
  end

  # Wraps `$stdout` and `$stderr` in appropriate cleaning streams.
  #
  # @return [void]
  def self.setup_cleaning_streams
    $stdout = wrap_in_cleaning_stream($stdout)
    $stderr = wrap_in_cleaning_stream($stderr)
  end

  # @return [Boolean] true if UTF-8 support is present, false if not
  def self.enable_utf8?(io)
    return true unless io.tty?

    %w(LC_ALL LC_CTYPE LANG).any? { |e| ENV[e] =~ /UTF/i }
  end

  # @return [Boolean] true if color support is present, false if not
  def self.enable_ansi_colors?(io)
    io.tty?
  end

  def self.after_setup_procs
    @after_setup_procs || []
  end

  def self.add_after_setup_proc(proc)
    @after_setup_procs ||= []
    @after_setup_procs << proc
  end
end
nanoc-4.4.7/lib/nanoc/helpers.rb0000644000004100000410000000112513033443476016515 0ustar  www-datawww-datamodule Nanoc::Helpers
  autoload 'Blogging',    'nanoc/helpers/blogging'
  autoload 'Breadcrumbs', 'nanoc/helpers/breadcrumbs'
  autoload 'Capturing',   'nanoc/helpers/capturing'
  autoload 'ChildParent', 'nanoc/helpers/child_parent'
  autoload 'Filtering',   'nanoc/helpers/filtering'
  autoload 'HTMLEscape',  'nanoc/helpers/html_escape'
  autoload 'LinkTo',      'nanoc/helpers/link_to'
  autoload 'Rendering',   'nanoc/helpers/rendering'
  autoload 'Tagging',     'nanoc/helpers/tagging'
  autoload 'Text',        'nanoc/helpers/text'
  autoload 'XMLSitemap',  'nanoc/helpers/xml_sitemap'
end
nanoc-4.4.7/lib/nanoc/version.rb0000644000004100000410000000011313033443476016534 0ustar  www-datawww-datamodule Nanoc
  # The current Nanoc version.
  VERSION = '4.4.7'.freeze
end
nanoc-4.4.7/lib/nanoc/extra/0000755000004100000410000000000013033443476015652 5ustar  www-datawww-datananoc-4.4.7/lib/nanoc/extra/core_ext.rb0000644000004100000410000000011413033443476020003 0ustar  www-datawww-datarequire 'nanoc/extra/core_ext/pathname'
require 'nanoc/extra/core_ext/time'
nanoc-4.4.7/lib/nanoc/extra/jruby_nokogiri_warner.rb0000644000004100000410000000223613033443476022614 0ustar  www-datawww-datarequire 'singleton'

module Nanoc::Extra
  # @api private
  class JRubyNokogiriWarner
    include Singleton

    TEXT = < :href,
      'audio' => :src,
      'form' => :action,
      'iframe' => :src,
      'img' => :src,
      'link' => :href,
      'script' => :src,
      'video' => :src,
    }.freeze

    def initialize(filenames, mode = nil)
      Nanoc::Extra::JRubyNokogiriWarner.check_and_warn

      @filenames = filenames
      @filter =
        case mode
        when nil
          ->(_h) { true }
        when :external
          ->(h) { external_href?(h) }
        when :internal
          ->(h) { !external_href?(h) }
        else
          raise ArgumentError, 'Expected mode argument to be :internal, :external or nil'
        end
    end

    def filenames_per_href
      grouped_filenames { |filename| hrefs_in_file(filename) }
    end

    def filenames_per_resource_uri
      grouped_filenames { |filename| resource_uris_in_file(filename) }
    end

    def external_href?(href)
      href =~ %r{^(\/\/|[a-z\-]+:)}
    end

    def hrefs_in_file(filename)
      uris_in_file filename, %w(a img)
    end

    def resource_uris_in_file(filename)
      uris_in_file filename, %w(audio form img iframe link script video)
    end

    private

    def grouped_filenames
      require 'nokogiri'
      grouped_filenames = {}
      @filenames.each do |filename|
        yield(filename).each do |resouce_uri|
          grouped_filenames[resouce_uri] ||= Set.new
          grouped_filenames[resouce_uri] << filename
        end
      end
      grouped_filenames
    end

    def uris_in_file(filename, tag_names)
      uris = Set.new
      doc = Nokogiri::HTML(::File.read(filename))
      tag_names.each do |tag_name|
        attr = URI_ATTRS[tag_name]
        doc.css(tag_name).each do |e|
          uris << e[attr] unless e[attr].nil?
        end
      end

      # Strip fragment
      uris.map! { |href| href.gsub(/#.*$/, '') }

      uris.select(&@filter)
    end
  end
end
nanoc-4.4.7/lib/nanoc/extra/core_ext/0000755000004100000410000000000013033443476017462 5ustar  www-datawww-datananoc-4.4.7/lib/nanoc/extra/core_ext/time.rb0000644000004100000410000000060413033443476020745 0ustar  www-datawww-data# @api private
module Nanoc::Extra::TimeExtensions
  # @return [String] The time in an ISO-8601 date format.
  def __nanoc_to_iso8601_date
    getutc.strftime('%Y-%m-%d')
  end

  # @return [String] The time in an ISO-8601 time format.
  def __nanoc_to_iso8601_time
    getutc.strftime('%Y-%m-%dT%H:%M:%SZ')
  end
end

# @api private
class Time
  include Nanoc::Extra::TimeExtensions
end
nanoc-4.4.7/lib/nanoc/extra/core_ext/pathname.rb0000644000004100000410000000076313033443476021612 0ustar  www-datawww-datamodule Nanoc::Extra
  # @api private
  module PathnameExtensions
    def __nanoc_components
      components = []
      tmp = self
      loop do
        old = tmp
        components << File.basename(tmp)
        tmp = File.dirname(tmp)
        break if old == tmp
      end
      components.reverse
    end

    def __nanoc_include_component?(component)
      __nanoc_components.include?(component)
    end
  end
end

# @api private
class ::Pathname
  include ::Nanoc::Extra::PathnameExtensions
end
nanoc-4.4.7/lib/nanoc/extra/piper.rb0000644000004100000410000000211113033443476017311 0ustar  www-datawww-datarequire 'open3'

module Nanoc::Extra
  # @api private
  class Piper
    class Error < ::Nanoc::Int::Errors::Generic
      def initialize(command, exit_code)
        @command   = command
        @exit_code = exit_code
      end

      def message
        "command exited with a nonzero status code #{@exit_code} (command: #{@command.join(' ')})"
      end
    end

    # @param [IO] stdout
    # @param [IO] stderr
    def initialize(stdout: $stdout, stderr: $stderr)
      @stdout = stdout
      @stderr = stderr
    end

    # @param [Array] cmd
    #
    # @param [String, nil] input
    def run(cmd, input)
      Open3.popen3(*cmd) do |stdin, stdout, stderr, wait_thr|
        stdout_thread = Thread.new { @stdout << stdout.read }
        stderr_thread = Thread.new { @stderr << stderr.read }

        if input
          stdin << input
        end
        stdin.close

        stdout_thread.join
        stderr_thread.join

        exit_status = wait_thr.value
        unless exit_status.success?
          raise Error.new(cmd, exit_status.to_i)
        end
      end
    end
  end
end
nanoc-4.4.7/lib/nanoc/extra/parallel_collection.rb0000644000004100000410000000227213033443476022211 0ustar  www-datawww-datarequire 'thread'

module Nanoc::Extra
  # @api private
  class ParallelCollection
    STOP = Object.new

    include Nanoc::Int::ContractsSupport

    contract C::RespondTo[:each], C::KeywordArgs[parallelism: Fixnum] => C::Any
    def initialize(enum, parallelism: 2)
      @enum = enum
      @parallelism = parallelism
    end

    contract C::Func[C::Any => C::Any] => self
    def each
      queue = SizedQueue.new(2 * @parallelism)
      error = nil

      threads = (1..@parallelism).map do
        Thread.new do
          loop do
            begin
              elem = queue.pop
              break if error
              break if STOP.equal?(elem)
              yield elem
            rescue => err
              error = err
              break
            end
          end
        end
      end

      @enum.each { |e| queue << e }
      @parallelism.times { queue << STOP }

      threads.each(&:join)

      raise error if error
      self
    end

    contract C::Func[C::Any => C::Any] => C::RespondTo[:each]
    def map
      [].tap do |all|
        mutex = Mutex.new
        each do |e|
          res = yield(e)
          mutex.synchronize { all << res }
        end
      end
    end
  end
end
nanoc-4.4.7/lib/nanoc/deploying/0000755000004100000410000000000013033443476016521 5ustar  www-datawww-datananoc-4.4.7/lib/nanoc/deploying/deployers/0000755000004100000410000000000013033443476020527 5ustar  www-datawww-datananoc-4.4.7/lib/nanoc/deploying/deployers/rsync.rb0000644000004100000410000000341213033443476022212 0ustar  www-datawww-datamodule Nanoc::Deploying::Deployers
  # A deployer that deploys a site using rsync.
  #
  # The configuration has should include a `:dst` value, a string containing
  # the destination to where rsync should upload its data. It will likely be
  # in `host:path` format. It should not end with a slash. For example,
  # `"example.com:/var/www/sites/mysite/html"`.
  #
  # @example A deployment configuration with public and staging configurations
  #
  #   deploy:
  #     public:
  #       kind: rsync
  #       dst: "ectype:sites/stoneship/public"
  #     staging:
  #       kind: rsync
  #       dst: "ectype:sites/stoneship-staging/public"
  #       options: [ "-glpPrtvz" ]
  #
  # @api private
  class Rsync < ::Nanoc::Deploying::Deployer
    # Default rsync options
    DEFAULT_OPTIONS = [
      '--group',
      '--links',
      '--perms',
      '--partial',
      '--progress',
      '--recursive',
      '--times',
      '--verbose',
      '--compress',
      '--exclude=".hg"',
      '--exclude=".svn"',
      '--exclude=".git"',
    ].freeze

    # @see Nanoc::Deploying::Deployer#run
    def run
      # Get params
      src = source_path + '/'
      dst = config[:dst]
      options = config[:options] || DEFAULT_OPTIONS

      # Validate
      raise 'No dst found in deployment configuration' if dst.nil?
      raise 'dst requires no trailing slash' if dst[-1, 1] == '/'

      # Run
      if dry_run
        warn 'Performing a dry-run; no actions will actually be performed'
        run_shell_cmd(['echo', 'rsync', options, src, dst].flatten)
      else
        run_shell_cmd(['rsync', options, src, dst].flatten)
      end
    end

    private

    def run_shell_cmd(cmd)
      piper = Nanoc::Extra::Piper.new(stdout: $stdout, stderr: $stderr)
      piper.run(cmd, nil)
    end
  end
end
nanoc-4.4.7/lib/nanoc/deploying/deployers/fog.rb0000644000004100000410000001213613033443476021632 0ustar  www-datawww-datamodule Nanoc::Deploying::Deployers
  # A deployer that deploys a site using [fog](https://github.com/geemus/fog).
  #
  # @example A deployment configuration with public and staging configurations
  #
  #   deploy:
  #     public:
  #       kind:       fog
  #       bucket:     nanoc-site
  #       cdn_id:     XXXXXX
  #     preprod:
  #       kind:       fog
  #       provider:   local
  #       local_root: ~/myCloud
  #       bucket:     nanoc-site
  #     staging:
  #       kind:       fog
  #       provider:   local
  #       local_root: ~/myCloud
  #       bucket:     nanoc-site-staging
  #
  # @api private
  class Fog < ::Nanoc::Deploying::Deployer
    class FogWrapper
      def initialize(directory, is_dry_run)
        @directory = directory
        @is_dry_run = is_dry_run
      end

      def upload(source_filename, destination_key)
        log_effectful("uploading #{source_filename} -> #{destination_key}")

        unless dry_run?
          # FIXME: source_filename file is never closed
          @directory.files.create(
            key: destination_key,
            body: File.open(source_filename),
            public: true,
          )
        end
      end

      def remove(keys)
        keys.each do |key|
          log_effectful("removing #{key}")

          unless dry_run?
            @directory.files.get(key).destroy
          end
        end
      end

      def invalidate(keys, cdn, distribution)
        keys.each_slice(1000) do |keys_slice|
          keys_slice.each do |key|
            log_effectful("invalidating #{key}")
          end

          unless dry_run?
            cdn.post_invalidation(distribution, keys_slice)
          end
        end
      end

      def dry_run?
        @is_dry_run
      end

      def log_effectful(s)
        if @is_dry_run
          puts "[dry run] #{s}"
        else
          puts s
        end
      end
    end

    # @see Nanoc::Deploying::Deployer#run
    def run
      require 'fog'

      src      = File.expand_path(source_path)
      bucket   = config[:bucket] || config[:bucket_name]
      path     = config[:path]
      cdn_id   = config[:cdn_id]

      if path && path.end_with?('/')
        raise "The path `#{path}` is not supposed to have a trailing slash"
      end

      connection = connect
      directory = get_or_create_bucket(connection, bucket, path)
      wrapper = FogWrapper.new(directory, dry_run?)

      remote_files = list_remote_files(directory)
      etags = read_etags(remote_files)

      modified_keys, retained_keys = upload_all(src, path, etags, wrapper)

      removed_keys = remote_files.map(&:key) - retained_keys - modified_keys
      wrapper.remove(removed_keys)

      if cdn_id
        cdn = ::Fog::CDN.new(config_for_fog)
        distribution = cdn.get_distribution(cdn_id)
        wrapper.invalidate(modified_keys + removed_keys, cdn, distribution)
      end
    end

    private

    def config_for_fog
      config.dup.tap do |c|
        c.delete(:bucket)
        c.delete(:bucket_name)
        c.delete(:path)
        c.delete(:cdn_id)
        c.delete(:kind)
      end
    end

    def connect
      ::Fog::Storage.new(config_for_fog)
    end

    def get_or_create_bucket(connection, bucket, path)
      directory =
        begin
          connection.directories.get(bucket, prefix: path)
        rescue ::Excon::Errors::NotFound
          nil
        end

      if directory
        directory
      elsif dry_run?
        puts '[dry run] creating bucket'
      else
        puts 'creating bucket'
        connection.directories.create(key: bucket, prefix: path)
      end
    end

    def remote_key_for_local_filename(local_filename, src, path)
      relative_local_filename = local_filename.sub(/\A#{src}\//, '')

      if path
        File.join(path, relative_local_filename)
      else
        relative_local_filename
      end
    end

    def list_remote_files(directory)
      if directory
        [].tap do |files|
          directory.files.each { |file| files << file }
        end
      else
        []
      end
    end

    def list_local_files(src)
      Dir[src + '/**/*'].select { |f| File.file?(f) }
    end

    def upload_all(src, path, etags, wrapper)
      modified_keys = []
      retained_keys = []

      local_files = list_local_files(src)
      local_files.each do |file_path|
        key = remote_key_for_local_filename(file_path, src, path)
        if needs_upload?(key, file_path, etags)
          wrapper.upload(file_path, key)
          modified_keys.push(key)
        else
          retained_keys.push(key)
        end
      end

      [modified_keys, retained_keys]
    end

    def needs_upload?(key, file_path, etags)
      remote_etag = etags[key]
      return true if remote_etag.nil?

      local_etag = calc_local_etag(file_path)
      remote_etag != local_etag
    end

    def read_etags(files)
      case config[:provider]
      when 'aws'
        files.each_with_object({}) do |file, etags|
          etags[file.key] = file.etag
        end
      else
        {}
      end
    end

    def calc_local_etag(file_path)
      case config[:provider]
      when 'aws'
        Digest::MD5.file(file_path).hexdigest
      end
    end
  end
end
nanoc-4.4.7/lib/nanoc/deploying/deployer.rb0000644000004100000410000000257313033443476020700 0ustar  www-datawww-datamodule Nanoc::Deploying
  # Represents a deployer, an object that allows uploading the compiled site
  # to a specific (remote) location.
  #
  # @abstract Subclass and override {#run} to implement a custom filter.
  #
  # @api private
  class Deployer
    extend Nanoc::Int::PluginRegistry::PluginMethods

    # @return [String] The path to the directory that contains the files to
    #   upload. It should not have a trailing slash.
    attr_reader :source_path

    # @return [Hash] The deployer configuration
    attr_reader :config

    # @return [Boolean] true if the deployer should only show what would be
    #   deployed instead of doing the actual deployment
    attr_reader :dry_run
    alias dry_run? dry_run

    # @param [String] source_path The path to the directory that contains the
    #   files to upload. It should not have a trailing slash.
    #
    # @return [Hash] config The deployer configuration
    #
    # @param [Boolean] dry_run true if the deployer should
    #   only show what would be deployed instead actually deploying
    def initialize(source_path, config, dry_run: false)
      @source_path  = source_path
      @config       = config
      @dry_run      = dry_run
    end

    # Performs the actual deployment.
    #
    # @abstract
    def run
      raise NotImplementedError.new('Nanoc::Deploying::Deployer subclasses must implement #run')
    end
  end
end
nanoc-4.4.7/lib/nanoc/deploying/deployers.rb0000644000004100000410000000054113033443476021054 0ustar  www-datawww-datamodule Nanoc::Deploying
  # @api private
  module Deployers
    autoload 'Fog',   'nanoc/deploying/deployers/fog'
    autoload 'Rsync', 'nanoc/deploying/deployers/rsync'

    Nanoc::Deploying::Deployer.register '::Nanoc::Deploying::Deployers::Fog',   :fog
    Nanoc::Deploying::Deployer.register '::Nanoc::Deploying::Deployers::Rsync', :rsync
  end
end
nanoc-4.4.7/lib/nanoc/checking/0000755000004100000410000000000013033443476016302 5ustar  www-datawww-datananoc-4.4.7/lib/nanoc/checking/issue.rb0000644000004100000410000000044713033443476017764 0ustar  www-datawww-datamodule Nanoc::Checking
  # @api private
  class Issue
    attr_reader :description
    attr_reader :subject
    attr_reader :check_class

    def initialize(desc, subject, check_class)
      @description   = desc
      @subject       = subject
      @check_class = check_class
    end
  end
end
nanoc-4.4.7/lib/nanoc/checking/check.rb0000644000004100000410000000263013033443476017705 0ustar  www-datawww-datamodule Nanoc::Checking
  # @api private
  class OutputDirNotFoundError < Nanoc::Int::Errors::Generic
    def initialize(directory_path)
      super("Unable to run check against output directory at “#{directory_path}”: directory does not exist.")
    end
  end

  # @api private
  class Check < Nanoc::Int::Context
    extend Nanoc::Int::PluginRegistry::PluginMethods

    attr_reader :issues

    def self.create(site)
      output_dir = site.config[:output_dir]
      unless File.exist?(output_dir)
        raise Nanoc::Checking::OutputDirNotFoundError.new(output_dir)
      end
      output_filenames = Dir[output_dir + '/**/*'].select { |f| File.file?(f) }

      # FIXME: ugly
      view_context = site.compiler.compilation_context.create_view_context(Nanoc::Int::DependencyTracker::Null.new)

      context = {
        items: Nanoc::ItemCollectionWithRepsView.new(site.items, view_context),
        layouts: Nanoc::LayoutCollectionView.new(site.layouts, view_context),
        config: Nanoc::ConfigView.new(site.config, view_context),
        output_filenames: output_filenames,
      }

      new(context)
    end

    def initialize(context)
      super(context)

      @issues = Set.new
    end

    def run
      raise NotImplementedError.new('Nanoc::Checking::Check subclasses must implement #run')
    end

    def add_issue(desc, subject: nil)
      @issues << Issue.new(desc, subject, self.class)
    end
  end
end
nanoc-4.4.7/lib/nanoc/checking/checks/0000755000004100000410000000000013033443476017542 5ustar  www-datawww-datananoc-4.4.7/lib/nanoc/checking/checks/internal_links.rb0000644000004100000410000000531013033443476023102 0ustar  www-datawww-datarequire 'uri'

module Nanoc::Checking::Checks
  # A check that verifies that all internal links point to a location that exists.
  #
  # @api private
  class InternalLinks < ::Nanoc::Checking::Check
    # Starts the validator. The results will be printed to stdout.
    #
    # Internal links that match a regexp pattern in `@config[:checks][:internal_links][:exclude]` will
    # be skipped.
    #
    # @return [void]
    def run
      # TODO: de-duplicate this (duplicated in external links check)
      filenames = output_filenames.select { |f| File.extname(f) == '.html' }
      hrefs_with_filenames = ::Nanoc::Extra::LinkCollector.new(filenames, :internal).filenames_per_href
      resource_uris_with_filenames = ::Nanoc::Extra::LinkCollector.new(filenames, :internal).filenames_per_resource_uri

      uris = hrefs_with_filenames.merge(resource_uris_with_filenames)
      uris.each_pair do |href, fns|
        fns.each do |filename|
          next if valid?(href, filename)

          add_issue(
            "broken reference to #{href}",
            subject: filename,
          )
        end
      end
    end

    protected

    def valid?(href, origin)
      # Skip hrefs that point to self
      # FIXME: this is ugly and won’t always be correct
      return true if href == '.'

      # Skip hrefs that are specified in the exclude configuration
      return true if excluded?(href, origin)

      # Remove target
      path = href.sub(/#.*$/, '')
      return true if path.empty?

      # Remove query string
      path = path.sub(/\?.*$/, '')
      return true if path.empty?

      # Decode URL (e.g. '%20' -> ' ')
      path = URI.unescape(path)

      # Make absolute
      path =
        if path[0, 1] == '/'
          @config[:output_dir] + path
        else
          ::File.expand_path(path, ::File.dirname(origin))
        end

      # Check whether file exists
      return true if File.file?(path)

      # Check whether directory with index file exists
      return true if File.directory?(path) && @config[:index_filenames].any? { |fn| File.file?(File.join(path, fn)) }

      # Nope :(
      false
    end

    def excluded?(href, origin)
      config = @config.fetch(:checks, {}).fetch(:internal_links, {})
      excluded_target?(href, config) || excluded_origin?(origin, config)
    end

    def excluded_target?(href, config)
      excludes = config.fetch(:exclude_targets, config.fetch(:exclude, []))
      excludes.any? { |pattern| Regexp.new(pattern).match(href) }
    end

    def excluded_origin?(origin, config)
      relative_origin = origin[@config[:output_dir].size..-1]
      excludes = config.fetch(:exclude_origins, [])
      excludes.any? { |pattern| Regexp.new(pattern).match(relative_origin) }
    end
  end
end
nanoc-4.4.7/lib/nanoc/checking/checks/mixed_content.rb0000644000004100000410000000161613033443476022733 0ustar  www-datawww-datamodule Nanoc::Checking::Checks
  # A check that verifies HTML files do not reference external resources with
  # URLs that would trigger "mixed content" warnings.
  #
  # @api private
  class MixedContent < ::Nanoc::Checking::Check
    PROTOCOL_PATTERN = /^(\w+):\/\//

    def run
      filenames = output_filenames.select { |f| File.extname(f) == '.html' }
      resource_uris_with_filenames = ::Nanoc::Extra::LinkCollector.new(filenames).filenames_per_resource_uri

      resource_uris_with_filenames.each_pair do |uri, fns|
        next unless guaranteed_insecure?(uri)
        fns.each do |filename|
          add_issue(
            "mixed content include: #{uri}",
            subject: filename,
          )
        end
      end
    end

    private

    def guaranteed_insecure?(href)
      protocol = PROTOCOL_PATTERN.match(href)

      protocol && protocol[1].casecmp('http').zero?
    end
  end
end
nanoc-4.4.7/lib/nanoc/checking/checks/css.rb0000644000004100000410000000036213033443476020660 0ustar  www-datawww-datamodule ::Nanoc::Checking::Checks
  # @api private
  class CSS < ::Nanoc::Checking::Checks::W3CValidator
    identifier :css

    def extension
      'css'
    end

    def validator_class
      ::W3CValidators::CSSValidator
    end
  end
end
nanoc-4.4.7/lib/nanoc/checking/checks/w3c_validator.rb0000644000004100000410000000137613033443476022637 0ustar  www-datawww-datamodule ::Nanoc::Checking::Checks
  # @api private
  class W3CValidator < ::Nanoc::Checking::Check
    def run
      require 'w3c_validators'

      Dir[@config[:output_dir] + '/**/*.' + extension].each do |filename|
        results = validator_class.new.validate_file(filename)
        lines = File.readlines(filename)
        results.errors.each do |e|
          line_num = e.line.to_i - 1
          line = lines[line_num]
          message = e.message.gsub(%r{\s+}, ' ').strip.sub(/\s+:$/, '')
          desc = "line #{line_num + 1}: #{message}: #{line}"
          add_issue(desc, subject: filename)
        end
      end
    end

    def extension
      raise NotImplementedError
    end

    def validator_class
      raise NotImplementedError
    end
  end
end
nanoc-4.4.7/lib/nanoc/checking/checks/stale.rb0000644000004100000410000000144713033443476021205 0ustar  www-datawww-datamodule Nanoc::Checking::Checks
  # @api private
  class Stale < ::Nanoc::Checking::Check
    def run
      require 'set'

      output_filenames.each do |f|
        next if pruner.filename_excluded?(f)
        next if item_rep_paths.include?(f)

        add_issue(
          'file without matching item',
          subject: f,
        )
      end
    end

    protected

    def item_rep_paths
      @item_rep_paths ||=
        Set.new(
          @items
            .flat_map(&:reps)
            .map(&:unwrap)
            .flat_map(&:raw_paths)
            .flat_map(&:values),
        )
    end

    def pruner
      exclude_config = @config.fetch(:prune, {}).fetch(:exclude, [])
      # FIXME: reps=nil is icky
      @pruner ||= Nanoc::Pruner.new(@config, nil, exclude: exclude_config)
    end
  end
end
nanoc-4.4.7/lib/nanoc/checking/checks/external_links.rb0000644000004100000410000000740213033443476023114 0ustar  www-datawww-datarequire 'net/http'
require 'net/https'
require 'nokogiri'
require 'timeout'
require 'uri'

module ::Nanoc::Checking::Checks
  # A validator that verifies that all external links point to a location that exists.
  #
  # @api private
  class ExternalLinks < ::Nanoc::Checking::Check
    identifiers :external_links, :elinks

    def run
      # Find all broken external hrefs
      # TODO: de-duplicate this (duplicated in internal links check)
      filenames = output_filenames.select { |f| File.extname(f) == '.html' && !excluded_file?(f) }
      hrefs_with_filenames = ::Nanoc::Extra::LinkCollector.new(filenames, :external).filenames_per_href
      results = select_invalid(hrefs_with_filenames.keys)

      # Report them
      results.each do |res|
        filenames = hrefs_with_filenames[res.href]
        filenames.each do |filename|
          add_issue(
            "broken reference to #{res.href}: #{res.explanation}",
            subject: filename,
          )
        end
      end
    end

    class Result
      attr_reader :href
      attr_reader :explanation

      def initialize(href, explanation)
        @href        = href
        @explanation = explanation
      end
    end

    def select_invalid(hrefs)
      col = Nanoc::Extra::ParallelCollection.new(hrefs, parallelism: 10)
      col.map { |href| validate(href) }.compact
    end

    def validate(href)
      # Parse
      url = nil
      begin
        url = URI.parse(href)
      rescue URI::InvalidURIError
        return Result.new(href, 'invalid URI')
      end

      # Skip excluded URLs
      return nil if excluded?(href)

      # Skip non-HTTP URLs
      return nil if url.scheme !~ /^https?$/

      # Get status
      res = nil
      last_err = nil
      timeouts = [3, 5, 10, 30, 60]
      5.times do |i|
        begin
          Timeout.timeout(timeouts[i]) do
            res = request_url_once(url)
            if res.code == '405'
              res = request_url_once(url, Net::HTTP::Get)
            end
          end
        rescue => e
          last_err = e
          next # can not allow
        end

        if res.code =~ /^3..$/
          if i == 4
            return Result.new(href, 'too many redirects')
          end

          # Find proper location
          location = res['Location']
          if location !~ /^https?:\/\//
            base_url = url.dup
            base_url.path = (location =~ /^\// ? '' : '/')
            base_url.query = nil
            base_url.fragment = nil
            location = base_url.to_s + location
          end

          url = URI.parse(location)
        elsif res.code == '200'
          return nil
        else
          return Result.new(href, res.code)
        end
      end
      if last_err
        return Result.new(href, last_err.message)
      else
        raise Nanoc::Int::Errors::InternalInconsistency, 'last_err cannot be nil'
      end
    end

    def path_for_url(url)
      path =
        if url.path.nil? || url.path.empty?
          '/'
        else
          url.path
        end

      if url.query
        path << '?' << url.query
      end

      path
    end

    def request_url_once(url, req_method = Net::HTTP::Head)
      req = req_method.new(path_for_url(url))
      http = Net::HTTP.new(url.host, url.port)
      if url.instance_of? URI::HTTPS
        http.use_ssl = true
        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
      end
      http.request(req)
    end

    def excluded?(href)
      excludes = @config.fetch(:checks, {}).fetch(:external_links, {}).fetch(:exclude, [])
      excludes.any? { |pattern| Regexp.new(pattern).match(href) }
    end

    def excluded_file?(file)
      excludes = @config.fetch(:checks, {}).fetch(:external_links, {}).fetch(:exclude_files, [])
      excludes.any? { |pattern| Regexp.new(pattern).match(file) }
    end
  end
end
nanoc-4.4.7/lib/nanoc/checking/checks/html.rb0000644000004100000410000000037613033443476021041 0ustar  www-datawww-datamodule ::Nanoc::Checking::Checks
  # @api private
  class HTML < ::Nanoc::Checking::Checks::W3CValidator
    identifier :html

    def extension
      '{htm,html}'
    end

    def validator_class
      ::W3CValidators::MarkupValidator
    end
  end
end
nanoc-4.4.7/lib/nanoc/checking/runner.rb0000644000004100000410000000724513033443476020150 0ustar  www-datawww-datamodule Nanoc::Checking
  # Runner is reponsible for running issue checks.
  #
  # @api private
  class Runner
    CHECKS_FILENAMES = ['Checks', 'Checks.rb', 'checks', 'checks.rb'].freeze

    # @param [Nanoc::Int::Site] site The Nanoc site this runner is for
    def initialize(site)
      @site = site
    end

    # @return [String] The name of the Checks file
    def checks_filename
      @_checks_filename ||= CHECKS_FILENAMES.find { |f| File.file?(f) }
    end

    # @return [Boolean] true if a Checks file exists, false otherwise
    def dsl_present?
      checks_filename && File.file?(checks_filename)
    end
    alias has_dsl? dsl_present?

    # Lists all available checks on stdout.
    #
    # @return [void]
    def list_checks
      load_dsl_if_available

      puts 'Available checks:'
      puts
      puts all_check_classes.map { |i| '  ' + i.identifier.to_s }.sort.join("\n")
    end

    # Runs all checks.
    #
    # @return [Boolean] true if successful, false otherwise
    def run_all
      load_dsl_if_available

      run_check_classes(all_check_classes)
    end

    # Runs the checks marked for deployment.
    #
    # @return [Boolean] true if successful, false otherwise
    def run_for_deploy
      require_dsl

      return true if dsl.nil?
      run_check_classes(check_classes_named(dsl.deploy_checks))
    end

    # Runs the checks with the given names.
    #
    # @param [Array] check_class_names The names of the checks
    #
    # @return [Boolean] true if successful, false otherwise
    def run_specific(check_class_names)
      load_dsl_if_available

      run_check_classes(check_classes_named(check_class_names))
    end

    def load_dsl_if_available
      @dsl_loaded ||= false
      unless @dsl_loaded
        @dsl =
          if dsl_present?
            Nanoc::Checking::DSL.from_file(checks_filename)
          else
            nil
          end
        @dsl_loaded = true
      end
    end

    def require_dsl
      load_dsl_if_available
      if dsl.nil?
        raise Nanoc::Int::Errors::GenericTrivial, "No checks defined (no #{CHECKS_FILENAMES.first} file present)"
      end
    end

    def dsl
      @dsl
    end

    def run_check_classes(classes)
      issues = run_checks(classes)
      print_issues(issues)
      issues.empty? ? true : false
    end

    def all_check_classes
      Nanoc::Checking::Check.all.map(&:last).uniq
    end

    def check_classes_named(n)
      n.map do |a|
        klass = Nanoc::Checking::Check.named(a)
        raise Nanoc::Int::Errors::GenericTrivial, "Unknown check: #{a}" if klass.nil?
        klass
      end
    end

    def run_checks(classes)
      return [] if classes.empty?

      # TODO: remove me
      @site.compiler.build_reps

      checks = []
      issues = Set.new
      length = classes.map { |c| c.identifier.to_s.length }.max + 18
      classes.each do |klass|
        print format("  %-#{length}s", "Running check #{klass.identifier}… ")

        check = klass.create(@site)
        check.run

        checks << check
        issues.merge(check.issues)

        # TODO: report progress

        puts check.issues.empty? ? 'ok'.green : 'error'.red
      end
      issues
    end

    def subject_to_s(s)
      s || '(global)'
    end

    def print_issues(issues)
      require 'colored'

      return if issues.empty?
      puts 'Issues found!'
      issues.group_by(&:subject).to_a.sort_by { |s| subject_to_s(s.first) }.each do |pair|
        subject = pair.first
        issues  = pair.last
        next if issues.empty?

        puts "  #{subject_to_s(subject)}:"
        issues.each do |i|
          puts "    [ #{'ERROR'.red} ] #{i.check_class.identifier} - #{i.description}"
        end
      end
    end
  end
end
nanoc-4.4.7/lib/nanoc/checking/checks.rb0000644000004100000410000000222013033443476020063 0ustar  www-datawww-datarequire_relative 'checks/w3c_validator'

# @api private
module Nanoc::Checking::Checks
  autoload 'CSS',           'nanoc/checking/checks/css'
  autoload 'ExternalLinks', 'nanoc/checking/checks/external_links'
  autoload 'HTML',          'nanoc/checking/checks/html'
  autoload 'InternalLinks', 'nanoc/checking/checks/internal_links'
  autoload 'Stale',         'nanoc/checking/checks/stale'
  autoload 'MixedContent',  'nanoc/checking/checks/mixed_content'

  Nanoc::Checking::Check.register '::Nanoc::Checking::Checks::CSS',           :css
  Nanoc::Checking::Check.register '::Nanoc::Checking::Checks::ExternalLinks', :external_links
  Nanoc::Checking::Check.register '::Nanoc::Checking::Checks::ExternalLinks', :elinks
  Nanoc::Checking::Check.register '::Nanoc::Checking::Checks::HTML',          :html
  Nanoc::Checking::Check.register '::Nanoc::Checking::Checks::InternalLinks', :internal_links
  Nanoc::Checking::Check.register '::Nanoc::Checking::Checks::InternalLinks', :ilinks
  Nanoc::Checking::Check.register '::Nanoc::Checking::Checks::Stale',         :stale
  Nanoc::Checking::Check.register '::Nanoc::Checking::Checks::MixedContent',  :mixed_content
end
nanoc-4.4.7/lib/nanoc/checking/dsl.rb0000644000004100000410000000114113033443476017406 0ustar  www-datawww-datamodule Nanoc::Checking
  # @api private
  class DSL
    attr_reader :deploy_checks

    def self.from_file(filename)
      dsl = new
      absolute_filename = File.expand_path(filename)
      dsl.instance_eval(File.read(filename), absolute_filename)
      dsl
    end

    def initialize
      @deploy_checks = []
    end

    def check(identifier, &block)
      klass = Class.new(::Nanoc::Checking::Check)
      klass.send(:define_method, :run, &block)
      klass.send(:identifier, identifier)
    end

    def deploy_check(*identifiers)
      identifiers.each { |i| @deploy_checks << i }
    end
  end
end
nanoc-4.4.7/lib/nanoc/rule_dsl/0000755000004100000410000000000013033443476016340 5ustar  www-datawww-datananoc-4.4.7/lib/nanoc/rule_dsl/rules_collection.rb0000644000004100000410000000766213033443476022245 0ustar  www-datawww-datamodule Nanoc::RuleDSL
  # Keeps track of the rules in a site.
  #
  # @api private
  class RulesCollection
    # @return [String] the contents of the Rules file
    attr_accessor :data

    # The hash containing layout-to-filter mapping rules. This hash is
    # ordered: iterating over the hash will happen in insertion order.
    #
    # @return [Hash] The layout-to-filter mapping rules
    attr_reader :layout_filter_mapping

    # The hash containing preprocessor code blocks that will be executed after
    #   all data is loaded but before the site is compiled.
    #
    # @return [Hash] The hash containing the preprocessor code blocks that will
    #   be executed after all data is loaded but before the site is compiled
    attr_accessor :preprocessors

    # The hash containing postprocessor code blocks that will be executed after
    #   all data is loaded and the site is compiled.
    #
    # @return [Hash] The hash containing the postprocessor code blocks that will
    #   be executed after all data is loaded and the site is compiled
    attr_accessor :postprocessors

    def initialize
      @item_compilation_rules = []
      @item_routing_rules     = []
      @layout_filter_mapping  = {}
      @preprocessors          = {}
      @postprocessors         = {}
    end

    # Add the given rule to the list of item compilation rules.
    #
    # @param [Nanoc::Int::Rule] rule The item compilation rule to add
    #
    # @return [void]
    def add_item_compilation_rule(rule)
      @item_compilation_rules << rule
    end

    # Add the given rule to the list of item routing rules.
    #
    # @param [Nanoc::Int::Rule] rule The item routing rule to add
    #
    # @return [void]
    def add_item_routing_rule(rule)
      @item_routing_rules << rule
    end

    # @param [Nanoc::Int::Item] item The item for which the compilation rules
    #   should be retrieved
    #
    # @return [Array] The list of item compilation rules for the given item
    def item_compilation_rules_for(item)
      @item_compilation_rules.select { |r| r.applicable_to?(item) }
    end

    # Finds the first matching compilation rule for the given item
    # representation.
    #
    # @param [Nanoc::Int::ItemRep] rep The item rep for which to fetch the rule
    #
    # @return [Nanoc::Int::Rule, nil] The compilation rule for the given item rep,
    #   or nil if no rules have been found
    def compilation_rule_for(rep)
      @item_compilation_rules.find do |rule|
        rule.applicable_to?(rep.item) && rule.rep_name == rep.name
      end
    end

    # Returns the list of routing rules that can be applied to the given item
    # representation. For each snapshot, the first matching rule will be
    # returned. The result is a hash containing the corresponding rule for
    # each snapshot.
    #
    # @param [Nanoc::Int::ItemRep] rep The item rep for which to fetch the rules
    #
    # @return [Hash] The routing rules for the given rep
    def routing_rules_for(rep)
      rules = {}
      @item_routing_rules.each do |rule|
        next unless rule.applicable_to?(rep.item)
        next if rule.rep_name != rep.name
        next if rules.key?(rule.snapshot_name)

        rules[rule.snapshot_name] = rule
      end
      rules
    end

    # Finds the filter name and arguments to use for the given layout.
    #
    # @param [Nanoc::Int::Layout] layout The layout for which to fetch the filter.
    #
    # @return [Array, nil] A tuple containing the filter name and the filter
    #   arguments for the given layout.
    def filter_for_layout(layout)
      @layout_filter_mapping.each_pair do |pattern, filter_name_and_args|
        return filter_name_and_args if pattern.match?(layout.identifier)
      end
      nil
    end

    # Returns an object that can be used for uniquely identifying objects.
    #
    # @return [Object] An unique reference to this object
    def reference
      :rules
    end

    def inspect
      "<#{self.class}>"
    end
  end
end
nanoc-4.4.7/lib/nanoc/rule_dsl/rule.rb0000644000004100000410000000447213033443476017643 0ustar  www-datawww-datamodule Nanoc::RuleDSL
  # Contains the processing information for a item.
  #
  # @api private
  class Rule
    # @return [Symbol] The name of the representation that will be compiled
    #   using this rule
    attr_reader :rep_name

    # @return [Symbol] The name of the snapshot this rule will apply to.
    #   Ignored for compilation rules, but used for routing rules.
    attr_reader :snapshot_name

    attr_reader :pattern

    # Creates a new item compilation rule with the given identifier regex,
    # compiler and block. The block will be called during compilation with the
    # item rep as its argument.
    #
    # @param [Nanoc::Int::Pattern] pattern
    #
    # @param [String, Symbol] rep_name The name of the item representation
    #   where this rule can be applied to
    #
    # @param [Proc] block A block that will be called when matching items are
    #   compiled
    #
    # @param [Symbol, nil] snapshot_name The name of the snapshot this rule will
    #   apply to. Ignored for compilation rules, but used for routing rules.
    def initialize(pattern, rep_name, block, snapshot_name: nil)
      @pattern = pattern
      @rep_name = rep_name.to_sym
      @snapshot_name = snapshot_name
      @block = block
    end

    # @param [Nanoc::Int::Item] item The item to check
    #
    # @return [Boolean] true if this rule can be applied to the given item
    #   rep, false otherwise
    def applicable_to?(item)
      @pattern.match?(item.identifier)
    end

    # Applies this rule to the given item rep.
    #
    # @param [Nanoc::Int::ItemRep] rep
    # @param [Nanoc::Int::Site] site
    # @param [Nanoc::Int::Executor, Nanoc::RuleDSL::RecordingExecutor] executor
    # @param [Nanoc::ViewContext] view_context
    #
    # @return [void]
    def apply_to(rep, site:, executor:, view_context:)
      context = Nanoc::RuleDSL::RuleContext.new(
        rep: rep, executor: executor, site: site, view_context: view_context,
      )
      context.instance_exec(matches(rep.item.identifier), &@block)
    end

    protected

    # Matches the rule regexp against items identifier and gives back group
    # captures if any
    #
    # @param [String] identifier Identifier to capture groups for
    #
    # @return [nil, Array] Captured groups, if any
    def matches(identifier)
      @pattern.captures(identifier)
    end
  end
end
nanoc-4.4.7/lib/nanoc/rule_dsl/compiler_dsl.rb0000644000004100000410000002536713033443476021356 0ustar  www-datawww-datamodule Nanoc::RuleDSL
  # Contains methods that will be executed by the site’s `Rules` file.
  #
  # @api private
  class CompilerDSL
    # The current rules filename.
    #
    # @return [String] The current rules filename.
    #
    # @api private
    attr_accessor :rules_filename

    # Creates a new compiler DSL for the given collection of rules.
    #
    # @api private
    #
    # @param [Nanoc::RuleDSL::RulesCollection] rules_collection The collection of
    #   rules to modify when loading this DSL
    #
    # @param [Hash] config The site configuration
    def initialize(rules_collection, config)
      @rules_collection = rules_collection
      @config = config
    end

    # Creates a preprocessor block that will be executed after all data is
    # loaded, but before the site is compiled.
    #
    # @yield The block that will be executed before site compilation starts
    #
    # @return [void]
    def preprocess(&block)
      if @rules_collection.preprocessors[rules_filename]
        warn 'WARNING: A preprocess block is already defined. Defining ' \
          'another preprocess block overrides the previously one.'
      end
      @rules_collection.preprocessors[rules_filename] = block
    end

    # Creates a compilation rule for all items whose identifier match the
    # given identifier, which may either be a string containing the *
    # wildcard, or a regular expression.
    #
    # This rule will be applicable to reps with a name equal to `:default`;
    # this can be changed by giving an explicit `:rep` parameter.
    #
    # An item rep will be compiled by calling the given block and passing the
    # rep as a block argument.
    #
    # @param [String] identifier A pattern matching identifiers of items that
    #   should be compiled using this rule
    #
    # @param [Symbol] rep The name of the representation
    #
    # @yield The block that will be executed when an item matching this
    #   compilation rule needs to be compiled
    #
    # @return [void]
    #
    # @example Compiling the default rep of the `/foo/` item
    #
    #     compile '/foo/' do
    #       rep.filter :erb
    #     end
    #
    # @example Compiling the `:raw` rep of the `/bar/` item
    #
    #     compile '/bar/', :rep => :raw do
    #       # do nothing
    #     end
    def compile(identifier, rep: :default, &block)
      raise ArgumentError.new('#compile requires a block') unless block_given?

      rule = Nanoc::RuleDSL::Rule.new(create_pattern(identifier), rep, block)
      @rules_collection.add_item_compilation_rule(rule)
    end

    # Creates a routing rule for all items whose identifier match the
    # given identifier, which may either be a string containing the `*`
    # wildcard, or a regular expression.
    #
    # This rule will be applicable to reps with a name equal to `:default`;
    # this can be changed by giving an explicit `:rep` parameter.
    #
    # The path of an item rep will be determined by calling the given block
    # and passing the rep as a block argument.
    #
    # @param [String] identifier A pattern matching identifiers of items that
    #   should be routed using this rule
    #
    # @param [Symbol] rep The name of the representation
    #
    # @param [Symbol] snapshot The name of the snapshot
    #
    # @yield The block that will be executed when an item matching this
    #   compilation rule needs to be routed
    #
    # @return [void]
    #
    # @example Routing the default rep of the `/foo/` item
    #
    #     route '/foo/' do
    #       item.identifier + 'index.html'
    #     end
    #
    # @example Routing the `:raw` rep of the `/bar/` item
    #
    #     route '/bar/', :rep => :raw do
    #       '/raw' + item.identifier + 'index.txt'
    #     end
    def route(identifier, rep: :default, snapshot: :last, &block)
      raise ArgumentError.new('#route requires a block') unless block_given?

      rule = Nanoc::RuleDSL::Rule.new(create_pattern(identifier), rep, block, snapshot_name: snapshot)
      @rules_collection.add_item_routing_rule(rule)
    end

    # Creates a layout rule for all layouts whose identifier match the given
    # identifier, which may either be a string containing the * wildcard, or a
    # regular expression. The layouts matching the identifier will be filtered
    # using the filter specified in the second argument. The params hash
    # contains filter arguments that will be passed to the filter.
    #
    # @param [String] identifier A pattern matching identifiers of layouts
    #   that should be filtered using this rule
    #
    # @param [Symbol] filter_name The name of the filter that should be run
    #   when processing the layout
    #
    # @param [Hash] params Extra filter arguments that should be passed to the
    #   filter when processing the layout (see {Nanoc::Filter#run})
    #
    # @return [void]
    #
    # @example Specifying the filter to use for a layout
    #
    #     layout '/default/', :erb
    #
    # @example Using custom filter arguments for a layout
    #
    #     layout '/custom/',  :haml, :format => :html5
    def layout(identifier, filter_name, params = {})
      pattern = Nanoc::Int::Pattern.from(create_pattern(identifier))
      @rules_collection.layout_filter_mapping[pattern] = [filter_name, params]
    end

    # Creates a pair of compilation and routing rules that indicate that the
    # specified item(s) should be copied to the output folder as-is. The items
    # are selected using an identifier, which may either be a string
    # containing the `*` wildcard, or a regular expression.
    #
    # This meta-rule will be applicable to reps with a name equal to
    # `:default`; this can be changed by giving an explicit `:rep` parameter.
    #
    # @param [String] identifier A pattern matching identifiers of items that
    #   should be processed using this meta-rule
    #
    # @param [Symbol] rep The name of the representation
    #
    # @return [void]
    #
    # @example Copying the `/foo/` item as-is
    #
    #     passthrough '/foo/'
    #
    # @example Copying the `:raw` rep of the `/bar/` item as-is
    #
    #     passthrough '/bar/', :rep => :raw
    def passthrough(identifier, rep: :default)
      raise ArgumentError.new('#passthrough does not require a block') if block_given?

      compilation_block = proc {}
      compilation_rule = Nanoc::RuleDSL::Rule.new(create_pattern(identifier), rep, compilation_block)
      @rules_collection.add_item_compilation_rule(compilation_rule)

      # Create routing rule
      routing_block = proc do
        if item.identifier.full?
          item.identifier.to_s
        else
          # This is a temporary solution until an item can map back to its data
          # source.
          # ATM item[:content_filename] is nil for items coming from the static
          # data source.
          item[:extension].nil? || (item[:content_filename].nil? && item.identifier =~ %r{#{item[:extension]}/$}) ? item.identifier.chop : item.identifier.chop + '.' + item[:extension]
        end
      end
      routing_rule = Nanoc::RuleDSL::Rule.new(create_pattern(identifier), rep, routing_block, snapshot_name: :last)
      @rules_collection.add_item_routing_rule(routing_rule)
    end

    # Creates a pair of compilation and routing rules that indicate that the
    # specified item(s) should be ignored, e.g. compiled and routed with an
    # empty rule. The items are selected using an identifier, which may either
    # be a string containing the `*` wildcard, or a regular expression.
    #
    # This meta-rule will be applicable to reps with a name equal to
    # `:default`; this can be changed by giving an explicit `:rep` parameter.
    #
    # @param [String] identifier A pattern matching identifiers of items that
    #   should be processed using this meta-rule
    #
    # @param [Symbol] rep The name of the representation
    #
    # @return [void]
    #
    # @example Suppressing compilation and output for all all `/foo/*` items.
    #
    #     ignore '/foo/*'
    def ignore(identifier, rep: :default)
      raise ArgumentError.new('#ignore does not require a block') if block_given?

      compilation_rule = Nanoc::RuleDSL::Rule.new(create_pattern(identifier), rep, proc {})
      @rules_collection.add_item_compilation_rule(compilation_rule)

      routing_rule = Nanoc::RuleDSL::Rule.new(create_pattern(identifier), rep, proc {}, snapshot_name: :last)
      @rules_collection.add_item_routing_rule(routing_rule)
    end

    # Includes an additional rules file in the current rules collection.
    #
    # @param [String] name The name of the rules file — an ".rb" extension is
    #   implied if not explicitly given
    #
    # @return [void]
    #
    # @example Including two additional rules files, 'rules/assets.rb' and
    #   'rules/content.rb'
    #
    #     include_rules 'rules/assets'
    #     include_rules 'rules/content'
    def include_rules(name)
      filename = [name.to_s, "#{name}.rb", "./#{name}", "./#{name}.rb"].find { |f| File.file?(f) }
      raise Nanoc::Int::Errors::NoRulesFileFound.new if filename.nil?

      Nanoc::RuleDSL::RulesLoader.new(@config, @rules_collection).parse(filename)
    end

    # Creates a postprocessor block that will be executed after all data is
    # loaded and the site is compiled.
    #
    # @yield The block that will be executed after site compilation completes
    #
    # @return [void]
    def postprocess(&block)
      if @rules_collection.postprocessors[rules_filename]
        warn 'WARNING: A postprocess block is already defined. Defining ' \
          'another postprocess block overrides the previously one.'
      end
      @rules_collection.postprocessors[rules_filename] = block
    end

    # @api private
    def create_pattern(arg)
      case @config[:string_pattern_type]
      when 'glob'
        Nanoc::Int::Pattern.from(arg)
      when 'legacy'
        Nanoc::Int::Pattern.from(identifier_to_regex(arg))
      else
        raise(
          Nanoc::Int::Errors::GenericTrivial,
          "Invalid string_pattern_type: #{@config[:string_pattern_type]}",
        )
      end
    end

    private

    # Converts the given identifier, which can contain the '*' or '+'
    # wildcard characters, matching zero or more resp. one or more
    # characters, to a regex. For example, 'foo/*/bar' is transformed
    # into /^foo\/(.*?)\/bar$/ and 'foo+' is transformed into /^foo(.+?)/.
    def identifier_to_regex(identifier)
      if identifier.is_a? String
        # Add leading/trailing slashes if necessary
        new_identifier = identifier.dup
        new_identifier[/^/] = '/' if identifier[0, 1] != '/'
        new_identifier[/$/] = '/?' unless ['*', '/'].include?(identifier[-1, 1])

        regex_string =
          new_identifier
          .gsub('.', '\.')
          .gsub('*', '(.*?)')
          .gsub('+', '(.+?)')

        /^#{regex_string}$/
      else
        identifier
      end
    end
  end
end
nanoc-4.4.7/lib/nanoc/rule_dsl/rules_loader.rb0000644000004100000410000000146513033443476021353 0ustar  www-datawww-datamodule Nanoc::RuleDSL
  # @api private
  class RulesLoader
    def initialize(config, rules_collection)
      @dsl = Nanoc::RuleDSL::CompilerDSL.new(rules_collection, config)
    end

    def load
      # Find rules file
      rules_filenames = ['Rules', 'rules', 'Rules.rb', 'rules.rb']
      rules_filename = rules_filenames.find { |f| File.file?(f) }
      raise Nanoc::Int::Errors::NoRulesFileFound.new if rules_filename.nil?

      parse(rules_filename)
    end

    def parse(rules_filename)
      rules_filename = File.absolute_path(rules_filename)

      # Get rule data
      data = File.read(rules_filename)

      old_rules_filename = @dsl.rules_filename
      @dsl.rules_filename = rules_filename
      @dsl.instance_eval(data, rules_filename)
      @dsl.rules_filename = old_rules_filename
    end
  end
end
nanoc-4.4.7/lib/nanoc/rule_dsl/action_provider.rb0000644000004100000410000000527113033443476022061 0ustar  www-datawww-datamodule Nanoc::RuleDSL
  class ActionProvider < Nanoc::Int::ActionProvider
    identifier :rule_dsl

    # @api private
    attr_reader :rules_collection

    def self.for(site)
      rules_collection = Nanoc::RuleDSL::RulesCollection.new

      rule_memory_calculator =
        Nanoc::RuleDSL::RuleMemoryCalculator.new(
          rules_collection: rules_collection, site: site,
        )

      action_provider = new(rules_collection, rule_memory_calculator)

      Nanoc::RuleDSL::RulesLoader.new(site.config, rules_collection).load

      action_provider
    end

    def initialize(rules_collection, rule_memory_calculator)
      @rules_collection = rules_collection
      @rule_memory_calculator = rule_memory_calculator
    end

    def rep_names_for(item)
      matching_rules = @rules_collection.item_compilation_rules_for(item)
      raise Nanoc::Int::Errors::NoMatchingCompilationRuleFound.new(item) if matching_rules.empty?

      matching_rules.map(&:rep_name).uniq
    end

    def memory_for(rep)
      @rule_memory_calculator[rep]
    end

    def snapshots_defs_for(rep)
      @rule_memory_calculator.snapshots_defs_for(rep)
    end

    def preprocess(site)
      ctx = new_preprocessor_context(site)

      @rules_collection.preprocessors.each_value do |preprocessor|
        ctx.instance_eval(&preprocessor)
      end
    end

    def postprocess(site, reps)
      dependency_tracker = Nanoc::Int::DependencyTracker::Null.new
      view_context =
        Nanoc::ViewContext.new(
          reps: reps,
          items: site.items,
          dependency_tracker: dependency_tracker,
          compilation_context: site.compiler.compilation_context,
        )
      ctx = new_postprocessor_context(site, view_context)

      @rules_collection.postprocessors.each_value do |postprocessor|
        ctx.instance_eval(&postprocessor)
      end
    end

    # @api private
    def new_preprocessor_context(site)
      dependency_tracker = Nanoc::Int::DependencyTracker::Null.new
      view_context =
        Nanoc::ViewContext.new(
          reps: nil,
          items: nil,
          dependency_tracker: dependency_tracker,
          compilation_context: nil,
        )

      Nanoc::Int::Context.new(
        config: Nanoc::MutableConfigView.new(site.config, view_context),
        items: Nanoc::MutableItemCollectionView.new(site.items, view_context),
        layouts: Nanoc::MutableLayoutCollectionView.new(site.layouts, view_context),
      )
    end

    # @api private
    def new_postprocessor_context(site, view_context)
      Nanoc::Int::Context.new(
        config: Nanoc::ConfigView.new(site.config, view_context),
        items: Nanoc::PostCompileItemCollectionView.new(site.items, view_context),
      )
    end
  end
end
nanoc-4.4.7/lib/nanoc/rule_dsl/rule_context.rb0000644000004100000410000000521413033443476021402 0ustar  www-datawww-datamodule Nanoc::RuleDSL
  # Provides a context in which compilation and routing rules can be executed.
  # It provides access to the item representation that is being compiled or
  # routed.
  #
  # @api private
  class RuleContext < Nanoc::Int::Context
    # @param [Nanoc::Int::ItemRep] rep
    # @param [Nanoc::Int::Site] site
    # @param [Nanoc::Int::Executor, Nanoc::RuleDSL::RecordingExecutor] executor
    # @param [Nanoc::ViewContext] view_context
    def initialize(rep:, site:, executor:, view_context:)
      @_executor = executor

      super({
        item: Nanoc::ItemWithoutRepsView.new(rep.item, view_context),
        rep: Nanoc::ItemRepView.new(rep, view_context),
        item_rep: Nanoc::ItemRepView.new(rep, view_context),
        items: Nanoc::ItemCollectionWithoutRepsView.new(site.items, view_context),
        layouts: Nanoc::LayoutCollectionView.new(site.layouts, view_context),
        config: Nanoc::ConfigView.new(site.config, view_context),
      })
    end

    # Filters the current representation (calls {Nanoc::Int::ItemRep#filter} with
    # the given arguments on the rep).
    #
    # @see Nanoc::Int::ItemRep#filter
    #
    # @param [Symbol] filter_name The name of the filter to run the item
    #   representations' content through
    #
    # @param [Hash] filter_args The filter arguments that should be passed to
    #   the filter's #run method
    #
    # @return [void]
    def filter(filter_name, filter_args = {})
      @_executor.filter(filter_name, filter_args)
    end

    # Layouts the current representation (calls {Nanoc::Int::ItemRep#layout} with
    # the given arguments on the rep).
    #
    # @see Nanoc::Int::ItemRep#layout
    #
    # @param [String] layout_identifier The identifier of the layout the item
    #   should be laid out with
    #
    # @return [void]
    def layout(layout_identifier, extra_filter_args = nil)
      @_executor.layout(layout_identifier, extra_filter_args)
    end

    # Creates a snapshot of the current compiled item content. Calls
    # {Nanoc::Int::ItemRep#snapshot} with the given arguments on the rep.
    #
    # @see Nanoc::Int::ItemRep#snapshot
    #
    # @param [Symbol] snapshot_name The name of the snapshot to create
    #
    # @param [String, nil] path
    #
    # @return [void]
    def snapshot(snapshot_name, path: nil)
      @_executor.snapshot(snapshot_name, path: path)
    end

    # Creates a snapshot named :last the current compiled item content, with
    # the given path. This is a convenience method for {#snapshot}.
    #
    # @see #snapshot
    #
    # @param [String] path
    #
    # @return [void]
    def write(path)
      snapshot(:last, path: path)
    end
  end
end
nanoc-4.4.7/lib/nanoc/rule_dsl/recording_executor.rb0000644000004100000410000000171313033443476022561 0ustar  www-datawww-datamodule Nanoc
  module RuleDSL
    class RecordingExecutor
      include Nanoc::Int::ContractsSupport

      def initialize(rule_memory)
        @rule_memory = rule_memory
      end

      def filter(filter_name, filter_args = {})
        @rule_memory.add_filter(filter_name, filter_args)
      end

      def layout(layout_identifier, extra_filter_args = {})
        unless layout_identifier.is_a?(String)
          raise ArgumentError.new('The layout passed to #layout must be a string')
        end

        unless @rule_memory.any_layouts?
          @rule_memory.add_snapshot(:pre, nil)
        end

        @rule_memory.add_layout(layout_identifier, extra_filter_args)
      end

      Pathlike = C::Maybe[C::Or[String, Nanoc::Identifier]]
      contract Symbol, C::KeywordArgs[path: C::Optional[Pathlike]] => nil
      def snapshot(snapshot_name, path: nil)
        @rule_memory.add_snapshot(snapshot_name, path && path.to_s)
        nil
      end
    end
  end
end
nanoc-4.4.7/lib/nanoc/rule_dsl/rule_memory_calculator.rb0000644000004100000410000001032013033443476023431 0ustar  www-datawww-datamodule Nanoc::RuleDSL
  # Calculates rule memories for objects that can be run through a rule (item
  # representations and layouts).
  #
  # @api private
  class RuleMemoryCalculator
    extend Nanoc::Int::Memoization

    class UnsupportedObjectTypeException < ::Nanoc::Error
      def initialize(obj)
        super("Do not know how to calculate the rule memory for #{obj.inspect}")
      end
    end

    class NoRuleMemoryForLayoutException < ::Nanoc::Error
      def initialize(layout)
        super("There is no layout rule specified for #{layout.inspect}")
      end
    end

    class NoRuleMemoryForItemRepException < ::Nanoc::Error
      def initialize(item)
        super("There is no compilation rule specified for #{item.inspect}")
      end
    end

    class PathWithoutInitialSlashError < ::Nanoc::Error
      def initialize(rep, basic_path)
        super("The path returned for the #{rep.inspect} item representation, “#{basic_path}”, does not start with a slash. Please ensure that all routing rules return a path that starts with a slash.")
      end
    end

    # @api private
    attr_accessor :rules_collection

    # @param [Nanoc::Int::Site] site
    # @param [Nanoc::RuleDSL::RulesCollection] rules_collection
    def initialize(site:, rules_collection:)
      @site = site
      @rules_collection = rules_collection
    end

    # @param [#reference] obj
    #
    # @return [Nanoc::Int::RuleMemory]
    def [](obj)
      case obj
      when Nanoc::Int::ItemRep
        new_rule_memory_for_rep(obj)
      when Nanoc::Int::Layout
        new_rule_memory_for_layout(obj)
      else
        raise UnsupportedObjectTypeException.new(obj)
      end
    end

    def snapshots_defs_for(rep)
      self[rep].snapshot_actions.map do |a|
        Nanoc::Int::SnapshotDef.new(a.snapshot_name)
      end
    end

    # @param [Nanoc::Int::ItemRep] rep The item representation to get the rule
    #   memory for
    #
    # @return [Nanoc::Int::RuleMemory]
    def new_rule_memory_for_rep(rep)
      dependency_tracker = Nanoc::Int::DependencyTracker::Null.new
      view_context = @site.compiler.compilation_context.create_view_context(dependency_tracker)

      rule_memory = Nanoc::Int::RuleMemory.new(rep)
      executor = Nanoc::RuleDSL::RecordingExecutor.new(rule_memory)
      rule = @rules_collection.compilation_rule_for(rep)

      unless rule
        raise NoRuleMemoryForItemRepException.new(rep)
      end

      executor.snapshot(:raw)
      rule.apply_to(rep, executor: executor, site: @site, view_context: view_context)
      if rule_memory.any_layouts?
        executor.snapshot(:post)
      end
      unless rule_memory.snapshot_actions.any? { |sa| sa.snapshot_name == :last }
        executor.snapshot(:last)
      end

      assign_paths_to_mem(rule_memory, rep: rep)
    end

    # @param [Nanoc::Int::Layout] layout
    #
    # @return [Nanoc::Int::RuleMemory]
    def new_rule_memory_for_layout(layout)
      res = @rules_collection.filter_for_layout(layout)

      unless res
        raise NoRuleMemoryForLayoutException.new(layout)
      end

      Nanoc::Int::RuleMemory.new(layout).tap do |rm|
        rm.add_filter(res[0], res[1])
      end
    end

    def assign_paths_to_mem(mem, rep:)
      mem.map do |action|
        if action.is_a?(Nanoc::Int::ProcessingActions::Snapshot) && action.path.nil?
          path_from_rules = basic_path_from_rules_for(rep, action.snapshot_name)
          if path_from_rules
            action.copy(path: path_from_rules.to_s)
          else
            action
          end
        else
          action
        end
      end
    end

    # FIXME: ugly
    def basic_path_from_rules_for(rep, snapshot_name)
      routing_rules = @rules_collection.routing_rules_for(rep)
      routing_rule = routing_rules[snapshot_name]
      return nil if routing_rule.nil?

      dependency_tracker = Nanoc::Int::DependencyTracker::Null.new
      view_context = Nanoc::ViewContext.new(reps: nil, items: nil, dependency_tracker: dependency_tracker, compilation_context: nil)
      basic_path = routing_rule.apply_to(rep, executor: nil, site: @site, view_context: view_context)
      if basic_path && !basic_path.start_with?('/')
        raise PathWithoutInitialSlashError.new(rep, basic_path)
      end
      basic_path
    end
  end
end
nanoc-4.4.7/lib/nanoc/cli/0000755000004100000410000000000013033443476015276 5ustar  www-datawww-datananoc-4.4.7/lib/nanoc/cli/ansi_string_colorizer.rb0000644000004100000410000000125213033443476022233 0ustar  www-datawww-datamodule Nanoc::CLI
  # A simple ANSI colorizer for strings. When given a string and a list of
  # attributes, it returns a colorized string.
  #
  # @api private
  module ANSIStringColorizer
    # TODO: complete mapping
    MAPPING = {
      bold: "\e[1m",
      red: "\e[31m",
      green: "\e[32m",
      yellow: "\e[33m",
      blue: "\e[34m",
    }.freeze

    # @param [String] s The string to colorize
    #
    # @param [Array] as An array of attributes from `MAPPING` to colorize the
    #   string with
    #
    # @return [String] A string colorized using the given attributes
    def self.c(s, *as)
      as.map { |a| MAPPING[a] }.join('') + s + "\e[0m"
    end
  end
end
nanoc-4.4.7/lib/nanoc/cli/commands/0000755000004100000410000000000013033443476017077 5ustar  www-datawww-datananoc-4.4.7/lib/nanoc/cli/commands/check.rb0000644000004100000410000000250613033443476020504 0ustar  www-datawww-datausage 'check [options] [names]'
summary 'run issue checks'
description "
Run issue checks on the current site. If the `--all` option is passed, all available issue checks will be run. If the `--deploy` option is passed, the issue checks marked for deployment will be run.
"

flag :a, :all,    'run all checks'
flag :L, :list,   'list all checks'
flag :d, :deploy, 'run checks for deployment'

module Nanoc::CLI::Commands
  class Check < ::Nanoc::CLI::CommandRunner
    def run
      validate_options_and_arguments
      load_site(preprocess: true)

      runner = Nanoc::Checking::Runner.new(site)

      if options[:list]
        runner.list_checks
        return
      end

      success =
        if options[:all]
          runner.run_all
        elsif options[:deploy]
          runner.run_for_deploy
        else
          runner.run_specific(arguments)
        end

      unless success
        raise Nanoc::Int::Errors::GenericTrivial, 'One or more checks failed'
      end
    end

    protected

    def validate_options_and_arguments
      if arguments.empty? && !options[:all] && !options[:deploy] && !options[:list]
        raise(
          Nanoc::Int::Errors::GenericTrivial,
          'nothing to do (pass either --all, --deploy or --list or a list of checks)',
        )
      end
    end
  end
end

runner Nanoc::CLI::Commands::Check
nanoc-4.4.7/lib/nanoc/cli/commands/shell.rb0000644000004100000410000000242613033443476020537 0ustar  www-datawww-datausage 'shell'
summary 'open a shell on the Nanoc environment'
aliases 'console'
description "
Open an IRB shell on a context that contains @items, @layouts, and @config.
"

module Nanoc::CLI::Commands
  class Shell < ::Nanoc::CLI::CommandRunner
    def run
      require 'pry'

      load_site

      Nanoc::Int::Context.new(env).pry
    end

    protected

    def env
      self.class.env_for_site(site)
    end

    def self.reps_for(site)
      Nanoc::Int::ItemRepRepo.new.tap do |reps|
        action_provider = Nanoc::Int::ActionProvider.named(:rule_dsl).for(site)
        builder = Nanoc::Int::ItemRepBuilder.new(site, action_provider, reps)
        builder.run
      end
    end

    def self.view_context_for(site)
      Nanoc::ViewContext.new(
        reps: reps_for(site),
        items: site.items,
        dependency_tracker: Nanoc::Int::DependencyTracker::Null.new,
        compilation_context: nil,
      )
    end

    def self.env_for_site(site)
      view_context = view_context_for(site)

      {
        items: Nanoc::ItemCollectionWithRepsView.new(site.items, view_context),
        layouts: Nanoc::LayoutCollectionView.new(site.layouts, view_context),
        config: Nanoc::ConfigView.new(site.config, view_context),
      }
    end
  end
end

runner Nanoc::CLI::Commands::Shell
nanoc-4.4.7/lib/nanoc/cli/commands/view.rb0000644000004100000410000000412413033443476020377 0ustar  www-datawww-datausage 'view [options]'
summary 'start the web server that serves static files'
description <<-EOS
Start the static web server. Unless specified, the web server will run on port
3000 and listen on all IP addresses. Running this static web server requires
`adsf` (not `asdf`!).
EOS

required :H, :handler, 'specify the handler to use (webrick/mongrel/...)'
required :o, :host,    'specify the host to listen on (default: 0.0.0.0)'
required :p, :port,    'specify the port to listen on (default: 3000)'

module Nanoc::CLI::Commands
  class View < ::Nanoc::CLI::CommandRunner
    DEFAULT_HANDLER_NAME = :thin

    def run
      load_adsf
      require 'rack'

      load_site

      # Set options
      options_for_rack = {
        Port: (options[:port] || 3000).to_i,
        Host: (options[:host] || '0.0.0.0'),
      }

      # Get handler
      if options.key?(:handler)
        handler = Rack::Handler.get(options[:handler])
      else
        begin
          handler = Rack::Handler.get(DEFAULT_HANDLER_NAME)
        rescue LoadError
          handler = Rack::Handler::WEBrick
        end
      end

      # Build app
      site = self.site
      app = Rack::Builder.new do
        use Rack::CommonLogger
        use Rack::ShowExceptions
        use Rack::Lint
        use Rack::Head
        use Adsf::Rack::IndexFileFinder,
            root: site.config[:output_dir],
            index_filenames: site.config[:index_filenames]
        run Rack::File.new(site.config[:output_dir])
      end.to_app

      # Run autocompiler
      handler.run(app, options_for_rack)
    end

    protected

    def load_adsf
      # Load adsf
      begin
        require 'adsf'
        return
      rescue LoadError
        $stderr.puts "Could not find the required 'adsf' gem, " \
          'which is necessary for the view command.'
      end

      # Check asdf
      begin
        require 'asdf'
        $stderr.puts "You appear to have 'asdf' installed, " \
          "but not 'adsf'. Please install 'adsf' (check the spelling)!"
      rescue LoadError
      end

      # Done
      exit 1
    end
  end
end

runner Nanoc::CLI::Commands::View
nanoc-4.4.7/lib/nanoc/cli/commands/create-site.rb0000644000004100000410000002365313033443476021642 0ustar  www-datawww-datausage 'create-site [options] path'
aliases :create_site, :cs
summary 'create a site'
description 'Create a new site at the given path. The site will use the `filesystem` data source.'
flag nil, :force, 'force creation of new site'

module Nanoc::CLI::Commands
  class CreateSite < ::Nanoc::CLI::CommandRunner
    class << self
      protected

      # Converts the given array to YAML format
      def array_to_yaml(array)
        '[ ' + array.map { |s| "'" + s + "'" }.join(', ') + ' ]'
      end
    end

    DEFAULT_CONFIG = <A Brand New Nanoc Site


You’ve just created a new Nanoc site. The page you are looking at right now is the home page for your site. To get started, consider replacing this default homepage with your own customized homepage. Some pointers on how to do so:



    
  
  • Change this page’s content by editing the “index.html” file in the “content” directory. This is the actual page content, and therefore doesn’t include the header, sidebar or style information (those are part of the layout).
    • 
  
  • Change the layout, which is the “default.html” file in the “layouts” directory, and create something unique (and hopefully less bland).
    • 




If you need any help with customizing your Nanoc web site, be sure to check out the documentation (see sidebar), and be sure to subscribe to the discussion group (also see sidebar). Enjoy!

EOS

    DEFAULT_STYLESHEET = <

  
    
    A Brand New Nanoc Site - <%= @item[:title] %>
    

    
    
  
  
    

      <%= yield %>
    

    
  

EOS

    def run
      # Extract arguments
      if arguments.length != 1
        raise Nanoc::Int::Errors::GenericTrivial, "usage: #{command.usage}"
      end
      path = arguments[0]

      # Check whether site exists
      if File.exist?(path) && (!File.directory?(path) || !(Dir.entries(path) - %w(. ..)).empty?) && !options[:force]
        raise(
          Nanoc::Int::Errors::GenericTrivial,
          "The site was not created because '#{path}' already exists. " \
          'Re-run the command using --force to create the site anyway.',
        )
      end

      # Setup notifications
      Nanoc::Int::NotificationCenter.on(:file_created) do |file_path|
        Nanoc::CLI::Logger.instance.file(:high, :create, file_path)
      end

      # Build entire site
      FileUtils.mkdir_p(path)
      FileUtils.cd(File.join(path)) do
        FileUtils.mkdir_p('content')
        FileUtils.mkdir_p('layouts')
        FileUtils.mkdir_p('lib')
        FileUtils.mkdir_p('output')

        write('nanoc.yaml', DEFAULT_CONFIG)
        write('Rules', DEFAULT_RULES)
        write('content/index.html', DEFAULT_ITEM)
        write('content/stylesheet.css', DEFAULT_STYLESHEET)
        write('layouts/default.html', DEFAULT_LAYOUT)
      end

      puts "Created a blank nanoc site at '#{path}'. Enjoy!"
    end

    private

    def write(filename, content)
      File.write(filename, content)
      Nanoc::Int::NotificationCenter.post(:file_created, filename)
    end
  end
end

runner Nanoc::CLI::Commands::CreateSite
nanoc-4.4.7/lib/nanoc/cli/commands/compile.rb0000644000004100000410000003204113033443476021054 0ustar  www-datawww-datausage 'compile [options]'
summary 'compile items of this site'
description <<-EOS
Compile all items of the current site.
EOS
flag nil, :profile, 'profile compilation' if Nanoc::Feature.enabled?(Nanoc::Feature::PROFILER)

module Nanoc::CLI::Commands
  class Compile < ::Nanoc::CLI::CommandRunner
    # Listens to compilation events and reacts to them. This abstract class
    # does not have a real implementation; subclasses should override {#start}
    # and set up notifications to listen to.
    #
    # @abstract Subclasses must override {#start} and may override {#stop}.
    class Listener
      def initialize(*); end

      # @param [Nanoc::CLI::CommandRunner] command_runner The command runner for this listener
      #
      # @return [Boolean] true if this listener should be enabled for the given command runner, false otherwise
      #
      # @abstract Returns `true` by default, but subclasses may override this.
      def self.enable_for?(command_runner) # rubocop:disable Lint/UnusedMethodArgument
        true
      end

      # Starts the listener. Subclasses should override this method and set up listener notifications.
      #
      # @return [void]
      #
      # @abstract
      def start
        raise NotImplementedError, 'Subclasses of Listener should implement #start'
      end

      # Stops the listener. The default implementation removes self from all notification center observers.
      #
      # @return [void]
      def stop; end

      # @api private
      def start_safely
        start
        @_started = true
      end

      # @api private
      def stop_safely
        stop if @_started
        @_started = false
      end
    end

    # Generates diffs for every output file written
    class DiffGenerator < Listener
      # @see Listener#enable_for?
      def self.enable_for?(command_runner)
        command_runner.site.config[:enable_output_diff]
      end

      # @see Listener#start
      def start
        require 'tempfile'
        setup_diffs
        old_contents = {}
        Nanoc::Int::NotificationCenter.on(:will_write_rep, self) do |rep, path|
          old_contents[rep] = File.file?(path) ? File.read(path) : nil
        end
        Nanoc::Int::NotificationCenter.on(:rep_written, self) do |rep, path, _is_created, _is_modified|
          unless rep.binary?
            new_contents = File.file?(path) ? File.read(path) : nil
            if old_contents[rep] && new_contents
              generate_diff_for(path, old_contents[rep], new_contents)
            end
            old_contents.delete(rep)
          end
        end
      end

      # @see Listener#stop
      def stop
        super

        Nanoc::Int::NotificationCenter.remove(:will_write_rep, self)
        Nanoc::Int::NotificationCenter.remove(:rep_written, self)

        teardown_diffs
      end

      protected

      def setup_diffs
        @diff_lock    = Mutex.new
        @diff_threads = []
        FileUtils.rm('output.diff') if File.file?('output.diff')
      end

      def teardown_diffs
        @diff_threads.each(&:join)
      end

      def generate_diff_for(path, old_content, new_content)
        return if old_content == new_content

        @diff_threads << Thread.new do
          # Generate diff
          diff = diff_strings(old_content, new_content)
          diff.sub!(/^--- .*/,    '--- ' + path)
          diff.sub!(/^\+\+\+ .*/, '+++ ' + path)

          # Write diff
          @diff_lock.synchronize do
            File.open('output.diff', 'a') { |io| io.write(diff) }
          end
        end
      end

      def diff_strings(a, b)
        require 'open3'

        # Create files
        Tempfile.open('old') do |old_file|
          Tempfile.open('new') do |new_file|
            # Write files
            old_file.write(a)
            old_file.flush
            new_file.write(b)
            new_file.flush

            # Diff
            cmd = ['diff', '-u', old_file.path, new_file.path]
            Open3.popen3(*cmd) do |_stdin, stdout, _stderr|
              result = stdout.read
              return (result == '' ? nil : result)
            end
          end
        end
      rescue Errno::ENOENT
        warn 'Failed to run `diff`, so no diff with the previously compiled ' \
             'content will be available.'
        nil
      end
    end

    # Records the time spent per filter and per item representation
    class TimingRecorder < Listener
      # @see Listener#enable_for?
      def self.enable_for?(command_runner)
        command_runner.options.fetch(:verbose, false)
      end

      # @param [Enumerable] reps
      def initialize(reps:)
        # rep ->
        #   filter_name ->
        #     accum -> 0.0
        #     last_start -> nil
        @times_per_rep = {}

        @reps = reps
      end

      # @see Listener#start
      def start
        Nanoc::Int::NotificationCenter.on(:filtering_started) do |rep, filter_name|
          @times_per_rep[rep] ||= {}
          @times_per_rep[rep][filter_name] ||= {}

          @times_per_rep[rep][filter_name][:last_start] = Time.now
          @times_per_rep[rep][filter_name][:accum] ||= []
          @times_per_rep[rep][filter_name][:suspended] = false
        end

        Nanoc::Int::NotificationCenter.on(:filtering_ended) do |rep, filter_name|
          times = @times_per_rep[rep][filter_name]
          last_start = @times_per_rep[rep][filter_name][:last_start]

          times[:accum] << (Time.now - last_start)
          @times_per_rep[rep][filter_name].delete(:last_start)
        end

        Nanoc::Int::NotificationCenter.on(:compilation_suspended) do |rep, _exception|
          @times_per_rep.fetch(rep, {}).each do |_filter_name, times|
            if times[:last_start]
              times[:accum] << (Time.now - times[:last_start])
              times.delete(:last_start)
              times[:suspended] = true

              break
            end
          end
        end

        Nanoc::Int::NotificationCenter.on(:compilation_started) do |rep|
          @times_per_rep.fetch(rep, {}).each do |filter_name, times|
            if times[:suspended]
              @times_per_rep[rep][filter_name][:last_start] = Time.now
              times[:suspended] = false

              break
            end
          end
        end
      end

      # @see Listener#stop
      def stop
        print_profiling_feedback
        super
      end

      protected

      def print_profiling_feedback
        # Get max filter length
        max_filter_name_length = durations_per_filter.keys.map { |k| k.to_s.size }.max
        return if max_filter_name_length.nil?

        # Print warning if necessary
        if @reps.any? { |r| !r.compiled? }
          $stderr.puts
          $stderr.puts 'Warning: profiling information may not be accurate because ' \
                       'some items were not compiled.'
        end

        # Print header
        puts
        puts ' ' * max_filter_name_length + ' | count    min    avg    max     tot'
        puts '-' * max_filter_name_length + '-+-----------------------------------'

        durations_per_filter.to_a.sort_by { |r| r[1] }.each do |row|
          print_row(row, max_filter_name_length)
        end
      end

      def print_row(row, length)
        # Extract data
        filter_name, samples = *row

        # Calculate stats
        count = samples.size
        min   = samples.min
        tot   = samples.reduce(0) { |acc, elem| acc + elem }
        avg   = tot / count
        max   = samples.max

        # Format stats
        count = format('%4d',   count)
        min   = format('%4.2f', min)
        avg   = format('%4.2f', avg)
        max   = format('%4.2f', max)
        tot   = format('%5.2f', tot)

        # Output stats
        key = format("%#{length}s", filter_name)
        puts "#{key} |  #{count}  #{min}s  #{avg}s  #{max}s  #{tot}s"
      end

      def durations_per_filter
        @_durations_per_filter ||= begin
          result = {}

          @times_per_rep.each do |_rep, times_per_filter|
            times_per_filter.each do |filter_name, data|
              result[filter_name] ||= []
              result[filter_name].concat(data[:accum])
            end
          end

          result
        end
      end
    end

    # Prints debug information (compilation started/ended, filtering started/ended, …)
    class DebugPrinter < Listener
      # @see Listener#enable_for?
      def self.enable_for?(command_runner)
        command_runner.debug?
      end

      # @see Listener#start
      def start
        Nanoc::Int::NotificationCenter.on(:compilation_started) do |rep|
          puts "*** Started compilation of #{rep.inspect}"
        end
        Nanoc::Int::NotificationCenter.on(:compilation_ended) do |rep|
          puts "*** Ended compilation of #{rep.inspect}"
          puts
        end
        Nanoc::Int::NotificationCenter.on(:compilation_suspended) do |rep, e|
          puts "*** Suspended compilation of #{rep.inspect}: #{e.message}"
        end
        Nanoc::Int::NotificationCenter.on(:cached_content_used) do |rep|
          puts "*** Used cached compiled content for #{rep.inspect} instead of recompiling"
        end
        Nanoc::Int::NotificationCenter.on(:filtering_started) do |rep, filter_name|
          puts "*** Started filtering #{rep.inspect} with #{filter_name}"
        end
        Nanoc::Int::NotificationCenter.on(:filtering_ended) do |rep, filter_name|
          puts "*** Ended filtering #{rep.inspect} with #{filter_name}"
        end
        Nanoc::Int::NotificationCenter.on(:dependency_created) do |src, dst|
          puts "*** Dependency created from #{src.inspect} onto #{dst.inspect}"
        end
      end
    end

    # Prints file actions (created, updated, deleted, identical, skipped)
    class FileActionPrinter < Listener
      def initialize(reps:)
        @start_times = {}
        @acc_durations = {}

        @reps = reps
      end

      # @see Listener#start
      def start
        Nanoc::Int::NotificationCenter.on(:compilation_started, self) do |rep|
          @start_times[rep] = Time.now
          @acc_durations[rep] ||= 0.0
        end

        Nanoc::Int::NotificationCenter.on(:compilation_suspended, self) do |rep|
          @acc_durations[rep] += Time.now - @start_times[rep]
        end

        Nanoc::Int::NotificationCenter.on(:rep_written, self) do |rep, path, is_created, is_modified|
          @acc_durations[rep] += Time.now - @start_times[rep]
          duration = @acc_durations[rep]

          action =
            if is_created then :create
            elsif is_modified then :update
            else :identical
            end
          level =
            if is_created then :high
            elsif is_modified then :high
            else :low
            end
          log(level, action, path, duration)
        end
      end

      # @see Listener#stop
      def stop
        super

        Nanoc::Int::NotificationCenter.remove(:compilation_started, self)
        Nanoc::Int::NotificationCenter.remove(:compilation_suspended, self)
        Nanoc::Int::NotificationCenter.remove(:rep_written, self)

        @reps.select { |r| !r.compiled? }.each do |rep|
          rep.raw_paths.each do |_snapshot_name, raw_path|
            log(:low, :skip, raw_path, nil)
          end
        end
      end

      private

      def log(level, action, path, duration)
        Nanoc::CLI::Logger.instance.file(level, action, path, duration)
      end
    end

    # Records a profile using StackProf
    class StackProfProfiler < Listener
      PROFILE_FILE = 'tmp/stackprof_profile'.freeze

      # @see Listener#enable_for?
      def self.enable_for?(command_runner)
        command_runner.options.fetch(:profile, false)
      end

      # @see Listener#start
      def start
        require 'stackprof'
        StackProf.start(mode: :cpu)
      end

      # @see Listener#stop
      def stop
        StackProf.stop
        StackProf.results(PROFILE_FILE)
      end
    end

    attr_accessor :listener_classes

    def initialize(options, arguments, command)
      super
      @listener_classes = default_listener_classes
    end

    def run
      time_before = Time.now

      load_site

      puts 'Compiling site…'
      run_listeners_while do
        site.compile
      end

      time_after = Time.now
      puts
      puts "Site compiled in #{format('%.2f', time_after - time_before)}s."
    end

    protected

    def default_listener_classes
      [
        Nanoc::CLI::Commands::Compile::StackProfProfiler,
        Nanoc::CLI::Commands::Compile::DiffGenerator,
        Nanoc::CLI::Commands::Compile::DebugPrinter,
        Nanoc::CLI::Commands::Compile::TimingRecorder,
        Nanoc::CLI::Commands::Compile::FileActionPrinter,
      ]
    end

    def setup_listeners
      @listeners =
        @listener_classes
        .select { |klass| klass.enable_for?(self) }
        .map    { |klass| klass.new(reps: reps) }

      @listeners.each(&:start_safely)
    end

    def listeners
      @listeners
    end

    def run_listeners_while
      setup_listeners
      yield
    ensure
      teardown_listeners
    end

    def teardown_listeners
      @listeners.reverse_each(&:stop_safely)
    end

    def reps
      site.compiler.reps
    end
  end
end

runner Nanoc::CLI::Commands::Compile
nanoc-4.4.7/lib/nanoc/cli/commands/show-rules.rb0000644000004100000410000000311313033443476021532 0ustar  www-datawww-datausage 'show-rules [thing]'
aliases :explain
summary 'describe the rules for each item'
description "
Prints the rules used for all items and layouts in the current site.
"

module Nanoc::CLI::Commands
  class ShowRules < ::Nanoc::CLI::CommandRunner
    def run
      load_site

      @c = Nanoc::CLI::ANSIStringColorizer

      compiler = site.compiler
      compiler.build_reps
      @reps = compiler.reps

      action_provider = site.compiler.action_provider
      unless action_provider.respond_to?(:rules_collection)
        raise(
          ::Nanoc::Int::Errors::GenericTrivial,
          'The show-rules command can only be used for sites with the Rule DSL action provider.',
        )
      end
      @rules = action_provider.rules_collection

      site.items.sort_by(&:identifier).each   { |e| explain_item(e) }
      site.layouts.sort_by(&:identifier).each { |e| explain_layout(e) }
    end

    def explain_item(item)
      puts "#{@c.c('Item ' + item.identifier, :bold, :yellow)}:"

      @reps[item].each do |rep|
        rule = @rules.compilation_rule_for(rep)
        puts "  Rep #{rep.name}: #{rule ? rule.pattern : '(none)'}"
      end

      puts
    end

    def explain_layout(layout)
      puts "#{@c.c('Layout ' + layout.identifier, :bold, :yellow)}:"

      found = false
      @rules.layout_filter_mapping.each do |pattern, _|
        if pattern.match?(layout.identifier)
          puts "  #{pattern}"
          found = true
          break
        end
      end
      unless found
        puts '  (none)'
      end

      puts
    end
  end
end

runner Nanoc::CLI::Commands::ShowRules
nanoc-4.4.7/lib/nanoc/cli/commands/nanoc.rb0000644000004100000410000000204113033443476020517 0ustar  www-datawww-datausage 'nanoc command [options] [arguments]'
summary 'Nanoc, a static site compiler written in Ruby'

opt :l, :color, 'enable color' do
  $stdout.remove_stream_cleaner(Nanoc::CLI::StreamCleaners::ANSIColors)
  $stderr.remove_stream_cleaner(Nanoc::CLI::StreamCleaners::ANSIColors)
end

opt :d, :debug, 'enable debugging' do
  Nanoc::CLI.debug = true
end

opt :e, :env, 'set environment', argument: :required do |value|
  ENV.store('NANOC_ENV', value)
end

opt :h, :help, 'show the help message and quit' do |_value, cmd|
  puts cmd.help
  exit 0
end

opt :C, :'no-color', 'disable color' do
  $stdout.add_stream_cleaner(Nanoc::CLI::StreamCleaners::ANSIColors)
  $stderr.add_stream_cleaner(Nanoc::CLI::StreamCleaners::ANSIColors)
end

opt :V, :verbose, 'make output more detailed' do
  Nanoc::CLI::Logger.instance.level = :low
end

opt :v, :version, 'show version information and quit' do
  puts Nanoc.version_information
  exit 0
end

opt :w, :warn, 'enable warnings' do
  $-w = true
end

run do |_opts, _args, cmd|
  cmd.command_named('compile').run([])
end
nanoc-4.4.7/lib/nanoc/cli/commands/show-data.rb0000644000004100000410000001033313033443476021313 0ustar  www-datawww-datausage 'show-data'
aliases :debug
summary 'show data in this site'
description <<-EOS
Show information about all items, item representations and layouts in the
current site, along with dependency information.
EOS

module Nanoc::CLI::Commands
  class ShowData < ::Nanoc::CLI::CommandRunner
    def run
      load_site(preprocess: true)

      # Get data
      items   = site.items
      layouts = site.layouts

      # Get dependency tracker
      compiler = site.compiler
      compiler.load_stores
      dependency_store = compiler.dependency_store

      # Build reps
      compiler.build_reps

      # Print data
      print_item_dependencies(items, dependency_store)
      print_item_rep_paths(items)
      print_item_rep_outdatedness(items, compiler)
      print_layouts(layouts, compiler)
    end

    protected

    def sorted_with_prev(objects)
      prev = nil
      objects.sort_by(&:identifier).each do |object|
        yield(object, prev)
        prev = object
      end
    end

    def sorted_reps_with_prev(items)
      prev = nil
      items.sort_by(&:identifier).each do |item|
        site.compiler.reps[item].sort_by { |r| r.name.to_s }.each do |rep|
          yield(rep, prev)
          prev = rep
        end
      end
    end

    def print_header(title)
      header = '=' * 78
      header[3..(title.length + 5)] = " #{title} "

      puts
      puts header
      puts
    end

    def print_item_dependencies(items, dependency_store)
      print_header('Item dependencies')

      puts 'Legend:'
      puts '  r = dependency on raw content'
      puts '  a = dependency on attributes'
      puts '  c = dependency on compiled content'
      puts '  p = dependency on the path'
      puts

      sorted_with_prev(items) do |item, prev|
        puts if prev
        puts "item #{item.identifier} depends on:"
        dependencies =
          dependency_store
          .dependencies_causing_outdatedness_of(item)
          .sort_by { |dep| dep.from ? dep.from.identifier : '' }
        dependencies.each do |dep|
          pred = dep.from

          type =
            case pred
            when Nanoc::Int::Layout
              'layout'
            when Nanoc::Int::ItemRep
              'item rep'
            when Nanoc::Int::Item
              'item'
            end

          props = ''
          props << (dep.props.raw_content? ? 'r' : '_')
          props << (dep.props.attributes? ? 'a' : '_')
          props << (dep.props.compiled_content? ? 'c' : '_')
          props << (dep.props.path? ? 'p' : '_')

          if pred
            puts "  [ #{format '%6s', type} ] (#{props}) #{pred.identifier}"
          else
            puts '  ( removed item )'
          end
        end
        puts '  (nothing)' if dependencies.empty?
      end
    end

    def print_item_rep_paths(items)
      print_header('Item representation paths')

      sorted_reps_with_prev(items) do |rep, prev|
        puts if prev
        puts "item #{rep.item.identifier}, rep #{rep.name}:"
        if rep.raw_paths.empty?
          puts '  (not written)'
        end
        length = rep.raw_paths.keys.map { |s| s.to_s.length }.max
        rep.raw_paths.each do |snapshot_name, raw_path|
          puts format("  [ %-#{length}s ] %s", snapshot_name, raw_path)
        end
      end
    end

    def print_item_rep_outdatedness(items, compiler)
      print_header('Item representation outdatedness')

      sorted_reps_with_prev(items) do |rep, prev|
        puts if prev
        puts "item #{rep.item.identifier}, rep #{rep.name}:"
        outdatedness_reason = compiler.outdatedness_checker.outdatedness_reason_for(rep)
        if outdatedness_reason
          puts "  is outdated: #{outdatedness_reason.message}"
        else
          puts '  is not outdated'
        end
      end
    end

    def print_layouts(layouts, compiler)
      print_header('Layouts')

      sorted_with_prev(layouts) do |layout, prev|
        puts if prev
        puts "layout #{layout.identifier}:"
        outdatedness_reason = compiler.outdatedness_checker.outdatedness_reason_for(layout)
        if outdatedness_reason
          puts "  is outdated: #{outdatedness_reason.message}"
        else
          puts '  is not outdated'
        end
        puts
      end
    end
  end
end

runner Nanoc::CLI::Commands::ShowData
nanoc-4.4.7/lib/nanoc/cli/commands/deploy.rb0000644000004100000410000000714013033443476020722 0ustar  www-datawww-datausage 'deploy [target] [options]'
summary 'deploy the compiled site'
description "
Deploys the compiled site. The compiled site contents in the output directory will be uploaded to the destination, which is specified using the `--target` option.
"

option :t, :target,         'specify the location to deploy to (default: `default`)', argument: :required
flag :C, :'no-check',       'do not run the issue checks marked for deployment'
flag :L, :list,             'list available locations to deploy to'
flag :D, :'list-deployers', 'list available deployers'
option :n, :'dry-run',      'show what would be deployed'

module Nanoc::CLI::Commands
  class Deploy < ::Nanoc::CLI::CommandRunner
    def run
      load_site(preprocess: true)

      if options[:'list-deployers']
        list_deployers
      elsif options[:list]
        list_deploy_configs
      else
        deploy
      end
    end

    private

    def list_deployers
      deployers      = Nanoc::Int::PluginRegistry.instance.find_all(Nanoc::Deploying::Deployer)
      deployer_names = deployers.keys.sort_by(&:to_s)
      puts 'Available deployers:'
      deployer_names.each do |name|
        puts "  #{name}"
      end
    end

    def list_deploy_configs
      if deploy_configs.empty?
        puts 'No deployment configurations.'
      else
        puts 'Available deployment configurations:'
        deploy_configs.keys.each do |name|
          puts "  #{name}"
        end
      end
    end

    def deploy
      deployer = deployer_for(deploy_config)

      checks_successful = options[:'no-check'] ? true : check
      return unless checks_successful

      deployer.run
    end

    def deploy_config
      if deploy_configs.empty?
        raise Nanoc::Int::Errors::GenericTrivial, 'The site has no deployment configurations.'
      end

      if arguments.length > 1
        raise Nanoc::Int::Errors::GenericTrivial, "usage: #{command.usage}"
      end

      target_from_arguments = arguments[0]
      target_from_options = options.fetch(:target, nil)
      if target_from_arguments && target_from_options
        raise Nanoc::Int::Errors::GenericTrivial, 'Only one deployment target can be specified on the command line.'
      end

      target = target_from_arguments || target_from_options || :default
      deploy_configs.fetch(target.to_sym) do
        raise Nanoc::Int::Errors::GenericTrivial, "The site has no deployment configuration named `#{target}`."
      end
    end

    def deployer_for(config)
      deployer_class_for_config(config).new(
        site.config[:output_dir],
        config,
        dry_run: options[:'dry-run'],
      )
    end

    def check
      runner = Nanoc::Checking::Runner.new(site)
      if runner.dsl_present?
        puts 'Running issue checks…'
        is_success = runner.run_for_deploy
        if is_success
          puts 'No issues found. Deploying!'
        else
          puts 'Issues found, deploy aborted.'
        end
        is_success
      else
        true
      end
    end

    def deploy_configs
      site.config.fetch(:deploy, {})
    end

    def deployer_class_for_config(config)
      names = Nanoc::Deploying::Deployer.all.keys
      name = config.fetch(:kind) do
        $stderr.puts 'Warning: The specified deploy target does not have a kind attribute. Assuming rsync.'
        'rsync'
      end

      deployer_class = Nanoc::Deploying::Deployer.named(name)
      if deployer_class.nil?
        raise Nanoc::Int::Errors::GenericTrivial, "The specified deploy target has an unrecognised kind “#{name}” (expected one of #{names.join(', ')})."
      end
      deployer_class
    end
  end
end

runner Nanoc::CLI::Commands::Deploy
nanoc-4.4.7/lib/nanoc/cli/commands/show-plugins.rb0000644000004100000410000000523413033443476022067 0ustar  www-datawww-datasummary 'show all available plugins'
aliases :info
usage 'show-plugins [options]'
description <<-EOS
Show a list of available plugins, including filters and data sources.
If the current directory contains a Nanoc web site, the plugins defined in this site will be shown as well.
EOS

module Nanoc::CLI::Commands
  class ShowPlugins < ::Nanoc::CLI::CommandRunner
    def run
      # Check arguments
      if arguments.any?
        raise Nanoc::Int::Errors::GenericTrivial, "usage: #{command.usage}"
      end

      # Get list of plugins (before and after)
      plugins_before = Nanoc::Int::PluginRegistry.instance.all
      site.code_snippets if site
      plugins_after = Nanoc::Int::PluginRegistry.instance.all

      # Divide list of plugins into builtin and custom
      plugins_builtin = plugins_before
      plugins_custom  = plugins_after - plugins_before

      # Find max identifiers length
      plugin_with_longest_identifiers = plugins_after.reduce do |longest, current|
        longest[:identifiers].join(', ').size > current[:identifiers].join(', ').size ? longest : current
      end
      max_identifiers_length = plugin_with_longest_identifiers[:identifiers].join(', ').size

      PLUGIN_CLASS_ORDER.each do |superclass|
        plugins_with_this_superclass = {
          builtin: plugins_builtin.select { |p| p[:superclass] == superclass },
          custom: plugins_custom.select { |p| p[:superclass] == superclass },
        }

        # Print kind
        kind = name_for_plugin_class(superclass)
        puts "#{kind}:"
        puts

        # Print plugins organised by subtype
        [:builtin, :custom].each do |type|
          # Find relevant plugins
          relevant_plugins = plugins_with_this_superclass[type]

          # Print type
          puts "  #{type}:"
          if relevant_plugins.empty?
            puts '    (none)'
            next
          end

          # Print plugins
          relevant_plugins.sort_by { |k| k[:identifiers].join(', ') }.each do |plugin|
            # Display
            puts format(
              "    %-#{max_identifiers_length}s (%s)",
              plugin[:identifiers].join(', '),
              plugin[:class].to_s.sub(/^::/, ''),
            )
          end
        end

        puts
      end
    end

    private

    PLUGIN_CLASS_ORDER = [
      Nanoc::Filter,
      Nanoc::DataSource,
      Nanoc::Deploying::Deployer,
    ].freeze

    PLUGIN_CLASSES = {
      Nanoc::Filter          => 'Filters',
      Nanoc::DataSource      => 'Data Sources',
      Nanoc::Deploying::Deployer => 'Deployers',
    }.freeze

    def name_for_plugin_class(klass)
      PLUGIN_CLASSES[klass]
    end
  end
end

runner Nanoc::CLI::Commands::ShowPlugins
nanoc-4.4.7/lib/nanoc/cli/commands/prune.rb0000644000004100000410000000316013033443476020555 0ustar  www-datawww-datausage 'prune'
summary 'remove files not managed by Nanoc from the output directory'
description <<-EOS
Find all files in the output directory that do not correspond to an item
managed by Nanoc and remove them. Since this is a hazardous operation, an
additional `--yes` flag is needed as confirmation.

Also see the `auto_prune` configuration option in `nanoc.yaml` (`config.yaml`
for older Nanoc sites), which will automatically prune after compilation.
EOS

flag :y, :yes,       'confirm deletion'
flag :n, :'dry-run', 'print files to be deleted instead of actually deleting them'

module Nanoc::CLI::Commands
  class Prune < ::Nanoc::CLI::CommandRunner
    def run
      load_site(preprocess: true)
      site.compiler.build_reps

      if options.key?(:yes)
        Nanoc::Pruner.new(site.config, site.compiler.reps, exclude: prune_config_exclude).run
      elsif options.key?(:'dry-run')
        Nanoc::Pruner.new(site.config, site.compiler.reps, exclude: prune_config_exclude, dry_run: true).run
      else
        $stderr.puts 'WARNING: Since the prune command is a destructive command, it requires an additional --yes flag in order to work.'
        $stderr.puts
        $stderr.puts 'Please ensure that the output directory does not contain any files (such as images or stylesheets) that are necessary but are not managed by Nanoc. If you want to get a list of all files that would be removed, pass --dry-run.'
        exit 1
      end
    end

    protected

    def prune_config
      site.config[:prune] || {}
    end

    def prune_config_exclude
      prune_config[:exclude] || {}
    end
  end
end

runner Nanoc::CLI::Commands::Prune
nanoc-4.4.7/lib/nanoc/cli/error_handler.rb0000644000004100000410000002431713033443476020460 0ustar  www-datawww-datamodule Nanoc::CLI
  # Catches errors and prints nice diagnostic messages, then exits.
  #
  # @api private
  class ErrorHandler
    # @param [Nanoc::CLI::Command, nil] command The command that is
    #   currently being executed, or nil if there is none
    def initialize(command: nil)
      @command = command
    end

    # Enables error handling in the given block.
    #
    # @param [Nanoc::CLI::Command, nil] command The command that is
    #   currently being executed, or nil if there is none
    #
    # @return [void]
    def self.handle_while(command: nil, &block)
      if @disabled
        yield
      else
        new(command: command).handle_while(&block)
      end
    end

    # Disables error handling. This is used by the test cases to prevent error
    # from being handled by the CLI while tests are running.
    def self.disable
      @disabled = true
    end

    # Re-enables error handling after it was disabled. This is used by the test
    # cases to prevent error from being handled by the CLI while tests are
    # running.
    def self.enable
      @disabled = false
    end

    # Enables error handling in the given block. This method should not be
    # called directly; use {Nanoc::CLI::ErrorHandler.handle_while} instead.
    #
    # @return [void]
    def handle_while(&_block)
      # Set exit handler
      %w(INT TERM).each do |signal|
        Signal.trap(signal) do
          puts
          exit!(0)
        end
      end

      # Set stack trace dump handler
      if !defined?(RUBY_ENGINE) || RUBY_ENGINE != 'jruby'
        begin
          Signal.trap('USR1') do
            puts 'Caught USR1; dumping a stack trace'
            puts caller.map { |i| "  #{i}" }.join("\n")
          end
        rescue ArgumentError
        end
      end

      # Run
      yield
    rescue Nanoc::Int::Errors::GenericTrivial => e
      $stderr.puts "Error: #{e.message}"
      exit(1)
    rescue Interrupt
      exit(1)
    rescue StandardError, ScriptError => e
      print_error(e)
      exit(1)
    end

    # Prints the given error to stderr. Includes message, possible resolution
    # (see {#resolution_for}), compilation stack, backtrace, etc.
    #
    # @param [Error] error The error that should be described
    #
    # @return [void]
    def self.print_error(error)
      new.print_error(error)
    end

    # Prints the given error to stderr. Includes message, possible resolution
    # (see {#resolution_for}), compilation stack, backtrace, etc.
    #
    # @param [Error] error The error that should be described
    #
    # @return [void]
    def print_error(error)
      write_compact_error(error, $stderr)

      File.open('crash.log', 'w') do |io|
        cio = Nanoc::CLI.wrap_in_cleaning_stream(io)
        cio.add_stream_cleaner(::Nanoc::CLI::StreamCleaners::ANSIColors)
        write_verbose_error(error, cio)
      end
    end

    # Writes a compact representation of the error, suitable for a terminal, on
    # the given stream (probably stderr).
    #
    # @param [Error] error The error that should be described
    #
    # @param [IO] stream The stream to write the description too
    #
    # @return [void]
    def write_compact_error(error, stream)
      # Header
      stream.puts
      stream.puts 'Captain! We’ve been hit!'

      # Sections
      write_error_message(stream, error)
      write_item_rep(stream, error)
      write_stack_trace(stream, error)

      # Issue link
      write_issue_link(stream)
    end

    # Writes a verbose representation of the error on the given stream.
    #
    # @param [Error] error The error that should be described
    #
    # @param [IO] stream The stream to write the description too
    #
    # @return [void]
    def write_verbose_error(error, stream)
      # Header
      stream.puts "Crashlog created at #{Time.now}"

      # Sections
      write_error_message(stream, error, verbose: true)
      write_item_rep(stream, error, verbose: true)
      write_stack_trace(stream, error, verbose: true)
      write_version_information(stream, verbose: true)
      write_system_information(stream, verbose: true)
      write_installed_gems(stream, verbose: true)
      write_gemfile_lock(stream, verbose: true)
      write_load_paths(stream, verbose: true)
    end

    protected

    # @return [Boolean] true if debug output is enabled, false if not
    #
    # @see Nanoc::CLI.debug?
    def debug?
      Nanoc::CLI.debug?
    end

    # @return [Nanoc::Int::Site] The site that is currently being processed
    def site
      @command && @command.site
    end

    # @return [Nanoc::Int::Compiler] The compiler for the current site
    def compiler
      site && site.compiler
    end

    # @return [Hash] A hash containing the gem names as keys and gem versions as value
    def gems_and_versions
      gems = {}
      Gem::Specification.find_all.sort_by { |s| [s.name, s.version] }.each do |spec|
        gems[spec.name] ||= []
        gems[spec.name] << spec.version.to_s
      end
      gems
    end

    # A hash that contains the name of the gem for a given required file. If a
    # `#require` fails, the gem name is looked up in this hash.
    GEM_NAMES = {
      'adsf'           => 'adsf',
      'bluecloth'      => 'bluecloth',
      'builder'        => 'builder',
      'coderay'        => 'coderay',
      'cri'            => 'cri',
      'erubis'         => 'erubis',
      'escape'         => 'escape',
      'fog'            => 'fog',
      'haml'           => 'haml',
      'handlebars'     => 'hbs',
      'json'           => 'json',
      'kramdown'       => 'kramdown',
      'less'           => 'less',
      'listen'         => 'listen',
      'markaby'        => 'markaby',
      'maruku'         => 'maruku',
      'mime/types'     => 'mime-types',
      'nokogiri'       => 'nokogiri',
      'pry'            => 'pry',
      'rack'           => 'rack',
      'rack/cache'     => 'rack-cache',
      'rainpress'      => 'rainpress',
      'rdiscount'      => 'rdiscount',
      'redcarpet'      => 'redcarpet',
      'redcloth'       => 'RedCloth',
      'rubypants'      => 'rubypants',
      'sass'           => 'sass',
      'w3c_validators' => 'w3c_validators',
    }.freeze

    # Attempts to find a resolution for the given error, or nil if no
    # resolution can be automatically obtained.
    #
    # @param [Error] error The error to find a resolution for
    #
    # @return [String] The resolution for the given error
    def resolution_for(error)
      error = unwrap_error(error)

      case error
      when LoadError
        # Get gem name
        matches = error.message.match(/(no such file to load|cannot load such file) -- ([^\s]+)/)
        return nil if matches.nil?
        gem_name = GEM_NAMES[matches[2]]

        # Build message
        if gem_name
          if using_bundler?
            'Make sure the gem is added to Gemfile and run `bundle install`.'
          else
            "Install the '#{gem_name}' gem using `gem install #{gem_name}`."
          end
        end
      when RuntimeError
        if error.message =~ /^can't modify frozen/
          'You attempted to modify immutable data. Some data cannot ' \
          'be modified once compilation has started. Such data includes ' \
          'content and attributes of items and layouts, and filter arguments.'
        end
      end
    end

    def using_bundler?
      defined?(Bundler) && Bundler::SharedHelpers.in_bundle?
    end

    def write_section_header(stream, title, verbose: false)
      stream.puts
      if verbose
        stream.puts '===== ' + title.upcase + ':'
      else
        stream.puts "\e[1m\e[31m" + title + ':' + "\e[0m"
      end
      stream.puts
    end

    def write_error_message(stream, error, verbose: false)
      write_section_header(stream, 'Message', verbose: verbose)

      error = unwrap_error(error)

      stream.puts "#{error.class}: #{error.message}"
      resolution = resolution_for(error)
      stream.puts resolution.to_s if resolution
    end

    def write_item_rep(stream, error, verbose: false)
      return unless error.is_a?(Nanoc::Int::Errors::CompilationError)

      write_section_header(stream, 'Item being compiled', verbose: verbose)

      item_rep = error.item_rep
      stream.puts "Item identifier: #{item_rep.item.identifier}"
      stream.puts "Item rep name:   #{item_rep.name.inspect}"
    end

    def write_stack_trace(stream, error, verbose: false)
      write_section_header(stream, 'Stack trace', verbose: verbose)

      error = unwrap_error(error)

      count = verbose ? -1 : 10
      error.backtrace[0...count].each_with_index do |item, index|
        stream.puts "  #{index}. #{item}"
      end
      if !verbose && error.backtrace.size > count
        stream.puts "  ... #{error.backtrace.size - count} more lines omitted. See full crash log for details."
      end
    end

    def write_issue_link(stream, _params = {})
      stream.puts
      stream.puts 'If you believe this is a bug in Nanoc, please do report it at'
      stream.puts '-> https://github.com/nanoc/nanoc/issues/new <-'
      stream.puts
      stream.puts 'A detailed crash log has been written to ./crash.log.'
    end

    def write_version_information(stream, verbose: false)
      write_section_header(stream, 'Version information', verbose: verbose)
      stream.puts Nanoc.version_information
    end

    def write_system_information(stream, verbose: false)
      uname = `uname -a`
      write_section_header(stream, 'System information', verbose: verbose)
      stream.puts uname
    rescue Errno::ENOENT
    end

    def write_installed_gems(stream, verbose: false)
      write_section_header(stream, 'Installed gems', verbose: verbose)
      gems_and_versions.each do |g|
        stream.puts "  #{g.first} #{g.last.join(', ')}"
      end
    end

    def write_gemfile_lock(stream, verbose: false)
      if File.exist?('Gemfile.lock')
        write_section_header(stream, 'Gemfile.lock', verbose: verbose)
        stream.puts File.read('Gemfile.lock')
      end
    end

    def write_load_paths(stream, verbose: false)
      write_section_header(stream, 'Load paths', verbose: verbose)
      $LOAD_PATH.each_with_index do |i, index|
        stream.puts "  #{index}. #{i}"
      end
    end

    def unwrap_error(e)
      case e
      when Nanoc::Int::Errors::CompilationError
        e.unwrap
      else
        e
      end
    end
  end
end
nanoc-4.4.7/lib/nanoc/cli/logger.rb0000644000004100000410000000356313033443476017111 0ustar  www-datawww-datarequire 'singleton'

module Nanoc::CLI
  # Nanoc::CLI::Logger is a singleton class responsible for generating
  # feedback in the terminal.
  #
  # @api private
  class Logger
    # Maps actions (`:create`, `:update`, `:identical`, `:skip` and `:delete`)
    # onto their ANSI color codes.
    ACTION_COLORS = {
      create: "\e[32m", # green
      update: "\e[33m", # yellow
      identical: '',    # (nothing)
      skip: '',         # (nothing)
      delete: "\e[31m"  # red
    }.freeze

    include Singleton

    # Returns the log level, which can be :high, :low or :off (which will log
    # all messages, only high-priority messages, or no messages at all,
    # respectively).
    #
    # @return [Symbol] The log level
    attr_accessor :level

    def initialize
      @level = :high
    end

    # Logs a file-related action.
    #
    # @param [:high, :low] level The importance of this action
    #
    # @param [:create, :update, :identical, :skip, :delete] action The kind of file action
    #
    # @param [String] name The name of the file the action was performed on
    #
    # @return [void]
    def file(level, action, name, duration = nil)
      log(
        level,
        format(
          '%s%12s%s  %s%s',
          ACTION_COLORS[action.to_sym],
          action,
          "\e[0m",
          duration.nil? ? '' : format('[%2.2fs]  ', duration),
          name,
        ),
      )
    end

    # Logs a message.
    #
    # @param [:high, :low] level The importance of this message
    #
    # @param [String] message The message to be logged
    #
    # @param [#puts] io The stream to which the message should be written
    #
    # @return [void]
    def log(level, message, io = $stdout)
      # Don't log when logging is disabled
      return if @level == :off

      # Log when level permits it
      io.puts(message) if @level == :low || @level == level
    end
  end
end
nanoc-4.4.7/lib/nanoc/cli/stream_cleaners/0000755000004100000410000000000013033443476020445 5ustar  www-datawww-datananoc-4.4.7/lib/nanoc/cli/stream_cleaners/ansi_colors.rb0000644000004100000410000000036413033443476023310 0ustar  www-datawww-datamodule Nanoc::CLI::StreamCleaners
  # Removes ANSI color escape sequences.
  #
  # @api private
  class ANSIColors < Abstract
    # @see Nanoc::CLI::StreamCleaners::Abstract#clean
    def clean(s)
      s.gsub(/\e\[.+?m/, '')
    end
  end
end
nanoc-4.4.7/lib/nanoc/cli/stream_cleaners/utf8.rb0000644000004100000410000000061713033443476021664 0ustar  www-datawww-datamodule Nanoc::CLI::StreamCleaners
  # Simplifies output by replacing UTF-8 characters with their ASCII decompositions.
  #
  # @api private
  class UTF8 < Abstract
    # @see Nanoc::CLI::StreamCleaners::Abstract#clean
    def clean(s)
      # FIXME: this decomposition is not generally usable
      s.gsub(/“|”/, '"').gsub(/‘|’/, '\'').gsub('…', '...').gsub('©', '(c)')
    end
  end
end
nanoc-4.4.7/lib/nanoc/cli/stream_cleaners/abstract.rb0000644000004100000410000000123313033443476022574 0ustar  www-datawww-datamodule Nanoc::CLI::StreamCleaners
  # Superclass for all stream cleaners. Stream cleaners have a single method,
  # {#clean}, that takes a string and returns a cleaned string. Stream cleaners
  # can have state, so they can act as a FSM.
  #
  # @abstract Subclasses must implement {#clean}
  #
  # @api private
  class Abstract
    # Returns a cleaned version of the given string.
    #
    # @param [String] s The string to clean
    #
    # @return [String] The cleaned string
    def clean(s) # rubocop:disable Lint/UnusedMethodArgument
      raise NotImplementedError, 'Subclasses of Nanoc::CLI::StreamCleaners::Abstract must implement #clean'
    end
  end
end
nanoc-4.4.7/lib/nanoc/cli/stream_cleaners.rb0000644000004100000410000000040413033443476020770 0ustar  www-datawww-datamodule Nanoc::CLI
  # @api private
  module StreamCleaners
    autoload 'Abstract',   'nanoc/cli/stream_cleaners/abstract'
    autoload 'ANSIColors', 'nanoc/cli/stream_cleaners/ansi_colors'
    autoload 'UTF8',       'nanoc/cli/stream_cleaners/utf8'
  end
end
nanoc-4.4.7/lib/nanoc/cli/cleaning_stream.rb0000644000004100000410000000627113033443476020764 0ustar  www-datawww-datamodule Nanoc::CLI
  # An output stream that passes output through stream cleaners. This can be
  # used to strip ANSI color sequences, for instance.
  #
  # @api private
  class CleaningStream
    # @param [IO, StringIO] stream The stream to wrap
    def initialize(stream)
      @stream = stream
      @stream_cleaners = []
    end

    # Adds a stream cleaner for the given class to this cleaning stream. If the
    # cleaning stream already has the given stream cleaner, nothing happens.
    #
    # @param [Nanoc::CLI::StreamCleaners::Abstract] klass The class of the
    #   stream cleaner to add
    #
    # @return [void]
    def add_stream_cleaner(klass)
      unless @stream_cleaners.map(&:class).include?(klass)
        @stream_cleaners << klass.new
      end
    end

    # Removes the stream cleaner for the given class from this cleaning stream.
    # If the cleaning stream does not have the given stream cleaner, nothing
    # happens.
    #
    # @param [Nanoc::CLI::StreamCleaners::Abstract] klass The class of the
    #   stream cleaner to add
    #
    # @return [void]
    def remove_stream_cleaner(klass)
      @stream_cleaners.delete_if { |c| c.class == klass }
    end

    # @group IO proxy methods

    # @see IO#write
    def write(s)
      _nanoc_swallow_broken_pipe_errors_while do
        @stream.write(_nanoc_clean(s))
      end
    end

    # @see IO#<<
    def <<(s)
      _nanoc_swallow_broken_pipe_errors_while do
        @stream.<<(_nanoc_clean(s))
      end
    end

    # @see IO#tty?
    def tty?
      @cached_is_tty ||= @stream.tty?
    end

    # @see IO#isatty
    def isatty
      tty?
    end

    # @see IO#flush
    def flush
      _nanoc_swallow_broken_pipe_errors_while do
        @stream.flush
      end
    end

    # @see IO#tell
    def tell
      @stream.tell
    end

    # @see IO#print
    def print(s)
      _nanoc_swallow_broken_pipe_errors_while do
        @stream.print(_nanoc_clean(s))
      end
    end

    # @see IO#puts
    def puts(*s)
      _nanoc_swallow_broken_pipe_errors_while do
        @stream.puts(*s.map { |ss| _nanoc_clean(ss) })
      end
    end

    # @see StringIO#string
    def string
      @stream.string
    end

    # @see IO#reopen
    def reopen(*a)
      @stream.reopen(*a)
    end

    # @see IO#close
    def close
      @stream.close
    end

    # @see File#exist?
    def exist?
      @stream.exist?
    end

    # @see File.exists?
    def exists?
      @stream.exists?
    end

    # @see IO.winsize
    def winsize
      @stream.winsize
    end

    # @see IO.winsize=
    def winsize=(arg)
      @stream.winsize = arg
    end

    # @see IO.sync
    def sync
      @stream.sync
    end

    # @see IO.sync=
    def sync=(arg)
      @stream.sync = arg
    end

    # @see IO.sync=
    def external_encoding
      @stream.external_encoding
    end

    # @see ARGF.set_encoding
    # rubocop:disable Style/AccessorMethodName
    def set_encoding(*args)
      @stream.set_encoding(*args)
    end
    # rubocop:enable Style/AccessorMethodName

    protected

    def _nanoc_clean(s)
      @stream_cleaners.reduce(s.to_s) { |acc, elem| elem.clean(acc) }
    end

    def _nanoc_swallow_broken_pipe_errors_while
      yield
    rescue Errno::EPIPE
    end
  end
end
nanoc-4.4.7/lib/nanoc/cli/command_runner.rb0000644000004100000410000000336313033443476020637 0ustar  www-datawww-datamodule Nanoc::CLI
  # A command runner subclass for Nanoc commands that adds Nanoc-specific
  # convenience methods and error handling.
  #
  # @api private
  class CommandRunner < ::Cri::CommandRunner
    # @see http://rubydoc.info/gems/cri/Cri/CommandRunner#call-instance_method
    #
    # @return [void]
    def call
      Nanoc::CLI::ErrorHandler.handle_while(command: self) do
        run
      end
    end

    # Gets the site ({Nanoc::Int::Site} instance) in the current directory and
    # loads its data.
    #
    # @return [Nanoc::Int::Site] The site in the current working directory
    def site
      # Load site if possible
      @site ||= nil
      if is_in_site_dir? && @site.nil?
        @site = Nanoc::Int::SiteLoader.new.new_from_cwd
      end

      @site
    end

    # For debugging purposes.
    #
    # @api private
    def site=(new_site)
      @site = new_site
    end

    # @return [Boolean] true if the current working directory is a Nanoc site
    #   directory, false otherwise
    def in_site_dir?
      Nanoc::Int::SiteLoader.cwd_is_nanoc_site?
    end
    alias is_in_site_dir? in_site_dir?

    # Asserts that the current working directory contains a site and loads the site into memory.
    #
    # @return [void]
    def load_site(preprocess: false)
      $stderr.print 'Loading site… '
      $stderr.flush

      if site.nil?
        raise ::Nanoc::Int::Errors::GenericTrivial, 'The current working directory does not seem to be a Nanoc site.'
      end

      if preprocess
        site.compiler.action_provider.preprocess(site)
      end

      $stderr.puts 'done'
    end

    # @return [Boolean] true if debug output is enabled, false if not
    #
    # @see Nanoc::CLI.debug?
    def debug?
      Nanoc::CLI.debug?
    end
  end
end
nanoc-4.4.7/lib/nanoc/base.rb0000644000004100000410000000063113033443476015766 0ustar  www-datawww-data# @api private
module Nanoc::Int
end

require_relative 'base/core_ext'
require_relative 'base/contracts_support'
require_relative 'base/memoization'
require_relative 'base/plugin_registry'
require_relative 'base/error'
require_relative 'base/errors'

require_relative 'base/entities'
require_relative 'base/feature'
require_relative 'base/repos'
require_relative 'base/services'
require_relative 'base/views'
nanoc-4.4.7/lib/nanoc/helpers/0000755000004100000410000000000013033443476016171 5ustar  www-datawww-datananoc-4.4.7/lib/nanoc/helpers/breadcrumbs.rb0000644000004100000410000000134213033443476021007 0ustar  www-datawww-datamodule Nanoc::Helpers
  # @see http://nanoc.ws/doc/reference/helpers/#breadcrumbs
  module Breadcrumbs
    # @return [Array]
    def breadcrumbs_trail
      # e.g. ['', '/foo', '/foo/bar']
      components = item.identifier.components
      prefixes = components.inject(['']) { |acc, elem| acc + [acc.last + '/' + elem] }

      if @item.identifier.legacy?
        prefixes.map { |pr| @items[Nanoc::Identifier.new('/' + pr, type: :legacy)] }
      else
        prefixes
          .reject { |pr| pr =~ /^\/index\./ }
          .map do |pr|
            if pr == ''
              @items['/index.*']
            else
              @items[Nanoc::Identifier.new(pr).without_ext + '.*']
            end
          end
      end
    end
  end
end
nanoc-4.4.7/lib/nanoc/helpers/tagging.rb0000644000004100000410000000163013033443476020136 0ustar  www-datawww-datamodule Nanoc::Helpers
  # @see http://nanoc.ws/doc/reference/helpers/#tagging
  module Tagging
    require 'nanoc/helpers/html_escape'
    include Nanoc::Helpers::HTMLEscape

    # @param [String] base_url
    # @param [String] none_text
    # @param [String] separator
    #
    # @return [String]
    def tags_for(item, base_url: nil, none_text: '(none)', separator: ', ')
      if item[:tags].nil? || item[:tags].empty?
        none_text
      else
        item[:tags].map { |tag| base_url ? link_for_tag(tag, base_url) : tag }.join(separator)
      end
    end

    # @param [String] tag
    #
    # @return [Array]
    def items_with_tag(tag)
      @items.select { |i| (i[:tags] || []).include?(tag) }
    end

    # @param [String] tag
    # @param [String] base_url
    #
    # @return [String]
    def link_for_tag(tag, base_url)
      %()
    end
  end
end
nanoc-4.4.7/lib/nanoc/helpers/text.rb0000644000004100000410000000124713033443476017506 0ustar  www-datawww-datamodule Nanoc::Helpers
  # @see http://nanoc.ws/doc/reference/helpers/#text
  module Text
    # @param [String] string
    # @param [Number] length
    # @param [String] omission
    #
    # @return [String]
    def excerptize(string, length: 25, omission: '...')
      if string.length > length
        excerpt_length = [0, length - omission.length].max
        string[0...excerpt_length] + omission
      else
        string
      end
    end

    # @param [String] string
    #
    # @return [String]
    def strip_html(string)
      # FIXME: will need something more sophisticated than this, because it sucks
      string.gsub(/<[^>]*(>+|\s*\z)/m, '').strip
    end
  end
end
nanoc-4.4.7/lib/nanoc/helpers/link_to.rb0000644000004100000410000000530113033443476020154 0ustar  www-datawww-datamodule Nanoc::Helpers
  # @see http://nanoc.ws/doc/reference/helpers/#linkto
  module LinkTo
    require 'nanoc/helpers/html_escape'
    include Nanoc::Helpers::HTMLEscape

    # @param [String] text
    #
    # @param [Hash] attributes
    #
    # @return [String]
    def link_to(text, target, attributes = {})
      # Find path
      path =
        case target
        when String
          target
        when Nanoc::ItemWithRepsView, Nanoc::ItemWithoutRepsView, Nanoc::ItemRepView
          raise "Cannot create a link to #{target.inspect} because this target is not outputted (its routing rule returns nil)" if target.path.nil?
          target.path
        else
          raise ArgumentError, "Cannot link to #{target.inspect} (expected a string or an item, not a #{target.class.name})"
        end

      # Join attributes
      attributes = attributes.reduce('') do |memo, (key, value)|
        memo + key.to_s + '="' + h(value) + '" '
      end

      # Create link
      "#{text}"
    end

    # @param [String] text
    #
    # @param [Hash] attributes
    #
    # @return [String]
    def link_to_unless_current(text, target, attributes = {})
      # Find path
      path = target.is_a?(String) ? target : target.path

      if @item_rep && @item_rep.path == path
        # Create message
        "#{text}"
      else
        link_to(text, target, attributes)
      end
    end

    # @return [String]
    def relative_path_to(target)
      require 'pathname'

      # Find path
      if target.is_a?(String)
        path = target
      else
        path = target.path
        if path.nil?
          # TODO: get proper error
          raise "Cannot get the relative path to #{target.inspect} because this target is not outputted (its routing rule returns nil)"
        end
      end

      # Handle Windows network (UNC) paths
      if path.start_with?('//', '\\\\')
        return path
      end

      # Get source and destination paths
      dst_path = Pathname.new(path)
      if @item_rep.path.nil?
        # TODO: get proper error
        raise "Cannot get the relative path to #{path} because the current item representation, #{@item_rep.inspect}, is not outputted (its routing rule returns nil)"
      end
      src_path = Pathname.new(@item_rep.path)

      # Calculate the relative path (method depends on whether destination is
      # a directory or not).
      from = src_path.to_s.end_with?('/') ? src_path : src_path.dirname
      relative_path = dst_path.relative_path_from(from).to_s

      # Add trailing slash if necessary
      if dst_path.to_s.end_with?('/')
        relative_path << '/'
      end

      # Done
      relative_path
    end
  end
end
nanoc-4.4.7/lib/nanoc/helpers/filtering.rb0000644000004100000410000000223113033443476020477 0ustar  www-datawww-datamodule Nanoc::Helpers
  # @see http://nanoc.ws/doc/reference/helpers/#filtering
  module Filtering
    require 'nanoc/helpers/capturing'
    include Nanoc::Helpers::Capturing

    # @param [Symbol] filter_name
    # @param [Hash] arguments
    #
    # @return [void]
    def filter(filter_name, arguments = {}, &block)
      # Capture block
      data = capture(&block)

      # Find filter
      klass = Nanoc::Filter.named(filter_name)
      raise Nanoc::Int::Errors::UnknownFilter.new(filter_name) if klass.nil?

      # Create filter
      assigns = {
        item: @item,
        rep: @rep,
        item_rep: @item_rep,
        items: @items,
        layouts: @layouts,
        config: @config,
        content: @content,
      }
      filter = klass.new(assigns)

      # Filter captured data
      Nanoc::Int::NotificationCenter.post(:filtering_started, @item_rep.unwrap, filter_name)
      filtered_data = filter.setup_and_run(data, arguments)
      Nanoc::Int::NotificationCenter.post(:filtering_ended, @item_rep.unwrap, filter_name)

      # Append filtered data to buffer
      buffer = eval('_erbout', block.binding)
      buffer << filtered_data
    end
  end
end
nanoc-4.4.7/lib/nanoc/helpers/html_escape.rb0000644000004100000410000000212413033443476021001 0ustar  www-datawww-datamodule Nanoc::Helpers
  # @see http://nanoc.ws/doc/reference/helpers/#filtering
  module HTMLEscape
    require 'nanoc/helpers/capturing'
    include Nanoc::Helpers::Capturing

    # @param [String] string
    #
    # @return [String]
    def html_escape(string = nil, &block)
      if block_given?
        # Capture and escape block
        data = capture(&block)
        escaped_data = html_escape(data)

        # Append filtered data to buffer
        buffer = eval('_erbout', block.binding)
        buffer << escaped_data
      elsif string
        unless string.is_a? String
          raise ArgumentError, 'The #html_escape or #h function needs either a ' \
            "string or a block to HTML-escape, but #{string.class} was given"
        end

        string
          .gsub('&', '&')
          .gsub('<', '<')
          .gsub('>', '>')
          .gsub('"', '"')
      else
        raise 'The #html_escape or #h function needs either a ' \
          'string or a block to HTML-escape, but neither a string nor a block was given'
      end
    end

    alias h html_escape
  end
end
nanoc-4.4.7/lib/nanoc/helpers/rendering.rb0000644000004100000410000000405113033443476020473 0ustar  www-datawww-datamodule Nanoc::Helpers
  # @see http://nanoc.ws/doc/reference/helpers/#rendering
  module Rendering
    include Nanoc::Helpers::Capturing

    # @param [String] identifier
    # @param [Hash] other_assigns
    #
    # @raise [Nanoc::Int::Errors::UnknownLayout]
    # @raise [Nanoc::Int::Errors::CannotDetermineFilter]
    # @raise [Nanoc::Int::Errors::UnknownFilter]
    #
    # @return [String, nil]
    def render(identifier, other_assigns = {}, &block)
      # Find layout
      layout_view = @layouts[identifier]
      layout_view ||= @layouts[identifier.__nanoc_cleaned_identifier]
      raise Nanoc::Int::Errors::UnknownLayout.new(identifier) if layout_view.nil?
      layout = layout_view.unwrap

      # Visit
      dependency_tracker = @config._context.dependency_tracker
      dependency_tracker.bounce(layout, raw_content: true)

      # Capture content, if any
      captured_content = block_given? ? capture(&block) : nil

      # Get assigns
      assigns = {
        content: captured_content,
        item: @item,
        item_rep: @item_rep,
        items: @items,
        layout: layout_view,
        layouts: @layouts,
        config: @config,
      }.merge(other_assigns)

      # Get filter name
      filter_name, filter_args = *@config._context.compilation_context.filter_name_and_args_for_layout(layout)
      raise Nanoc::Int::Errors::CannotDetermineFilter.new(layout.identifier) if filter_name.nil?

      # Get filter class
      filter_class = Nanoc::Filter.named(filter_name)
      raise Nanoc::Int::Errors::UnknownFilter.new(filter_name) if filter_class.nil?

      # Create filter
      filter = filter_class.new(assigns)

      # Layout
      content = layout.content
      arg = content.binary? ? content.filename : content.string
      result = filter.setup_and_run(arg, filter_args)

      # Append to erbout if we have a block
      if block_given?
        # Append result and return nothing
        erbout = eval('_erbout', block.binding)
        erbout << result
        ''
      else
        # Return result
        result
      end
    end
  end
end
nanoc-4.4.7/lib/nanoc/helpers/xml_sitemap.rb0000644000004100000410000000275313033443476021047 0ustar  www-datawww-datamodule Nanoc::Helpers
  # @see http://nanoc.ws/doc/reference/helpers/#xmlsitemap
  module XMLSitemap
    # @option params [Array] :items
    # @option params [Proc] :rep_select
    #
    # @return [String]
    def xml_sitemap(params = {})
      require 'builder'

      # Extract parameters
      items       = params.fetch(:items) { @items.reject { |i| i[:is_hidden] } }
      select_proc = params.fetch(:rep_select, nil)

      # Create builder
      buffer = ''
      xml = Builder::XmlMarkup.new(target: buffer, indent: 2)

      # Check for required attributes
      if @config[:base_url].nil?
        raise 'The Nanoc::Helpers::XMLSitemap helper requires the site configuration to specify the base URL for the site.'
      end

      # Build sitemap
      xml.instruct!
      xml.urlset(xmlns: 'http://www.sitemaps.org/schemas/sitemap/0.9') do
        # Add item
        items.sort_by(&:identifier).each do |item|
          reps = item.reps.reject { |r| r.raw_path.nil? }
          reps.reject! { |r| !select_proc[r] } if select_proc
          reps.sort_by { |r| r.name.to_s }.each do |rep|
            xml.url do
              xml.loc @config[:base_url] + rep.path
              xml.lastmod item[:mtime].__nanoc_to_iso8601_date unless item[:mtime].nil?
              xml.changefreq item[:changefreq] unless item[:changefreq].nil?
              xml.priority item[:priority] unless item[:priority].nil?
            end
          end
        end
      end

      # Return sitemap
      buffer
    end
  end
end
nanoc-4.4.7/lib/nanoc/helpers/child_parent.rb0000644000004100000410000000104613033443476021153 0ustar  www-datawww-datamodule Nanoc::Helpers
  # @see http://nanoc.ws/doc/reference/helpers/#childparent
  module ChildParent
    def parent_of(item)
      if item.identifier.legacy?
        item.parent
      else
        path_without_last_component = item.identifier.to_s.sub(/[^\/]+$/, '').chop
        @items[path_without_last_component + '.*']
      end
    end

    def children_of(item)
      if item.identifier.legacy?
        item.children
      else
        pattern = item.identifier.without_ext + '/*'
        @items.find_all(pattern)
      end
    end
  end
end
nanoc-4.4.7/lib/nanoc/helpers/capturing.rb0000644000004100000410000000647213033443476020523 0ustar  www-datawww-datamodule Nanoc::Helpers
  # @see http://nanoc.ws/doc/reference/helpers/#capturing
  module Capturing
    # @overload content_for(name, params = {}, &block)
    #   @param [Symbol, String] name
    #   @option params [Symbol] existing
    #   @return [void]
    #
    # @overload content_for(item, name)
    #   @param [Symbol, String] name
    #   @return [String]
    def content_for(*args, &block)
      if block_given? # Set content
        # Get args
        case args.size
        when 1
          name = args[0]
          params = {}
        when 2
          name = args[0]
          params = args[1]
        else
          raise ArgumentError, 'expected 1 or 2 argument (the name ' \
            "of the capture, and optionally params) but got #{args.size} instead"
        end
        name = args[0]
        existing_behavior = params.fetch(:existing, :error)

        # Capture
        content_string = capture(&block)

        # Get existing contents and prep for store
        snapshot_contents = @item.reps[:default].unwrap.snapshot_contents
        capture_name = "__capture_#{name}".to_sym
        old_content_string =
          case existing_behavior
          when :overwrite
            ''
          when :append
            c = snapshot_contents[capture_name]
            c ? c.string : ''
          when :error
            if snapshot_contents[capture_name] && snapshot_contents[capture_name].string != content_string
              # FIXME: get proper exception
              raise "a capture named #{name.inspect} for #{@item.identifier} already exists"
            else
              ''
            end
          else
            raise ArgumentError, 'expected :existing_behavior param to #content_for to be one of ' \
              ":overwrite, :append, or :error, but #{existing_behavior.inspect} was given"
          end

        # Store
        snapshot_contents[capture_name] = Nanoc::Int::TextualContent.new(old_content_string + content_string)
      else # Get content
        if args.size != 2
          raise ArgumentError, 'expected 2 arguments (the item ' \
            "and the name of the capture) but got #{args.size} instead"
        end
        item = args[0]
        name = args[1]

        rep = item.reps[:default].unwrap

        # Create dependency
        if @item.nil? || item != @item.unwrap
          dependency_tracker = @config._context.dependency_tracker
          dependency_tracker.bounce(item.unwrap, compiled_content: true)

          unless rep.compiled?
            Fiber.yield(Nanoc::Int::Errors::UnmetDependency.new(rep))
            return content_for(*args, &block)
          end
        end

        content = rep.snapshot_contents["__capture_#{name}".to_sym]
        content ? content.string : nil
      end
    end

    # @return [String]
    def capture(&block)
      # Get erbout so far
      erbout = eval('_erbout', block.binding)
      erbout_length = erbout.length

      # Execute block
      yield

      # Get new piece of erbout
      erbout_addition = erbout[erbout_length..-1]

      # Remove addition
      erbout[erbout_length..-1] = ''

      # Depending on how the filter outputs, the result might be a
      # single string or an array of strings (slim outputs the latter).
      erbout_addition = erbout_addition.join('') if erbout_addition.is_a? Array

      # Done.
      erbout_addition
    end
  end
end
nanoc-4.4.7/lib/nanoc/helpers/blogging.rb0000644000004100000410000001654213033443476020316 0ustar  www-datawww-datamodule Nanoc::Helpers
  # @see http://nanoc.ws/doc/reference/helpers/#blogging
  module Blogging
    # @return [Array]
    def articles
      blk = -> { @items.select { |item| item[:kind] == 'article' } }
      if @items.frozen?
        @article_items ||= blk.call
      else
        blk.call
      end
    end

    # @return [Array]
    def sorted_articles
      blk = -> { articles.sort_by { |a| attribute_to_time(a[:created_at]) }.reverse }

      if @items.frozen?
        @sorted_article_items ||= blk.call
      else
        blk.call
      end
    end

    class AtomFeedBuilder
      include Nanoc::Helpers::Blogging

      attr_accessor :config

      attr_accessor :limit
      attr_accessor :relevant_articles
      attr_accessor :preserve_order
      attr_accessor :content_proc
      attr_accessor :excerpt_proc
      attr_accessor :title
      attr_accessor :author_name
      attr_accessor :author_uri
      attr_accessor :icon
      attr_accessor :logo

      def initialize(config, item)
        @config = config
        @item = item
      end

      def validate
        validate_config
        validate_feed_item
        validate_articles
      end

      def build
        buffer = ''
        xml = Builder::XmlMarkup.new(target: buffer, indent: 2)
        build_for_feed(xml)
        buffer
      end

      protected

      def sorted_relevant_articles
        all = relevant_articles

        unless @preserve_order
          all = all.sort_by { |a| attribute_to_time(a[:created_at]) }
        end

        all.reverse.first(limit)
      end

      def last_article
        sorted_relevant_articles.first
      end

      def updated
        relevant_articles.map { |a| attribute_to_time(a[:updated_at] || a[:created_at]) }.max
      end

      def validate_config
        if @config[:base_url].nil?
          raise Nanoc::Int::Errors::GenericTrivial.new('Cannot build Atom feed: site configuration has no base_url')
        end
      end

      def validate_feed_item
        if title.nil?
          raise Nanoc::Int::Errors::GenericTrivial.new('Cannot build Atom feed: no title in params, item or site config')
        end
        if author_name.nil?
          raise Nanoc::Int::Errors::GenericTrivial.new('Cannot build Atom feed: no author_name in params, item or site config')
        end
        if author_uri.nil?
          raise Nanoc::Int::Errors::GenericTrivial.new('Cannot build Atom feed: no author_uri in params, item or site config')
        end
      end

      def validate_articles
        if relevant_articles.empty?
          raise Nanoc::Int::Errors::GenericTrivial.new('Cannot build Atom feed: no articles')
        end
        if relevant_articles.any? { |a| a[:created_at].nil? }
          raise Nanoc::Int::Errors::GenericTrivial.new('Cannot build Atom feed: one or more articles lack created_at')
        end
      end

      def build_for_feed(xml)
        xml.instruct!
        xml.feed(xmlns: 'http://www.w3.org/2005/Atom') do
          root_url = @config[:base_url] + '/'

          # Add primary attributes
          xml.id root_url
          xml.title title

          # Add date
          xml.updated(updated.__nanoc_to_iso8601_time)

          # Add links
          xml.link(rel: 'alternate', href: root_url)
          xml.link(rel: 'self',      href: feed_url)

          # Add author information
          xml.author do
            xml.name author_name
            xml.uri author_uri
          end

          # Add icon and logo
          xml.icon icon if icon
          xml.logo logo if logo

          # Add articles
          sorted_relevant_articles.each do |a|
            build_for_article(a, xml)
          end
        end
      end

      def build_for_article(a, xml)
        # Get URL
        url = url_for(a)
        return if url.nil?

        xml.entry do
          # Add primary attributes
          xml.id atom_tag_for(a)
          xml.title a[:title], type: 'html'

          # Add dates
          xml.published attribute_to_time(a[:created_at]).__nanoc_to_iso8601_time
          xml.updated attribute_to_time(a[:updated_at] || a[:created_at]).__nanoc_to_iso8601_time

          # Add specific author information
          if a[:author_name] || a[:author_uri]
            xml.author do
              xml.name a[:author_name] || author_name
              xml.uri a[:author_uri] || author_uri
            end
          end

          # Add link
          xml.link(rel: 'alternate', href: url)

          # Add content
          summary = excerpt_proc.call(a)
          xml.content content_proc.call(a), type: 'html'
          xml.summary summary, type: 'html' unless summary.nil?
        end
      end
    end

    # @option params [Number] :limit
    # @option params [Array] :articles
    # @option params [Boolean] :preserve_order
    # @option params [Proc] :content_proc
    # @option params [Proc] :excerpt_proc
    # @option params [String] :title
    # @option params [String] :author_name
    # @option params [String] :author_uri
    # @option params [String] :icon
    # @option params [String] :logo
    #
    # @return [String]
    def atom_feed(params = {})
      require 'builder'

      # Create builder
      builder = AtomFeedBuilder.new(@config, @item)

      # Fill builder
      builder.limit             = params[:limit] || 5
      builder.relevant_articles = params[:articles] || articles || []
      builder.preserve_order    = params.fetch(:preserve_order, false)
      builder.content_proc      = params[:content_proc] || ->(a) { a.compiled_content(snapshot: :pre) }
      builder.excerpt_proc      = params[:excerpt_proc] || ->(a) { a[:excerpt] }
      builder.title             = params[:title] || @item[:title] || @config[:title]
      builder.author_name       = params[:author_name] || @item[:author_name] || @config[:author_name]
      builder.author_uri        = params[:author_uri] || @item[:author_uri] || @config[:author_uri]
      builder.icon              = params[:icon]
      builder.logo              = params[:logo]

      # Run
      builder.validate
      builder.build
    end

    # @return [String]
    def url_for(item)
      # Check attributes
      if @config[:base_url].nil?
        raise Nanoc::Int::Errors::GenericTrivial.new('Cannot build Atom feed: site configuration has no base_url')
      end

      # Build URL
      if item[:custom_url_in_feed]
        item[:custom_url_in_feed]
      elsif item[:custom_path_in_feed]
        @config[:base_url] + item[:custom_path_in_feed]
      elsif item.path
        @config[:base_url] + item.path
      end
    end

    # @return [String]
    def feed_url
      # Check attributes
      if @config[:base_url].nil?
        raise Nanoc::Int::Errors::GenericTrivial.new('Cannot build Atom feed: site configuration has no base_url')
      end

      @item[:feed_url] || @config[:base_url] + @item.path
    end

    # @return [String]
    def atom_tag_for(item)
      hostname, base_dir = %r{^.+?://([^/]+)(.*)$}.match(@config[:base_url])[1..2]

      formatted_date = attribute_to_time(item[:created_at]).__nanoc_to_iso8601_date

      'tag:' + hostname + ',' + formatted_date + ':' + base_dir + (item.path || item.identifier.to_s)
    end

    # @param [String, Time, Date, DateTime] arg
    #
    # @return [Time]
    def attribute_to_time(arg)
      case arg
      when DateTime
        arg.to_time
      when Date
        Time.utc(arg.year, arg.month, arg.day)
      when String
        Time.parse(arg)
      else
        arg
      end
    end
  end
end
nanoc-4.4.7/lib/nanoc/rule_dsl.rb0000644000004100000410000000052713033443476016671 0ustar  www-datawww-datarequire_relative 'rule_dsl/compiler_dsl'
require_relative 'rule_dsl/action_provider'
require_relative 'rule_dsl/recording_executor'
require_relative 'rule_dsl/rule_context'
require_relative 'rule_dsl/rule_memory_calculator'
require_relative 'rule_dsl/rule'
require_relative 'rule_dsl/rules_collection'
require_relative 'rule_dsl/rules_loader'
nanoc-4.4.7/lib/nanoc/extra.rb0000644000004100000410000000076413033443476016206 0ustar  www-datawww-datarequire 'nanoc/checking'
require 'nanoc/deploying'

# @api private
module Nanoc::Extra
  autoload 'LinkCollector',       'nanoc/extra/link_collector.rb'
  autoload 'Piper',               'nanoc/extra/piper'
  autoload 'JRubyNokogiriWarner', 'nanoc/extra/jruby_nokogiri_warner'

  # @deprecated
  Checking = Nanoc::Checking

  # @deprecated
  Deployer = Nanoc::Deploying::Deployer

  # @deprecated
  Pruner = Nanoc::Pruner
end

require 'nanoc/extra/core_ext'
require 'nanoc/extra/parallel_collection'
nanoc-4.4.7/lib/nanoc/data_sources/0000755000004100000410000000000013033443476017203 5ustar  www-datawww-datananoc-4.4.7/lib/nanoc/data_sources/filesystem/0000755000004100000410000000000013033443476021367 5ustar  www-datawww-datananoc-4.4.7/lib/nanoc/data_sources/filesystem/errors.rb0000644000004100000410000000326513033443476023236 0ustar  www-datawww-dataclass Nanoc::DataSources::Filesystem < Nanoc::DataSource
  # @api private
  module Errors
    class Generic < ::Nanoc::Error
    end

    class BinaryLayout < Generic
      def initialize(content_filename)
        super("The layout file '#{content_filename}' is a binary file, but layouts can only be textual")
      end
    end

    class MultipleMetaFiles < Generic
      def initialize(meta_filenames, basename)
        super("Found #{meta_filenames.size} meta files for #{basename}; expected 0 or 1")
      end
    end

    class MultipleContentFiles < Generic
      def initialize(content_filenames, basename)
        super("Found #{content_filenames.size} content files for #{basename}; expected 0 or 1")
      end
    end

    class InvalidFormat < Generic
      def initialize(content_filename)
        super("The file '#{content_filename}' appears to start with a metadata section (three or five dashes at the top) but it does not seem to be in the correct format.")
      end
    end

    class UnparseableMetadata < Generic
      def initialize(filename, error)
        super("Could not parse metadata for #{filename}: #{error.message}")
      end
    end

    class InvalidMetadata < Generic
      def initialize(filename, klass)
        super("The file #{filename} has invalid metadata (expected key-value pairs, found #{klass} instead)")
      end
    end

    class InvalidEncoding < Generic
      def initialize(filename, encoding)
        super("Could not read #{filename} because the file is not valid #{encoding}.")
      end
    end

    class FileUnreadable < Generic
      def initialize(filename, error)
        super("Could not read #{filename}: #{error.inspect}")
      end
    end
  end
end
nanoc-4.4.7/lib/nanoc/data_sources/filesystem/tools.rb0000644000004100000410000001244713033443476023064 0ustar  www-datawww-dataclass Nanoc::DataSources::Filesystem < Nanoc::DataSource
  # Contains useful functions for managing the filesystem.
  #
  # @api private
  module Tools
    # Error that is raised when too many symlink indirections are encountered.
    class MaxSymlinkDepthExceededError < ::Nanoc::Int::Errors::GenericTrivial
      # @return [String] The last filename that was attempted to be
      #   resolved before giving up
      attr_reader :filename

      # @param [String] filename The last filename that was attempted to be
      #   resolved before giving up
      def initialize(filename)
        @filename = filename
        super("Too many indirections while resolving symlinks. I gave up after finding out #{filename} was yet another symlink. Sorry!")
      end
    end

    # Error that is raised when a file of an unknown type is encountered
    # (something other than file, directory or link).
    class UnsupportedFileTypeError < ::Nanoc::Int::Errors::GenericTrivial
      # @return [String] The filename of the file whose type is not supported
      attr_reader :filename

      # @param [String] filename The filename of the file whose type is not
      #   supported
      def initialize(filename)
        @filename = filename
        super("The file at #{filename} is of an unsupported type (expected file, directory or link, but it is #{File.ftype(filename)}")
      end
    end

    # Returns all files in the given directory and directories below it,
    # following symlinks up to a maximum of `recursion_limit` times.
    #
    # @param [String] dir_name The name of the directory whose contents to
    #   fetch
    #
    # @param [String, Array, nil] extra_files The list of extra patterns
    #   to extend the file search for files not found by default, example
    #   "**/.{htaccess,htpasswd}"
    #
    # @param [Integer] recursion_limit The maximum number of times to
    #   recurse into a symlink to a directory
    #
    # @return [Array] A list of file names
    #
    # @raise [MaxSymlinkDepthExceededError] if too many indirections are
    #   encountered while resolving symlinks
    #
    # @raise [UnsupportedFileTypeError] if a file of an unsupported type is
    #   detected (something other than file, directory or link)
    def all_files_in(dir_name, extra_files, recursion_limit = 10)
      all_files_and_dirs_in(dir_name, extra_files).map do |fn|
        case File.ftype(fn)
        when 'link'
          if recursion_limit.zero?
            raise MaxSymlinkDepthExceededError.new(fn)
          else
            absolute_target = resolve_symlink(fn)
            if File.file?(absolute_target)
              fn
            else
              all_files_in(absolute_target, extra_files, recursion_limit - 1).map do |sfn|
                fn + sfn[absolute_target.size..-1]
              end
            end
          end
        when 'file'
          fn
        when 'directory'
          nil
        else
          raise UnsupportedFileTypeError.new(fn)
        end
      end.compact.flatten
    end
    module_function :all_files_in

    # Returns all files and directories in the given directory and
    # directories below it.
    #
    # @param [String] dir_name The name of the directory whose contents to
    #   fetch
    #
    # @param [String, Array, nil] extra_files The list of extra patterns
    #   to extend the file search for files not found by default, example
    #   "**/.{htaccess,htpasswd}"
    #
    # @return [Array] A list of files and directories
    #
    # @raise [GenericTrivial] when pattern can not be handled
    def all_files_and_dirs_in(dir_name, extra_files)
      base_patterns = ["#{dir_name}/**/*"]

      extra_patterns =
        case extra_files
        when nil
          []
        when String
          ["#{dir_name}/#{extra_files}"]
        when Array
          extra_files.map { |extra_file| "#{dir_name}/#{extra_file}" }
        else
          raise(
            Nanoc::Int::Errors::GenericTrivial,
            "Do not know how to handle extra_files: #{extra_files.inspect}",
          )
        end

      patterns = base_patterns + extra_patterns
      Dir.glob(patterns)
    end
    module_function :all_files_and_dirs_in

    # Resolves the given symlink into an absolute path.
    #
    # @param [String] filename The filename of the symlink to resolve
    #
    # @param [Integer] recursion_limit The maximum number of times to recurse
    #   into a symlink
    #
    # @return [String] The absolute resolved filename of the symlink target
    #
    # @raise [MaxSymlinkDepthExceededError] if too many indirections are
    #   encountered while resolving symlinks
    #
    # @raise [UnsupportedFileTypeError] if a file of an unsupported type is
    #   detected (something other than file, directory or link)
    def resolve_symlink(filename, recursion_limit = 5)
      target = File.readlink(filename)
      absolute_target = File.expand_path(target, File.dirname(filename))

      case File.ftype(absolute_target)
      when 'link'
        if recursion_limit.zero?
          raise MaxSymlinkDepthExceededError.new(absolute_target)
        else
          resolve_symlink(absolute_target, recursion_limit - 1)
        end
      when 'file', 'directory'
        absolute_target
      else
        raise UnsupportedFileTypeError.new(absolute_target)
      end
    end
    module_function :resolve_symlink
  end
end
nanoc-4.4.7/lib/nanoc/data_sources/filesystem.rb0000644000004100000410000003514613033443476021725 0ustar  www-datawww-datamodule Nanoc::DataSources
  # The filesystem data source stores its items and layouts in nested
  # directories. Items and layouts are represented by one or two files; if it
  # is represented using one file, the metadata can be contained in this file.
  #
  # The default root directory for items is the `content` directory; for
  # layouts, this is the `layouts` directory. This can be overridden
  # in the data source configuration:
  #
  #     data_sources:
  #       - type:         filesystem
  #         content_dir:  items
  #         layouts_dir:  layouts
  #
  # The metadata for items and layouts can be stored in a separate file with
  # the same base name but with the `.yaml` extension. If such a file is
  # found, metadata is read from that file. Alternatively, the content file
  # itself can start with a metadata section: it can be stored at the top of
  # the file, between `---` (three dashes) separators. For example:
  #
  #     ---
  #     title: "Moo!"
  #     ---
  #     h1. Hello!
  #
  # The metadata section can be omitted. If the file does not start with
  # three or five dashes, the entire file will be considered as content.
  #
  # The identifier of items and layouts is the filename itself, without the
  # root directory (as determined by the `content_dir` or `layouts_dir`
  # configuration attribute, for items resp. layouts). For example:
  #
  #     foo/bar/index.html → /foo/bar/index.html
  #     foo/bar.html       → /foo/bar.html
  #
  # Note that each item must have an unique identifier. Nanoc will display an
  # error if two items with the same identifier are found.
  #
  # The file extension does not determine the filters to run on items; the
  # Rules file is used to specify processing instructors for each item.
  #
  # It is possible to set an explicit encoding that should be used when reading
  # files. In the data source configuration, set `encoding` to an encoding
  # understood by Ruby’s `Encoding`. If no encoding is set in the configuration,
  # one will be inferred from the environment.
  #
  # @api private
  class Filesystem < Nanoc::DataSource
    # See {Nanoc::DataSource#up}.
    def up; end

    # See {Nanoc::DataSource#down}.
    def down; end

    def content_dir_name
      config.fetch(:content_dir, 'content')
    end

    def layouts_dir_name
      config.fetch(:layouts_dir, 'layouts')
    end

    # See {Nanoc::DataSource#items}.
    def items
      load_objects(content_dir_name, Nanoc::Int::Item)
    end

    # See {Nanoc::DataSource#layouts}.
    def layouts
      load_objects(layouts_dir_name, Nanoc::Int::Layout)
    end

    protected

    class ProtoDocument
      attr_reader :attributes
      attr_reader :content_checksum_data
      attr_reader :attributes_checksum_data
      attr_reader :is_binary
      alias binary? is_binary

      def initialize(is_binary:, content: nil, filename: nil, attributes:, content_checksum_data: nil, attributes_checksum_data: nil)
        if content.nil? && filename.nil?
          raise ArgumentError, '#initialize needs at least content or filename'
        end

        @is_binary = is_binary
        @content = content
        @filename = filename
        @attributes = attributes
        @content_checksum_data = content_checksum_data
        @attributes_checksum_data = attributes_checksum_data
      end

      def content
        if binary?
          raise ArgumentError, 'cannot fetch content of binary item'
        else
          @content
        end
      end

      def filename
        if binary?
          @filename
        else
          raise ArgumentError, 'cannot fetch filename of non-binary item'
        end
      end
    end

    def read_proto_document(content_filename, meta_filename, klass)
      is_binary = content_filename && !@site_config[:text_extensions].include?(File.extname(content_filename)[1..-1])

      if is_binary && klass == Nanoc::Int::Item
        meta = (meta_filename && YAML.load_file(meta_filename)) || {}

        ProtoDocument.new(is_binary: true, filename: content_filename, attributes: meta)
      elsif is_binary && klass == Nanoc::Int::Layout
        raise Errors::BinaryLayout.new(content_filename)
      else
        parse_result = parse(content_filename, meta_filename)

        ProtoDocument.new(
          is_binary: false,
          content: parse_result.content,
          attributes: parse_result.attributes,
          content_checksum_data: parse_result.content,
          attributes_checksum_data: parse_result.attributes_data,
        )
      end
    end

    # Creates instances of klass corresponding to the files in dir_name. The
    # kind attribute indicates the kind of object that is being loaded and is
    # used solely for debugging purposes.
    #
    # This particular implementation loads objects from a filesystem-based
    # data source where content and attributes can be spread over two separate
    # files. The content and meta-file are optional (but at least one of them
    # needs to be present, obviously) and the content file can start with a
    # metadata section.
    #
    # @see Nanoc::DataSources::Filesystem#load_objects
    def load_objects(dir_name, klass)
      res = []

      return [] if dir_name.nil?

      all_split_files_in(dir_name).each do |base_filename, (meta_ext, content_exts)|
        content_exts.each do |content_ext|
          meta_filename    = filename_for(base_filename, meta_ext)
          content_filename = filename_for(base_filename, content_ext)

          proto_doc = read_proto_document(content_filename, meta_filename, klass)

          content = content_for(proto_doc, content_filename)
          attributes = attributes_for(proto_doc, content_filename, meta_filename)
          identifier = identifier_for(content_filename, meta_filename, dir_name)

          res << klass.new(
            content,
            attributes,
            identifier,
            content_checksum_data: proto_doc.content_checksum_data,
            attributes_checksum_data: attributes_checksum_data_for(proto_doc, content_filename, meta_filename),
          )
        end
      end

      res
    end

    def attributes_checksum_data_for(proto_doc, content_filename, meta_filename)
      YAML.dump(
        attributes: proto_doc.attributes_checksum_data,
        extra_attributes: extra_attributes_for(content_filename, meta_filename),
      )
    end

    def extra_attributes_for(content_filename, meta_filename)
      {
        filename: content_filename,
        content_filename: content_filename,
        meta_filename: meta_filename,
        extension: content_filename ? ext_of(content_filename)[1..-1] : nil,
        mtime: mtime_of(content_filename, meta_filename),
      }
    end

    def attributes_for(proto_doc, content_filename, meta_filename)
      extra_attributes_for(content_filename, meta_filename).merge(proto_doc.attributes)
    end

    def identifier_for(content_filename, meta_filename, dir_name)
      if content_filename
        identifier_for_filename(content_filename[dir_name.length..-1])
      elsif meta_filename
        identifier_for_filename(meta_filename[dir_name.length..-1])
      else
        raise 'meta_filename and content_filename are both nil'
      end
    end

    def content_for(proto_doc, content_filename)
      full_content_filename = content_filename && File.expand_path(content_filename)

      if proto_doc.binary?
        Nanoc::Int::BinaryContent.new(full_content_filename)
      else
        Nanoc::Int::TextualContent.new(proto_doc.content, filename: full_content_filename)
      end
    end

    def mtime_of(content_filename, meta_filename)
      meta_mtime = meta_filename ? File.stat(meta_filename).mtime : nil
      content_mtime = content_filename ? File.stat(content_filename).mtime : nil
      if meta_mtime && content_mtime
        meta_mtime > content_mtime ? meta_mtime : content_mtime
      elsif meta_mtime
        meta_mtime
      elsif content_mtime
        content_mtime
      else
        raise 'meta_mtime and content_mtime are both nil'
      end
    end

    # e.g.
    #
    #   {
    #     'content/foo' => [ 'yaml', ['html', 'md'] ],
    #     'content/bar' => [ 'yaml', [nil]          ],
    #     'content/qux' => [ nil,    ['html']       ]
    #   }
    def all_split_files_in(dir_name)
      by_basename =
        all_files_in(dir_name)
        .reject   { |fn| fn =~ /(~|\.orig|\.rej|\.bak)$/ }
        .group_by { |fn| basename_of(fn) }

      all = {}

      by_basename.each_pair do |basename, filenames|
        # Divide
        meta_filenames    = filenames.select { |fn| ext_of(fn) == '.yaml' }
        content_filenames = filenames.select { |fn| ext_of(fn) != '.yaml' }

        # Check number of files per type
        unless [0, 1].include?(meta_filenames.size)
          raise Errors::MultipleMetaFiles.new(meta_filenames, basename)
        end
        unless config[:identifier_type] == 'full'
          unless [0, 1].include?(content_filenames.size)
            raise Errors::MultipleContentFiles.new(meta_filenames, basename)
          end
        end

        all[basename] = []
        all[basename][0] =
          meta_filenames[0] ? 'yaml' : nil
        all[basename][1] =
          content_filenames.any? ? content_filenames.map { |fn| ext_of(fn)[1..-1] || '' } : [nil]
      end

      all
    end

    # Returns all files in the given directory and directories below it.
    def all_files_in(dir_name)
      Nanoc::DataSources::Filesystem::Tools.all_files_in(dir_name, config[:extra_files])
    end

    # Returns the filename for the given base filename and the extension.
    #
    # If the extension is nil, this function should return nil as well.
    #
    # A simple implementation would simply concatenate the base filename, a
    # period and an extension (which is what the
    # {Nanoc::DataSources::FilesystemCompact} data source does), but other
    # data sources may prefer to implement this differently (for example,
    # {Nanoc::DataSources::FilesystemVerbose} doubles the last part of the
    # basename before concatenating it with a period and the extension).
    def filename_for(base_filename, ext)
      if ext.nil?
        nil
      elsif ext.empty?
        base_filename
      else
        base_filename + '.' + ext
      end
    end

    # Returns the identifier that corresponds with the given filename, which
    # can be the content filename or the meta filename.
    def identifier_for_filename(filename)
      if config[:identifier_type] == 'full'
        return Nanoc::Identifier.new(filename)
      end

      regex =
        if filename =~ /(^|\/)index(\.[^\/]+)?$/
          @config && @config[:allow_periods_in_identifiers] ? /\/?(index)?(\.[^\/\.]+)?$/ : /\/?index(\.[^\/]+)?$/
        else
          @config && @config[:allow_periods_in_identifiers] ? /\.[^\/\.]+$/ : /\.[^\/]+$/
        end
      Nanoc::Identifier.new(filename.sub(regex, ''), type: :legacy)
    end

    # Returns the base name of filename, i.e. filename with the first or all
    # extensions stripped off. By default, all extensions are stripped off,
    # but when allow_periods_in_identifiers is set to true in the site
    # configuration, only the last extension will be stripped .
    def basename_of(filename)
      filename.sub(extension_regex, '')
    end

    # Returns the extension(s) of filename. Supports multiple extensions.
    # Includes the leading period.
    def ext_of(filename)
      filename =~ extension_regex ? Regexp.last_match[1] : ''
    end

    # Returns a regex that is used for determining the extension of a file
    # name. The first match group will be the entire extension, including the
    # leading period.
    #
    # @return [Regex]
    def extension_regex
      if @config && @config[:allow_periods_in_identifiers]
        /(\.[^\/\.]+$)/
      else
        /(\.[^\/]+$)/
      end
    end

    # @return [ParseResult]
    def parse(content_filename, meta_filename)
      if meta_filename
        parse_with_separate_meta_filename(content_filename, meta_filename)
      else
        parse_with_frontmatter(content_filename)
      end
    end

    # @return [ParseResult]
    def parse_with_separate_meta_filename(content_filename, meta_filename)
      content = content_filename ? read(content_filename) : ''
      meta_raw = read(meta_filename)
      meta = parse_metadata(meta_raw, meta_filename)
      ParseResult.new(content: content, attributes: meta, attributes_data: meta_raw)
    end

    # @return [ParseResult]
    def parse_with_frontmatter(content_filename)
      data = read(content_filename)

      if data !~ /\A-{3,5}\s*$/
        return ParseResult.new(content: data, attributes: {}, attributes_data: '')
      end

      pieces = data.split(/^(-{5}|-{3})[ \t]*\r?\n?/, 3)
      if pieces.size < 4
        raise Errors::InvalidFormat.new(content_filename)
      end

      meta = parse_metadata(pieces[2], content_filename)
      content = pieces[4]

      ParseResult.new(content: content, attributes: meta, attributes_data: pieces[2])
    end

    # @return [Hash]
    def parse_metadata(data, filename)
      begin
        meta = YAML.load(data) || {}
      rescue => e
        raise Errors::UnparseableMetadata.new(filename, e)
      end

      verify_meta(meta, filename)

      meta
    end

    class ParseResult
      attr_reader :content
      attr_reader :attributes
      attr_reader :attributes_data

      def initialize(content:, attributes:, attributes_data:)
        @content = content
        @attributes = attributes
        @attributes_data = attributes_data
      end
    end

    def verify_meta(meta, filename)
      return if meta.is_a?(Hash)

      raise Errors::InvalidMetadata.new(filename, meta.class)
    end

    # Reads the content of the file with the given name and returns a string
    # in UTF-8 encoding. The original encoding of the string is derived from
    # the default external encoding, but this can be overridden by the
    # “encoding” configuration attribute in the data source configuration.
    def read(filename)
      # Read
      begin
        data = File.read(filename)
      rescue => e
        raise Errors::FileUnreadable.new(filename, e)
      end

      # Fix
      if data.respond_to?(:encode!)
        if @config && @config[:encoding]
          original_encoding = Encoding.find(@config[:encoding])
          data.force_encoding(@config[:encoding])
        else
          original_encoding = data.encoding
        end

        begin
          data.encode!('UTF-8')
        rescue
          raise Errors::InvalidEncoding.new(filename, original_encoding)
        end

        unless data.valid_encoding?
          raise Errors::InvalidEncoding.new(filename, original_encoding)
        end
      end

      # Remove UTF-8 BOM (ugly)
      data.delete!("\xEF\xBB\xBF")

      data
    end
  end
end

require_relative 'filesystem/tools'
require_relative 'filesystem/errors'
nanoc-4.4.7/lib/nanoc/data_sources.rb0000644000004100000410000000036413033443476017533 0ustar  www-datawww-data# @api private
module Nanoc::DataSources
end

require_relative 'data_sources/filesystem'

Nanoc::DataSource.register ::Nanoc::DataSources::Filesystem, :filesystem
Nanoc::DataSource.register ::Nanoc::DataSources::Filesystem, :filesystem_unified
nanoc-4.4.7/test/0000755000004100000410000000000013033443476013642 5ustar  www-datawww-datananoc-4.4.7/test/base/0000755000004100000410000000000013033443476014554 5ustar  www-datawww-datananoc-4.4.7/test/base/test_outdatedness_checker.rb0000644000004100000410000003757013033443476022342 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Int::OutdatednessCheckerTest < Nanoc::TestCase
  def test_not_outdated
    # Compile once
    with_site(name: 'foo') do |site|
      File.open('content/index.html', 'w') { |io| io.write('o hello') }
      File.open('lib/stuff.rb', 'w') { |io| io.write('$foo = 123') }

      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile
    end

    # Check
    with_site(name: 'foo') do |site|
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compiler.build_reps
      site.compiler.load_stores
      outdatedness_checker = site.compiler.send :outdatedness_checker
      rep = site.compiler.reps[site.items.find { |i| i.identifier == '/' }][0]
      assert_nil outdatedness_checker.outdatedness_reason_for(rep)
    end
  end

  def test_outdated_if_item_checksum_nil
    # Compile once
    with_site(name: 'foo') do |site|
      File.open('content/index.html', 'w') { |io| io.write('o hello') }
      File.open('lib/stuff.rb', 'w') { |io| io.write('$foo = 123') }

      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile
    end

    # Delete checksums
    with_site(name: 'foo') do |_site|
      FileUtils.rm('tmp/checksums')
    end

    # Check
    with_site(name: 'foo') do |site|
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compiler.build_reps
      site.compiler.load_stores
      outdatedness_checker = site.compiler.send :outdatedness_checker
      rep = site.compiler.reps[site.items.find { |i| i.identifier == '/' }][0]
      assert_equal ::Nanoc::Int::OutdatednessReasons::ContentModified, outdatedness_checker.outdatedness_reason_for(rep)
    end
  end

  def test_outdated_if_compiled_file_doesnt_exist
    # Compile once
    with_site(name: 'foo') do |site|
      File.open('content/index.html', 'w') { |io| io.write('o hello') }
      File.open('lib/stuff.rb', 'w') { |io| io.write('$foo = 123') }

      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile
    end

    # Delete old item
    FileUtils.cd('foo') do
      FileUtils.rm_rf('output/index.html')
    end

    # Check
    with_site(name: 'foo') do |site|
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compiler.build_reps
      site.compiler.load_stores
      outdatedness_checker = site.compiler.send :outdatedness_checker
      rep = site.compiler.reps[site.items.find { |i| i.identifier == '/' }][0]
      assert_equal ::Nanoc::Int::OutdatednessReasons::NotWritten, outdatedness_checker.outdatedness_reason_for(rep)
    end
  end

  def test_outdated_if_item_content_checksum_is_different
    # Compile once
    with_site(name: 'foo') do |site|
      File.open('content/index.html', 'w') { |io| io.write('o hello') }
      File.open('content/new.html', 'w') { |io| io.write('o hello too') }
      File.open('lib/stuff.rb', 'w') { |io| io.write('$foo = 123') }

      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile
    end

    # Update item
    FileUtils.cd('foo') do
      File.open('content/new.html', 'w') { |io| io.write('o hello DIFFERENT!!!') }
    end

    # Check
    with_site(name: 'foo') do |site|
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compiler.build_reps
      site.compiler.load_stores
      outdatedness_checker = site.compiler.send :outdatedness_checker
      rep = site.compiler.reps[site.items.find { |i| i.identifier == '/new/' }][0]
      assert_equal ::Nanoc::Int::OutdatednessReasons::ContentModified, outdatedness_checker.outdatedness_reason_for(rep)
    end
  end

  def test_outdated_if_item_attributes_checksum_is_different
    # Compile once
    with_site(name: 'foo') do |site|
      File.open('content/index.html', 'w') { |io| io.write('o hello') }
      File.open('content/new.html', 'w') { |io| io.write('o hello too') }
      File.open('lib/stuff.rb', 'w') { |io| io.write('$foo = 123') }

      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile
    end

    # Update item
    FileUtils.cd('foo') do
      File.open('content/new.html', 'w') { |io| io.write("---\ntitle: donkey\n---\no hello too") }
    end

    # Check
    with_site(name: 'foo') do |site|
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compiler.build_reps
      site.compiler.load_stores
      outdatedness_checker = site.compiler.send :outdatedness_checker
      rep = site.compiler.reps[site.items.find { |i| i.identifier == '/new/' }][0]
      assert_equal ::Nanoc::Int::OutdatednessReasons::AttributesModified, outdatedness_checker.outdatedness_reason_for(rep)
    end
  end

  def test_outdated_if_dependent_layout_outdated
    # Compile once
    with_site(name: 'foo', compilation_rule_content: 'layout "/default/"', has_layout: true) do |site|
      File.open('content/index.html', 'w') { |io| io.write('o hello') }
      File.open('layouts/default.html', 'w') { |io| io.write('!!! <%= yield %> !!!') }

      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile
    end

    # Change layout
    FileUtils.cd('foo') do
      File.open('layouts/default.html', 'w') { |io| io.write('!!! <%= yield %> !!! different') }
    end

    # Check
    with_site(name: 'foo') do |site|
      # FIXME: ugly fugly hack
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compiler.build_reps
      site.compiler.load_stores

      outdatedness_checker = site.compiler.send :outdatedness_checker
      rep = site.compiler.reps[site.items.find { |i| i.identifier == '/' }][0]
      assert_equal ::Nanoc::Int::OutdatednessReasons::DependenciesOutdated, outdatedness_checker.outdatedness_reason_for(rep)
    end
  end

  def test_outdated_if_dependent_item_outdated
    # Compile once
    with_site(name: 'foo', compilation_rule_content: 'filter :erb') do |site|
      File.open('content/a.html', 'w') do |io|
        io.write('<%= @items.find { |i| i.identifier == "/b/" }.compiled_content %>')
      end
      File.open('content/b.html', 'w') do |io|
        io.write('stuff')
      end

      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile
    end

    # Change item
    FileUtils.cd('foo') do
      File.open('content/b.html', 'w') do |io|
        io.write('stuff different!!!')
      end
    end

    # Check
    with_site(name: 'foo') do |site|
      # FIXME: ugly fugly hack
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compiler.build_reps
      site.compiler.load_stores

      outdatedness_checker = site.compiler.send :outdatedness_checker
      rep = site.compiler.reps[site.items.find { |i| i.identifier == '/a/' }][0]
      assert_equal ::Nanoc::Int::OutdatednessReasons::DependenciesOutdated, outdatedness_checker.outdatedness_reason_for(rep)
    end
  end

  def test_outdated_if_dependent_item_outdated_chained
    # Compile once
    with_site(name: 'foo', compilation_rule_content: 'filter :erb') do |site|
      File.open('content/a.html', 'w') do |io|
        io.write('<%= @items.find { |i| i.identifier == "/b/" }.compiled_content %> aaa')
      end
      File.open('content/b.html', 'w') do |io|
        io.write('<%= @items.find { |i| i.identifier == "/c/" }.compiled_content %> bbb')
      end
      File.open('content/c.html', 'w') do |io|
        io.write('stuff')
      end

      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile
    end

    # Change item
    FileUtils.cd('foo') do
      File.open('content/c.html', 'w') do |io|
        io.write('stuff different!!!')
      end
    end

    # Check
    with_site(name: 'foo') do |site|
      # FIXME: ugly fugly hack
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compiler.build_reps
      site.compiler.load_stores

      outdatedness_checker = site.compiler.send :outdatedness_checker
      rep = site.compiler.reps[site.items.find { |i| i.identifier == '/a/' }][0]
      assert_equal ::Nanoc::Int::OutdatednessReasons::DependenciesOutdated, outdatedness_checker.outdatedness_reason_for(rep)
    end
  end

  def test_outdated_if_dependent_item_removed
    # Compile once
    with_site(name: 'foo', compilation_rule_content: 'filter :erb') do |site|
      File.open('content/a.html', 'w') do |io|
        io.write('<% @items.select { |i| i.identifier != @item.identifier }.each do |i| %>')
        io.write('  <%= i.compiled_content %>')
        io.write('<% end %>')
      end
      File.open('content/b.html', 'w') do |io|
        io.write('stuff')
      end

      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile
    end

    # Delete item
    FileUtils.cd('foo') do
      FileUtils.rm_rf('content/b.html')
    end

    # Check
    with_site(name: 'foo') do |site|
      # FIXME: ugly fugly hack
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compiler.build_reps
      site.compiler.load_stores

      outdatedness_checker = site.compiler.send :outdatedness_checker
      rep = site.compiler.reps[site.items.find { |i| i.identifier == '/a/' }][0]
      assert_equal ::Nanoc::Int::OutdatednessReasons::DependenciesOutdated, outdatedness_checker.outdatedness_reason_for(rep)
    end
  end

  def test_outdated_if_dependent_item_added
    # Compile once
    with_site(name: 'foo', compilation_rule_content: 'filter :erb') do |site|
      File.open('content/a.html', 'w') do |io|
        io.write('<% @items.select { |i| i.identifier != @item.identifier }.each do |i| %>')
        io.write('  <%= i.compiled_content %>')
        io.write('<% end %>')
      end
      File.open('content/b.html', 'w') do |io|
        io.write('stuff')
      end

      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile
    end

    # Add item
    FileUtils.cd('foo') do
      File.open('content/z.html', 'w') do |io|
        io.write('moar stuff')
      end
    end

    # Check
    with_site(name: 'foo') do |site|
      # FIXME: ugly fugly hack
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compiler.build_reps
      site.compiler.load_stores

      outdatedness_checker = site.compiler.send :outdatedness_checker
      rep = site.compiler.reps[site.items.find { |i| i.identifier == '/a/' }][0]
      assert_equal ::Nanoc::Int::OutdatednessReasons::DependenciesOutdated, outdatedness_checker.outdatedness_reason_for(rep)
    end
  end

  # TODO: make sure outdatedness of non-outdated items is correct

  def test_outdated_if_code_snippets_outdated
    # Compile once
    with_site(name: 'foo') do |site|
      File.open('content/index.html', 'w') { |io| io.write('o hello') }

      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile
    end

    # Change code
    FileUtils.cd('foo') do
      File.open('lib/moo.rb', 'w') { |io| io.write('def moo ; puts "moo" ; end') }
    end

    # Check
    with_site(name: 'foo') do |site|
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compiler.build_reps
      site.compiler.load_stores
      outdatedness_checker = site.compiler.send :outdatedness_checker
      rep = site.compiler.reps[site.items.find { |i| i.identifier == '/' }][0]
      assert_equal ::Nanoc::Int::OutdatednessReasons::CodeSnippetsModified, outdatedness_checker.outdatedness_reason_for(rep)
    end
  end

  def test_outdated_if_config_outdated
    # Compile once
    with_site(name: 'foo') do |site|
      File.open('content/index.html', 'w') { |io| io.write('o hello') }

      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile
    end

    # Change code
    FileUtils.cd('foo') do
      File.open('nanoc.yaml', 'w') do |io|
        io << 'awesome: true' << "\n"
        io << 'string_pattern_type: legacy' << "\n"
        io << 'data_sources:' << "\n"
        io << '  -' << "\n"
        io << '    type: filesystem' << "\n"
        io << '    identifier_type: legacy' << "\n"
      end
    end

    # Check
    with_site(name: 'foo') do |site|
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compiler.build_reps
      site.compiler.load_stores
      outdatedness_checker = site.compiler.send :outdatedness_checker
      rep = site.compiler.reps[site.items.find { |i| i.identifier == '/' }][0]
      assert_equal ::Nanoc::Int::OutdatednessReasons::ConfigurationModified, outdatedness_checker.outdatedness_reason_for(rep)
    end
  end

  def test_not_outdated_if_irrelevant_rule_modified
    # Compile once
    with_site(name: 'foo') do |site|
      File.open('content/index.html', 'w') { |io| io.write('o hello') }

      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile
    end

    # Change code
    FileUtils.cd('foo') do
      File.open('Rules', 'a') { |io| io.write('layout "/moo/", :haml') }
    end

    # Check
    with_site(name: 'foo') do |site|
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compiler.build_reps
      site.compiler.load_stores
      outdatedness_checker = site.compiler.send :outdatedness_checker
      rep = site.compiler.reps[site.items.find { |i| i.identifier == '/' }][0]
      assert_nil outdatedness_checker.outdatedness_reason_for(rep)
    end
  end

  def test_outdated_if_relevant_rule_modified
    # Create site
    with_site(name: 'foo') do |_site|
      File.open('content/index.html', 'w') { |io| io.write('o hello') }
      File.open('Rules', 'w') do |io|
        io.write("compile '/' do\n")
        io.write("  filter :erb\n")
        io.write("end\n")
        io.write("\n")
        io.write("route '/' do\n")
        io.write("  '/index.html'\n")
        io.write("end\n")
      end
    end

    # Compile once
    FileUtils.cd('foo') do
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile
    end

    # Modify rules
    FileUtils.cd('foo') do
      File.open('Rules', 'w') do |io|
        io.write("compile '/' do\n")
        io.write("end\n")
        io.write("\n")
        io.write("route '/' do\n")
        io.write("  '/index.html'\n")
        io.write("end\n")
      end
    end

    # Check
    FileUtils.cd('foo') do
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compiler.build_reps
      site.compiler.load_stores
      outdatedness_checker = site.compiler.send :outdatedness_checker
      rep = site.compiler.reps[site.items.find { |i| i.identifier == '/' }][0]
      assert_equal ::Nanoc::Int::OutdatednessReasons::RulesModified, outdatedness_checker.outdatedness_reason_for(rep)
    end
  end

  def test_items_in_rules_should_not_cause_outdatedness
    # Create site
    with_site(name: 'foo') do |_site|
      File.open('content/index.html', 'w') { |io| io.write('o hello') }
      File.open('Rules', 'w') do |io|
        io.write("compile '/' do\n")
        io.write("  filter :erb, :stuff => @items\n")
        io.write("end\n")
        io.write("\n")
        io.write("route '/' do\n")
        io.write("  '/index.html'\n")
        io.write("end\n")
      end
    end

    # Compile
    FileUtils.cd('foo') do
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile
    end

    # Assert not outdated
    FileUtils.cd('foo') do
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      outdatedness_checker = site.compiler.outdatedness_checker
      site.items.each do |item|
        refute outdatedness_checker.outdated?(item), 'item should not be outdated'
      end
    end
  end

  def test_non_serializable_parameters_in_rules_should_be_allowed
    # Create site
    with_site(name: 'foo') do |_site|
      File.open('content/index.html', 'w') { |io| io.write('o hello') }
      File.open('Rules', 'w') do |io|
        io.write("compile '/' do\n")
        io.write("  c = Class.new {}\n")
        io.write("  def c.inspect ; 'I am so classy' ; end\n")
        io.write("  filter :erb, :stuff => c, :more => 123\n")
        io.write("end\n")
        io.write("\n")
        io.write("route '/' do\n")
        io.write("  '/index.html'\n")
        io.write("end\n")
      end
    end

    # Compile
    FileUtils.cd('foo') do
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile
    end

    # Assert not outdated
    FileUtils.cd('foo') do
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      outdatedness_checker = site.compiler.outdatedness_checker
      site.items.each do |item|
        refute outdatedness_checker.outdated?(item), 'item should not be outdated'
      end
    end
  end
end
nanoc-4.4.7/test/base/test_item_array.rb0000644000004100000410000000347713033443476020307 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Int::IdentifiableCollectionTest < Nanoc::TestCase
  def setup
    super

    @one = Nanoc::Int::Item.new('Item One', {}, '/one/')
    @two = Nanoc::Int::Item.new('Item Two', {}, '/two/')

    @items = Nanoc::Int::IdentifiableCollection.new({})
    @items << @one
    @items << @two
  end

  def test_change_item_identifier
    assert_equal @one, @items['/one/']
    assert_nil @items['/foo/']

    @one.identifier = '/foo/'

    assert_nil @items['/one/']
    assert_equal @one, @items['/foo/']
  end

  def test_enumerable
    assert_equal @one, @items.find { |i| i.identifier == '/one/' }
  end

  def test_brackets_with_glob
    @items = Nanoc::Int::IdentifiableCollection.new(string_pattern_type: 'glob')
    @items << @one
    @items << @two

    assert_equal @one, @items['/on*/']
    assert_equal @two, @items['/*wo/']
  end

  def test_brackets_with_identifier
    assert_equal @one, @items['/one/']
    assert_equal @two, @items['/two/']
    assert_nil @items['/max-payne/']
  end

  def test_brackets_with_malformed_identifier
    assert_nil @items['one/']
    assert_nil @items['/one']
    assert_nil @items['one']
    assert_nil @items['//one/']
  end

  def test_brackets_frozen
    @items.freeze

    assert_equal @one, @items['/one/']
    assert_nil @items['/tenthousand/']
  end

  def test_regex
    foo = Nanoc::Int::Item.new('Item Foo', {}, '/foo/')
    @items << foo

    assert_equal @one, @items[/n/]
    assert_equal @two, @items[%r{o/}] # not foo
  end

  def test_less_than_less_than
    assert_nil @items['/foo/']

    foo = Nanoc::Int::Item.new('Item Foo', {}, '/foo/')
    @items << foo

    assert_equal foo, @items['/foo/']
  end

  def test_concat
    new_item = Nanoc::Int::Item.new('New item', {}, '/new/')
    @items.concat([new_item])

    assert_equal new_item, @items['/new/']
  end
end
nanoc-4.4.7/test/base/core_ext/0000755000004100000410000000000013033443476016364 5ustar  www-datawww-datananoc-4.4.7/test/base/core_ext/pathname_spec.rb0000644000004100000410000000000013033443476021506 0ustar  www-datawww-datananoc-4.4.7/test/base/core_ext/hash_spec.rb0000644000004100000410000000211113033443476020641 0ustar  www-datawww-datarequire 'helper'

describe 'Hash#__nanoc_symbolize_keys_recursively' do
  it 'should convert keys to symbols' do
    hash_old = { 'foo' => 'bar' }
    hash_new = { foo: 'bar' }
    hash_old.__nanoc_symbolize_keys_recursively.must_equal hash_new
  end

  it 'should not require string keys' do
    hash_old = { Time.now => 'abc' }
    hash_new = hash_old
    hash_old.__nanoc_symbolize_keys_recursively.must_equal hash_new
  end
end

describe 'Hash#__nanoc_freeze_recursively' do
  include Nanoc::TestHelpers

  it 'should prevent first-level elements from being modified' do
    hash = { a: { b: :c } }
    hash.__nanoc_freeze_recursively

    assert_raises_frozen_error do
      hash[:a] = 123
    end
  end

  it 'should prevent second-level elements from being modified' do
    hash = { a: { b: :c } }
    hash.__nanoc_freeze_recursively

    assert_raises_frozen_error do
      hash[:a][:b] = 123
    end
  end

  it 'should not freeze infinitely' do
    a = {}
    a[:x] = a

    a.__nanoc_freeze_recursively

    assert a.frozen?
    assert a[:x].frozen?
    assert_equal a, a[:x]
  end
end
nanoc-4.4.7/test/base/core_ext/string_spec.rb0000644000004100000410000000123013033443476021225 0ustar  www-datawww-datarequire 'helper'

describe 'String#__nanoc_cleaned_identifier' do
  it 'should not convert already clean paths' do
    '/foo/bar/'.__nanoc_cleaned_identifier.must_equal '/foo/bar/'
  end

  it 'should prepend slash if necessary' do
    'foo/bar/'.__nanoc_cleaned_identifier.must_equal '/foo/bar/'
  end

  it 'should append slash if necessary' do
    '/foo/bar'.__nanoc_cleaned_identifier.must_equal '/foo/bar/'
  end

  it 'should remove double slashes at start' do
    '//foo/bar/'.__nanoc_cleaned_identifier.must_equal '/foo/bar/'
  end

  it 'should remove double slashes at end' do
    '/foo/bar//'.__nanoc_cleaned_identifier.must_equal '/foo/bar/'
  end
end
nanoc-4.4.7/test/base/core_ext/array_spec.rb0000644000004100000410000000172713033443476021050 0ustar  www-datawww-datarequire 'helper'

describe 'Array#__nanoc_symbolize_keys_recursively' do
  it 'should convert keys to symbols' do
    array_old = [:abc, 'xyz', { 'foo' => 'bar', :baz => :qux }]
    array_new = [:abc, 'xyz', { foo: 'bar', baz: :qux }]
    array_old.__nanoc_symbolize_keys_recursively.must_equal array_new
  end
end

describe 'Array#__nanoc_freeze_recursively' do
  include Nanoc::TestHelpers

  it 'should prevent first-level elements from being modified' do
    array = [:a, [:b, :c], :d]
    array.__nanoc_freeze_recursively

    assert_raises_frozen_error do
      array[0] = 123
    end
  end

  it 'should prevent second-level elements from being modified' do
    array = [:a, [:b, :c], :d]
    array.__nanoc_freeze_recursively

    assert_raises_frozen_error do
      array[1][0] = 123
    end
  end

  it 'should not freeze infinitely' do
    a = []
    a << a

    a.__nanoc_freeze_recursively

    assert a.frozen?
    assert a[0].frozen?
    assert_equal a, a[0]
  end
end
nanoc-4.4.7/test/base/test_dependency_tracker.rb0000644000004100000410000001515413033443476021777 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Int::DependencyTrackerTest < Nanoc::TestCase
  def test_initialize
    # Mock items
    items = [
      Nanoc::Int::Item.new('a', {}, '/a.md'),
      Nanoc::Int::Item.new('b', {}, '/b.md'),
    ]

    # Create
    store = Nanoc::Int::DependencyStore.new(items)

    # Verify no dependencies yet
    assert_empty store.objects_causing_outdatedness_of(items[0])
    assert_empty store.objects_causing_outdatedness_of(items[1])
  end

  def test_record_dependency
    # Mock items
    items = [
      Nanoc::Int::Item.new('a', {}, '/a.md'),
      Nanoc::Int::Item.new('b', {}, '/b.md'),
    ]

    # Create
    store = Nanoc::Int::DependencyStore.new(items)

    # Record some dependencies
    store.record_dependency(items[0], items[1])

    # Verify dependencies
    assert_contains_exactly [items[1]], store.objects_causing_outdatedness_of(items[0])
  end

  def test_record_dependency_no_self
    # Mock items
    items = [
      Nanoc::Int::Item.new('a', {}, '/a.md'),
      Nanoc::Int::Item.new('b', {}, '/b.md'),
    ]

    # Create
    store = Nanoc::Int::DependencyStore.new(items)

    # Record some dependencies
    store.record_dependency(items[0], items[0])
    store.record_dependency(items[0], items[1])

    # Verify dependencies
    assert_contains_exactly [items[1]], store.objects_causing_outdatedness_of(items[0])
  end

  def test_record_dependency_no_doubles
    # Mock items
    items = [
      Nanoc::Int::Item.new('a', {}, '/a.md'),
      Nanoc::Int::Item.new('b', {}, '/b.md'),
    ]

    # Create
    store = Nanoc::Int::DependencyStore.new(items)

    # Record some dependencies
    store.record_dependency(items[0], items[1])
    store.record_dependency(items[0], items[1])
    store.record_dependency(items[0], items[1])

    # Verify dependencies
    assert_contains_exactly [items[1]], store.objects_causing_outdatedness_of(items[0])
  end

  def test_objects_causing_outdatedness_of
    # Mock items
    items = [
      Nanoc::Int::Item.new('a', {}, '/a.md'),
      Nanoc::Int::Item.new('b', {}, '/b.md'),
      Nanoc::Int::Item.new('c', {}, '/c.md'),
    ]

    # Create
    store = Nanoc::Int::DependencyStore.new(items)

    # Record some dependencies
    store.record_dependency(items[0], items[1])
    store.record_dependency(items[1], items[2])

    # Verify dependencies
    assert_contains_exactly [items[1]], store.objects_causing_outdatedness_of(items[0])
  end

  def test_store_graph_and_load_graph_simple
    # Mock items
    items = [
      Nanoc::Int::Item.new('a', {}, '/a.md'),
      Nanoc::Int::Item.new('b', {}, '/b.md'),
      Nanoc::Int::Item.new('c', {}, '/c.md'),
      Nanoc::Int::Item.new('d', {}, '/d.md'),
    ]

    # Create
    store = Nanoc::Int::DependencyStore.new(items)

    # Record some dependencies
    store.record_dependency(items[0], items[1])
    store.record_dependency(items[1], items[2])
    store.record_dependency(items[1], items[3])

    # Store
    store.store
    assert File.file?(store.filename)

    # Re-create
    store = Nanoc::Int::DependencyStore.new(items)

    # Load
    store.load

    # Check loaded graph
    assert_contains_exactly [items[1]],           store.objects_causing_outdatedness_of(items[0])
    assert_contains_exactly [items[2], items[3]], store.objects_causing_outdatedness_of(items[1])
    assert_empty store.objects_causing_outdatedness_of(items[2])
    assert_empty store.objects_causing_outdatedness_of(items[3])
  end

  def test_store_graph_and_load_graph_with_removed_items
    # Mock items
    items = [
      Nanoc::Int::Item.new('a', {}, '/a.md'),
      Nanoc::Int::Item.new('b', {}, '/b.md'),
      Nanoc::Int::Item.new('c', {}, '/c.md'),
      Nanoc::Int::Item.new('d', {}, '/d.md'),
    ]

    # Create new and old lists
    old_items = [items[0], items[1], items[2], items[3]]
    new_items = [items[0], items[1], items[2]]

    # Create
    store = Nanoc::Int::DependencyStore.new(old_items)

    # Record some dependencies
    store.record_dependency(old_items[0], old_items[1])
    store.record_dependency(old_items[1], old_items[2])
    store.record_dependency(old_items[1], old_items[3])

    # Store
    store.store
    assert File.file?(store.filename)

    # Re-create
    store = Nanoc::Int::DependencyStore.new(new_items)

    # Load
    store.load

    # Check loaded graph
    assert_contains_exactly [items[1]],       store.objects_causing_outdatedness_of(items[0])
    assert_contains_exactly [items[2], nil],  store.objects_causing_outdatedness_of(items[1])
    assert_empty store.objects_causing_outdatedness_of(items[2])
  end

  def test_store_graph_with_nils_in_dst
    # Mock items
    items = [
      Nanoc::Int::Item.new('a', {}, '/a.md'),
      Nanoc::Int::Item.new('b', {}, '/b.md'),
      Nanoc::Int::Item.new('c', {}, '/c.md'),
    ]

    # Create
    store = Nanoc::Int::DependencyStore.new(items)

    # Record some dependencies
    store.record_dependency(items[0], items[1])
    store.record_dependency(items[1], nil)

    # Store
    store.store
    assert File.file?(store.filename)

    # Re-create
    store = Nanoc::Int::DependencyStore.new(items)

    # Load
    store.load

    # Check loaded graph
    assert_contains_exactly [items[1]], store.objects_causing_outdatedness_of(items[0])
    assert_contains_exactly [nil],      store.objects_causing_outdatedness_of(items[1])
  end

  def test_store_graph_with_nils_in_src
    # Mock items
    items = [
      Nanoc::Int::Item.new('a', {}, '/a.md'),
      Nanoc::Int::Item.new('b', {}, '/b.md'),
      Nanoc::Int::Item.new('c', {}, '/c.md'),
    ]

    # Create
    store = Nanoc::Int::DependencyStore.new(items)

    # Record some dependencies
    store.record_dependency(items[0], items[1])
    store.record_dependency(nil,      items[2])

    # Store
    store.store
    assert File.file?(store.filename)

    # Re-create
    store = Nanoc::Int::DependencyStore.new(items)

    # Load
    store.load

    # Check loaded graph
    assert_contains_exactly [items[1]], store.objects_causing_outdatedness_of(items[0])
    assert_empty store.objects_causing_outdatedness_of(items[1])
  end

  def test_forget_dependencies_for
    # Mock items
    items = [
      Nanoc::Int::Item.new('a', {}, '/a.md'),
      Nanoc::Int::Item.new('b', {}, '/b.md'),
      Nanoc::Int::Item.new('c', {}, '/c.md'),
    ]

    # Create
    store = Nanoc::Int::DependencyStore.new(items)

    # Record some dependencies
    store.record_dependency(items[0], items[1])
    store.record_dependency(items[1], items[2])
    assert_contains_exactly [items[1]], store.objects_causing_outdatedness_of(items[0])

    # Forget dependencies
    store.forget_dependencies_for(items[0])
    assert_empty store.objects_causing_outdatedness_of(items[0])
  end
end
nanoc-4.4.7/test/base/test_plugin.rb0000644000004100000410000000115013033443476017433 0ustar  www-datawww-datarequire 'helper'

class Nanoc::PluginTest < Nanoc::TestCase
  class SampleFilter < Nanoc::Filter
    identifier :_plugin_test_sample_filter
  end

  def test_named
    # Find existant filter
    filter = Nanoc::Filter.named(:erb)
    assert(!filter.nil?)

    # Find non-existant filter
    filter = Nanoc::Filter.named(:lksdaffhdlkashlgkskahf)
    assert(filter.nil?)
  end

  def test_register
    SampleFilter.send(:identifier, :_plugin_test_sample_filter)

    registry = Nanoc::Int::PluginRegistry.instance
    filter = registry.find(Nanoc::Filter, :_plugin_test_sample_filter)

    refute_nil filter
  end
end
nanoc-4.4.7/test/base/test_directed_graph.rb0000644000004100000410000002404213033443476021106 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Int::DirectedGraphTest < Nanoc::TestCase
  def test_direct_predecessors
    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])
    graph.add_edge(1, 2)
    graph.add_edge(2, 3)

    assert_equal [], graph.direct_predecessors_of(1)
    assert_equal [1], graph.direct_predecessors_of(2)
    assert_equal [2], graph.direct_predecessors_of(3)
  end

  def test_predecessors
    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])
    graph.add_edge(1, 2)
    graph.add_edge(2, 3)

    assert_equal [], graph.predecessors_of(1).sort
    assert_equal [1],    graph.predecessors_of(2).sort
    assert_equal [1, 2], graph.predecessors_of(3).sort
  end

  def test_direct_successors
    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])
    graph.add_edge(1, 2)
    graph.add_edge(2, 3)

    assert_equal [2], graph.direct_successors_of(1)
    assert_equal [3], graph.direct_successors_of(2)
    assert_equal [], graph.direct_successors_of(3)
  end

  def test_successors
    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])
    graph.add_edge(1, 2)
    graph.add_edge(2, 3)

    assert_equal [2, 3], graph.successors_of(1).sort
    assert_equal [3],    graph.successors_of(2).sort
    assert_equal [], graph.successors_of(3).sort
  end

  def test_edges
    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])
    graph.add_edge(1, 2)
    graph.add_edge(2, 3)

    assert_equal [[0, 1, nil], [1, 2, nil]], graph.edges.sort
  end

  def test_edges_with_new_vertices
    graph = Nanoc::Int::DirectedGraph.new([1])
    assert_equal [1], graph.vertices
    graph.add_edge(1, 2)
    assert_equal [1, 2], graph.vertices
    graph.add_edge(3, 2)
    assert_equal [1, 2, 3], graph.vertices

    assert_equal [[0, 1, nil], [2, 1, nil]], graph.edges.sort
  end

  def test_edge_with_props
    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])
    graph.add_edge(1, 2, props: { donkey: 14 })
    graph.add_edge(2, 3, props: { giraffe: 3 })

    assert_equal [[0, 1, { donkey: 14 }], [1, 2, { giraffe: 3 }]], graph.edges.sort
  end

  def test_props_for
    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3, 4])
    graph.add_edge(1, 2, props: { donkey: 14 })
    graph.add_edge(2, 3, props: { giraffe: 3 })
    graph.add_edge(3, 4)

    assert_equal({ donkey: 14 }, graph.props_for(1, 2))
    assert_equal({ giraffe: 3 }, graph.props_for(2, 3))
    assert_equal(nil, graph.props_for(3, 4))
  end

  def test_props_for_with_deleted_edge
    graph = Nanoc::Int::DirectedGraph.new([1, 2])
    graph.add_edge(1, 2, props: { donkey: 14 })
    graph.delete_edge(1, 2)

    assert_equal(nil, graph.props_for(1, 2))
  end

  def test_props_for_with_deleted_edges_from
    graph = Nanoc::Int::DirectedGraph.new([1, 2])
    graph.add_edge(1, 2, props: { donkey: 14 })
    graph.delete_edges_from(1)

    assert_equal(nil, graph.props_for(1, 2))
  end

  def test_props_for_with_deleted_edges_to
    graph = Nanoc::Int::DirectedGraph.new([1, 2])
    graph.add_edge(1, 2, props: { donkey: 14 })
    graph.delete_edges_to(2)

    assert_equal(nil, graph.props_for(1, 2))
  end

  def test_add_edge
    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])

    assert_equal [], graph.successors_of(1)
    assert_equal [], graph.predecessors_of(2)

    graph.add_edge(1, 2)

    assert_equal [2], graph.successors_of(1)
    assert_equal [1], graph.predecessors_of(2)
  end

  def test_add_edge_with_new_vertices
    graph = Nanoc::Int::DirectedGraph.new([1])
    graph.add_edge(1, 2)
    graph.add_edge(3, 2)

    assert graph.vertices.include?(2)
    assert graph.vertices.include?(3)
  end

  def test_delete_edge
    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])
    graph.add_edge(1, 2)

    assert_equal [2], graph.successors_of(1)
    assert_equal [1], graph.predecessors_of(2)

    graph.delete_edge(1, 2)

    assert_equal [], graph.successors_of(1)
    assert_equal [], graph.predecessors_of(2)
  end

  def test_delete_edges_from
    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])

    graph.add_edge(1, 2)
    graph.add_edge(2, 1)
    graph.add_edge(2, 3)
    graph.add_edge(3, 2)
    graph.add_edge(1, 3)
    graph.add_edge(3, 1)

    assert_equal [2, 3], graph.direct_predecessors_of(1).sort
    assert_equal [2, 3], graph.direct_successors_of(1).sort
    assert_equal [1, 3], graph.direct_predecessors_of(2).sort
    assert_equal [1, 3], graph.direct_successors_of(2).sort
    assert_equal [1, 2], graph.direct_predecessors_of(3).sort
    assert_equal [1, 2], graph.direct_successors_of(3).sort
    assert_equal Set.new([]), graph.roots

    graph.delete_edges_from(1)

    assert_equal [2, 3], graph.direct_predecessors_of(1).sort
    assert_equal [], graph.direct_successors_of(1).sort
    assert_equal [3], graph.direct_predecessors_of(2).sort
    assert_equal [1, 3], graph.direct_successors_of(2).sort
    assert_equal [2], graph.direct_predecessors_of(3).sort
    assert_equal [1, 2], graph.direct_successors_of(3).sort
    assert_equal Set.new([]), graph.roots

    graph.delete_edges_from(2)

    assert_equal [3], graph.direct_predecessors_of(1).sort
    assert_equal [], graph.direct_successors_of(1).sort
    assert_equal [3], graph.direct_predecessors_of(2).sort
    assert_equal [], graph.direct_successors_of(2).sort
    assert_equal [], graph.direct_predecessors_of(3).sort
    assert_equal [1, 2], graph.direct_successors_of(3).sort
    assert_equal Set.new([3]), graph.roots
  end

  def test_delete_edges_to
    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])

    graph.add_edge(1, 2)
    graph.add_edge(2, 1)
    graph.add_edge(2, 3)
    graph.add_edge(3, 2)
    graph.add_edge(1, 3)
    graph.add_edge(3, 1)

    assert_equal [2, 3], graph.direct_predecessors_of(1).sort
    assert_equal [2, 3], graph.direct_successors_of(1).sort
    assert_equal [1, 3], graph.direct_predecessors_of(2).sort
    assert_equal [1, 3], graph.direct_successors_of(2).sort
    assert_equal [1, 2], graph.direct_predecessors_of(3).sort
    assert_equal [1, 2], graph.direct_successors_of(3).sort
    assert_equal Set.new([]), graph.roots

    graph.delete_edges_to(1)

    assert_equal [], graph.direct_predecessors_of(1).sort
    assert_equal [2, 3], graph.direct_successors_of(1).sort
    assert_equal [1, 3], graph.direct_predecessors_of(2).sort
    assert_equal [3], graph.direct_successors_of(2).sort
    assert_equal [1, 2], graph.direct_predecessors_of(3).sort
    assert_equal [2], graph.direct_successors_of(3).sort
    assert_equal Set.new([1]), graph.roots

    graph.delete_edges_to(2)

    assert_equal [], graph.direct_predecessors_of(1).sort
    assert_equal [3], graph.direct_successors_of(1).sort
    assert_equal [], graph.direct_predecessors_of(2).sort
    assert_equal [3], graph.direct_successors_of(2).sort
    assert_equal [1, 2], graph.direct_predecessors_of(3).sort
    assert_equal [], graph.direct_successors_of(3).sort
    assert_equal Set.new([1, 2]), graph.roots
  end

  def test_delete_vertex
    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])

    graph.add_edge(1, 2)
    graph.add_edge(2, 1)
    graph.add_edge(2, 3)
    graph.add_edge(3, 2)
    graph.add_edge(1, 3)
    graph.add_edge(3, 1)

    graph.delete_vertex(2)

    assert_equal [3], graph.direct_predecessors_of(1).sort
    assert_equal [3], graph.direct_successors_of(1).sort
    assert_equal [1], graph.direct_predecessors_of(3).sort
    assert_equal [1], graph.direct_successors_of(3).sort
    assert_equal Set.new([]), graph.roots
  end

  def test_delete_vertex_resulting_roots
    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])
    assert_equal Set.new([1, 2, 3]), graph.roots

    graph.add_edge(1, 2)
    graph.add_edge(2, 3)
    assert_equal Set.new([1]), graph.roots

    graph.delete_vertex(2)
    assert_equal Set.new([1, 3]), graph.roots
  end

  def test_should_return_empty_array_for_nonexistant_vertices
    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])

    assert_equal [], graph.direct_predecessors_of(4)
    assert_equal [], graph.predecessors_of(4)
    assert_equal [], graph.direct_successors_of(4)
    assert_equal [], graph.successors_of(4)
  end

  def test_roots_after_init
    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])

    assert_equal Set.new([1, 2, 3]), graph.roots
  end

  def test_roots_after_adding_edge
    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])
    graph.add_edge(1, 2)
    assert_equal Set.new([1, 3]), graph.roots

    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])
    graph.add_edge(1, 3)
    assert_equal Set.new([1, 2]), graph.roots

    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])
    graph.add_edge(2, 1)
    assert_equal Set.new([2, 3]), graph.roots

    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])
    graph.add_edge(1, 2)
    graph.add_edge(2, 3)
    assert_equal Set.new([1]), graph.roots

    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])
    graph.add_edge(1, 2)
    graph.add_edge(2, 3)
    graph.add_edge(3, 1)
    assert_equal Set.new([]), graph.roots
  end

  def test_roots_after_removing_edge
    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])
    graph.add_edge(1, 2)
    graph.delete_edge(1, 2)
    assert_equal Set.new([1, 2, 3]), graph.roots

    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])
    graph.add_edge(1, 3)
    assert_equal Set.new([1, 2]), graph.roots
    graph.delete_edge(1, 2) # no such edge
    assert_equal Set.new([1, 2]), graph.roots

    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])
    graph.add_edge(2, 1)
    graph.delete_edge(2, 1)
    assert_equal Set.new([1, 2, 3]), graph.roots

    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])
    graph.add_edge(1, 2)
    graph.add_edge(2, 3)
    graph.delete_edge(1, 2)
    assert_equal Set.new([1, 2]), graph.roots
    graph.delete_edge(2, 3)
    assert_equal Set.new([1, 2, 3]), graph.roots

    graph = Nanoc::Int::DirectedGraph.new([1, 2, 3])
    graph.add_edge(1, 2)
    graph.add_edge(2, 3)
    graph.add_edge(3, 1)
    graph.delete_edge(1, 2)
    assert_equal Set.new([2]), graph.roots
    graph.delete_edge(2, 3)
    assert_equal Set.new([2, 3]), graph.roots
    graph.delete_edge(3, 1)
    assert_equal Set.new([1, 2, 3]), graph.roots
  end

  def test_example
    YARD.parse(LIB_DIR + '/nanoc/base/entities/directed_graph.rb')
    assert_examples_correct 'Nanoc::Int::DirectedGraph'
  end
end
nanoc-4.4.7/test/base/test_notification_center.rb0000644000004100000410000000130413033443476022164 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Int::NotificationCenterTest < Nanoc::TestCase
  def test_post
    # Set up notification
    Nanoc::Int::NotificationCenter.on :ping_received, :test do
      @ping_received = true
    end

    # Post
    @ping_received = false
    Nanoc::Int::NotificationCenter.post :ping_received
    assert(@ping_received)
  end

  def test_remove
    # Set up notification
    Nanoc::Int::NotificationCenter.on :ping_received, :test do
      @ping_received = true
    end

    # Remove observer
    Nanoc::Int::NotificationCenter.remove :ping_received, :test

    # Post
    @ping_received = false
    Nanoc::Int::NotificationCenter.post :ping_received
    assert(!@ping_received)
  end
end
nanoc-4.4.7/test/base/test_memoization.rb0000644000004100000410000000213513033443476020474 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Int::MemoizationTest < Nanoc::TestCase
  class Sample1
    extend Nanoc::Int::Memoization

    def initialize(value)
      @value = value
    end

    def run(n)
      @value * 10 + n
    end
    memoize :run
  end

  class Sample2
    extend Nanoc::Int::Memoization

    def initialize(value)
      @value = value
    end

    def run(n)
      @value * 100 + n
    end
    memoize :run
  end

  class Upcaser
    extend Nanoc::Int::Memoization

    def run(value)
      value.upcase
    end
    memoize :run
  end

  def test_normal
    sample1a = Sample1.new(10)
    sample1b = Sample1.new(15)
    sample2a = Sample2.new(20)
    sample2b = Sample2.new(25)

    3.times do
      assert_equal 10 * 10 + 5,  sample1a.run(5)
      assert_equal 10 * 15 + 7,  sample1b.run(7)
      assert_equal 100 * 20 + 5, sample2a.run(5)
      assert_equal 100 * 25 + 7, sample2b.run(7)
    end
  end

  def test_weak_inspect
    upcaser = Upcaser.new
    10_000.times do |i|
      upcaser.run("hello world #{i}")
    end

    GC.start
    GC.start

    # Should not raise
    upcaser.inspect
  end
end
nanoc-4.4.7/test/base/test_layout.rb0000644000004100000410000000064413033443476017461 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Int::LayoutTest < Nanoc::TestCase
  def test_initialize
    # Make sure attributes are cleaned
    layout = Nanoc::Int::Layout.new('content', { 'foo' => 'bar' }, '/foo')
    assert_equal({ foo: 'bar' }, layout.attributes)
  end

  def test_attributes
    layout = Nanoc::Int::Layout.new('content', { 'foo' => 'bar' }, '/foo/')
    assert_equal({ foo: 'bar' }, layout.attributes)
  end
end
nanoc-4.4.7/test/base/test_site.rb0000644000004100000410000001027113033443476017105 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Int::SiteTest < Nanoc::TestCase
  def test_initialize_with_dir_without_config_yaml
    assert_raises(Nanoc::Int::ConfigLoader::NoConfigFileFoundError) do
      Nanoc::Int::SiteLoader.new.new_from_cwd
    end
  end

  def test_initialize_with_dir_with_config_yaml
    File.open('config.yaml', 'w') { |io| io.write('output_dir: public_html') }
    site = Nanoc::Int::SiteLoader.new.new_from_cwd
    assert_equal 'public_html', site.config[:output_dir]
  end

  def test_initialize_with_dir_with_nanoc_yaml
    File.open('nanoc.yaml', 'w') { |io| io.write('output_dir: public_html') }
    site = Nanoc::Int::SiteLoader.new.new_from_cwd
    assert_equal 'public_html', site.config[:output_dir]
  end

  def test_initialize_with_config_hash
    site = Nanoc::Int::SiteLoader.new.new_with_config(foo: 'bar')
    assert_equal 'bar', site.config[:foo]
  end

  def test_initialize_with_incomplete_data_source_config
    site = Nanoc::Int::SiteLoader.new.new_with_config(data_sources: [{ items_root: '/bar/' }])
    assert_equal('filesystem', site.config[:data_sources][0][:type])
    assert_equal('/bar/', site.config[:data_sources][0][:items_root])
    assert_equal('/',     site.config[:data_sources][0][:layouts_root])
    assert_equal({},      site.config[:data_sources][0][:config])
  end

  def test_initialize_with_existing_parent_config_file
    File.open('nanoc.yaml', 'w') do |io|
      io.write <<-EOF
output_dir: public_html
parent_config_file: foo/foo.yaml
EOF
    end
    FileUtils.mkdir_p('foo')
    FileUtils.cd('foo') do
      File.open('foo.yaml', 'w') do |io|
        io.write <<-EOF
parent_config_file: ../bar/bar.yaml
EOF
      end
    end
    FileUtils.mkdir_p('bar')
    FileUtils.cd('bar') do
      File.open('bar.yaml', 'w') do |io|
        io.write <<-EOF
enable_output_diff: true
foo: bar
output_dir: output
EOF
      end
    end

    site = Nanoc::Int::SiteLoader.new.new_from_cwd
    assert_nil site.config[:parent_config_file]
    assert site.config[:enable_output_diff]
    assert_equal 'bar', site.config[:foo]
    assert_equal 'public_html', site.config[:output_dir]
  end

  def test_initialize_with_missing_parent_config_file
    File.open('nanoc.yaml', 'w') do |io|
      io.write <<-EOF
parent_config_file: foo/foo.yaml
EOF
    end

    assert_raises(Nanoc::Int::ConfigLoader::NoParentConfigFileFoundError) do
      Nanoc::Int::SiteLoader.new.new_from_cwd
    end
  end

  def test_initialize_with_parent_config_file_cycle
    File.open('nanoc.yaml', 'w') do |io|
      io.write <<-EOF
parent_config_file: foo/foo.yaml
EOF
    end
    FileUtils.mkdir_p('foo')
    FileUtils.cd('foo') do
      File.open('foo.yaml', 'w') do |io|
        io.write <<-EOF
parent_config_file: ../nanoc.yaml
EOF
      end
    end

    assert_raises(Nanoc::Int::ConfigLoader::CyclicalConfigFileError) do
      Nanoc::Int::SiteLoader.new.new_from_cwd
    end
  end

  def test_identifier_classes
    Nanoc::CLI.run %w(create_site bar)
    FileUtils.cd('bar') do
      FileUtils.mkdir_p('content')
      FileUtils.mkdir_p('layouts')

      File.open('content/foo_bar.md', 'w') { |io| io << 'asdf' }
      File.open('layouts/detail.erb', 'w') { |io| io << 'asdf' }

      site = Nanoc::Int::SiteLoader.new.new_from_cwd

      site.items.each do |item|
        assert_equal Nanoc::Identifier, item.identifier.class
      end

      site.layouts.each do |layout|
        assert_equal Nanoc::Identifier, layout.identifier.class
      end
    end
  end

  def test_multiple_items_with_same_identifier
    with_site do
      File.open('content/sam.html', 'w') { |io| io.write('I am Sam!') }
      FileUtils.mkdir_p('content/sam')
      File.open('content/sam/index.html', 'w') { |io| io.write('I am Sam, too!') }

      assert_raises(Nanoc::Int::Errors::DuplicateIdentifier) do
        Nanoc::Int::SiteLoader.new.new_from_cwd
      end
    end
  end

  def test_multiple_layouts_with_same_identifier
    with_site do
      File.open('layouts/sam.html', 'w') { |io| io.write('I am Sam!') }
      FileUtils.mkdir_p('layouts/sam')
      File.open('layouts/sam/index.html', 'w') { |io| io.write('I am Sam, too!') }

      assert_raises(Nanoc::Int::Errors::DuplicateIdentifier) do
        Nanoc::Int::SiteLoader.new.new_from_cwd
      end
    end
  end
end
nanoc-4.4.7/test/base/test_item.rb0000644000004100000410000000164513033443476017104 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Int::ItemTest < Nanoc::TestCase
  def test_initialize_with_attributes_with_string_keys
    item = Nanoc::Int::Item.new('foo', { 'abc' => 'xyz' }, '/foo/')

    assert_equal nil,   item.attributes['abc']
    assert_equal 'xyz', item.attributes[:abc]
  end

  def test_reference
    item = Nanoc::Int::Item.new(
      'content',
      { one: 'one in item' },
      '/path/',
    )

    assert_equal([:item, '/path/'], item.reference)
  end

  def test_attributes
    item = Nanoc::Int::Item.new('content', { 'one' => 'one in item' }, '/path/')
    assert_equal({ one: 'one in item' }, item.attributes)
  end

  def test_freeze_should_disallow_changes
    item = Nanoc::Int::Item.new('foo', { a: { b: 123 } }, '/foo/')
    item.freeze

    assert_raises_frozen_error do
      item.attributes[:abc] = '123'
    end

    assert_raises_frozen_error do
      item.attributes[:a][:b] = '456'
    end
  end
end
nanoc-4.4.7/test/base/test_compiler.rb0000644000004100000410000003326413033443476017762 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Int::CompilerTest < Nanoc::TestCase
  def new_compiler(site = nil)
    site ||= Nanoc::Int::Site.new(
      config: nil,
      code_snippets: [],
      items: [],
      layouts: [],
    )

    reps = Nanoc::Int::ItemRepRepo.new

    action_provider = Nanoc::Int::ActionProvider.named(:rule_dsl).for(site)

    objects = site.items.to_a + site.layouts.to_a

    params = {
      compiled_content_cache: Nanoc::Int::CompiledContentCache.new(items: site.items),
      checksum_store: Nanoc::Int::ChecksumStore.new(site: site, objects: objects),
      rule_memory_store: Nanoc::Int::RuleMemoryStore.new,
      dependency_store: Nanoc::Int::DependencyStore.new(
        site.items.to_a + site.layouts.to_a,
      ),
      action_provider: action_provider,
      reps: reps,
      outdatedness_store: Nanoc::Int::OutdatednessStore.new(site: site, reps: reps),
    }

    params[:outdatedness_checker] =
      Nanoc::Int::OutdatednessChecker.new(
        site: site,
        checksum_store: params[:checksum_store],
        dependency_store: params[:dependency_store],
        rule_memory_store: params[:rule_memory_store],
        action_provider: action_provider,
        reps: reps,
      )

    Nanoc::Int::Compiler.new(site, params)
  end

  def test_compile_rep_should_write_proper_snapshots_real
    with_site do |site|
      File.write('content/moo.txt', '<%= 1 %> <%%= 2 %> <%%%= 3 %>')
      File.write('layouts/default.erb', 'head <%= yield %> foot')

      File.open('Rules', 'w') do |io|
        io.write "compile '/**/*' do\n"
        io.write "  filter :erb\n"
        io.write "  filter :erb\n"
        io.write "  layout 'default'\n"
        io.write "  filter :erb\n"
        io.write "end\n"
        io.write "\n"
        io.write "route '/**/*', snapshot: :raw do\n"
        io.write "  '/moo-raw.txt'\n"
        io.write "end\n"
        io.write "\n"
        io.write "route '/**/*', snapshot: :pre do\n"
        io.write "  '/moo-pre.txt'\n"
        io.write "end\n"
        io.write "\n"
        io.write "route '/**/*', snapshot: :post do\n"
        io.write "  '/moo-post.txt'\n"
        io.write "end\n"
        io.write "\n"
        io.write "route '/**/*' do\n"
        io.write "  '/moo-last.txt'\n"
        io.write "end\n"
        io.write "\n"
        io.write "layout '/**/*', :erb\n"
      end

      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile

      assert File.file?('output/moo-raw.txt')
      # assert File.file?('output/moo-pre.txt')
      assert File.file?('output/moo-post.txt')
      assert File.file?('output/moo-last.txt')
      assert_equal '<%= 1 %> <%%= 2 %> <%%%= 3 %>', File.read('output/moo-raw.txt')
      # assert_equal '1 2 <%= 3 %>',                  File.read('output/moo-pre.txt')
      assert_equal 'head 1 2 3 foot',               File.read('output/moo-post.txt')
      assert_equal 'head 1 2 3 foot',               File.read('output/moo-last.txt')
    end
  end

  def test_compile_with_no_reps
    with_site do |site|
      site.compile

      assert Dir['output/*'].empty?
    end
  end

  def test_compile_with_one_rep
    with_site do |site|
      File.open('content/index.html', 'w') { |io| io.write('o hello') }

      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile

      assert Dir['output/*'].size == 1
      assert File.file?('output/index.html')
      assert File.read('output/index.html') == 'o hello'
    end
  end

  def test_compile_with_two_independent_reps
    with_site do |site|
      File.open('content/foo.html', 'w') { |io| io.write('o hai') }
      File.open('content/bar.html', 'w') { |io| io.write('o bai') }

      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile

      assert Dir['output/*'].size == 2
      assert File.file?('output/foo/index.html')
      assert File.file?('output/bar/index.html')
      assert File.read('output/foo/index.html') == 'o hai'
      assert File.read('output/bar/index.html') == 'o bai'
    end
  end

  def test_compile_with_two_dependent_reps
    with_site(compilation_rule_content: 'filter :erb') do |site|
      File.open('content/foo.html', 'w') do |io|
        io.write('<%= @items.find { |i| i.identifier == "/bar/" }.compiled_content %>!!!')
      end
      File.open('content/bar.html', 'w') do |io|
        io.write('manatee')
      end

      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile

      assert Dir['output/*'].size == 2
      assert File.file?('output/foo/index.html')
      assert File.file?('output/bar/index.html')
      assert File.read('output/foo/index.html') == 'manatee!!!'
      assert File.read('output/bar/index.html') == 'manatee'
    end
  end

  def test_compile_with_two_mutually_dependent_reps
    with_site(compilation_rule_content: 'filter :erb') do |site|
      File.open('content/foo.html', 'w') do |io|
        io.write('<%= @items.find { |i| i.identifier == "/bar/" }.compiled_content %>')
      end
      File.open('content/bar.html', 'w') do |io|
        io.write('<%= @items.find { |i| i.identifier == "/foo/" }.compiled_content %>')
      end

      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      assert_raises Nanoc::Int::Errors::RecursiveCompilation do
        site.compile
      end
    end
  end

  def test_disallow_routes_not_starting_with_slash
    # Create site
    Nanoc::CLI.run %w(create_site bar)

    FileUtils.cd('bar') do
      # Create routes
      File.open('Rules', 'w') do |io|
        io.write "compile '/**/*' do\n"
        io.write "  layout 'default'\n"
        io.write "end\n"
        io.write "\n"
        io.write "route '/**/*' do\n"
        io.write "  'index.html'\n"
        io.write "end\n"
        io.write "\n"
        io.write "layout '/**/*', :erb\n"
      end

      # Create site
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      error = assert_raises(Nanoc::Error) do
        site.compile
      end
      assert_match(/^The path returned for the.*does not start with a slash. Please ensure that all routing rules return a path that starts with a slash./, error.message)
    end
  end

  def test_disallow_duplicate_routes
    # Create site
    Nanoc::CLI.run %w(create_site bar)

    FileUtils.cd('bar') do
      # Create routes
      File.open('Rules', 'w') do |io|
        io.write "compile '/**/*' do\n"
        io.write "end\n"
        io.write "\n"
        io.write "route '/**/*' do\n"
        io.write "  '/index.html'\n"
        io.write "end\n"
      end

      # Create files
      File.write('content/foo.html', 'asdf')
      File.write('content/bar.html', 'asdf')

      # Create site
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      assert_raises(Nanoc::Int::ItemRepRouter::IdenticalRoutesError) do
        site.compile
      end
    end
  end

  def test_disallow_multiple_snapshots_with_the_same_name
    # Create site
    Nanoc::CLI.run %w(create_site bar)

    FileUtils.cd('bar') do
      # Create routes
      File.open('Rules', 'w') do |io|
        io.write "compile '/**/*' do\n"
        io.write "  snapshot :aaa\n"
        io.write "  snapshot :aaa\n"
        io.write "end\n"
        io.write "\n"
        io.write "route '/**/*' do\n"
        io.write "  item.identifier.to_s\n"
        io.write "end\n"
        io.write "\n"
        io.write "layout '/**/*', :erb\n"
      end

      # Compile
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      assert_raises Nanoc::Int::Errors::CannotCreateMultipleSnapshotsWithSameName do
        site.compile
      end
    end
  end

  def test_include_compiled_content_of_active_item_at_previous_snapshot
    with_site do |site|
      # Create item
      File.open('content/index.html', 'w') do |io|
        io.write('[<%= @item.compiled_content(:snapshot => :aaa) %>]')
      end

      # Create routes
      File.open('Rules', 'w') do |io|
        io.write "compile '*' do\n"
        io.write "  snapshot :aaa\n"
        io.write "  filter :erb\n"
        io.write "  filter :erb\n"
        io.write "end\n"
        io.write "\n"
        io.write "route '*' do\n"
        io.write "  '/index.html'\n"
        io.write "end\n"
        io.write "\n"
        io.write "layout '*', :erb\n"
      end

      # Compile
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile

      # Check
      assert_equal '[[[<%= @item.compiled_content(:snapshot => :aaa) %>]]]', File.read('output/index.html')
    end
  end

  def test_mutually_include_compiled_content_at_previous_snapshot
    with_site do |site|
      # Create items
      File.open('content/a.html', 'w') do |io|
        io.write('[<%= @items.find { |i| i.identifier == "/z/" }.compiled_content(:snapshot => :guts) %>]')
      end
      File.open('content/z.html', 'w') do |io|
        io.write('stuff')
      end

      # Create routes
      File.open('Rules', 'w') do |io|
        io.write "compile '*' do\n"
        io.write "  snapshot :guts\n"
        io.write "  filter :erb\n"
        io.write "end\n"
        io.write "\n"
        io.write "route '*' do\n"
        io.write "  item.identifier + 'index.html'\n"
        io.write "end\n"
        io.write "\n"
        io.write "layout '*', :erb\n"
      end

      # Compile
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile

      # Check
      assert_equal '[stuff]', File.read('output/a/index.html')
      assert_equal 'stuff', File.read('output/z/index.html')
    end
  end

  def test_layout_with_extra_filter_args
    with_site do |site|
      # Create item
      File.open('content/index.html', 'w') do |io|
        io.write('This is <%= @foo %>.')
      end

      # Create routes
      File.open('Rules', 'w') do |io|
        io.write "compile '*' do\n"
        io.write "  filter :erb, :locals => { :foo => 123 }\n"
        io.write "end\n"
        io.write "\n"
        io.write "route '*' do\n"
        io.write "  '/index.html'\n"
        io.write "end\n"
        io.write "\n"
        io.write "layout '*', :erb\n"
      end

      # Compile
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile

      # Check
      assert_equal 'This is 123.', File.read('output/index.html')
    end
  end

  def test_change_routing_rule_and_recompile
    with_site do |site|
      # Create items
      File.open('content/a.html', 'w') do |io|
        io.write('
A
')
      end
      File.open('content/b.html', 'w') do |io|
        io.write('
B
')
      end

      # Create routes
      File.open('Rules', 'w') do |io|
        io.write "compile '*' do\n"
        io.write "end\n"
        io.write "\n"
        io.write "route '/a/' do\n"
        io.write "  '/index.html'\n"
        io.write "end\n"
        io.write "\n"
        io.write "route '*' do\n"
        io.write "  nil\n"
        io.write "end\n"
      end

      # Compile
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile

      # Check
      assert_equal '
A
', File.read('output/index.html')

      # Create routes
      File.open('Rules', 'w') do |io|
        io.write "compile '*' do\n"
        io.write "end\n"
        io.write "\n"
        io.write "route '/b/' do\n"
        io.write "  '/index.html'\n"
        io.write "end\n"
        io.write "\n"
        io.write "route '*' do\n"
        io.write "  nil\n"
        io.write "end\n"
      end

      # Compile
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile

      # Check
      assert_equal '
B
', File.read('output/index.html')
    end
  end

  def test_rep_assigns
    with_site do |site|
      # Create item
      File.open('content/index.html', 'w') do |io|
        io.write('@rep.name = <%= @rep.name %> - @item_rep.name = <%= @item_rep.name %>')
      end

      # Create routes
      File.open('Rules', 'w') do |io|
        io.write "compile '*' do\n"
        io.write "  if @rep.name == :default && @item_rep.name == :default\n"
        io.write "    filter :erb\n"
        io.write "  end\n"
        io.write "end\n"
        io.write "\n"
        io.write "route '*' do\n"
        io.write "  '/index.html'\n"
        io.write "end\n"
        io.write "\n"
        io.write "layout '*', :erb\n"
      end

      # Compile
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile

      # Check
      assert_equal '@rep.name = default - @item_rep.name = default', File.read('output/index.html')
    end
  end

  def test_unfiltered_binary_item_should_not_be_moved_outside_content
    with_site do
      File.open('content/blah.dat', 'w') { |io| io.write('o hello') }

      File.open('Rules', 'w') do |io|
        io.write "compile '*' do\n"
        io.write "end\n"
        io.write "\n"
        io.write "route '*' do\n"
        io.write "  item.identifier.chop + '.' + item[:extension]\n"
        io.write "end\n"
        io.write "\n"
        io.write "layout '*', :erb\n"
      end

      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile

      assert_equal Set.new(%w(content/blah.dat)), Set.new(Dir['content/*'])
      assert_equal Set.new(%w(output/blah.dat)), Set.new(Dir['output/*'])
    end
  end

  def test_tmp_text_items_are_removed_after_compilation
    with_site do |site|
      # Create item
      File.open('content/index.html', 'w') do |io|
        io.write('stuff')
      end

      # Compile
      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile

      # Check
      assert Dir['tmp/text_items/*'].empty?
    end
  end

  def test_find_layouts_by_glob
    Nanoc::CLI.run %w(create_site bar)
    FileUtils.cd('bar') do
      File.open('Rules', 'w') do |io|
        io.write "compile '/**/*' do\n"
        io.write "  layout '/default.*'\n"
        io.write "end\n"
        io.write "\n"
        io.write "route '/**/*' do\n"
        io.write "  item.identifier.to_s\n"
        io.write "end\n"
        io.write "\n"
        io.write "layout '/**/*', :erb\n"
      end

      site = Nanoc::Int::SiteLoader.new.new_from_cwd
      site.compile
    end
  end
end
nanoc-4.4.7/test/base/test_context.rb0000644000004100000410000000157113033443476017630 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Int::ContextTest < Nanoc::TestCase
  def test_context_with_instance_variable
    # Create context
    context = Nanoc::Int::Context.new(foo: 'bar', baz: 'quux')

    # Ensure correct evaluation
    assert_equal('bar', eval('@foo', context.get_binding))
  end

  def test_context_with_instance_method
    # Create context
    context = Nanoc::Int::Context.new(foo: 'bar', baz: 'quux')

    # Ensure correct evaluation
    assert_equal('bar', eval('foo', context.get_binding))
  end

  def test_example
    # Parse
    YARD.parse(LIB_DIR + '/nanoc/base/entities/context.rb')

    # Run
    assert_examples_correct 'Nanoc::Int::Context#initialize'
  end

  def test_include
    context = Nanoc::Int::Context.new({})
    eval('include Nanoc::Helpers::HTMLEscape', context.get_binding)
    assert_equal('<>', eval('h("<>")', context.get_binding))
  end
end
nanoc-4.4.7/test/base/test_filter.rb0000644000004100000410000000330013033443476017421 0ustar  www-datawww-datarequire 'helper'

class Nanoc::FilterTest < Nanoc::TestCase
  def test_initialize
    # Create filter
    filter = Nanoc::Filter.new

    # Test assigns
    assert_equal({}, filter.instance_eval { @assigns })
  end

  def test_assigns
    # Create filter
    filter = Nanoc::Filter.new(foo: 'bar')

    # Check assigns
    assert_equal('bar', filter.assigns[:foo])
  end

  def test_assigns_with_instance_variables
    # Create filter
    filter = Nanoc::Filter.new(foo: 'bar')

    # Check assigns
    assert_equal('bar', filter.instance_eval { @foo })
  end

  def test_assigns_with_instance_methods
    # Create filter
    filter = Nanoc::Filter.new(foo: 'bar')

    # Check assigns
    assert_equal('bar', filter.instance_eval { foo })
  end

  def test_run
    # Create filter
    filter = Nanoc::Filter.new

    # Make sure an error is raised
    assert_raises(NotImplementedError) do
      filter.run(nil)
    end
  end

  def test_filename_item
    # Mock items
    item = mock
    item.expects(:identifier).returns('/foo/bar/baz/')
    item_rep = mock
    item_rep.expects(:name).returns(:quux)

    # Create filter
    filter = Nanoc::Filter.new(item: item, item_rep: item_rep)

    # Check filename
    assert_equal('item /foo/bar/baz/ (rep quux)', filter.filename)
  end

  def test_filename_layout
    # Mock items
    layout = mock
    layout.expects(:identifier).returns('/wohba/')

    # Create filter
    filter = Nanoc::Filter.new(item: mock, item_rep: mock, layout: layout)

    # Check filename
    assert_equal('layout /wohba/', filter.filename)
  end

  def test_filename_unknown
    # Create filter
    filter = Nanoc::Filter.new({})

    # Check filename
    assert_equal('?', filter.filename)
  end
end
nanoc-4.4.7/test/base/test_code_snippet.rb0000644000004100000410000000121113033443476020607 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Int::CodeSnippetTest < Nanoc::TestCase
  def test_load
    # Initialize
    $complete_insane_parrot = 'meow'

    # Create code and load it
    code_snippet = Nanoc::Int::CodeSnippet.new("$complete_insane_parrot = 'woof'", 'parrot.rb')
    code_snippet.load

    # Ensure code is loaded
    assert_equal('woof', $complete_insane_parrot)
  end

  def test_load_with_toplevel_binding
    # Initialize
    @foo = 'meow'

    # Create code and load it
    code_snippet = Nanoc::Int::CodeSnippet.new("@foo = 'woof'", 'dog.rb')
    code_snippet.load

    # Ensure binding is correct
    assert_equal('meow', @foo)
  end
end
nanoc-4.4.7/test/base/test_data_source.rb0000644000004100000410000000543113033443476020434 0ustar  www-datawww-datarequire 'helper'

class Nanoc::DataSourceTest < Nanoc::TestCase
  def test_loading
    # Create data source
    data_source = Nanoc::DataSource.new(nil, nil, nil, nil)
    data_source.expects(:up).times(1)
    data_source.expects(:down).times(1)

    # Test nested loading
    assert_equal(0, data_source.instance_eval { @references })
    data_source.loading do
      assert_equal(1, data_source.instance_eval { @references })
      data_source.loading do
        assert_equal(2, data_source.instance_eval { @references })
      end
      assert_equal(1, data_source.instance_eval { @references })
    end
    assert_equal(0, data_source.instance_eval { @references })
  end

  def test_not_implemented
    # Create data source
    data_source = Nanoc::DataSource.new(nil, nil, nil, nil)

    # Test optional methods
    data_source.up
    data_source.down

    # Test methods - loading data
    assert_equal [], data_source.items
    assert_equal [], data_source.layouts
  end

  def test_new_item
    data_source = Nanoc::DataSource.new(nil, nil, nil, nil)

    item = data_source.new_item('stuff', { title: 'Stuff!' }, '/asdf/', checksum_data: 'abcdef')
    assert_equal 'stuff', item.content.string
    assert_equal 'Stuff!', item.attributes[:title]
    assert_equal Nanoc::Identifier.new('/asdf/'), item.identifier
    assert_equal 'abcdef', item.checksum_data
  end

  def test_new_item_with_checksums
    data_source = Nanoc::DataSource.new(nil, nil, nil, nil)

    item = data_source.new_item('stuff', { title: 'Stuff!' }, '/asdf/', content_checksum_data: 'con-cs', attributes_checksum_data: 'attr-cs')
    assert_equal 'stuff', item.content.string
    assert_equal 'Stuff!', item.attributes[:title]
    assert_equal Nanoc::Identifier.new('/asdf/'), item.identifier
    assert_equal 'con-cs', item.content_checksum_data
    assert_equal 'attr-cs', item.attributes_checksum_data
  end

  def test_new_layout
    data_source = Nanoc::DataSource.new(nil, nil, nil, nil)

    layout = data_source.new_layout('stuff', { title: 'Stuff!' }, '/asdf/', checksum_data: 'abcdef')
    assert_equal 'stuff', layout.content.string
    assert_equal 'Stuff!', layout.attributes[:title]
    assert_equal Nanoc::Identifier.new('/asdf/'), layout.identifier
    assert_equal 'abcdef', layout.checksum_data
  end

  def test_new_layout_with_checksums
    data_source = Nanoc::DataSource.new(nil, nil, nil, nil)

    layout = data_source.new_layout('stuff', { title: 'Stuff!' }, '/asdf/', content_checksum_data: 'con-cs', attributes_checksum_data: 'attr-cs')
    assert_equal 'stuff', layout.content.string
    assert_equal 'Stuff!', layout.attributes[:title]
    assert_equal Nanoc::Identifier.new('/asdf/'), layout.identifier
    assert_equal 'con-cs', layout.content_checksum_data
    assert_equal 'attr-cs', layout.attributes_checksum_data
  end
end
nanoc-4.4.7/test/base/test_store.rb0000644000004100000410000000417713033443476017305 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Int::StoreTest < Nanoc::TestCase
  class TestStore < Nanoc::Int::Store
    def data
      @data
    end

    def data=(new_data)
      @data = new_data
    end
  end

  def test_delete_and_reload_on_error
    store = TestStore.new('test.db', 1)

    # Create
    store.load
    store.data = { fun: 'sure' }
    store.store

    # Test stored values
    store = TestStore.new('test.db', 1)
    store.load
    assert_equal({ fun: 'sure' }, store.data)

    # Mess up
    File.open('test.db', 'w') do |io|
      io << 'Damn {}#}%@}$^)@&$&*^#@ broken stores!!!'
    end

    # Reload
    store = TestStore.new('test.db', 1)
    store.load
    assert_equal(nil, store.data)
  end

  def test_tmp_path_with_nil_env
    tmp_path_for_checksum = Nanoc::Int::Store.tmp_path_for(env_name: nil, store_name: 'checksum')
    tmp_path_for_rule_memory = Nanoc::Int::Store.tmp_path_for(env_name: nil, store_name: 'rule_memory')
    tmp_path_for_dependencies = Nanoc::Int::Store.tmp_path_for(env_name: nil, store_name: 'dependencies')
    tmp_path_for_compiled_content = Nanoc::Int::Store.tmp_path_for(env_name: nil, store_name: 'compiled_content')
    assert_equal('tmp/checksum', tmp_path_for_checksum)
    assert_equal('tmp/rule_memory', tmp_path_for_rule_memory)
    assert_equal('tmp/dependencies', tmp_path_for_dependencies)
    assert_equal('tmp/compiled_content', tmp_path_for_compiled_content)
  end

  def test_tmp_path_with_test_env
    tmp_path_for_checksum = Nanoc::Int::Store.tmp_path_for(env_name: 'test', store_name: 'checksum')
    tmp_path_for_rule_memory = Nanoc::Int::Store.tmp_path_for(env_name: 'test', store_name: 'rule_memory')
    tmp_path_for_dependencies = Nanoc::Int::Store.tmp_path_for(env_name: 'test', store_name: 'dependencies')
    tmp_path_for_compiled_content = Nanoc::Int::Store.tmp_path_for(env_name: 'test', store_name: 'compiled_content')
    assert_equal('tmp/test/checksum', tmp_path_for_checksum)
    assert_equal('tmp/test/rule_memory', tmp_path_for_rule_memory)
    assert_equal('tmp/test/dependencies', tmp_path_for_dependencies)
    assert_equal('tmp/test/compiled_content', tmp_path_for_compiled_content)
  end
end
nanoc-4.4.7/test/helper.rb0000644000004100000410000001471513033443476015456 0ustar  www-datawww-data$VERBOSE = false

require 'simplecov'
SimpleCov.start

require 'minitest/autorun'
require 'mocha/setup'
require 'vcr'

require 'tmpdir'
require 'stringio'
require 'yard'

VCR.configure do |c|
  c.cassette_library_dir = 'test/fixtures/vcr_cassettes'
  c.hook_into :webmock
end

require 'nanoc'
require 'nanoc/cli'

Nanoc::CLI.setup

module Nanoc::TestHelpers
  LIB_DIR = File.expand_path(File.dirname(__FILE__) + '/../lib')

  def disable_nokogiri?
    ENV.key?('DISABLE_NOKOGIRI')
  end

  def skip_v8_on_ruby24
    if ENV.key?('DISABLE_V8')
      skip 'V8 specs are disabled (broken on Ruby 2.4)'
    end
  end

  def if_have(*libs)
    libs.each do |lib|
      if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby' && lib == 'nokogiri' && disable_nokogiri?
        skip 'Pure Java Nokogiri has issues that cause problems with nanoc (see https://github.com/nanoc/nanoc/pull/422) -- run without DISABLE_NOKOGIRI to enable Nokogiri tests'
      end

      begin
        require lib
      rescue LoadError
        skip "requiring #{lib} failed"
      end
    end

    yield
  end

  def if_implemented
    yield
  rescue NotImplementedError, NameError
    skip $ERROR_INFO
    return
  end

  def with_site(params = {})
    # Build site name
    site_name = params[:name]
    if site_name.nil?
      @site_num ||= 0
      site_name = "site-#{@site_num}"
      @site_num += 1
    end

    # Build rules
    rules_content = < ...')
          end
        end

        File.open('nanoc.yaml', 'w') do |io|
          io << 'string_pattern_type: legacy' << "\n" if params.fetch(:legacy, true)
          io << 'data_sources:' << "\n"
          io << '  -' << "\n"
          io << '    type: filesystem' << "\n"
          io << '    identifier_type: legacy' << "\n" if params.fetch(:legacy, true)
        end

        File.open('Rules', 'w') { |io| io.write(rules_content) }
      end
    end

    # Yield site
    FileUtils.cd(site_name) do
      yield Nanoc::Int::SiteLoader.new.new_from_cwd
    end
  end

  def setup
    # Check skipped
    if ENV['skip']
      if ENV['skip'].split(',').include?(self.class.to_s)
        skip 'manually skipped'
      end
    end

    # Clean up
    GC.start

    # Go quiet
    unless ENV['QUIET'] == 'false'
      @orig_stdout = $stdout
      @orig_stderr = $stderr

      $stdout = StringIO.new
      $stderr = StringIO.new
    end

    # Enter tmp
    @tmp_dir = Dir.mktmpdir('nanoc-test')
    @orig_wd = FileUtils.pwd
    FileUtils.cd(@tmp_dir)

    # Let us get to the raw errors
    Nanoc::CLI::ErrorHandler.disable
  end

  def teardown
    # Restore normal error handling
    Nanoc::CLI::ErrorHandler.enable

    # Exit tmp
    FileUtils.cd(@orig_wd)
    FileUtils.rm_rf(@tmp_dir)

    # Go unquiet
    unless ENV['QUIET'] == 'false'
      $stdout = @orig_stdout
      $stderr = @orig_stderr
    end
  end

  def capturing_stdio(&_block)
    # Store
    orig_stdout = $stdout
    orig_stderr = $stderr

    # Run
    $stdout = StringIO.new
    $stderr = StringIO.new
    yield
    { stdout: $stdout.string, stderr: $stderr.string }
  ensure
    # Restore
    $stdout = orig_stdout
    $stderr = orig_stderr
  end

  # Adapted from http://github.com/lsegal/yard-examples/tree/master/doctest
  def assert_examples_correct(object)
    P(object).tags(:example).each do |example|
      # Classify
      lines = example.text.lines.map do |line|
        [line =~ /^\s*# ?=>/ ? :result : :code, line]
      end

      # Join
      pieces = []
      lines.each do |line|
        if !pieces.empty? && pieces.last.first == line.first
          pieces.last.last << line.last
        else
          pieces << line
        end
      end
      lines = pieces.map(&:last)

      # Test
      b = binding
      lines.each_slice(2) do |pair|
        actual_out   = eval(pair.first, b)
        expected_out = eval(pair.last.match(/# ?=>(.*)/)[1], b)

        assert_equal(
          expected_out,
          actual_out,
          "Incorrect example:\n#{pair.first}",
        )
      end
    end
  end

  def assert_contains_exactly(expected, actual)
    assert_equal(
      expected.size,
      actual.size,
      format('Expected %s to be of same size as %s', actual.inspect, expected.inspect),
    )
    remaining = actual.dup.to_a
    expected.each do |e|
      index = remaining.index(e)
      remaining.delete_at(index) if index
    end
    assert(
      remaining.empty?,
      format('Expected %s to contain all the elements of %s', actual.inspect, expected.inspect),
    )
  end

  def assert_raises_frozen_error
    error = assert_raises(RuntimeError, TypeError) { yield }
    assert_match(/(^can't modify frozen |^unable to modify frozen object$)/, error.message)
  end

  def with_env_vars(hash, &_block)
    orig_env_hash = ENV.to_hash
    hash.each_pair { |k, v| ENV[k] = v }
    yield
  ensure
    orig_env_hash.each_pair { |k, v| ENV[k] = v }
  end

  def on_windows?
    Nanoc.on_windows?
  end

  def command?(cmd)
    which, null = on_windows? ? %w(where NUL) : ['which', '/dev/null']
    system("#{which} #{cmd} > #{null} 2>&1")
  end

  def symlinks_supported?
    File.symlink nil, nil
  rescue NotImplementedError
    return false
  rescue
    return true
  end

  def skip_unless_have_command(cmd)
    skip "Could not find external command \"#{cmd}\"" unless command?(cmd)
  end

  def skip_unless_symlinks_supported
    skip 'Symlinks are not supported by Ruby on Windows' unless symlinks_supported?
  end

  def root_dir
    File.absolute_path(File.dirname(__FILE__) + '/..')
  end
end

class Nanoc::TestCase < Minitest::Test
  include Nanoc::TestHelpers
end

# Unexpected system exit is unexpected
::Minitest::Test::PASSTHROUGH_EXCEPTIONS.delete(SystemExit)

# A more precise inspect method for Time improves assert failure messages.
#
class Time
  def inspect
    strftime("%a %b %d %H:%M:%S.#{format('%06d', usec)} %Z %Y")
  end
end
nanoc-4.4.7/test/filters/0000755000004100000410000000000013033443476015312 5ustar  www-datawww-datananoc-4.4.7/test/filters/test_slim.rb0000644000004100000410000000164013033443476017643 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Filters::SlimTest < Nanoc::TestCase
  def test_filter
    if_have 'slim' do
      # Create filter
      filter = ::Nanoc::Filters::Slim.new(rabbit: 'The rabbit is on the branch.')

      # Run filter (no assigns)
      result = filter.setup_and_run('html')
      assert_match(/.*<\/html>/, result)

      # Run filter (assigns without @)
      result = filter.setup_and_run('p = rabbit')
      assert_equal('
The rabbit is on the branch.
', result)

      # Run filter (assigns with @)
      result = filter.setup_and_run('p = @rabbit')
      assert_equal('
The rabbit is on the branch.
', result)
    end
  end

  def test_filter_with_yield
    if_have 'slim' do
      filter = ::Nanoc::Filters::Slim.new(content: 'The rabbit is on the branch.')

      result = filter.setup_and_run('p = yield')
      assert_equal('
The rabbit is on the branch.
', result)
    end
  end
end
nanoc-4.4.7/test/filters/test_redcloth.rb0000644000004100000410000000146013033443476020503 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Filters::RedClothTest < Nanoc::TestCase
  def test_filter
    if_have 'redcloth' do
      # Get filter
      filter = ::Nanoc::Filters::RedCloth.new

      # Run filter
      result = filter.setup_and_run('h1. Foo')
      assert_equal('
Foo
', result)
    end
  end

  def test_filter_with_options
    if_have 'redcloth' do
      # Get filter
      filter = ::Nanoc::Filters::RedCloth.new

      # Run filter without options
      result = filter.setup_and_run('I am a member of SPECTRE.')
      assert_equal('
I am a member of SPECTRE.
', result)

      # Run filter with options
      result = filter.setup_and_run('I am a member of SPECTRE.', no_span_caps: true)
      assert_equal('
I am a member of SPECTRE.
', result)
    end
  end
end
nanoc-4.4.7/test/filters/test_uglify_js.rb0000644000004100000410000000160513033443476020673 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Filters::UglifyJSTest < Nanoc::TestCase
  def test_filter
    skip_v8_on_ruby24

    if_have 'uglifier' do
      # Create filter
      filter = ::Nanoc::Filters::UglifyJS.new

      # Run filter
      input = 'foo = 1; (function(bar) { if (true) alert(bar); })(foo)'
      result = filter.setup_and_run(input)
      assert_match(/foo=1,function\((.)\)\{alert\(\1\)\}\(foo\);/, result)
    end
  end

  def test_filter_with_options
    skip_v8_on_ruby24

    if_have 'uglifier' do
      filter = ::Nanoc::Filters::UglifyJS.new
      input = "if(donkey) alert('It is a donkey!');"

      result = filter.setup_and_run(input, output: { beautify: false })
      assert_equal 'donkey&&alert("It is a donkey!");', result

      result = filter.setup_and_run(input, output: { beautify: true })
      assert_equal 'donkey && alert("It is a donkey!");', result
    end
  end
end
nanoc-4.4.7/test/filters/test_yui_compressor.rb0000644000004100000410000000210713033443476021760 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Filters::YUICompressorTest < Nanoc::TestCase
  def test_filter_javascript
    if_have 'yuicompressor' do
      filter = ::Nanoc::Filters::YUICompressor.new

      sample_js = <<-JAVASCRIPT
        function factorial(n) {
            var result = 1;
            for (var i = 2; i <= n; i++) {
                result *= i
            }
            return result;
        }
      JAVASCRIPT

      result = filter.setup_and_run(sample_js, type: 'js', munge: true)
      assert_match 'function factorial(c){var a=1;for(var b=2;b<=c;b++){a*=b}return a};', result

      result = filter.setup_and_run(sample_js, type: 'js', munge: false)
      assert_match 'function factorial(n){var result=1;for(var i=2;i<=n;i++){result*=i}return result};', result
    end
  end

  def test_filter_css
    if_have 'yuicompressor' do
      filter = ::Nanoc::Filters::YUICompressor.new

      sample_css = <<-CSS
        * {
          margin: 0;
        }
      CSS

      result = filter.setup_and_run(sample_css, type: 'css')
      assert_match '*{margin:0}', result
    end
  end
end
nanoc-4.4.7/test/filters/test_typogruby.rb0000644000004100000410000000104513033443476020742 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Filters::TypogrubyTest < Nanoc::TestCase
  def test_filter
    if_have 'typogruby' do
      # Get filter
      filter = ::Nanoc::Filters::Typogruby.new

      # Run filter
      a = '"Typogruby makes HTML look smarter & better, don\'t you think?"'
      b = '“Typogruby makes HTML look smarter & better, don’t you think?”'
      result = filter.setup_and_run(a)
      assert_equal(b, result)
    end
  end
end
nanoc-4.4.7/test/filters/test_maruku.rb0000644000004100000410000000054113033443476020202 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Filters::MarukuTest < Nanoc::TestCase
  def test_filter
    if_have 'maruku' do
      # Create filter
      filter = ::Nanoc::Filters::Maruku.new

      # Run filter
      result = filter.setup_and_run('This is _so_ *cool*!')
      assert_equal('
This is so cool!
', result.strip)
    end
  end
end
nanoc-4.4.7/test/filters/test_coffeescript.rb0000644000004100000410000000062613033443476021356 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Filters::CoffeeScriptTest < Nanoc::TestCase
  def test_filter
    skip_v8_on_ruby24

    if_have 'coffee-script' do
      # Create filter
      filter = ::Nanoc::Filters::CoffeeScript.new

      # Run filter (no assigns)
      result = filter.setup_and_run('alert 42')
      assert_equal('(function() { alert(42); }).call(this); ', result.gsub(/\s+/, ' '))
    end
  end
end
nanoc-4.4.7/test/filters/test_pandoc.rb0000644000004100000410000000222013033443476020136 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Filters::PandocTest < Nanoc::TestCase
  def test_filter
    if_have 'pandoc-ruby' do
      skip_unless_have_command 'pandoc'

      # Create filter
      filter = ::Nanoc::Filters::Pandoc.new

      # Run filter
      result = filter.setup_and_run("# Heading\n")
      assert_match(%r{
Heading
\s*}, result)
    end
  end

  def test_params_old
    if_have 'pandoc-ruby' do
      skip_unless_have_command 'pandoc'

      # Create filter
      filter = ::Nanoc::Filters::Pandoc.new

      # Run filter
      args = { f: :markdown, to: :html }
      result = filter.setup_and_run("# Heading\n", args)
      assert_match(%r{
Heading
\s*}, result)
    end
  end

  def test_params_new
    if_have 'pandoc-ruby' do
      skip_unless_have_command 'pandoc'

      # Create filter
      filter = ::Nanoc::Filters::Pandoc.new

      # Run filter
      args = [:s, { f: :markdown, to: :html }, 'no-wrap', :toc]
      result = filter.setup_and_run("# Heading\n", args: args)
      assert_match '
', result
      assert_match(%r{
Heading
\s*}, result)
    end
  end
end
nanoc-4.4.7/test/filters/test_rainpress.rb0000644000004100000410000000116013033443476020702 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Filters::RainpressTest < Nanoc::TestCase
  def test_filter
    if_have 'rainpress' do
      # Create filter
      filter = ::Nanoc::Filters::Rainpress.new

      # Run filter
      result = filter.setup_and_run('body { color: black; }')
      assert_equal('body{color:#000}', result)
    end
  end

  def test_filter_with_options
    if_have 'rainpress' do
      # Create filter
      filter = ::Nanoc::Filters::Rainpress.new

      # Run filter
      result = filter.setup_and_run('body { color: #aabbcc; }', colors: false)
      assert_equal('body{color:#aabbcc}', result)
    end
  end
end
nanoc-4.4.7/test/filters/test_markaby.rb0000644000004100000410000000047213033443476020327 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Filters::MarkabyTest < Nanoc::TestCase
  def test_filter
    if_have 'markaby' do
      # Create filter
      filter = ::Nanoc::Filters::Markaby.new

      # Run filter
      result = filter.setup_and_run("html do\nend")
      assert_equal('', result)
    end
  end
end
nanoc-4.4.7/test/filters/test_rdiscount.rb0000644000004100000410000000162213033443476020711 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Filters::RDiscountTest < Nanoc::TestCase
  def test_filter
    if_have 'rdiscount' do
      # Create filter
      filter = ::Nanoc::Filters::RDiscount.new

      # Run filter
      result = filter.setup_and_run('> Quote')
      assert_match(/
\s*
Quote<\/p>\s*<\/blockquote>/, result)
    end
  end

  # FIXME: Re-enable this test (flaky; quotation marks are not transformed consistently)
  # def test_with_extensions
  #   if_have 'rdiscount' do
  #     # Create filter
  #     filter = ::Nanoc::Filters::RDiscount.new
  #
  #     # Run filter
  #     input           = "The quotation 'marks' sure make this look sarcastic!"
  #     output_expected = /The quotation ‘marks’ sure make this look sarcastic!/
  #     output_actual   = filter.setup_and_run(input, extensions: [:smart])
  #     assert_match(output_expected, output_actual)
  #   end
  # end
end
nanoc-4.4.7/test/filters/test_rdoc.rb0000644000004100000410000000045613033443476017632 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Filters::RDocTest < Nanoc::TestCase
  def test_filter
    # Get filter
    filter = ::Nanoc::Filters::RDoc.new

    # Run filter
    result = filter.setup_and_run('= Foo')
    assert_match(%r{\A\s*Foo(.*)?\s*\Z}, result)
  end
end
nanoc-4.4.7/test/filters/test_sass.rb0000644000004100000410000002115113033443476017647 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Filters::SassTest < Nanoc::TestCase
  def setup
    super

    if_have 'sass' do
      unless ::Sass.load_paths.include?('.')
        ::Sass.load_paths << '.'
      end
    end
  end

  def test_filter
    if_have 'sass' do
      # Get filter
      filter = create_filter(foo: 'bar')

      # Run filter
      result = filter.setup_and_run(".foo #bar\n  color: #f00")
      assert_match(/.foo\s+#bar\s*\{\s*color:\s+(red|#f00);?\s*\}/, result)
    end
  end

  def test_filter_with_params
    if_have 'sass' do
      # Create filter
      filter = create_filter(foo: 'bar')

      # Check with compact
      result = filter.setup_and_run(".foo #bar\n  color: #f00", style: 'compact')
      assert_match(/^\.foo #bar[\s]*\{[\s]*color:\s*(red|#f00);?[\s]*\}/m, result)

      # Check with compressed
      result = filter.setup_and_run(".foo #bar\n  color: #f00", style: 'compressed')
      assert_match(/^\.foo #bar[\s]*\{[\s]*color:\s*(red|#f00);?[\s]*\}/m, result)
    end
  end

  def test_filter_error
    if_have 'sass' do
      # Create filter
      filter = create_filter

      # Run filter
      raised = false
      begin
        filter.setup_and_run('$*#&!@($')
      rescue Sass::SyntaxError => e
        assert_match ':1', e.backtrace[0]
        raised = true
      end
      assert raised
    end
  end

  def test_filter_can_import_external_files
    if_have 'sass' do
      # Create filter
      filter = create_filter

      # Create sample file
      File.open('moo.sass', 'w') { |io| io.write "body\n  color: red" }

      # Run filter
      filter.setup_and_run('@import moo')
    end
  end

  def test_filter_can_import_relative_files
    if_have 'sass' do
      # Create filter
      filter = create_filter

      # Create sample file
      File.open('moo.sass', 'w') { |io| io.write %(@import subdir/relative) }
      FileUtils.mkdir_p('subdir')
      File.open('subdir/relative.sass', 'w') { |io| io.write "body\n  color: red" }

      # Run filter
      filter.setup_and_run('@import moo')
    end
  end

  def test_filter_will_skip_items_without_filename
    if_have 'sass' do
      # Create filter
      filter = create_filter

      # Create sample file
      File.open('moo.sass', 'w') { |io| io.write "body\n  color: red" }

      # Run filter
      filter.setup_and_run('@import moo')
    end
  end

  def test_css_imports_work
    if_have 'sass' do
      # Create filter
      filter = create_filter

      # Run filter
      filter.setup_and_run('@import moo.css')
    end
  end

  def test_recompile_includes
    if_have 'sass' do
      with_site do |site|
        # Create two Sass files
        Dir['content/*'].each { |i| FileUtils.rm(i) }
        File.open('content/a.sass', 'w') do |io|
          io.write('@import b.sass')
        end
        File.open('content/b.sass', 'w') do |io|
          io.write("p\n  color: red")
        end

        # Update rules
        File.open('Rules', 'w') do |io|
          io.write "compile '*' do\n"
          io.write "  filter :sass\n"
          io.write "end\n"
          io.write "\n"
          io.write "route '/a/' do\n"
          io.write "  item.identifier.chop + '.css'\n"
          io.write "end\n"
          io.write "\n"
          io.write "route '/b/' do\n"
          io.write "  nil\n"
          io.write "end\n"
        end

        # Compile
        site = Nanoc::Int::SiteLoader.new.new_from_cwd
        site.compile

        # Check
        assert Dir['output/*'].size == 1
        assert File.file?('output/a.css')
        refute File.file?('output/b.css')
        assert_match(/^p\s*\{\s*color:\s*red;?\s*\}/, File.read('output/a.css'))

        # Update included file
        File.open('content/b.sass', 'w') do |io|
          io.write("p\n  color: blue")
        end

        # Recompile
        site = Nanoc::Int::SiteLoader.new.new_from_cwd
        site.compile

        # Recheck
        assert Dir['output/*'].size == 1
        assert File.file?('output/a.css')
        refute File.file?('output/b.css')
        assert_match(/^p\s*\{\s*color:\s*blue;?\s*\}/, File.read('output/a.css'))
      end
    end
  end

  def test_recompile_includes_with_underscore_without_extension
    if_have 'sass' do
      with_site do |site|
        # Create two Sass files
        Dir['content/*'].each { |i| FileUtils.rm(i) }
        File.open('content/a.sass', 'w') do |io|
          io.write('@import b')
        end
        File.open('content/_b.sass', 'w') do |io|
          io.write("p\n  color: red")
        end

        # Update rules
        File.open('Rules', 'w') do |io|
          io.write "compile '*' do\n"
          io.write "  filter :sass\n"
          io.write "end\n"
          io.write "\n"
          io.write "route '/a/' do\n"
          io.write "  item.identifier.chop + '.css'\n"
          io.write "end\n"
          io.write "\n"
          io.write "route '/_b/' do\n"
          io.write "  nil\n"
          io.write "end\n"
        end

        # Compile
        site = Nanoc::Int::SiteLoader.new.new_from_cwd
        site.compile

        # Check
        assert Dir['output/*'].size == 1
        assert File.file?('output/a.css')
        refute File.file?('output/b.css')
        assert_match(/^p\s*\{\s*color:\s*red;?\s*\}/, File.read('output/a.css'))

        # Update included file
        File.open('content/_b.sass', 'w') do |io|
          io.write("p\n  color: blue")
        end

        # Recompile
        site = Nanoc::Int::SiteLoader.new.new_from_cwd
        site.compile

        # Recheck
        assert Dir['output/*'].size == 1
        assert File.file?('output/a.css')
        refute File.file?('output/b.css')
        assert_match(/^p\s*\{\s*color:\s*blue;?\s*\}/, File.read('output/a.css'))
      end
    end
  end

  def test_recompile_includes_with_relative_path
    if_have 'sass', 'compass' do
      with_site do |site|
        # Write compass config
        FileUtils.mkdir_p('compass')
        File.open('compass/config.rb', 'w') do |io|
          io << "project_path = \".\"\n"
          io << "sass_path = \"content/style\"\n"
        end

        # Create two Sass files
        Dir['content/*'].each { |i| FileUtils.rm(i) }
        FileUtils.mkdir_p('content/style/super')
        FileUtils.mkdir_p('content/style/sub')
        File.open('content/style/super/main.sass', 'w') do |io|
          io.write('@import sub/include.sass')
        end
        File.open('content/style/sub/include.sass', 'w') do |io|
          io.write("p\n  color: red")
        end

        # Update rules
        File.open('Rules', 'w') do |io|
          io.write "require 'compass'\n"
          io.write "Compass.add_project_configuration 'compass/config.rb'\n"
          io.write "\n"
          io.write "compile '*' do\n"
          io.write "  filter :sass, Compass.sass_engine_options\n"
          io.write "end\n"
          io.write "\n"
          io.write "route '/style/super/main/' do\n"
          io.write "  item.identifier.chop + '.css'\n"
          io.write "end\n"
          io.write "\n"
          io.write "route '/style/sub/include/' do\n"
          io.write "  nil\n"
          io.write "end\n"
        end

        # Compile
        site = Nanoc::Int::SiteLoader.new.new_from_cwd
        site.compile

        # Check
        output_files = Dir['output/**/*'].select { |f| File.file?(f) }
        assert_equal ['output/style/super/main.css'], output_files
        assert_match(/^p\s*\{\s*color:\s*red;?\s*\}/, File.read('output/style/super/main.css'))

        # Update included file
        File.open('content/style/sub/include.sass', 'w') do |io|
          io.write("p\n  color: blue")
        end

        # Recompile
        site = Nanoc::Int::SiteLoader.new.new_from_cwd
        site.compile

        # Recheck
        output_files = Dir['output/**/*'].select { |f| File.file?(f) }
        assert_equal ['output/style/super/main.css'], output_files
        assert_match(/^p\s*\{\s*color:\s*blue;?\s*\}/, File.read('output/style/super/main.css'))
      end
    end
  end

  def test_sass_without_filter
    if_have 'sass' do
      File.open('_morestuff.sass', 'w') do |io|
        io.write("p\n  color: blue")
      end

      options = { filename: File.join(Dir.getwd, 'test.sass') }
      ::Sass::Engine.new('@import "morestuff"', options).render
    end
  end

  private

  def create_filter(params = {})
    FileUtils.mkdir_p('content')
    File.open('content/xyzzy.sass', 'w') { |io| io.write('p\n  color: green') }

    items = [
      Nanoc::ItemWithRepsView.new(
        Nanoc::Int::Item.new(
          'blah',
          { content_filename: 'content/xyzzy.sass' },
          '/blah/',
        ),
        nil,
      ),
    ]
    params = { item: items[0], items: items }.merge(params)
    ::Nanoc::Filters::Sass.new(params)
  end
end
nanoc-4.4.7/test/filters/test_asciidoc.rb0000644000004100000410000000052013033443476020451 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Filters::AsciiDocTest < Nanoc::TestCase
  def test_filter
    skip_unless_have_command 'asciidoc'

    # Create filter
    filter = ::Nanoc::Filters::AsciiDoc.new

    # Run filter
    result = filter.setup_and_run('== Blah blah')
    assert_match %r{
Blah blah
}, result
  end
end
nanoc-4.4.7/test/filters/test_mustache.rb0000644000004100000410000000205613033443476020512 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Filters::MustacheTest < Nanoc::TestCase
  def test_filter
    if_have 'mustache' do
      # Create item
      item = Nanoc::Int::Item.new(
        'content',
        { title: 'Max Payne', protagonist: 'Max Payne' },
        '/games/max-payne/',
      )

      # Create filter
      filter = ::Nanoc::Filters::Mustache.new(item: item)

      # Run filter
      result = filter.setup_and_run('The protagonist of {{title}} is {{protagonist}}.')
      assert_equal('The protagonist of Max Payne is Max Payne.', result)
    end
  end

  def test_filter_with_yield
    if_have 'mustache' do
      # Create item
      item = Nanoc::Int::Item.new(
        'content',
        { title: 'Max Payne', protagonist: 'Max Payne' },
        '/games/max-payne/',
      )

      # Create filter
      filter = ::Nanoc::Filters::Mustache.new(
        content: 'No Payne No Gayne', item: item,
      )

      # Run filter
      result = filter.setup_and_run('Max says: {{yield}}.')
      assert_equal('Max says: No Payne No Gayne.', result)
    end
  end
end
nanoc-4.4.7/test/filters/colorize_syntax/0000755000004100000410000000000013033443476020546 5ustar  www-datawww-datananoc-4.4.7/test/filters/colorize_syntax/test_pygments.rb0000644000004100000410000000130113033443476023773 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Filters::ColorizeSyntax::PygmentsTest < Nanoc::TestCase
  def test_pygmentsrb
    skip 'pygments.rb does not support Windows' if on_windows?
    if_have 'pygments', 'nokogiri' do
      # Create filter
      filter = ::Nanoc::Filters::ColorizeSyntax.new

      # Get input and expected output
      input = '
# comment…
'
      expected_output = '
# comment…
'

      # Run filter
      actual_output = filter.setup_and_run(input, colorizers: { ruby: :pygmentsrb })
      assert_equal(expected_output, actual_output)
    end
  end
end
nanoc-4.4.7/test/filters/colorize_syntax/test_pygmentize.rb0000644000004100000410000000237313033443476024332 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Filters::ColorizeSyntax::PygmentizeTest < Nanoc::TestCase
  def test_pygmentize
    if_have 'nokogiri' do
      skip_unless_have_command 'pygmentize'

      # Create filter
      filter = ::Nanoc::Filters::ColorizeSyntax.new

      # Get input and expected output
      input = '
# comment
'
      expected_output = '
# comment
'

      # Run filter
      actual_output = filter.setup_and_run(input, colorizers: { ruby: :pygmentize })
      assert_equal(expected_output, actual_output)
    end
  end

  def test_colorize_syntax_with_default_colorizer
    skip_unless_have_command 'pygmentize'

    if_have 'nokogiri' do
      # Create filter
      filter = ::Nanoc::Filters::ColorizeSyntax.new

      # Get input and expected output
      input = '
puts "foo"
'
      expected_output = '
puts "foo"
'

      # Run filter
      actual_output = filter.setup_and_run(input, default_colorizer: :pygmentize)
      assert_equal(expected_output, actual_output)
    end
  end
end
nanoc-4.4.7/test/filters/colorize_syntax/test_common.rb0000644000004100000410000000471713033443476023433 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Filters::ColorizeSyntax::CommonTest < Nanoc::TestCase
  def test_dummy
    if_have 'nokogiri' do
      # Create filter
      filter = ::Nanoc::Filters::ColorizeSyntax.new

      # Get input and expected output
      input = '
# comment
'
      expected_output = input # because we are using a dummy

      # Run filter
      actual_output = filter.setup_and_run(input, default_colorizer: :dummy)
      assert_equal(expected_output, actual_output)
    end
  end

  def test_with_frozen_input
    if_have 'nokogiri' do
      input = '
# comment
'.freeze
      input.freeze

      filter = ::Nanoc::Filters::ColorizeSyntax.new
      filter.setup_and_run(input, default_colorizer: :dummy)
    end
  end

  def test_full_page
    if_have 'nokogiri' do
      # Create filter
      filter = ::Nanoc::Filters::ColorizeSyntax.new

      # Get input and expected output
      input = <

  
    Foo
  
  
    
# comment

  

EOS
      expected_output_regex = %r{^\s*\s*\s*\s*Foo\s*\s*\s*
# comment
\s*\s*}

      # Run filter
      actual_output = filter.setup_and_run(input, default_colorizer: :dummy, is_fullpage: true)
      assert_match expected_output_regex, actual_output
    end
  end

  def test_colorize_syntax_with_missing_executables
    if_have 'nokogiri' do
      begin
        original_path = ENV['PATH']
        ENV['PATH'] = './blooblooblah'

        # Create filter
        filter = ::Nanoc::Filters::ColorizeSyntax.new

        # Get input and expected output
        input = '
puts "foo"
'

        # Run filter
        [:albino, :pygmentize, :simon_highlight].each do |colorizer|
          begin
            input = '
puts "foo"
'
            filter.setup_and_run(
              input,
              colorizers: { ruby: colorizer },
            )
            flunk 'expected colorizer to raise if no executable is available'
          rescue
          end
        end
      ensure
        ENV['PATH'] = original_path
      end
    end
  end
end
nanoc-4.4.7/test/filters/colorize_syntax/test_simon.rb0000644000004100000410000000124713033443476023263 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Filters::ColorizeSyntax::SimonTest < Nanoc::TestCase
  def test_simon_highlight
    if_have 'nokogiri' do
      skip_unless_have_command 'highlight'

      # Create filter
      filter = ::Nanoc::Filters::ColorizeSyntax.new

      # Get input and expected output
      input = %(

# comment

)
      expected_output = '
# comment
'

      # Run filter
      actual_output = filter.setup_and_run(input, default_colorizer: :simon_highlight)
      assert_equal(expected_output, actual_output)
    end
  end
end
nanoc-4.4.7/test/filters/colorize_syntax/test_coderay.rb0000644000004100000410000001611613033443476023565 0ustar  www-datawww-datarequire 'helper'

class Nanoc::Filters::ColorizeSyntax::CoderayTest < Nanoc::TestCase
  CODERAY_PRE  = '
'.freeze
  CODERAY_POST = '
'.freeze

  def test_coderay_simple
    if_have 'coderay', 'nokogiri' do
      # Create filter
      filter = ::Nanoc::Filters::ColorizeSyntax.new

      # Get input and expected output
      input = '
# comment
'
      expected_output = CODERAY_PRE + '
# comment
' + CODERAY_POST

      # Run filter
      actual_output = filter.setup_and_run(input)
      assert_equal(expected_output, actual_output)
    end
  end

  def test_coderay_with_comment
    if_have 'coderay', 'nokogiri' do
      # Create filter
      filter = ::Nanoc::Filters::ColorizeSyntax.new

      # Get input and expected output
      input = %(
#!ruby
# comment
)
      expected_output = CODERAY_PRE + '
# comment
' + CODERAY_POST

      # Run filter
      actual_output = filter.setup_and_run(input)
      assert_equal(expected_output, actual_output)
    end
  end

  def test_coderay_with_comment_in_middle
    if_have 'coderay', 'nokogiri' do
      # Create filter
      filter = ::Nanoc::Filters::ColorizeSyntax.new

      # Get input and expected output
      input = %(
def moo ; end
#!ruby
# comment
)
      expected_output = "
def moo ; end\n#!ruby\n# comment
"

      # Run filter
      actual_output = filter.setup_and_run(input)
      assert_equal(expected_output, actual_output)
    end
  end

  def test_coderay_with_comment_and_class
    if_have 'coderay', 'nokogiri' do
      # Create filter
      filter = ::Nanoc::Filters::ColorizeSyntax.new

      # Get input and expected output
      input = %(
#!ruby
# comment
)
      expected_output = CODERAY_PRE + %(
#!ruby
# comment
) + CODERAY_POST

      # Run filter
      actual_output = filter.setup_and_run(input)
      assert_equal(expected_output, actual_output)
    end
  end

  def test_coderay_with_more_classes
    if_have 'coderay', 'nokogiri' do
      # Create filter
      filter = ::Nanoc::Filters::ColorizeSyntax.new

      # Get input and expected output
      input = '
# comment
'
      expected_output = CODERAY_PRE + '
# comment
' + CODERAY_POST

      # Run filter
      actual_output = filter.setup_and_run(input)
      assert_equal(expected_output, actual_output)
    end
  end

  def test_colorize_syntax_with_unknown_syntax
    if_have 'coderay', 'nokogiri' do
      # Create filter
      filter = ::Nanoc::Filters::ColorizeSyntax.new

      # Run filter
      assert_raises RuntimeError do
        filter.setup_and_run('
whatever
', syntax: :kasflwafhaweoineurl)
      end
    end
  end

  def test_colorize_syntax_with_xml
    if_have 'coderay', 'nokogiri' do
      # Create filter
      filter = ::Nanoc::Filters::ColorizeSyntax.new

      # Get input and expected output
      input = '
foo
bar
'
      expected_output = '
foo
bar
'

      # Run filter
      actual_output = filter.setup_and_run(input, syntax: :xml)
      assert_equal(expected_output, actual_output)
    end
  end

  def test_colorize_syntax_with_xhtml
    if_have 'coderay', 'nokogiri' do
      # Create filter
      filter = ::Nanoc::Filters::ColorizeSyntax.new

      # Get input and expected output
      input = '
foo
bar
'
      expected_output = '
foo
bar
'

      # Run filter
      actual_output = filter.setup_and_run(input, syntax: :xhtml)
      assert_equal(expected_output, actual_output)
    end
  end

  def test_colorize_syntax_with_non_language_shebang_line
    if_have 'coderay', 'nokogiri' do
      # Create filter
      filter = ::Nanoc::Filters::ColorizeSyntax.new

      # Get input and expected output
      input = <
#!/usr/bin/env ruby
puts 'hi!'


after
EOS
      expected_output = <
#!/usr/bin/env ruby
puts 'hi!'


after
EOS

      # Run filter
      actual_output = filter.setup_and_run(input).sub(/\s*\Z/m, '')
      assert_equal(expected_output, actual_output)
    end
  end

  def test_colorize_syntax_with_non_language_shebang_line_and_language_line
    if_have 'coderay', 'nokogiri' do
      # Create filter
      filter = ::Nanoc::Filters::ColorizeSyntax.new

      # Get input and expected output
      input = <
#!ruby
#!/usr/bin/env ruby
puts 'hi!'
after EOS expected_output = <#!/usr/bin/env ruby puts 'hi!'#{CODERAY_POST} after EOS # Run filter actual_output = filter.setup_and_run(input).sub(/\s*\Z/m, '') assert_equal(expected_output, actual_output) end end def test_not_outside_pre if_have 'coderay', 'nokogiri' do # Create filter filter = ::Nanoc::Filters::ColorizeSyntax.new # Get input and expected output input = '# comment' expected_output = '# comment' # Run filter actual_output = filter.setup_and_run(input, outside_pre: false) assert_equal(expected_output, actual_output) end end def test_outside_pre if_have 'coderay', 'nokogiri' do # Create filter filter = ::Nanoc::Filters::ColorizeSyntax.new # Get input and expected output input = '# comment' expected_output = '# comment' # Run filter actual_output = filter.setup_and_run(input, outside_pre: true) assert_equal(expected_output, actual_output) end end def test_strip if_have 'coderay', 'nokogiri' do # Create filter filter = ::Nanoc::Filters::ColorizeSyntax.new # Simple test assert_equal ' bar', filter.send(:strip, "\n bar") # Get input and expected output input = < def foo end after EOS expected_output = < def foo end#{CODERAY_POST} after EOS # Run filter actual_output = filter.setup_and_run(input).sub(/\s*\Z/m, '') assert_equal(expected_output, actual_output) end end end nanoc-4.4.7/test/filters/test_redcarpet.rb0000644000004100000410000000635113033443476020654 0ustar www-datawww-datarequire 'helper' class Nanoc::Filters::RedcarpetTest < Nanoc::TestCase def test_find if_have 'redcarpet' do refute Nanoc::Filter.named(:redcarpet).nil? end end def test_filter if_have 'redcarpet' do # Create filter filter = ::Nanoc::Filters::Redcarpet.new # Run filter result = filter.setup_and_run('> Quote') assert_match(/
\s*

Quote<\/p>\s*<\/blockquote>/, result) end end def test_with_extensions if_have 'redcarpet' do # Create filter filter = ::Nanoc::Filters::Redcarpet.new # Run filter if ::Redcarpet::VERSION > '2' input = 'this is ~~good~~ bad' output_expected = /this is good<\/del> bad/ output_actual = filter.setup_and_run(input, options: { strikethrough: true }) else input = "The quotation 'marks' sure make this look sarcastic!" output_expected = /The quotation ‘marks’ sure make this look sarcastic!/ output_actual = filter.setup_and_run(input, options: [:smart]) end assert_match(output_expected, output_actual) end end def test_html_by_default if_have 'redcarpet' do # Create filter filter = ::Nanoc::Filters::Redcarpet.new # Run filter input = "![Alt](/path/to/img 'Title')" output_expected = %r{Alt} output_actual = filter.setup_and_run(input) assert_match(output_expected, output_actual) end end def test_xhtml_if_requested if_have 'redcarpet' do # Create filter filter = ::Nanoc::Filters::Redcarpet.new # Run filter input = "![Alt](/path/to/img 'Title')" output_expected = %r{Alt} output_actual = if ::Redcarpet::VERSION > '2' filter.setup_and_run(input, renderer_options: { xhtml: true }) else filter.setup_and_run(input, options: [:xhtml]) end assert_match(output_expected, output_actual) end end def test_html_toc if_have 'redcarpet' do unless ::Redcarpet::VERSION > '2' skip 'Requires Redcarpet >= 2' end # Create filter filter = ::Nanoc::Filters::Redcarpet.new # Run filter input = "# Heading 1\n## Heading 2\n" output_actual = filter.run(input, renderer: Redcarpet::Render::HTML_TOC) # Test output_expected = %r{

} assert_match(output_expected, output_actual) end end def test_toc_if_requested if_have 'redcarpet' do # Create filter filter = ::Nanoc::Filters::Redcarpet.new # Run filter input = "A Title\n======" if ::Redcarpet::VERSION > '2' output_expected = %r{\n

A Title

\n} output_actual = filter.setup_and_run(input, with_toc: true) else output_expected = %r{

A Title

\n} output_actual = filter.setup_and_run(input) end # Test assert_match(output_expected, output_actual) end end end nanoc-4.4.7/test/filters/test_kramdown.rb0000644000004100000410000000343613033443476020526 0ustar www-datawww-datarequire 'helper' class Nanoc::Filters::KramdownTest < Nanoc::TestCase def test_filter if_have 'kramdown' do # Create filter filter = ::Nanoc::Filters::Kramdown.new # Run filter result = filter.setup_and_run('This is _so_ **cool**!') assert_equal("

This is so cool!

\n", result) end end def test_warnings if_have 'kramdown' do # Create item item = Nanoc::Int::Item.new('foo', {}, '/foo.md') item_view = Nanoc::ItemWithRepsView.new(item, nil) item_rep = Nanoc::Int::ItemRep.new(item, :default) item_rep_view = Nanoc::ItemRepView.new(item_rep, nil) # Create filter filter = ::Nanoc::Filters::Kramdown.new(item: item_view, item_rep: item_rep_view) # Run filter io = capturing_stdio do filter.setup_and_run('{:foo}this is bogus') end assert_empty io[:stdout] assert_equal "kramdown warning(s) for #{item_rep_view.inspect}\n Found span IAL after text - ignoring it\n", io[:stderr] end end def test_warning_filters if_have 'kramdown' do # Create item item = Nanoc::Int::Item.new('foo', {}, '/foo.md') item_view = Nanoc::ItemWithRepsView.new(item, nil) item_rep = Nanoc::Int::ItemRep.new(item, :default) item_rep_view = Nanoc::ItemRepView.new(item_rep, nil) # Create filter filter = ::Nanoc::Filters::Kramdown.new(item: item_view, item_rep: item_rep_view) # Run filter io = capturing_stdio do filter.setup_and_run("{:foo}this is bogus\n[foo]: http://foo.com\n", warning_filters: 'No link definition') end assert_empty io[:stdout] assert_equal "kramdown warning(s) for #{item_rep_view.inspect}\n Found span IAL after text - ignoring it\n", io[:stderr] end end end nanoc-4.4.7/test/filters/test_rubypants.rb0000644000004100000410000000050013033443476020720 0ustar www-datawww-datarequire 'helper' class Nanoc::Filters::RubyPantsTest < Nanoc::TestCase def test_filter if_have 'rubypants' do # Get filter filter = ::Nanoc::Filters::RubyPants.new # Run filter result = filter.setup_and_run('Wait---what?') assert_equal('Wait—what?', result) end end end nanoc-4.4.7/test/filters/test_erb.rb0000644000004100000410000000551413033443476017453 0ustar www-datawww-datarequire 'helper' class Nanoc::Filters::ERBTest < Nanoc::TestCase def test_filter_with_instance_variable # Create filter filter = ::Nanoc::Filters::ERB.new(location: 'a cheap motel') # Run filter result = filter.setup_and_run('<%= "I was hiding in #{@location}." %>') assert_equal('I was hiding in a cheap motel.', result) end def test_filter_with_instance_method # Create filter filter = ::Nanoc::Filters::ERB.new(location: 'a cheap motel') # Run filter result = filter.setup_and_run('<%= "I was hiding in #{location}." %>') assert_equal('I was hiding in a cheap motel.', result) end def test_filter_error_item # Create item and item rep item = MiniTest::Mock.new item.expect(:identifier, '/foo/bar/baz/') item_rep = MiniTest::Mock.new item_rep.expect(:name, :quux) # Create filter filter = ::Nanoc::Filters::ERB.new( item: item, item_rep: item_rep, location: 'a cheap motel', ) # Run filter raised = false begin filter.setup_and_run('<%= this isn\'t really ruby so it\'ll break, muahaha %>') rescue SyntaxError => e e.message =~ /(.+?):\d+: / assert_match 'item /foo/bar/baz/ (rep quux)', Regexp.last_match[1] raised = true end assert raised end def test_filter_with_yield # Create filter filter = ::Nanoc::Filters::ERB.new(content: 'a cheap motel') # Run filter result = filter.setup_and_run('<%= "I was hiding in #{yield}." %>') assert_equal('I was hiding in a cheap motel.', result) end def test_filter_with_yield_without_content # Create filter filter = ::Nanoc::Filters::ERB.new(location: 'a cheap motel') # Run filter assert_raises LocalJumpError do filter.setup_and_run('<%= "I was hiding in #{yield}." %>') end end def test_safe_level if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby' skip 'JRuby does not implement safe levels' end # Set up filter = ::Nanoc::Filters::ERB.new File.open('moo', 'w') { |io| io.write('one miiillion dollars') } # Without res = filter.setup_and_run('<%= File.read("moo") %>', safe_level: nil) assert_equal 'one miiillion dollars', res # With assert_raises(SecurityError) do res = filter.setup_and_run('<%= eval File.read("moo") %>', safe_level: 1) end end def test_trim_mode # Set up filter = ::Nanoc::Filters::ERB.new(location: 'a cheap motel') $trim_mode_works = false # Without filter.setup_and_run('% $trim_mode_works = true') refute $trim_mode_works # With filter.setup_and_run('% $trim_mode_works = true', trim_mode: '%') assert $trim_mode_works end def test_locals filter = ::Nanoc::Filters::ERB.new result = filter.setup_and_run('<%= @local %>', locals: { local: 123 }) assert_equal '123', result end end nanoc-4.4.7/test/filters/test_relativize_paths.rb0000644000004100000410000005057513033443476022267 0ustar www-datawww-datarequire 'helper' class Nanoc::Filters::RelativizePathsTest < Nanoc::TestCase def test_filter_html_with_double_quotes # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/foo/bar/baz/' end # Set content raw_content = %(foo) expected_content = %(foo) # Test actual_content = filter.setup_and_run(raw_content, type: :html) assert_equal(expected_content, actual_content) end def test_filter_html_with_single_quotes # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/foo/bar/baz/' end # Set content raw_content = %(foo) expected_content = %(foo) # Test actual_content = filter.setup_and_run(raw_content, type: :html) assert_equal(expected_content, actual_content) end def test_filter_html_without_quotes # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/foo/bar/baz/' end # Set content raw_content = %(foo) expected_content = %(foo) # Test actual_content = filter.setup_and_run(raw_content, type: :html) assert_equal(expected_content, actual_content) end def test_filter_html_with_boilerplate # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/foo/bar/baz/' end # Set content raw_content = < Hello foo EOS expected0 = %r{foo} expected1 = %r{\A\s*\s*\s*(.|\s)*Hello\s*\s*\s*foo\s*\s*\s*\Z}m # Test actual_content = filter.setup_and_run(raw_content, type: :html) assert_match(expected0, actual_content) assert_match(expected1, actual_content) end def test_filter_html_multiple # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/foo/bar/baz/' end # Set content raw_content = %(foo bar) expected_content = %(foo bar) # Test actual_content = filter.setup_and_run(raw_content, type: :html) assert_equal(expected_content, actual_content) end def test_filter_html_nested # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/foo/bar/baz/' end # Set content raw_content = %() expected_content = %() # Test actual_content = filter.setup_and_run(raw_content, type: :html) assert_equal(expected_content, actual_content) end def test_filter_html_outside_tag # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/foo/bar/baz/' end # Set content raw_content = %(stuff href="/foo" more stuff) expected_content = %(stuff href="/foo" more stuff) # Test actual_content = filter.setup_and_run(raw_content, type: :html) assert_equal(expected_content, actual_content) end def test_filter_html_root # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/woof/meow/' end # Set content raw_content = %(foo) expected_content = %(foo) # Test actual_content = filter.setup_and_run(raw_content, type: :html) assert_equal(expected_content, actual_content) end def test_filter_html_network_path # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/woof/meow/' end # Set content raw_content = %(example.com) expected_content = %(example.com) # Test actual_content = filter.setup_and_run(raw_content, type: :html) assert_equal(expected_content, actual_content) end def test_filter_html_with_anchor # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/woof/meow/' end # Set content raw_content = %(Max Payne) expected_content = %(Max Payne) # Test actual_content = filter.setup_and_run(raw_content, type: :html) assert_equal(expected_content, actual_content) end def test_filter_html_with_url # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/woof/meow/' end # Set content raw_content = %(Example) expected_content = %(Example) # Test actual_content = filter.setup_and_run(raw_content, type: :html) assert_equal(expected_content, actual_content) end def test_filter_html_with_relative_path # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/woof/meow/' end # Set content raw_content = %(Example) expected_content = %(Example) # Test actual_content = filter.setup_and_run(raw_content, type: :html) assert_equal(expected_content, actual_content) end def test_filter_html_object_with_relative_path # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/woof/meow/' end raw_content = %() actual_content = filter.setup_and_run(raw_content, type: :html) assert_match(//, actual_content) assert_match(/) expected_content = %(
) # Test actual_content = filter.setup_and_run(raw_content, type: :html) assert_equal(expected_content, actual_content) end def test_filter_implicit # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Test assert_raises(RuntimeError) do filter.setup_and_run('moo') end end def test_filter_css_with_double_quotes # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/foo/bar/baz/' end # Set content raw_content = %[background: url("/foo/bar/background.png");] expected_content = %[background: url("../background.png");] # Test actual_content = filter.setup_and_run(raw_content, type: :css) assert_equal(expected_content, actual_content) end def test_filter_css_with_single_quotes # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/foo/bar/baz/' end # Set content raw_content = %[background: url('/foo/bar/background.png');] expected_content = %[background: url('../background.png');] # Test actual_content = filter.setup_and_run(raw_content, type: :css) assert_equal(expected_content, actual_content) end def test_filter_css_without_quotes # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/foo/bar/baz/' end # Set content raw_content = %[background: url(/foo/bar/background.png);] expected_content = %[background: url(../background.png);] # Test actual_content = filter.setup_and_run(raw_content, type: :css) assert_equal(expected_content, actual_content) end def test_filter_css_multiple # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/foo/bar/baz/' end # Set content raw_content = %[background: url(/foo/bar/a.png) url(/foo/bar/b.png);] expected_content = %[background: url(../a.png) url(../b.png);] # Test actual_content = filter.setup_and_run(raw_content, type: :css) assert_equal(expected_content, actual_content) end def test_filter_css_root # It is probably a bit weird to have “url(/)” in CSS, but I’ve made a # test case for this situation anyway. Can’t hurt… # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/woof/meow/' end # Set content raw_content = %[background: url(/);] expected_content = %[background: url(../../);] # Test actual_content = filter.setup_and_run(raw_content, type: :css) assert_equal(expected_content, actual_content) end def test_filter_css_network_path # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/woof/meow/' end # Set content raw_content = %[background: url(//example.com);] expected_content = %[background: url(//example.com);] # Test actual_content = filter.setup_and_run(raw_content, type: :css) assert_equal(expected_content, actual_content) end def test_filter_xml if_have 'nokogiri' do # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/foo/bar/baz/' end # Set content expected = /baz<\/bar>/ raw_content = <<-XML baz XML actual_content = filter.setup_and_run(raw_content, type: :xml, select: ['*/@boo']) assert_match(expected, actual_content) end end def test_filter_fragment_xml if_have 'nokogiri' do # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/foo/bar/baz/' end # Set content raw_content = <<-XML baz XML actual_content = filter.setup_and_run(raw_content, type: :xml, select: ['far/@href']) assert_match(//, actual_content) assert_match(/baz<\/far><\/bar>/, actual_content) end end def test_filter_xml_with_namespaces if_have 'nokogiri' do # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/foo/bar/baz/' end # Set content raw_content = <<-XML baz XML options = { type: :xml, namespaces: { ex: 'http://example.org' }, select: ['ex:a/@href'], } actual_content = filter.setup_and_run(raw_content, options) assert_match(//, actual_content) assert_match(/baz<\/a><\/bar>/, actual_content) end end def test_filter_xhtml if_have 'nokogiri' do # Create filter with mock item filter = Nanoc::Filters::RelativizePaths.new # Mock item filter.instance_eval do @item_rep = Nanoc::Int::ItemRep.new( Nanoc::Int::Item.new( 'content', {}, '/foo/bar/baz/', ), :blah, ) @item_rep.paths[:last] = '/foo/bar/baz/' end # Set content raw_content = <<-XML bar XML actual_content = filter.setup_and_run(raw_content, type: :xhtml) assert_match(/]*href="..\/..\/..\/css"[^>]*\/>/, actual_content) assert_match(/', '
', '', '', '', ]) check = Nanoc::Checking::Checks::MixedContent.create(site) check.run assert_empty check.issues end end def test_root_relative_content with_site do |site| create_output_file('foo.html', [ '', '', '', '
', '', '', '', ]) check = Nanoc::Checking::Checks::MixedContent.create(site) check.run assert_empty check.issues end end def test_protocol_relative_content with_site do |site| create_output_file('foo.html', [ '', '', '', '
', '', '', '', ]) check = Nanoc::Checking::Checks::MixedContent.create(site) check.run assert_empty check.issues end end def test_document_relative_content with_site do |site| create_output_file('foo.html', [ '', '', '', '
', '', '', '', ]) check = Nanoc::Checking::Checks::MixedContent.create(site) check.run assert_empty check.issues end end def test_query_relative_content with_site do |site| create_output_file('foo.html', [ '', '', '', '
', '', '', '', ]) check = Nanoc::Checking::Checks::MixedContent.create(site) check.run assert_empty check.issues end end def test_fragment_relative_content with_site do |site| create_output_file('foo.html', [ '', '', '', '
', '', '', '', ]) check = Nanoc::Checking::Checks::MixedContent.create(site) check.run assert_empty check.issues end end def test_http_content with_site do |site| create_output_file('foo.html', [ '', '', '', '', '
', '', '', '', ]) check = Nanoc::Checking::Checks::MixedContent.create(site) check.run issues = check.issues.to_a assert_equal 8, issues.count descriptions = issues.map(&:description) issues.each do |issue| assert_equal 'output/foo.html', issue.subject end # The order of the reported issues is not important, so use this class's # `assert_include` helper to avoid asserting those details assert_include descriptions, 'mixed content include: http://nanoc.ws/logo.png' assert_include descriptions, 'mixed content include: HTTP://nanoc.ws/logo.png' assert_include descriptions, 'mixed content include: http://nanoc.ws/style.css' assert_include descriptions, 'mixed content include: http://nanoc.ws/app.js' assert_include descriptions, 'mixed content include: http://nanoc.ws/process.cgi' assert_include descriptions, 'mixed content include: http://nanoc.ws/preview.html' assert_include descriptions, 'mixed content include: http://nanoc.ws/theme-song.flac' assert_include descriptions, 'mixed content include: http://nanoc.ws/screencast.mkv' end end def test_inert_content with_site do |site| create_output_file('foo.html', [ 'The homepage', 'Content', '', '', '', '', '
', '', '', '', '

http://nanoc.ws/harmless-text

', ]) check = Nanoc::Checking::Checks::MixedContent.create(site) check.run assert_empty check.issues end end end nanoc-4.4.7/test/checking/checks/test_internal_links.rb0000644000004100000410000000741213033443476023261 0ustar www-datawww-datarequire 'helper' class Nanoc::Checking::Checks::InternalLinksTest < Nanoc::TestCase def test_run with_site do |site| # Create files FileUtils.mkdir_p('output') FileUtils.mkdir_p('output/stuff') File.open('output/foo.txt', 'w') { |io| io.write('broken') } File.open('output/bar.html', 'w') { |io| io.write('not broken') } # Create check check = Nanoc::Checking::Checks::InternalLinks.create(site) check.run # Test assert check.issues.empty? end end def test_resource_uris with_site do |site| # Create files FileUtils.mkdir_p('output') File.open('output/bar.html', 'w') { |io| io.write('') } # Create check check = Nanoc::Checking::Checks::InternalLinks.create(site) check.run # Test assert check.issues.size == 1 end end def test_valid? with_site do |site| # Create files FileUtils.mkdir_p('output') FileUtils.mkdir_p('output/stuff') File.open('output/origin', 'w') { |io| io.write('hi') } File.open('output/foo', 'w') { |io| io.write('hi') } File.open('output/stuff/blah', 'w') { |io| io.write('hi') } # Create check check = Nanoc::Checking::Checks::InternalLinks.create(site) # Test assert check.send(:valid?, 'foo', 'output/origin') assert check.send(:valid?, 'origin', 'output/origin') assert check.send(:valid?, 'stuff/blah', 'output/origin') assert check.send(:valid?, '/foo', 'output/origin') assert check.send(:valid?, '/origin', 'output/origin') assert check.send(:valid?, '/stuff/blah', 'output/origin') end end def test_remove_query_string with_site do |site| FileUtils.mkdir_p('output/stuff') File.open('output/stuff/right', 'w') { |io| io.write('hi') } check = Nanoc::Checking::Checks::InternalLinks.create(site) assert check.send(:valid?, 'stuff/right?foo=123', 'output/origin') refute check.send(:valid?, 'stuff/wrong?foo=123', 'output/origin') end end def test_exclude with_site do |site| # Create check check = Nanoc::Checking::Checks::InternalLinks.create(site) site.config.update(checks: { internal_links: { exclude: ['^/excluded\d+'] } }) # Test assert check.send(:valid?, '/excluded1', 'output/origin') assert check.send(:valid?, '/excluded2', 'output/origin') assert !check.send(:valid?, '/excluded_not', 'output/origin') end end def test_exclude_targets with_site do |site| # Create check check = Nanoc::Checking::Checks::InternalLinks.create(site) site.config.update(checks: { internal_links: { exclude_targets: ['^/excluded\d+'] } }) # Test assert check.send(:valid?, '/excluded1', 'output/origin') assert check.send(:valid?, '/excluded2', 'output/origin') assert !check.send(:valid?, '/excluded_not', 'output/origin') end end def test_exclude_origins with_site do |site| # Create check check = Nanoc::Checking::Checks::InternalLinks.create(site) site.config.update(checks: { internal_links: { exclude_origins: ['^/excluded'] } }) # Test assert check.send(:valid?, '/foo', 'output/excluded') assert !check.send(:valid?, '/foo', 'output/not_excluded') end end def test_unescape_url with_site do |site| FileUtils.mkdir_p('output/stuff') File.open('output/stuff/right foo', 'w') { |io| io.write('hi') } check = Nanoc::Checking::Checks::InternalLinks.create(site) assert check.send(:valid?, 'stuff/right%20foo', 'output/origin') refute check.send(:valid?, 'stuff/wrong%20foo', 'output/origin') end end end nanoc-4.4.7/test/checking/test_runner.rb0000644000004100000410000000207613033443476020317 0ustar www-datawww-datarequire 'helper' class Nanoc::Checking::RunnerTest < Nanoc::TestCase def test_run_specific with_site do |site| File.open('output/blah', 'w') { |io| io.write('I am stale! Haha!') } runner = Nanoc::Checking::Runner.new(site) runner.run_specific(%w(stale)) end end def test_run_specific_custom with_site do |site| File.open('Checks', 'w') do |io| io.write('check :my_foo_check do ; puts "I AM FOO!" ; end') end runner = Nanoc::Checking::Runner.new(site) ios = capturing_stdio do runner.run_specific(%w(my_foo_check)) end assert ios[:stdout].include?('I AM FOO!') end end def test_list_checks with_site do |site| File.open('Checks', 'w') do |io| io.write('check :my_foo_check do ; end') end runner = Nanoc::Checking::Runner.new(site) ios = capturing_stdio do runner.list_checks end assert ios[:stdout].include?('my_foo_check') assert ios[:stdout].include?('internal_links') assert ios[:stderr].empty? end end end nanoc-4.4.7/test/checking/test_dsl.rb0000644000004100000410000000157413033443476017572 0ustar www-datawww-datarequire 'helper' class Nanoc::Checking::DSLTest < Nanoc::TestCase def test_from_file with_site do |_site| File.open('Checks', 'w') { |io| io.write("check :foo do\n\nend\ndeploy_check :bar\n") } dsl = Nanoc::Checking::DSL.from_file('Checks') # One new check refute Nanoc::Checking::Check.named(:foo).nil? # One check marked for deployment assert_equal [:bar], dsl.deploy_checks end end def test_has_base_path with_site do |_site| File.write('stuff.rb', '$greeting = "hello"') File.write('Checks', 'require "./stuff"') Nanoc::Checking::DSL.from_file('Checks') assert_equal 'hello', $greeting end end def test_has_absolute_path with_site do |_site| File.write('Checks', '$stuff = __FILE__') Nanoc::Checking::DSL.from_file('Checks') assert($stuff.start_with?('/')) end end end nanoc-4.4.7/test/rule_dsl/0000755000004100000410000000000013033443476015453 5ustar www-datawww-datananoc-4.4.7/test/rule_dsl/test_rules_collection.rb0000644000004100000410000000626113033443476022411 0ustar www-datawww-datarequire 'helper' class Nanoc::RuleDSL::RulesCollectionTest < Nanoc::TestCase def test_compilation_rule_for # Mock rules rules = [mock, mock, mock] rules[0].expects(:applicable_to?).returns(false) rules[1].expects(:applicable_to?).returns(true) rules[1].expects(:rep_name).returns('wrong') rules[2].expects(:applicable_to?).returns(true) rules[2].expects(:rep_name).returns('right') rules_collection = Nanoc::RuleDSL::RulesCollection.new rules_collection.instance_eval { @item_compilation_rules = rules } # Mock rep rep = mock rep.stubs(:name).returns('right') item = mock rep.stubs(:item).returns(item) # Test assert_equal rules[2], rules_collection.compilation_rule_for(rep) end def test_filter_for_layout_with_existant_layout rules_collection = Nanoc::RuleDSL::RulesCollection.new rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(/.*/)] = [:erb, { foo: 'bar' }] # Mock layout layout = MiniTest::Mock.new layout.expect(:identifier, '/some_layout/') # Check assert_equal([:erb, { foo: 'bar' }], rules_collection.filter_for_layout(layout)) end def test_filter_for_layout_with_existant_layout_and_unknown_filter rules_collection = Nanoc::RuleDSL::RulesCollection.new rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(/.*/)] = [:some_unknown_filter, { foo: 'bar' }] # Mock layout layout = MiniTest::Mock.new layout.expect(:identifier, '/some_layout/') # Check assert_equal([:some_unknown_filter, { foo: 'bar' }], rules_collection.filter_for_layout(layout)) end def test_filter_for_layout_with_nonexistant_layout rules_collection = Nanoc::RuleDSL::RulesCollection.new rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(%r{^/foo/$})] = [:erb, { foo: 'bar' }] # Mock layout layout = MiniTest::Mock.new layout.expect(:identifier, '/bar/') # Check assert_equal(nil, rules_collection.filter_for_layout(layout)) end def test_filter_for_layout_with_many_layouts rules_collection = Nanoc::RuleDSL::RulesCollection.new rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(%r{^/a/b/c/.*/$})] = [:erb, { char: 'd' }] rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(%r{^/a/.*/$})] = [:erb, { char: 'b' }] rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(%r{^/a/b/.*/$})] = [:erb, { char: 'c' }] # never used! rules_collection.layout_filter_mapping[Nanoc::Int::Pattern.from(%r{^/.*/$})] = [:erb, { char: 'a' }] # Mock layout layouts = [mock, mock, mock, mock] layouts[0].stubs(:identifier).returns('/a/b/c/d/') layouts[1].stubs(:identifier).returns('/a/b/c/') layouts[2].stubs(:identifier).returns('/a/b/') layouts[3].stubs(:identifier).returns('/a/') # Get expectations expectations = { 0 => 'd', 1 => 'b', # never used! not c, because b takes priority 2 => 'b', 3 => 'a', } # Check expectations.each_pair do |num, char| filter_and_args = rules_collection.filter_for_layout(layouts[num]) refute_nil(filter_and_args) assert_equal(char, filter_and_args[1][:char]) end end end nanoc-4.4.7/test/rule_dsl/test_compiler_dsl.rb0000644000004100000410000002746013033443476021524 0ustar www-datawww-datarequire 'helper' class Nanoc::RuleDSL::CompilerDSLTest < Nanoc::TestCase def test_compile # TODO: implement end def test_route # TODO: implement end def test_layout # TODO: implement end def test_preprocess_twice rules_collection = Nanoc::RuleDSL::RulesCollection.new compiler_dsl = Nanoc::RuleDSL::CompilerDSL.new(rules_collection, {}) # first time io = capturing_stdio do compiler_dsl.preprocess {} end assert_empty io[:stdout] assert_empty io[:stderr] # second time io = capturing_stdio do compiler_dsl.preprocess {} end assert_empty io[:stdout] assert_match(/WARNING: A preprocess block is already defined./, io[:stderr]) end def test_postprocess_twice rules_collection = Nanoc::RuleDSL::RulesCollection.new compiler_dsl = Nanoc::RuleDSL::CompilerDSL.new(rules_collection, {}) # first time io = capturing_stdio do compiler_dsl.postprocess {} end assert_empty io[:stdout] assert_empty io[:stderr] # second time io = capturing_stdio do compiler_dsl.postprocess {} end assert_empty io[:stdout] assert_match(/WARNING: A postprocess block is already defined./, io[:stderr]) end def test_postprocessor_modified_method with_site do |site| # Create rules File.open('Rules', 'w') do |io| io.write <" end # Compile site = Nanoc::Int::SiteLoader.new.new_from_cwd site.compile # Check paths assert_equal ['output/foo'], Dir['output/*'] assert_equal ['output/foo/index.html'], Dir['output/foo/*'] end end def test_passthrough_with_full_identifiers with_site do File.open('nanoc.yaml', 'w') do |io| io << 'string_pattern_type: legacy' << "\n" io << 'data_sources:' << "\n" io << ' -' << "\n" io << ' type: filesystem' << "\n" io << ' identifier_type: full' << "\n" end # Create rules File.open('Rules', 'w') do |io| io << 'passthrough \'*\'' end # Create items assert Dir['content/*'].empty? File.open('content/robots.txt', 'w') do |io| io.write 'Hello I am robots' end # Compile site = Nanoc::Int::SiteLoader.new.new_from_cwd site.compile # Check paths assert_equal ['output/robots.txt'], Dir['output/*'] end end def test_ignore with_site do # Create rules File.open('Rules', 'w') do |io| io.write <" end # Compile site = Nanoc::Int::SiteLoader.new.new_from_cwd site.compile # Check paths assert_equal ['output/foo'], Dir['output/*'] assert_equal ['output/foo/index.html'], Dir['output/foo/*'] end end def test_create_pattern_with_string_with_no_config compiler_dsl = Nanoc::RuleDSL::CompilerDSL.new(nil, {}) err = assert_raises(Nanoc::Int::Errors::GenericTrivial) do compiler_dsl.create_pattern('/foo/*') end assert_equal 'Invalid string_pattern_type: ', err.message end def test_create_pattern_with_string_with_glob_string_pattern_type compiler_dsl = Nanoc::RuleDSL::CompilerDSL.new(nil, string_pattern_type: 'glob') pattern = compiler_dsl.create_pattern('/foo/*') assert pattern.match?('/foo/aaaa') refute pattern.match?('/foo/aaaa/') refute pattern.match?('/foo/a/a/a/a') end def test_create_pattern_with_regex compiler_dsl = Nanoc::RuleDSL::CompilerDSL.new(nil, string_pattern_type: 'glob') pattern = compiler_dsl.create_pattern(%r{\A/foo/a*/}) assert pattern.match?('/foo/aaaa/') end def test_create_pattern_with_string_with_unknown_string_pattern_type compiler_dsl = Nanoc::RuleDSL::CompilerDSL.new(nil, string_pattern_type: 'donkey') err = assert_raises(Nanoc::Int::Errors::GenericTrivial) do compiler_dsl.create_pattern('/foo/*') end assert_equal 'Invalid string_pattern_type: donkey', err.message end def test_identifier_to_regex_without_wildcards # Create compiler DSL compiler_dsl = Nanoc::RuleDSL::CompilerDSL.new(nil, {}) actual = compiler_dsl.instance_eval { identifier_to_regex('foo') } expected = %r{^/foo/?$} assert_equal(expected.to_s, actual.to_s) assert_equal(expected.source, actual.source) assert_equal(expected.kcode, actual.kcode) if expected.respond_to?(:kcode) assert_equal(expected.casefold?, actual.casefold?) assert_equal(expected.options, actual.options) end def test_identifier_to_regex_with_one_wildcard # Create compiler DSL compiler_dsl = Nanoc::RuleDSL::CompilerDSL.new(nil, {}) actual = compiler_dsl.instance_eval { identifier_to_regex('foo/*/bar') } expected = %r{^/foo/(.*?)/bar/?$} assert_equal(expected.to_s, actual.to_s) assert_equal(expected.source, actual.source) assert_equal(expected.kcode, actual.kcode) if expected.respond_to?(:kcode) assert_equal(expected.casefold?, actual.casefold?) assert_equal(expected.options, actual.options) end def test_identifier_to_regex_with_two_wildcards # Create compiler DSL compiler_dsl = Nanoc::RuleDSL::CompilerDSL.new(nil, {}) actual = compiler_dsl.instance_eval { identifier_to_regex('foo/*/bar/*/qux') } expected = %r{^/foo/(.*?)/bar/(.*?)/qux/?$} assert_equal(expected.to_s, actual.to_s) assert_equal(expected.source, actual.source) assert_equal(expected.kcode, actual.kcode) if expected.respond_to?(:kcode) assert_equal(expected.casefold?, actual.casefold?) assert_equal(expected.options, actual.options) end def test_identifier_to_regex_with_just_one_wildcard # Create compiler DSL compiler_dsl = Nanoc::RuleDSL::CompilerDSL.new(nil, {}) actual = compiler_dsl.instance_eval { identifier_to_regex('*') } expected = %r{^/(.*?)$} assert_equal(expected.to_s, actual.to_s) assert_equal(expected.source, actual.source) assert_equal(expected.kcode, actual.kcode) if expected.respond_to?(:kcode) assert_equal(expected.casefold?, actual.casefold?) assert_equal(expected.options, actual.options) end def test_identifier_to_regex_with_root # Create compiler DSL compiler_dsl = Nanoc::RuleDSL::CompilerDSL.new(nil, {}) actual = compiler_dsl.instance_eval { identifier_to_regex('/') } expected = %r{^/$} assert_equal(expected.to_s, actual.to_s) assert_equal(expected.source, actual.source) assert_equal(expected.kcode, actual.kcode) if expected.respond_to?(:kcode) assert_equal(expected.casefold?, actual.casefold?) assert_equal(expected.options, actual.options) end def test_identifier_to_regex_with_only_children # Create compiler DSL compiler_dsl = Nanoc::RuleDSL::CompilerDSL.new(nil, {}) actual = compiler_dsl.instance_eval { identifier_to_regex('/foo/*/') } expected = %r{^/foo/(.*?)/$} assert_equal(expected.to_s, actual.to_s) assert_equal(expected.source, actual.source) assert_equal(expected.kcode, actual.kcode) if expected.respond_to?(:kcode) assert_equal(expected.casefold?, actual.casefold?) assert_equal(expected.options, actual.options) end def test_identifier_to_regex_with_plus_wildcard # Create compiler DSL compiler_dsl = Nanoc::RuleDSL::CompilerDSL.new(nil, {}) actual = compiler_dsl.instance_eval { identifier_to_regex('/foo/+') } expected = %r{^/foo/(.+?)/?$} assert_equal(expected.to_s, actual.to_s) assert_equal(expected.source, actual.source) assert_equal(expected.kcode, actual.kcode) if expected.respond_to?(:kcode) assert_equal(expected.casefold?, actual.casefold?) assert_equal(expected.options, actual.options) assert('/foo/bar/' =~ actual) refute('/foo/' =~ actual) end def test_identifier_to_regex_with_full_identifier # Create compiler DSL compiler_dsl = Nanoc::RuleDSL::CompilerDSL.new(nil, {}) actual = compiler_dsl.instance_eval { identifier_to_regex('/favicon.ico') } expected = %r{^/favicon\.ico/?$} assert_equal(expected.to_s, actual.to_s) assert('/favicon.ico' =~ actual) assert('/favicon.ico/' =~ actual) refute('/faviconxico' =~ actual) end def test_dsl_has_no_access_to_compiler compiler_dsl = Nanoc::RuleDSL::CompilerDSL.new(nil, {}) assert_raises(NameError) do compiler_dsl.instance_eval { compiler } end end def test_config $venetian = 'unsnares' compiler_dsl = Nanoc::RuleDSL::CompilerDSL.new(nil, venetian: 'snares') compiler_dsl.instance_eval { $venetian = @config[:venetian] } assert_equal 'snares', $venetian end end nanoc-4.4.7/test/rule_dsl/test_action_provider.rb0000644000004100000410000000446113033443476022233 0ustar www-datawww-datarequire 'helper' class Nanoc::RuleDSL::ActionProviderTest < Nanoc::TestCase def new_action_provider(site) rules_collection = Nanoc::RuleDSL::RulesCollection.new rule_memory_calculator = Nanoc::RuleDSL::RuleMemoryCalculator.new( rules_collection: rules_collection, site: site, ) action_provider = Nanoc::RuleDSL::ActionProvider.new( rules_collection, rule_memory_calculator ) Nanoc::RuleDSL::RulesLoader.new(site.config, rules_collection).load action_provider end def test_per_rules_file_preprocessor # Create site Nanoc::CLI.run %w(create_site foo) FileUtils.cd('foo') do # Create a bonus rules file File.write( 'more_rules.rb', "preprocess { @items['/index.*'][:preprocessed] = true }", ) # Adjust normal rules file File.write( 'Rules', "include_rules 'more_rules'\n\npreprocess {}\n\n" + File.read('Rules'), ) # Create site and compiler site = Nanoc::Int::SiteLoader.new.new_from_cwd action_provider = new_action_provider(site) # Check that the two preprocess blocks have been added assert_equal 2, action_provider.rules_collection.preprocessors.size refute_nil action_provider.rules_collection.preprocessors.first refute_nil action_provider.rules_collection.preprocessors.to_a.last # Apply preprocess blocks action_provider.preprocess(site) assert site.items['/index.*'].attributes[:preprocessed] end end def test_per_rules_file_postprocessor # Create site Nanoc::CLI.run %w(create_site foo) FileUtils.cd('foo') do # Create a bonus rules file File.write( 'more_rules.rb', 'postprocess {}', ) # Adjust normal rules file File.write( 'Rules', "include_rules 'more_rules'\n\npostprocess {}\n\n" + File.read('Rules'), ) # Create site and compiler site = Nanoc::Int::SiteLoader.new.new_from_cwd action_provider = new_action_provider(site) # Check that the two postprocess blocks have been added assert_equal 2, action_provider.rules_collection.postprocessors.size refute_nil action_provider.rules_collection.postprocessors.first refute_nil action_provider.rules_collection.postprocessors.to_a.last end end end nanoc-4.4.7/test/rule_dsl/test_rule.rb0000644000004100000410000000076313033443476020014 0ustar www-datawww-datarequire 'helper' class Nanoc::Int::RuleTest < Nanoc::TestCase def test_initialize # TODO: implement end def test_applicable_to # TODO: implement end def test_apply_to # TODO: implement end def test_matches pattern = Nanoc::Int::Pattern.from(%r{/(.*)/(.*)/}) identifier = '/anything/else/' expected = %w(anything else) rule = Nanoc::RuleDSL::Rule.new(pattern, :string, proc {}) assert_equal expected, rule.send(:matches, identifier) end end nanoc-4.4.7/test/cli/0000755000004100000410000000000013033443476014411 5ustar www-datawww-datananoc-4.4.7/test/cli/commands/0000755000004100000410000000000013033443476016212 5ustar www-datawww-datananoc-4.4.7/test/cli/commands/test_compile.rb0000644000004100000410000001507213033443476021233 0ustar www-datawww-datarequire 'helper' class Nanoc::CLI::Commands::CompileTest < Nanoc::TestCase def test_profiling_information with_site do |_site| File.open('content/foo.md', 'w') { |io| io << 'asdf' } File.open('content/bar.md', 'w') { |io| io << 'asdf' } File.open('content/baz.md', 'w') { |io| io << 'asdf' } File.open('Rules', 'w') do |io| io.write "compile '*' do\n" io.write " filter :erb\n" io.write "end\n" io.write "\n" io.write "route '*' do\n" io.write " if item.binary?\n" io.write " item.identifier.chop + '.' + item[:extension]\n" io.write " else\n" io.write " item.identifier + 'index.html'\n" io.write " end\n" io.write "end\n" io.write "\n" io.write "layout '*', :erb\n" end Nanoc::CLI.run %w(compile --verbose) end end def test_auto_prune with_site do |_site| File.open('content/foo.md', 'w') { |io| io << 'asdf' } File.open('content/bar.md', 'w') { |io| io << 'asdf' } File.open('content/baz.md', 'w') { |io| io << 'asdf' } File.open('Rules', 'w') do |io| io.write "compile '*' do\n" io.write " filter :erb\n" io.write "end\n" io.write "\n" io.write "route '*' do\n" io.write " if item.binary?\n" io.write " item.identifier.chop + '.' + item[:extension]\n" io.write " else\n" io.write " item.identifier + 'index.html'\n" io.write " end\n" io.write "end\n" io.write "\n" io.write "layout '*', :erb\n" end File.open('nanoc.yaml', 'w') do |io| io.write "string_pattern_type: legacy\n" io.write "prune:\n" io.write " auto_prune: false\n" end File.open('output/stray.html', 'w') do |io| io.write 'I am a stray file and I am about to be deleted!' end assert File.file?('output/stray.html') Nanoc::CLI.run %w(compile) assert File.file?('output/stray.html') File.open('nanoc.yaml', 'w') do |io| io.write "string_pattern_type: legacy\n" io.write "prune:\n" io.write " auto_prune: true\n" end assert File.file?('output/stray.html') Nanoc::CLI.run %w(compile) refute File.file?('output/stray.html') end end def test_auto_prune_with_exclude with_site do |_site| File.open('content/foo.md', 'w') { |io| io << 'asdf' } File.open('content/bar.md', 'w') { |io| io << 'asdf' } File.open('content/baz.md', 'w') { |io| io << 'asdf' } File.open('Rules', 'w') do |io| io.write "compile '*' do\n" io.write " filter :erb\n" io.write "end\n" io.write "\n" io.write "route '*' do\n" io.write " if item.binary?\n" io.write " item.identifier.chop + '.' + item[:extension]\n" io.write " else\n" io.write " item.identifier + 'index.html'\n" io.write " end\n" io.write "end\n" io.write "\n" io.write "layout '*', :erb\n" end Dir.mkdir('output/excluded_dir') File.open('nanoc.yaml', 'w') do |io| io.write "string_pattern_type: legacy\n" io.write "prune:\n" io.write " auto_prune: false\n" end File.open('output/stray.html', 'w') do |io| io.write 'I am a stray file and I am about to be deleted!' end assert File.file?('output/stray.html') Nanoc::CLI.run %w(compile) assert File.file?('output/stray.html') File.open('nanoc.yaml', 'w') do |io| io.write "string_pattern_type: legacy\n" io.write "prune:\n" io.write " auto_prune: true\n" io.write " exclude: [ 'excluded_dir' ]\n" end assert File.file?('output/stray.html') Nanoc::CLI.run %w(compile) refute File.file?('output/stray.html') assert File.directory?('output/excluded_dir'), 'excluded_dir should still be there' end end def test_setup_and_teardown_listeners with_site do test_listener_class = Class.new(::Nanoc::CLI::Commands::Compile::Listener) do def start @started = true end def stop @stopped = true end def started? @started end def stopped? @stopped end end options = {} arguments = [] cmd = nil cmd_runner = Nanoc::CLI::Commands::Compile.new(options, arguments, cmd) cmd_runner.listener_classes = [test_listener_class] cmd_runner.run listeners = cmd_runner.send(:listeners) assert listeners.size == 1 assert listeners.first.started? assert listeners.first.stopped? end end def test_file_action_printer_normal # Create data item = Nanoc::Int::Item.new('content', {}, '/') rep = Nanoc::Int::ItemRep.new(item, :default) rep.raw_paths[:last] = 'output/foo.txt' rep.compiled = true # Listen listener = new_file_action_printer([rep]) listener.start Nanoc::Int::NotificationCenter.post(:compilation_started, rep) Nanoc::Int::NotificationCenter.post(:rep_written, rep, rep.raw_path, false, true) listener.stop # Check assert_equal 1, listener.events.size assert_equal :high, listener.events[0][:level] assert_equal :update, listener.events[0][:action] assert_equal 'output/foo.txt', listener.events[0][:path] assert_in_delta 0.0, listener.events[0][:duration], 1.0 end def test_file_action_printer_skip # Create data item = Nanoc::Int::Item.new('content', {}, '/') rep = Nanoc::Int::ItemRep.new(item, :default) rep.raw_paths[:last] = 'output/foo.txt' # Listen listener = new_file_action_printer([rep]) listener.start Nanoc::Int::NotificationCenter.post(:compilation_started, rep) listener.stop # Check assert_equal 1, listener.events.size assert_equal :low, listener.events[0][:level] assert_equal :skip, listener.events[0][:action] assert_equal 'output/foo.txt', listener.events[0][:path] assert_nil listener.events[0][:duration] end def new_file_action_printer(reps) # Ensure CLI is loaded begin Nanoc::CLI.run(%w(help %)) rescue SystemExit end listener = Nanoc::CLI::Commands::Compile::FileActionPrinter.new(reps: reps) def listener.log(level, action, path, duration) @events ||= [] @events << { level: level, action: action, path: path, duration: duration, } end def listener.events @events end listener end end nanoc-4.4.7/test/cli/commands/test_check.rb0000644000004100000410000000066713033443476020664 0ustar www-datawww-datarequire 'helper' class Nanoc::CLI::Commands::CheckTest < Nanoc::TestCase def test_check_stale with_site do |_site| FileUtils.mkdir_p('output') # Should not raise now Nanoc::CLI.run %w(check stale) # Should raise now File.open('output/blah.html', 'w') { |io| io.write 'moo' } assert_raises Nanoc::Int::Errors::GenericTrivial do Nanoc::CLI.run %w(check stale) end end end end nanoc-4.4.7/test/cli/commands/test_prune.rb0000644000004100000410000001174713033443476020741 0ustar www-datawww-datarequire 'helper' class Nanoc::CLI::Commands::PruneTest < Nanoc::TestCase def test_run_without_yes with_site do |_site| # Set output dir File.open('nanoc.yaml', 'w') { |io| io.write "output_dir: output2\nstring_pattern_type: legacy\n" } FileUtils.mkdir_p('output2') # Create source files File.open('content/index.html', 'w') { |io| io.write 'stuff' } # Create output files File.open('output2/foo.html', 'w') { |io| io.write 'this is a foo.' } File.open('output2/index.html', 'w') { |io| io.write 'this is a index.' } assert_raises SystemExit do Nanoc::CLI.run %w(prune) end assert File.file?('output2/index.html') assert File.file?('output2/foo.html') end end def test_run_with_yes with_site do |_site| # Set output dir File.open('nanoc.yaml', 'w') do |io| io << 'output_dir: output2' << "\n" io << 'string_pattern_type: legacy' << "\n" io << 'data_sources:' << "\n" io << ' -' << "\n" io << ' type: filesystem' << "\n" io << ' identifier_type: legacy' << "\n" end FileUtils.mkdir_p('output2') # Create source files File.open('content/index.html', 'w') { |io| io.write 'stuff' } # Create output files File.open('output2/foo.html', 'w') { |io| io.write 'this is a foo.' } File.open('output2/index.html', 'w') { |io| io.write 'this is a index.' } Nanoc::CLI.run %w(prune --yes) assert File.file?('output2/index.html') assert !File.file?('output2/foo.html') end end def test_run_with_dry_run with_site do |_site| # Set output dir File.open('nanoc.yaml', 'w') { |io| io.write "string_pattern_type: legacy\noutput_dir: output2" } FileUtils.mkdir_p('output2') # Create source files File.open('content/index.html', 'w') { |io| io.write 'stuff' } # Create output files File.open('output2/foo.html', 'w') { |io| io.write 'this is a foo.' } File.open('output2/index.html', 'w') { |io| io.write 'this is a index.' } Nanoc::CLI.run %w(prune --dry-run) assert File.file?('output2/index.html') assert File.file?('output2/foo.html') end end def test_run_with_exclude with_site do |_site| # Set output dir File.open('nanoc.yaml', 'w') do |io| io << 'prune:' << "\n" io << ' exclude: [ "good-dir", "good-file.html" ]' << "\n" io << 'string_pattern_type: legacy' << "\n" io << 'data_sources:' << "\n" io << ' -' << "\n" io << ' type: filesystem' << "\n" io << ' identifier_type: legacy' << "\n" end FileUtils.mkdir_p('output') # Create source files File.open('content/index.html', 'w') { |io| io.write 'stuff' } # Create output files FileUtils.mkdir_p('output/good-dir') FileUtils.mkdir_p('output/bad-dir') File.open('output/good-file.html', 'w') { |io| io.write 'stuff' } File.open('output/good-dir/blah', 'w') { |io| io.write 'stuff' } File.open('output/bad-file.html', 'w') { |io| io.write 'stuff' } File.open('output/bad-dir/blah', 'w') { |io| io.write 'stuff' } File.open('output/index.html', 'w') { |io| io.write 'stuff' } Nanoc::CLI.run %w(prune --yes) assert File.file?('output/index.html') assert File.file?('output/good-dir/blah') assert File.file?('output/good-file.html') assert !File.file?('output/bad-dir/blah') assert !File.file?('output/bad-file.html') end end def test_run_with_symlink_to_output_dir skip_unless_symlinks_supported if defined?(JRUBY_VERSION) skip 'JRuby has buggy File.find behavior (see https://github.com/jruby/jruby/issues/1647)' end with_site do |_site| # Set output dir FileUtils.rm_rf('output') FileUtils.mkdir_p('output-real') File.symlink('output-real', 'output') # Create source files File.open('content/index.html', 'w') { |io| io.write 'stuff' } # Create output files FileUtils.mkdir_p('output-real/some-dir') File.open('output-real/some-file.html', 'w') { |io| io.write 'stuff' } File.open('output-real/index.html', 'w') { |io| io.write 'stuff' } Nanoc::CLI.run %w(prune --yes) assert File.file?('output-real/index.html') assert !File.directory?('output-real/some-dir') assert !File.file?('output-real/some-file.html') end end def test_run_with_nested_empty_dirs with_site do |_site| # Set output dir File.open('nanoc.yaml', 'w') { |io| io.write 'output_dir: output' } FileUtils.mkdir_p('output') # Create output files FileUtils.mkdir_p('output/a/b/c') File.open('output/a/b/c/index.html', 'w') { |io| io.write 'stuff' } Nanoc::CLI.run %w(prune --yes) assert !File.file?('output/a/b/c/index.html') assert !File.directory?('output/a/b/c') assert !File.directory?('output/a/b') assert !File.directory?('output/a') end end end nanoc-4.4.7/test/cli/commands/test_info.rb0000644000004100000410000000017613033443476020535 0ustar www-datawww-datarequire 'helper' class Nanoc::CLI::Commands::InfoTest < Nanoc::TestCase def test_run Nanoc::CLI.run %w(info) end end nanoc-4.4.7/test/cli/commands/test_create_site.rb0000644000004100000410000000644413033443476022075 0ustar www-datawww-datarequire 'helper' class Nanoc::CLI::Commands::CreateSiteTest < Nanoc::TestCase def test_create_site_with_existing_name Nanoc::CLI.run %w(create_site foo) assert_raises(::Nanoc::Int::Errors::GenericTrivial) do Nanoc::CLI.run %w(create_site foo) end end def test_can_compile_new_site Nanoc::CLI.run %w(create_site foo) FileUtils.cd('foo') do site = Nanoc::Int::SiteLoader.new.new_from_cwd site.compile end end def test_can_compile_new_site_in_current_directory FileUtils.mkdir('foo') FileUtils.cd('foo') do Nanoc::CLI.run %w(create_site ./) site = Nanoc::Int::SiteLoader.new.new_from_cwd site.compile end end def test_can_compile_new_site_with_binary_items Nanoc::CLI.run %w(create_site foo) FileUtils.cd('foo') do File.open('content/blah', 'w') { |io| io << 'asdf' } site = Nanoc::Int::SiteLoader.new.new_from_cwd site.compile assert File.file?('output/blah') end end def test_can_compile_site_in_nonempty_directory FileUtils.mkdir('foo') FileUtils.touch(File.join('foo', 'SomeFile.txt')) Nanoc::CLI.run %w(create_site foo --force) FileUtils.cd('foo') do site = Nanoc::Int::SiteLoader.new.new_from_cwd site.compile end end def test_compiled_site_output FileUtils.mkdir('foo') FileUtils.touch(File.join('foo', 'SomeFile.txt')) Nanoc::CLI.run %w(create_site foo --force) FileUtils.cd('foo') do site = Nanoc::Int::SiteLoader.new.new_from_cwd site.compile assert File.file?('output/index.html') end end def test_default_encoding unless defined?(Encoding) skip 'No Encoding class' return end original_encoding = Encoding.default_external Encoding.default_external = 'ISO-8859-1' # ew! Nanoc::CLI.run %w(create_site foo) FileUtils.cd('foo') do # Try with encoding = default encoding = utf-8 File.open('content/index.html', 'w') { |io| io.write('Hello ' + 0xD6.chr + "!\n") } exception = assert_raises(Nanoc::DataSources::Filesystem::Errors::InvalidEncoding) do Nanoc::Int::SiteLoader.new.new_from_cwd end assert_equal 'Could not read content/index.html because the file is not valid UTF-8.', exception.message # Try with encoding = specific File.open('nanoc.yaml', 'w') do |io| io.write("string_pattern_type: glob\n") io.write("data_sources:\n") io.write(" -\n") io.write(" type: filesystem\n") io.write(" identifier_type: full\n") end site = Nanoc::Int::SiteLoader.new.new_from_cwd site.compile end FileUtils ensure Encoding.default_external = original_encoding end def test_new_site_has_correct_stylesheets Nanoc::CLI.run %w(create_site foo) FileUtils.cd('foo') do Nanoc::CLI.run %w(compile) assert File.file?('content/stylesheet.css') assert_match(/\/stylesheet.css/, File.read('output/index.html')) end end def test_new_site_prunes_by_default FileUtils.mkdir('foo') FileUtils.touch(File.join('foo', 'SomeFile.txt')) Nanoc::CLI.run %w(create_site foo --force) FileUtils.cd('foo') do File.write('output/blah.txt', 'stuff') Nanoc::CLI.run %w(compile) refute File.file?('output/blah.txt') end end end nanoc-4.4.7/test/cli/commands/test_help.rb0000644000004100000410000000023513033443476020526 0ustar www-datawww-datarequire 'helper' class Nanoc::CLI::Commands::HelpTest < Nanoc::TestCase def test_run Nanoc::CLI.run %w(help) Nanoc::CLI.run %w(help co) end end nanoc-4.4.7/test/cli/test_error_handler.rb0000644000004100000410000000606013033443476020625 0ustar www-datawww-datarequire 'helper' class Nanoc::CLI::ErrorHandlerTest < Nanoc::TestCase def setup super @handler = Nanoc::CLI::ErrorHandler.new end def test_resolution_for_with_unknown_gem error = LoadError.new('no such file to load -- afjlrestjlsgrshter') assert_nil @handler.send(:resolution_for, error) end def test_resolution_for_with_known_gem_without_bundler def @handler.using_bundler? false end error = LoadError.new('no such file to load -- kramdown') assert_match(/^Install the 'kramdown' gem using `gem install kramdown`./, @handler.send(:resolution_for, error)) end def test_resolution_for_with_known_gem_with_bundler def @handler.using_bundler? true end error = LoadError.new('no such file to load -- kramdown') assert_match(/^Make sure the gem is added to Gemfile/, @handler.send(:resolution_for, error)) end def test_resolution_for_with_not_load_error error = RuntimeError.new('nuclear meltdown detected') assert_nil @handler.send(:resolution_for, error) end def test_write_stack_trace_verbose error = new_error(20) stream = StringIO.new @handler.send(:write_stack_trace, stream, error, verbose: false) assert_match(/See full crash log for details./, stream.string) stream = StringIO.new @handler.send(:write_stack_trace, stream, error, verbose: false) assert_match(/See full crash log for details./, stream.string) stream = StringIO.new @handler.send(:write_stack_trace, stream, error, verbose: true) refute_match(/See full crash log for details./, stream.string) end def test_write_error_message_wrapped stream = StringIO.new @handler.send(:write_error_message, stream, new_wrapped_error(new_error), verbose: true) refute_match(/CompilationError/, stream.string) end def test_write_stack_trace_wrapped stream = StringIO.new @handler.send(:write_stack_trace, stream, new_wrapped_error(new_error), verbose: false) assert_match(/new_error/, stream.string) end def test_write_item_rep stream = StringIO.new @handler.send(:write_item_rep, stream, new_wrapped_error(new_error), verbose: false) assert_match(/^Item identifier: \/about\.md$/, stream.string) assert_match(/^Item rep name: :latex$/, stream.string) end def test_resolution_for_wrapped def @handler.using_bundler? true end error = new_wrapped_error(LoadError.new('no such file to load -- kramdown')) assert_match(/^Make sure the gem is added to Gemfile/, @handler.send(:resolution_for, error)) end def new_wrapped_error(wrapped) item = Nanoc::Int::Item.new('asdf', {}, '/about.md') item_rep = Nanoc::Int::ItemRep.new(item, :latex) raise Nanoc::Int::Errors::CompilationError.new(wrapped, item_rep) rescue => e return e end def new_error(amount_factor = 1) backtrace_generator = lambda do |af| if af.zero? raise 'finally!' else backtrace_generator.call(af - 1) end end begin backtrace_generator.call(amount_factor) rescue => e return e end end end nanoc-4.4.7/test/cli/test_cleaning_stream.rb0000644000004100000410000000346413033443476021137 0ustar www-datawww-datarequire 'helper' class Nanoc::CLI::CleaningStreamTest < Nanoc::TestCase class Stream attr_accessor :called_methods def initialize @called_methods = [] end # rubocop:disable Style/MethodMissing def method_missing(symbol, *_args) @called_methods << symbol end # rubocop:enable Style/MethodMissing def respond_to_missing?(*_args) true end end def test_forward methods = [:write, :<<, :tty?, :tty?, :flush, :tell, :print, :puts, :string, :reopen, :exist?, :exists?, :close] s = Stream.new cs = Nanoc::CLI::CleaningStream.new(s) cs.write('aaa') cs << 'bb' cs.tty? cs.isatty cs.flush cs.tell cs.print('cc') cs.puts('dd') cs.string cs.reopen('/dev/null', 'r') cs.exist? cs.exists? cs.close methods.each do |m| assert s.called_methods.include?(m), "expected #{m} to be called" end end def test_forward_tty_cached s = Stream.new cs = Nanoc::CLI::CleaningStream.new(s) cs.tty? cs.isatty assert_equal [:tty?], s.called_methods end def test_works_with_logger require 'logger' stream = StringIO.new cleaning_stream = Nanoc::CLI::CleaningStream.new(stream) logger = Logger.new(cleaning_stream) logger.info('Some info') logger.warn('Something could start going wrong!') end def test_broken_pipe stream = StringIO.new def stream.write(_s) raise Errno::EPIPE.new end cleaning_stream = Nanoc::CLI::CleaningStream.new(stream) cleaning_stream.write('lol') end def test_non_string obj = Object.new def obj.to_s 'Hello… world!' end stream = StringIO.new cleaning_stream = Nanoc::CLI::CleaningStream.new(stream) cleaning_stream << obj assert_equal 'Hello… world!', stream.string end end nanoc-4.4.7/test/cli/test_logger.rb0000644000004100000410000000013213033443476017250 0ustar www-datawww-datarequire 'helper' class Nanoc::CLI::LoggerTest < Nanoc::TestCase def test_stub; end end nanoc-4.4.7/test/cli/test_cli.rb0000644000004100000410000001240513033443476016546 0ustar www-datawww-datarequire 'helper' class Nanoc::CLITest < Nanoc::TestCase COMMAND_CODE = < 'en_US.ISO-8859-1', 'LC_CTYPE' => 'en_US.ISO-8859-1', 'LANG' => 'en_US.ISO-8859-1', } with_env_vars(new_env_diff) do io = StringIO.new def io.tty? true end refute Nanoc::CLI.enable_utf8?(io) io = StringIO.new def io.tty? false end assert Nanoc::CLI.enable_utf8?(io) end end def test_enable_utf8 io = StringIO.new def io.tty? true end new_env_diff = { 'LC_ALL' => 'en_US.ISO-8859-1', 'LC_CTYPE' => 'en_US.ISO-8859-1', 'LANG' => 'en_US.ISO-8859-1', } with_env_vars(new_env_diff) do refute Nanoc::CLI.enable_utf8?(io) with_env_vars('LC_ALL' => 'en_US.UTF-8') { assert Nanoc::CLI.enable_utf8?(io) } with_env_vars('LC_CTYPE' => 'en_US.UTF-8') { assert Nanoc::CLI.enable_utf8?(io) } with_env_vars('LANG' => 'en_US.UTF-8') { assert Nanoc::CLI.enable_utf8?(io) } with_env_vars('LC_ALL' => 'en_US.utf-8') { assert Nanoc::CLI.enable_utf8?(io) } with_env_vars('LC_CTYPE' => 'en_US.utf-8') { assert Nanoc::CLI.enable_utf8?(io) } with_env_vars('LANG' => 'en_US.utf-8') { assert Nanoc::CLI.enable_utf8?(io) } with_env_vars('LC_ALL' => 'en_US.utf8') { assert Nanoc::CLI.enable_utf8?(io) } with_env_vars('LC_CTYPE' => 'en_US.utf8') { assert Nanoc::CLI.enable_utf8?(io) } with_env_vars('LANG' => 'en_US.utf8') { assert Nanoc::CLI.enable_utf8?(io) } end end end nanoc-4.4.7/test/helpers/0000755000004100000410000000000013033443476015304 5ustar www-datawww-datananoc-4.4.7/test/helpers/test_xml_sitemap.rb0000644000004100000410000002073213033443476021216 0ustar www-datawww-datarequire 'helper' class Nanoc::Helpers::XMLSitemapTest < Nanoc::TestCase include Nanoc::Helpers::XMLSitemap def setup super @reps = Nanoc::Int::ItemRepRepo.new dependency_tracker = Nanoc::Int::DependencyTracker.new(nil) @view_context = Nanoc::ViewContext.new(reps: @reps, items: nil, dependency_tracker: dependency_tracker, compilation_context: :__irrelevant__) @items = nil @item = nil @site = nil @config = nil end def test_xml_sitemap if_have 'builder', 'nokogiri' do # Create items @items = Nanoc::Int::IdentifiableCollection.new({}) # Create item 1 item = Nanoc::ItemWithRepsView.new(Nanoc::Int::Item.new('some content 1', {}, '/item-one/'), @view_context) @items << item create_item_rep(item.unwrap, :one_a, '/item-one/a/') create_item_rep(item.unwrap, :one_b, '/item-one/b/') # Create item 2 item = Nanoc::ItemWithRepsView.new(Nanoc::Int::Item.new('some content 2', { is_hidden: true }, '/item-two/'), @view_context) @items << item # Create item 3 attrs = { mtime: Time.parse('2004-07-12 00:00:00 +02:00'), changefreq: 'daily', priority: 0.5 } item = Nanoc::ItemWithRepsView.new(Nanoc::Int::Item.new('some content 3', attrs, '/item-three/'), @view_context) @items << item create_item_rep(item.unwrap, :three_a, '/item-three/a/') create_item_rep(item.unwrap, :three_b, '/item-three/b/') # Create item 4 item = Nanoc::ItemWithRepsView.new(Nanoc::Int::Item.new('some content 4', {}, '/item-four/'), @view_context) @items << item create_item_rep(item.unwrap, :four_a, nil) # Create sitemap item @item = Nanoc::ItemWithRepsView.new(Nanoc::Int::Item.new('sitemap content', {}, '/sitemap/'), @view_context) # Create site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Build sitemap res = xml_sitemap # Check doc = Nokogiri::XML(res) urlsets = doc.css('> urlset') assert_equal 1, urlsets.size urls = urlsets.css('> url') assert_equal 4, urls.size assert_equal 'http://example.com/item-one/a/', urls[0].css('> loc').inner_text assert_equal 'http://example.com/item-one/b/', urls[1].css('> loc').inner_text assert_equal 'http://example.com/item-three/a/', urls[2].css('> loc').inner_text assert_equal 'http://example.com/item-three/b/', urls[3].css('> loc').inner_text assert_equal '', urls[0].css('> changefreq').inner_text assert_equal '', urls[1].css('> changefreq').inner_text assert_equal 'daily', urls[2].css('> changefreq').inner_text assert_equal 'daily', urls[3].css('> changefreq').inner_text assert_equal '', urls[0].css('> priority').inner_text assert_equal '', urls[1].css('> priority').inner_text assert_equal '0.5', urls[2].css('> priority').inner_text assert_equal '0.5', urls[3].css('> priority').inner_text assert_equal '', urls[0].css('> lastmod').inner_text assert_equal '', urls[1].css('> lastmod').inner_text assert_equal '2004-07-11', urls[2].css('> lastmod').inner_text assert_equal '2004-07-11', urls[3].css('> lastmod').inner_text end end def test_sitemap_with_items_as_param if_have 'builder', 'nokogiri' do # Create items @items = Nanoc::Int::IdentifiableCollection.new({}) @items << nil item = Nanoc::ItemWithRepsView.new(Nanoc::Int::Item.new('some content 1', {}, '/item-one/'), @view_context) @items << item create_item_rep(item.unwrap, :one_a, '/item-one/a/') create_item_rep(item.unwrap, :one_b, '/item-one/b/') @items << nil # Create sitemap item @item = Nanoc::Int::Item.new('sitemap content', {}, '/sitemap/') # Create site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Build sitemap res = xml_sitemap(items: [item]) # Check doc = Nokogiri::XML(res) urlsets = doc.css('> urlset') assert_equal 1, urlsets.size urls = urlsets.css('> url') assert_equal 2, urls.size assert_equal 'http://example.com/item-one/a/', urls[0].css('> loc').inner_text assert_equal 'http://example.com/item-one/b/', urls[1].css('> loc').inner_text assert_equal '', urls[0].css('> changefreq').inner_text assert_equal '', urls[1].css('> changefreq').inner_text assert_equal '', urls[0].css('> priority').inner_text assert_equal '', urls[1].css('> priority').inner_text assert_equal '', urls[0].css('> lastmod').inner_text assert_equal '', urls[1].css('> lastmod').inner_text end end def test_filter if_have 'builder', 'nokogiri' do # Create items @items = Nanoc::Int::IdentifiableCollection.new({}) item = Nanoc::ItemWithRepsView.new(Nanoc::Int::Item.new('some content 1', {}, '/item-one/'), @view_context) @items << item create_item_rep(item.unwrap, :one_a, '/item-one/a/') create_item_rep(item.unwrap, :one_b, '/item-one/b/') # Create sitemap item @item = Nanoc::ItemWithRepsView.new(Nanoc::Int::Item.new('sitemap content', {}, '/sitemap/'), @view_context) # Create site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Build sitemap res = xml_sitemap(rep_select: ->(rep) { rep.name == :one_a }) # Check doc = Nokogiri::XML(res) urlsets = doc.css('> urlset') assert_equal 1, urlsets.size urls = urlsets.css('> url') assert_equal 1, urls.size assert_equal 'http://example.com/item-one/a/', urls[0].css('> loc').inner_text assert_equal '', urls[0].css('> changefreq').inner_text assert_equal '', urls[0].css('> priority').inner_text assert_equal '', urls[0].css('> lastmod').inner_text end end def test_sorted if_have 'builder', 'nokogiri' do # Create items @items = Nanoc::Int::IdentifiableCollection.new({}) item = Nanoc::ItemWithRepsView.new(Nanoc::Int::Item.new('some content 1', {}, '/george/'), @view_context) @items << item create_item_rep(item.unwrap, :a_alice, '/george/alice/') create_item_rep(item.unwrap, :b_zoey, '/george/zoey/') item = Nanoc::ItemWithRepsView.new(Nanoc::Int::Item.new('some content 1', {}, '/walton/'), @view_context) @items << item create_item_rep(item.unwrap, :a_eve, '/walton/eve/') create_item_rep(item.unwrap, :b_bob, '/walton/bob/') item = Nanoc::ItemWithRepsView.new(Nanoc::Int::Item.new('some content 1', {}, '/lucas/'), @view_context) @items << item create_item_rep(item.unwrap, :a_trudy, '/lucas/trudy/') create_item_rep(item.unwrap, :b_mallory, '/lucas/mallory/') # Create sitemap item @item = Nanoc::ItemWithRepsView.new(Nanoc::Int::Item.new('sitemap content', {}, '/sitemap/'), @view_context) # Create site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Build sitemap res = xml_sitemap(items: @items) # Check doc = Nokogiri::XML(res) urlsets = doc.css('> urlset') assert_equal 1, urlsets.size urls = urlsets.css('> url') assert_equal 6, urls.size assert_equal 'http://example.com/george/alice/', urls[0].css('> loc').inner_text assert_equal 'http://example.com/george/zoey/', urls[1].css('> loc').inner_text assert_equal 'http://example.com/lucas/trudy/', urls[2].css('> loc').inner_text assert_equal 'http://example.com/lucas/mallory/', urls[3].css('> loc').inner_text assert_equal 'http://example.com/walton/eve/', urls[4].css('> loc').inner_text assert_equal 'http://example.com/walton/bob/', urls[5].css('> loc').inner_text end end protected def create_item_rep(item, name, path) rep = Nanoc::Int::ItemRep.new(item, name) rep.paths = { last: path } rep.raw_paths = { last: path } @reps << rep rep end end nanoc-4.4.7/test/helpers/test_blogging.rb0000644000004100000410000005026713033443476020472 0ustar www-datawww-datarequire 'helper' class Nanoc::Helpers::BloggingTest < Nanoc::TestCase include Nanoc::Helpers::Blogging include Nanoc::Helpers::Text def mock_article item = mock item.stubs(:[]).with(:updated_at).returns(Time.now - 500) item.stubs(:[]).with(:kind).returns('article') item.stubs(:[]).with(:created_at).returns(Time.now - 1000) item.stubs(:[]).with(:title).returns('An Item') item.stubs(:[]).with(:custom_path_in_feed).returns(nil) item.stubs(:[]).with(:custom_url_in_feed).returns(nil) item.stubs(:[]).with(:excerpt).returns(nil) item.stubs(:path).returns('/item/') item.stubs(:[]).with(:author_name).returns(nil) item.stubs(:[]).with(:author_uri).returns(nil) item.stubs(:compiled_content).returns('item content') item end def mock_item item = mock item.stubs(:[]).with(:kind).returns('item') item end def test_atom_feed if_have 'builder' do # Create items @items = [mock, mock_article, mock_article] # Create item 0 @items[0].stubs(:[]).with(:kind).returns('item') # Create item 1 @items[1].stubs(:[]).with(:updated_at).returns(Date.today - 1) @items[1].stubs(:[]).with(:kind).returns('article') @items[1].stubs(:[]).with(:created_at).returns((Date.today - 2).to_s) @items[1].stubs(:[]).with(:title).returns('Item One') @items[1].stubs(:[]).with(:custom_path_in_feed).returns(nil) @items[1].stubs(:[]).with(:custom_url_in_feed).returns(nil) @items[1].stubs(:[]).with(:excerpt).returns(nil) @items[1].stubs(:path).returns('/item1/') @items[1].expects(:compiled_content).with(snapshot: :pre).returns('item 1 content') # Create item 2 @items[2].expects(:compiled_content).with(snapshot: :pre).returns('item 2 content') # Mock site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Create feed item @item = mock @item.stubs(:[]).with(:title).returns('My Cool Blog') @item.stubs(:[]).with(:author_name).returns('Denis Defreyne') @item.stubs(:[]).with(:author_uri).returns('http://stoneship.org/') @item.stubs(:[]).with(:feed_url).returns(nil) @item.stubs(:path).returns('/journal/feed/') # Check atom_feed end end def test_atom_feed_with_times if_have 'builder' do # Create items @items = [mock_item, mock_article, mock_article] # Create item 1 @items[1].stubs(:[]).with(:updated_at).returns(Time.now - 500) @items[1].stubs(:[]).with(:created_at).returns(Time.now - 1000) @items[1].expects(:compiled_content).returns('item 1 content') # Create item 2 @items[2].stubs(:[]).with(:updated_at).returns(Time.now - 250) @items[2].stubs(:[]).with(:created_at).returns(Time.now - 1200) @items[2].expects(:compiled_content).returns('item 2 content') # Mock site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Create feed item @item = mock @item.stubs(:[]).with(:title).returns('My Cool Blog') @item.stubs(:[]).with(:author_name).returns('Denis Defreyne') @item.stubs(:[]).with(:author_uri).returns('http://stoneship.org/') @item.stubs(:[]).with(:feed_url).returns(nil) @item.stubs(:path).returns('/journal/feed/') # Check atom_feed end end def test_atom_feed_updated_is_most_recent if_have 'builder' do # Create items @items = [mock_item, mock_article, mock_article] # Create item 1 @items[1].stubs(:[]).with(:updated_at).returns(nil) @items[1].stubs(:[]).with(:created_at).returns(Time.parse('2016-12-01 17:20:00 +00:00')) @items[1].expects(:compiled_content).returns('item 1 content') # Create item 2 @items[2].stubs(:[]).with(:updated_at).returns(nil) @items[2].stubs(:[]).with(:created_at).returns(Time.parse('2016-12-01 18:40:00 +00:00')) @items[2].expects(:compiled_content).returns('item 2 content') # Mock site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Create feed item @item = mock @item.stubs(:[]).with(:title).returns('My Cool Blog') @item.stubs(:[]).with(:author_name).returns('Denis Defreyne') @item.stubs(:[]).with(:author_uri).returns('http://stoneship.org/') @item.stubs(:[]).with(:feed_url).returns(nil) @item.stubs(:path).returns('/journal/feed/') # Check assert_match(%r{My Cool Blog\n 2016-12-01T18:40:00Z}, atom_feed) end end def test_atom_feed_updated_is_most_recent_updated_at if_have 'builder' do # Create items @items = [mock_item, mock_article, mock_article] # Create item 1 @items[1].stubs(:[]).with(:updated_at).returns(Time.parse('2016-12-01 19:20:00 +00:00')) @items[1].stubs(:[]).with(:created_at).returns(Time.parse('2016-12-01 17:20:00 +00:00')) @items[1].expects(:compiled_content).returns('item 1 content') # Create item 2 @items[2].stubs(:[]).with(:updated_at).returns(Time.parse('2016-12-01 20:40:00 +00:00')) @items[2].stubs(:[]).with(:created_at).returns(Time.parse('2016-12-01 18:40:00 +00:00')) @items[2].expects(:compiled_content).returns('item 2 content') # Mock site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Create feed item @item = mock @item.stubs(:[]).with(:title).returns('My Cool Blog') @item.stubs(:[]).with(:author_name).returns('Denis Defreyne') @item.stubs(:[]).with(:author_uri).returns('http://stoneship.org/') @item.stubs(:[]).with(:feed_url).returns(nil) @item.stubs(:path).returns('/journal/feed/') # Check assert_match(%r{My Cool Blog\n 2016-12-01T20:40:00Z}, atom_feed) end end def test_atom_feed_without_articles if_have 'builder' do # Mock items @items = [mock_item, mock_item] # Mock site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Create feed item @item = mock @item.stubs(:[]).with(:title).returns('My Blog Or Something') @item.stubs(:[]).with(:author_name).returns('J. Doe') @item.stubs(:[]).with(:author_uri).returns('http://example.com/~jdoe') # Check error = assert_raises(Nanoc::Int::Errors::GenericTrivial) do atom_feed end assert_equal( 'Cannot build Atom feed: no articles', error.message, ) end end def test_atom_feed_without_base_url if_have 'builder' do # Create items @items = [mock_item, mock_article] # Mock site @config = Nanoc::ConfigView.new({ base_url: nil }, nil) # Create feed item @item = mock @item.stubs(:[]).with(:title).returns('My Blog Or Something') @item.stubs(:[]).with(:author_name).returns('J. Doe') @item.stubs(:[]).with(:author_uri).returns('http://example.com/~jdoe') # Check error = assert_raises(Nanoc::Int::Errors::GenericTrivial) do atom_feed end assert_equal( 'Cannot build Atom feed: site configuration has no base_url', error.message, ) end end def test_atom_feed_without_title if_have 'builder' do # Create items @items = [mock_item, mock_article] # Mock site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Create feed item @item = mock @item.stubs(:[]).with(:title).returns(nil) @item.stubs(:[]).with(:author_name).returns('J. Doe') @item.stubs(:[]).with(:author_uri).returns('http://example.com/~jdoe') # Check error = assert_raises(Nanoc::Int::Errors::GenericTrivial) do atom_feed end assert_equal( 'Cannot build Atom feed: no title in params, item or site config', error.message, ) end end def test_atom_feed_without_author_name if_have 'builder' do # Create items @items = [mock_item, mock_article] # Mock site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Create feed item @item = mock @item.stubs(:[]).with(:title).returns('My Blog Or Something') @item.stubs(:[]).with(:author_name).returns(nil) @item.stubs(:[]).with(:author_uri).returns('http://example.com/~jdoe') # Check error = assert_raises(Nanoc::Int::Errors::GenericTrivial) do atom_feed end assert_equal( 'Cannot build Atom feed: no author_name in params, item or site config', error.message, ) end end def test_atom_feed_with_author_name_and_uri_from_content_item if_have 'builder' do # Create items @items = [mock_article] # Create item 1 @items[0].stubs(:[]).with(:author_name).returns('Don Alias') @items[0].stubs(:[]).with(:author_uri).returns('http://don.example.com/') @items[0].expects(:compiled_content).returns('item 1 content') # Mock site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com/' }, nil) # Create feed item @item = mock @item.stubs(:[]).with(:kind).returns(nil) @item.stubs(:[]).with(:title).returns('My Cool Blog') @item.stubs(:[]).with(:author_name).returns('Denis Defreyne') @item.stubs(:[]).with(:author_uri).returns('http://stoneship.org/') @item.stubs(:[]).with(:feed_url).returns(nil) @item.stubs(:path).returns('/journal/feed/') # Check # TODO: Use xpath matchers for more specific test result = atom_feed # Still should keep feed level author assert_match( /#{Regexp.escape('Denis Defreyne')}/, #' result, ) assert_match( /#{Regexp.escape('http://stoneship.org/')}/, #' result, ) # Overrides on specific items assert_match( /#{Regexp.escape('Don Alias')}/, #' result, ) assert_match( /#{Regexp.escape('http://don.example.com/')}/, #' result, ) end end def test_atom_feed_without_author_uri if_have 'builder' do # Create items @items = [mock_item, mock_article] # Mock site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Create feed item @item = mock @item.stubs(:[]).with(:title).returns('My Blog Or Something') @item.stubs(:[]).with(:author_name).returns('J. Doe') @item.stubs(:[]).with(:author_uri).returns(nil) # Check error = assert_raises(Nanoc::Int::Errors::GenericTrivial) do atom_feed end assert_equal( 'Cannot build Atom feed: no author_uri in params, item or site config', error.message, ) end end def test_atom_feed_without_articles_created_at if_have 'builder' do # Create items @items = [mock_item, mock_article, mock_article] @items[1].stubs(:[]).with(:created_at).returns(Time.now.to_s) @items[2].stubs(:[]).with(:created_at).returns(nil) # Mock site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Create feed item @item = mock @item.stubs(:[]).with(:title).returns('My Blog Or Something') @item.stubs(:[]).with(:author_name).returns('J. Doe') @item.stubs(:[]).with(:author_uri).returns('http://example.com/~jdoe') # Check error = assert_raises(Nanoc::Int::Errors::GenericTrivial) do atom_feed end assert_equal( 'Cannot build Atom feed: one or more articles lack created_at', error.message, ) end end def test_atom_feed_with_title_author_name_and_uri_as_params if_have 'builder' do # Create items @items = [mock_item, mock_article] @items[1].expects(:compiled_content).with(snapshot: :pre).returns('asdf') # Mock site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Create feed item @item = mock @item.stubs(:[]).with(:title).returns(nil) @item.stubs(:[]).with(:author_name).returns(nil) @item.stubs(:[]).with(:author_uri).returns(nil) @item.stubs(:[]).with(:[]).with(:feed_url).returns('http://example.com/feed') # Check atom_feed( author_name: 'Bob', author_uri: 'http://example.com/~bob/', title: 'My Blog Or Something', ) end end def test_atom_feed_with_title_author_name_and_uri_from_config if_have 'builder' do # Create items @items = [mock_item, mock_article] @items[1].expects(:compiled_content).with(snapshot: :pre).returns('asdf') # Mock site @config = Nanoc::ConfigView.new( { author_name: 'Bob', author_uri: 'http://example.com/~bob/', title: 'My Blog Or Something', base_url: 'http://example.com', }, nil, ) # Create feed item @item = mock @item.stubs(:[]).with(:title).returns(nil) @item.stubs(:[]).with(:author_name).returns(nil) @item.stubs(:[]).with(:author_uri).returns(nil) @item.stubs(:[]).with(:[]).with(:feed_url).returns('http://example.com/feed') # Check atom_feed end end def test_atom_feed_with_articles_param if_have 'builder' do # Mock items @items = [mock_article, mock_article] @items[0].expects(:compiled_content).never @items[1].stubs(:[]).with(:title).returns('Item One') @items[1].expects(:compiled_content).with(snapshot: :pre).returns('asdf') # Mock site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Create feed item @item = mock @item.stubs(:[]).with(:title).returns('My Blog Or Something') @item.stubs(:[]).with(:author_name).returns('J. Doe') @item.stubs(:[]).with(:author_uri).returns('http://example.com/~jdoe') @item.stubs(:[]).with(:[]).with(:feed_url).returns('http://example.com/feed') # Check atom_feed articles: [@items[1]] end end def test_atom_feed_with_limit_param if_have 'builder' do # Mock articles @items = [mock_article, mock_article] @items.each_with_index do |article, i| article.stubs(:[]).with(:title).returns("Article #{i}") article.stubs(:[]).with(:created_at).returns(Time.now - i) end # Mock site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Create feed item @item = mock @item.stubs(:[]).with(:title).returns('My Blog Or Something') @item.stubs(:[]).with(:author_name).returns('J. Doe') @item.stubs(:[]).with(:author_uri).returns('http://example.com/~jdoe') @item.stubs(:[]).with(:feed_url).returns('http://example.com/feed') # Check result = atom_feed limit: 1, articles: @items assert_match( Regexp.new('Article 0', Regexp::MULTILINE), result, ) refute_match( Regexp.new('Article 1', Regexp::MULTILINE), result, ) end end def test_atom_feed_sorting if_have 'builder' do # Mock articles @items = [mock_article, mock_article] @items.each_with_index do |article, i| article.stubs(:[]).with(:title).returns("Article #{i}") end @items[0].stubs(:[]).with(:created_at).returns('23-02-2009') @items[1].stubs(:[]).with(:created_at).returns('22-03-2009') # Mock site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Create feed item @item = mock @item.stubs(:[]).with(:title).returns('My Blog Or Something') @item.stubs(:[]).with(:author_name).returns('J. Doe') @item.stubs(:[]).with(:author_uri).returns('http://example.com/~jdoe') @item.stubs(:[]).with(:feed_url).returns('http://example.com/feed') # Check result = atom_feed assert_match( Regexp.new('Article 1.*Article 0', Regexp::MULTILINE), result, ) end end def test_atom_feed_preserve_order if_have 'builder' do # Mock articles @items = [mock_article, mock_article] @items.each_with_index do |article, i| article.stubs(:[]).with(:title).returns("Article #{i}") end @items[0].stubs(:[]).with(:created_at).returns('01-01-2015') @items[1].stubs(:[]).with(:created_at).returns('01-01-2014') # Mock site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Create feed item @item = mock @item.stubs(:[]).with(:title).returns('My Blog Or Something') @item.stubs(:[]).with(:author_name).returns('J. Doe') @item.stubs(:[]).with(:author_uri).returns('http://example.com/~jdoe') @item.stubs(:[]).with(:feed_url).returns('http://example.com/feed') # Check result = atom_feed(preserve_order: true) assert_match( Regexp.new('Article 1.*Article 0', Regexp::MULTILINE), result, ) end end def test_atom_feed_with_content_proc_param if_have 'builder' do # Mock article @items = [mock_article] # Mock site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Create feed item @item = mock @item.stubs(:[]).with(:title).returns('My Blog Or Something') @item.stubs(:[]).with(:author_name).returns('J. Doe') @item.stubs(:[]).with(:author_uri).returns('http://example.com/~jdoe') @item.stubs(:[]).with(:feed_url).returns('http://example.com/feed') # Check result = atom_feed content_proc: ->(_a) { 'foobar!' } assert_match 'foobar!', result end end def test_atom_feed_with_excerpt_proc_param if_have 'builder' do # Mock article @items = [mock_article] # Mock site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Create feed item @item = mock @item.stubs(:[]).with(:title).returns('My Blog Or Something') @item.stubs(:[]).with(:author_name).returns('J. Doe') @item.stubs(:[]).with(:author_uri).returns('http://example.com/~jdoe') @item.stubs(:[]).with(:[]).with(:feed_url).returns('http://example.com/feed') # Check result = atom_feed excerpt_proc: ->(_a) { 'foobar!' } assert_match 'foobar!', result end end def test_atom_feed_with_icon_param if_have 'builder' do # Mock article @items = [mock_article] # Mock site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Create feed item @item = mock @item.stubs(:[]).with(:title).returns('My Blog Or Something') @item.stubs(:[]).with(:author_name).returns('J. Doe') @item.stubs(:[]).with(:author_uri).returns('http://example.com/~jdoe') @item.stubs(:[]).with(:feed_url).returns('http://example.com/feed') # Check result = atom_feed icon: 'http://example.com/icon.png' assert_match 'http://example.com/icon.png', result end end def test_atom_feed_with_logo_param if_have 'builder' do # Mock article @items = [mock_article] # Mock site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Create feed item @item = mock @item.stubs(:[]).with(:title).returns('My Blog Or Something') @item.stubs(:[]).with(:author_name).returns('J. Doe') @item.stubs(:[]).with(:author_uri).returns('http://example.com/~jdoe') @item.stubs(:[]).with(:feed_url).returns('http://example.com/feed') # Check result = atom_feed logo: 'http://example.com/logo.png' assert_match 'http://example.com/logo.png', result end end def test_atom_feed_with_item_without_path if_have 'builder' do # Create items @items = [mock_article] @items[0].stubs(:path).returns(nil) # Mock site @config = Nanoc::ConfigView.new({ base_url: 'http://example.com' }, nil) # Create feed item @item = mock @item.stubs(:identifier).returns('/feed/') @item.stubs(:[]).with(:title).returns('My Cool Blog') @item.stubs(:[]).with(:author_name).returns('Denis Defreyne') @item.stubs(:[]).with(:author_uri).returns('http://stoneship.org/') @item.stubs(:[]).with(:feed_url).returns(nil) @item.stubs(:path).returns('/journal/feed/') # Check atom_feed end end end nanoc-4.4.7/test/helpers/test_capturing.rb0000644000004100000410000001255613033443476020675 0ustar www-datawww-datarequire 'helper' class Nanoc::Helpers::CapturingTest < Nanoc::TestCase include Nanoc::Helpers::Capturing def item_rep_repo_for(item) Nanoc::Int::ItemRepRepo.new.tap do |repo| repo << Nanoc::Int::ItemRep.new(item, :default) end end def view_context_for(item) Nanoc::ViewContext.new( reps: item_rep_repo_for(item), items: :__irrelevant__, dependency_tracker: :__irrelevant__, compilation_context: :__irrelevant__, ) end def before super Nanoc::CLI::ErrorHandler.enable end def test_dependencies with_site do |_site| # Prepare File.open('lib/helpers.rb', 'w') do |io| io.write 'include Nanoc::Helpers::Capturing' end File.open('content/includer.erb', 'w') do |io| io.write '[<%= content_for(@items.find { |i| i.identifier == \'/includee/\' }, :blah) %>]' end File.open('Rules', 'w') do |io| io.write "compile '*' do ; filter :erb ; end\n" io.write "route '*' do ; item.identifier + 'index.html' ; end\n" end # Compile once File.open('content/includee.erb', 'w') do |io| io.write '{<% content_for :blah do %>Old content<% end %>}' end Nanoc::CLI.run(%w(compile)) assert_equal '[Old content]', File.read('output/includer/index.html') # Compile again File.open('content/includee.erb', 'w') do |io| io.write '{<% content_for :blah do %>New content<% end %>}' end Nanoc::CLI.run(%w(compile)) assert_equal '[New content]', File.read('output/includer/index.html') end end def test_content_for_recursively require 'erb' File.open('Rules', 'w') do |io| io.write "compile '*' do ; filter :erb ; end\n" io.write "route '*' do ; item.identifier + 'index.html' ; end\n" end content = < basic <% end %> <% content_for :outerbox do %> before <%= content_for @item, :box %> after <% end %> <%= content_for @item, :outerbox %> foot EOS item = Nanoc::Int::Item.new('content', {}, '/') @item = Nanoc::ItemWithRepsView.new(item, view_context_for(item)) result = ::ERB.new(content).result(binding) expected = %w(head before basic after foot) actual = result.scan(/[a-z]+/) assert_equal expected, actual end def test_dependency_without_item_variable with_site do |_site| # Prepare File.open('lib/helpers.rb', 'w') do |io| io.write "include Nanoc::Helpers::Capturing\n" io.write "include Nanoc::Helpers::Rendering\n" end File.open('content/includer.erb', 'w') do |io| io.write '{<%= render \'partial\', :item => nil %>}' end File.open('layouts/partial.erb', 'w') do |io| io.write '[<%= @item.inspect %>-<%= content_for(@items.find { |i| i.identifier == \'/includee/\' }, :blah) %>]' end File.open('Rules', 'w') do |io| io.write "compile '*' do ; filter :erb ; end\n" io.write "route '*' do ; item.identifier + 'index.html' ; end\n" io.write "layout '*', :erb\n" end # Compile once File.open('content/includee.erb', 'w') do |io| io.write '{<% content_for :blah do %>Old content<% end %>}' end Nanoc::CLI.run(%w(compile)) assert_equal '{[nil-Old content]}', File.read('output/includer/index.html') # Compile again File.open('content/includee.erb', 'w') do |io| io.write '{<% content_for :blah do %>New content<% end %>}' end Nanoc::CLI.run(%w(compile)) assert_equal '{[nil-New content]}', File.read('output/includer/index.html') end end def test_self with_site do |_site| File.open('lib/helpers.rb', 'w') do |io| io.write 'include Nanoc::Helpers::Capturing' end File.open('content/self.erb', 'w') do |io| io.write '<% content_for :foo do %>Foo!<% end %>' io.write '<%= content_for(@item, :foo) %>' end File.open('Rules', 'w') do |io| io.write "compile '*' do ; filter :erb ; end\n" io.write "route '*' do ; item.identifier + 'index.html' ; end\n" end Nanoc::CLI.run(%w(compile)) assert_equal 'Foo!', File.read('output/self/index.html') end end def test_recompile_dependency with_site do |_site| # Prepare File.open('lib/helpers.rb', 'w') do |io| io.write 'include Nanoc::Helpers::Capturing' end File.open('content/includee.erb', 'w') do |io| io.write '{<% content_for :blah do %>Content<% end %>}' end File.open('Rules', 'w') do |io| io.write "compile '*' do ; filter :erb ; end\n" io.write "route '*' do ; item.identifier + 'index.html' ; end\n" end # Compile once File.open('content/includer.erb', 'w') do |io| io.write 'Old-<%= content_for(@items.find { |i| i.identifier == \'/includee/\' }, :blah) %>' end Nanoc::CLI.run(%w(compile)) assert_equal '{}', File.read('output/includee/index.html') assert_equal 'Old-Content', File.read('output/includer/index.html') # Compile again File.open('content/includer.erb', 'w') do |io| io.write 'New-<%= content_for(@items.find { |i| i.identifier == \'/includee/\' }, :blah) %>' end Nanoc::CLI.run(%w(compile)) assert_equal '{}', File.read('output/includee/index.html') assert_equal 'New-Content', File.read('output/includer/index.html') end end end nanoc-4.4.7/test/helpers/test_link_to.rb0000644000004100000410000000302213033443476020324 0ustar www-datawww-datarequire 'helper' class Nanoc::Helpers::LinkToTest < Nanoc::TestCase include Nanoc::Helpers::LinkTo def test_examples_link_to # Parse YARD.parse(LIB_DIR + '/nanoc/helpers/link_to.rb') # Mock @items = [ Nanoc::ItemRepView.new(mock, {}), Nanoc::ItemRepView.new(mock, {}), Nanoc::ItemRepView.new(mock, {}), ] @items[0].stubs(:identifier).returns('/about/') @items[0].stubs(:path).returns('/about.html') @items[1].stubs(:identifier).returns('/software/') @items[1].stubs(:path).returns('/software.html') @items[2].stubs(:identifier).returns('/software/nanoc/') @items[2].stubs(:path).returns('/software/nanoc.html') about_rep_vcard = Nanoc::ItemRepView.new(mock, {}) about_rep_vcard.stubs(:path).returns('/about.vcf') @items[0].stubs(:rep).with(:vcard).returns(about_rep_vcard) # Run assert_examples_correct 'Nanoc::Helpers::LinkTo#link_to' end def test_examples_link_to_unless_current # Parse YARD.parse(LIB_DIR + '/nanoc/helpers/link_to.rb') # Mock @item_rep = mock @item_rep.stubs(:path).returns('/about/') @item = mock @item.stubs(:path).returns(@item_rep.path) # Run assert_examples_correct 'Nanoc::Helpers::LinkTo#link_to_unless_current' end def test_examples_relative_path_to # Parse YARD.parse(LIB_DIR + '/nanoc/helpers/link_to.rb') # Mock @item_rep = mock @item_rep.stubs(:path).returns('/foo/bar/') # Run assert_examples_correct 'Nanoc::Helpers::LinkTo#relative_path_to' end end nanoc-4.4.7/test/data_sources/0000755000004100000410000000000013033443476016316 5ustar www-datawww-datananoc-4.4.7/test/data_sources/test_filesystem_tools.rb0000644000004100000410000001126613033443476023314 0ustar www-datawww-datarequire 'helper' class Nanoc::DataSources::FilesystemToolsTest < Nanoc::TestCase def setup super skip_unless_symlinks_supported end def test_all_files_in_follows_symlinks_to_dirs # Write sample files (0..15).each do |i| FileUtils.mkdir_p("dir#{i}") File.open("dir#{i}/foo.md", 'w') { |io| io.write('o hai') } end (1..10).each do |i| File.symlink("../dir#{i}", "dir#{i - 1}/sub") end # Check # 11 expected files (follow symlink 10 times) # sort required because 10 comes before 2 expected_files = [ 'dir0/foo.md', 'dir0/sub/foo.md', 'dir0/sub/sub/foo.md', 'dir0/sub/sub/sub/foo.md', 'dir0/sub/sub/sub/sub/foo.md', 'dir0/sub/sub/sub/sub/sub/foo.md', 'dir0/sub/sub/sub/sub/sub/sub/foo.md', 'dir0/sub/sub/sub/sub/sub/sub/sub/foo.md', 'dir0/sub/sub/sub/sub/sub/sub/sub/sub/foo.md', 'dir0/sub/sub/sub/sub/sub/sub/sub/sub/sub/foo.md', 'dir0/sub/sub/sub/sub/sub/sub/sub/sub/sub/sub/foo.md', ] actual_files = Nanoc::DataSources::Filesystem::Tools.all_files_in('dir0', nil).sort assert_equal expected_files, actual_files end def test_all_files_in_follows_symlinks_to_dirs_too_many # Write sample files (0..15).each do |i| FileUtils.mkdir_p("dir#{i}") File.open("dir#{i}/foo.md", 'w') { |io| io.write('o hai') } end (1..15).each do |i| File.symlink("../dir#{i}", "dir#{i - 1}/sub") end assert_raises Nanoc::DataSources::Filesystem::Tools::MaxSymlinkDepthExceededError do Nanoc::DataSources::Filesystem::Tools.all_files_in('dir0', nil) end end def test_all_files_in_relativizes_directory_names FileUtils.mkdir('foo') FileUtils.mkdir('bar') File.open('foo/x.md', 'w') { |io| io.write('o hai from foo/x') } File.open('bar/y.md', 'w') { |io| io.write('o hai from bar/y') } File.symlink('../bar', 'foo/barlink') expected_files = ['foo/barlink/y.md', 'foo/x.md'] actual_files = Nanoc::DataSources::Filesystem::Tools.all_files_in('foo', nil).sort assert_equal expected_files, actual_files end def test_all_files_in_follows_symlinks_to_files # Write sample files File.open('bar', 'w') { |io| io.write('o hai from bar') } FileUtils.mkdir_p('dir') File.open('dir/foo', 'w') { |io| io.write('o hai from foo') } File.symlink('../bar', 'dir/bar-link') # Check expected_files = ['dir/bar-link', 'dir/foo'] actual_files = Nanoc::DataSources::Filesystem::Tools.all_files_in('dir', nil).sort assert_equal expected_files, actual_files end def test_resolve_symlink File.open('foo', 'w') { |io| io.write('o hai') } File.symlink('foo', 'bar') File.symlink('bar', 'baz') File.symlink('baz', 'qux') expected = File.expand_path('foo') actual = Nanoc::DataSources::Filesystem::Tools.resolve_symlink('qux') assert_equal expected, actual end def test_resolve_symlink_too_many File.open('foo', 'w') { |io| io.write('o hai') } File.symlink('foo', 'symlin-0') (1..7).each do |i| File.symlink("symlink-#{i - 1}", "symlink-#{i}") end assert_raises Nanoc::DataSources::Filesystem::Tools::MaxSymlinkDepthExceededError do Nanoc::DataSources::Filesystem::Tools.resolve_symlink('symlink-7') end end def test_unwanted_dotfiles_not_found # Write sample files FileUtils.mkdir_p('dir') File.open('dir/.DS_Store', 'w') { |io| io.write('o hai') } File.open('dir/.htaccess', 'w') { |io| io.write('o hai') } actual_files = Nanoc::DataSources::Filesystem::Tools.all_files_in('dir', nil).sort assert_equal [], actual_files end def test_user_dotfiles_are_valid_items # Write sample files FileUtils.mkdir_p('dir') File.open('dir/.other', 'w') { |io| io.write('o hai') } actual_files = Nanoc::DataSources::Filesystem::Tools.all_files_in('dir', '**/.other').sort assert_equal ['dir/.other'], actual_files end def test_multiple_user_dotfiles_are_valid_items # Write sample files FileUtils.mkdir_p('dir') File.open('dir/.other', 'w') { |io| io.write('o hai') } File.open('dir/.DS_Store', 'w') { |io| io.write('o hai') } actual_files = Nanoc::DataSources::Filesystem::Tools.all_files_in('dir', ['**/.other', '**/.DS_Store']).sort assert_equal ['dir/.other', 'dir/.DS_Store'].sort, actual_files.sort end def test_unknown_pattern # Write sample files FileUtils.mkdir_p('dir') File.open('dir/.other', 'w') { |io| io.write('o hai') } pattern = { dotfiles: '**/.other' } assert_raises Nanoc::Int::Errors::GenericTrivial, "Do not know how to handle extra_files: #{pattern.inspect}" do Nanoc::DataSources::Filesystem::Tools.all_files_in('dir0', pattern) end end end nanoc-4.4.7/test/data_sources/test_filesystem.rb0000644000004100000410000007652613033443476022106 0ustar www-datawww-datarequire 'helper' class Nanoc::DataSources::FilesystemTest < Nanoc::TestCase def new_data_source(params = nil) # Mock site site = Nanoc::Int::SiteLoader.new.new_empty # Create data source data_source = Nanoc::DataSources::Filesystem.new(site.config, nil, nil, params) # Done data_source end def test_load_objects # Create data source data_source = new_data_source # Create a fake class klass = Class.new do attr_reader :stuff def initialize(*stuff) @stuff = stuff end def ==(other) @stuff == other.stuff end end # Create sample files FileUtils.mkdir_p('foo') FileUtils.mkdir_p('foo/a/b') File.open('foo/bar.html', 'w') { |io| io.write("---\nnum: 1\n---\ntest 1") } File.open('foo/b.c.html', 'w') { |io| io.write("---\nnum: 2\n---\ntest 2") } File.open('foo/a/b/c.html', 'w') { |io| io.write("---\nnum: 3\n---\ntest 3") } File.open('foo/ugly.html~', 'w') { |io| io.write("---\nnum: 4\n---\ntest 4") } File.open('foo/ugly.html.orig', 'w') { |io| io.write("---\nnum: 5\n---\ntest 5") } File.open('foo/ugly.html.rej', 'w') { |io| io.write("---\nnum: 6\n---\ntest 6") } File.open('foo/ugly.html.bak', 'w') { |io| io.write("---\nnum: 7\n---\ntest 7") } # Get expected and actual output expected_out = [ klass.new( 'test 1', { 'num' => 1, :filename => 'foo/bar.html', :extension => 'html', mtime: File.mtime('foo/bar.html') }, '/bar/', ), klass.new( 'test 2', { 'num' => 2, :filename => 'foo/b.c.html', :extension => 'c.html', mtime: File.mtime('foo/b.c.html') }, '/b/', ), klass.new( 'test 3', { 'num' => 3, :filename => 'foo/a/b/c.html', :extension => 'html', mtime: File.mtime('foo/a/b/c.html') }, '/a/b/c/', ), ] actual_out = data_source.send(:load_objects, 'foo', klass).sort_by { |i| i.stuff[0].string } # Check (0..expected_out.size - 1).each do |i| assert_equal expected_out[i].stuff[0], actual_out[i].stuff[0].string, 'content must match' assert_equal expected_out[i].stuff[2], actual_out[i].stuff[2], 'identifier must match' ['num', :filename, :extension, :mtime].each do |key| assert_equal expected_out[i].stuff[1][key], actual_out[i].stuff[1][key], "attribute key #{key} must match" end end end def test_load_objects_with_same_extensions # Create data source data_source = new_data_source(identifier_type: 'full') # Create a fake class klass = Class.new do attr_reader :stuff def initialize(*stuff) @stuff = stuff end def ==(other) @stuff == other.stuff end end # Create sample files FileUtils.mkdir_p('foo') File.open('foo/bar.html', 'w') { |io| io.write("---\nnum: 1\n---\ntest 1") } File.open('foo/bar.md', 'w') { |io| io.write("---\nnum: 1\n---\ntest 1") } # Check actual_out = data_source.send(:load_objects, 'foo', klass) assert_equal 2, actual_out.size end def test_load_binary_objects # Create data source data_source = new_data_source # Create sample files FileUtils.mkdir_p('foo') File.open('foo/stuff.dat', 'w') { |io| io.write('random binary data') } # Load items = data_source.send(:load_objects, 'foo', Nanoc::Int::Item) # Check assert_equal 1, items.size assert items[0].content.binary? assert_equal "#{Dir.getwd}/foo/stuff.dat", items[0].content.filename assert_equal Nanoc::Int::BinaryContent, items[0].content.class end def test_load_layouts_with_nil_dir_name # Create data source data_source = new_data_source(layouts_dir: nil) # Create sample files FileUtils.mkdir_p('layouts') File.write('layouts/stuff.txt', 'blah blah') # Load layouts = data_source.layouts # Check assert_empty(layouts) end def test_load_binary_layouts # Create data source data_source = new_data_source # Create sample files FileUtils.mkdir_p('foo') File.open('foo/stuff.dat', 'w') { |io| io.write('random binary data') } # Load assert_raises(Nanoc::DataSources::Filesystem::Errors::BinaryLayout) do data_source.send(:load_objects, 'foo', Nanoc::Int::Layout) end end def test_identifier_for_filename_with_full_style_identifier # Create data source data_source = new_data_source(identifier_type: 'full') # Get input and expected output expected = { '/foo' => Nanoc::Identifier.new('/foo', type: :full), '/foo.html' => Nanoc::Identifier.new('/foo.html', type: :full), '/foo/index.html' => Nanoc::Identifier.new('/foo/index.html', type: :full), '/foo.html.erb' => Nanoc::Identifier.new('/foo.html.erb', type: :full), } # Check expected.each_pair do |input, expected_output| actual_output = data_source.send(:identifier_for_filename, input) assert_equal( expected_output, actual_output, "identifier_for_filename(#{input.inspect}) should equal #{expected_output.inspect}, not #{actual_output.inspect}" ) end end def test_identifier_for_filename_allowing_periods_in_identifiers # Create data source data_source = new_data_source(allow_periods_in_identifiers: true) # Get input and expected output expected = { '/foo' => '/foo/', '/foo.html' => '/foo/', '/foo/index.html' => '/foo/', '/foo.entry.html' => '/foo.entry/', } # Check expected.each_pair do |input, expected_output| actual_output = data_source.send(:identifier_for_filename, input) assert_equal( expected_output, actual_output, "identifier_for_filename(#{input.inspect}) should equal #{expected_output.inspect}, not #{actual_output.inspect}" ) end end def test_identifier_for_filename_disallowing_periods_in_identifiers # Create data source data_source = new_data_source # Get input and expected output expected = { '/foo' => '/foo/', '/foo.html' => '/foo/', '/foo/index.html' => '/foo/', '/foo.html.erb' => '/foo/', } # Check expected.each_pair do |input, expected_output| actual_output = data_source.send(:identifier_for_filename, input) assert_equal( expected_output, actual_output, "identifier_for_filename(#{input.inspect}) should equal #{expected_output.inspect}, not #{actual_output.inspect}" ) end end def test_identifier_for_filename_with_subfilename_allowing_periods_in_identifiers expectations = { 'foo/bar.yaml' => '/foo/bar/', 'foo/quxbar.yaml' => '/foo/quxbar/', 'foo/barqux.yaml' => '/foo/barqux/', 'foo/quxbarqux.yaml' => '/foo/quxbarqux/', 'foo/qux.bar.yaml' => '/foo/qux.bar/', 'foo/bar.qux.yaml' => '/foo/bar.qux/', 'foo/qux.bar.qux.yaml' => '/foo/qux.bar.qux/', 'foo/index.yaml' => '/foo/', 'index.yaml' => '/', 'foo/blah_index.yaml' => '/foo/blah_index/', } data_source = new_data_source(allow_periods_in_identifiers: true) expectations.each_pair do |meta_filename, expected_identifier| content_filename = meta_filename.sub(/yaml$/, 'html') [meta_filename, content_filename].each do |filename| assert_equal( expected_identifier, data_source.instance_eval { identifier_for_filename(filename) }, ) end end end def test_identifier_for_filename_with_subfilename_disallowing_periods_in_identifiers expectations = { 'foo/bar.yaml' => '/foo/bar/', 'foo/quxbar.yaml' => '/foo/quxbar/', 'foo/barqux.yaml' => '/foo/barqux/', 'foo/quxbarqux.yaml' => '/foo/quxbarqux/', 'foo/qux.bar.yaml' => '/foo/qux/', 'foo/bar.qux.yaml' => '/foo/bar/', 'foo/qux.bar.qux.yaml' => '/foo/qux/', 'foo/index.yaml' => '/foo/', 'index.yaml' => '/', 'foo/blah_index.yaml' => '/foo/blah_index/', } data_source = new_data_source expectations.each_pair do |meta_filename, expected_identifier| content_filename = meta_filename.sub(/yaml$/, 'html') [meta_filename, content_filename].each do |filename| assert_equal( expected_identifier, data_source.instance_eval { identifier_for_filename(filename) }, ) end end end def test_identifier_for_filename_with_index_filenames_allowing_periods_in_identifier expected = { '/index.html.erb' => '/index.html/', '/index.html' => '/', '/index' => '/', '/foo/index.html.erb' => '/foo/index.html/', '/foo/index.html' => '/foo/', '/foo/index' => '/foo/', } data_source = new_data_source(allow_periods_in_identifiers: true) expected.each_pair do |input, expected_output| actual_output = data_source.send(:identifier_for_filename, input) assert_equal( expected_output, actual_output, "identifier_for_filename(#{input.inspect}) should equal #{expected_output.inspect}, not #{actual_output.inspect}" ) end end def test_identifier_for_filename_with_index_filenames_disallowing_periods_in_identifier expected = { '/index.html.erb' => '/', '/index.html' => '/', '/index' => '/', '/foo/index.html.erb' => '/foo/', '/foo/index.html' => '/foo/', '/foo/index' => '/foo/', } data_source = new_data_source expected.each_pair do |input, expected_output| actual_output = data_source.send(:identifier_for_filename, input) assert_equal( expected_output, actual_output, "identifier_for_filename(#{input.inspect}) should equal #{expected_output.inspect}, not #{actual_output.inspect}" ) end end def test_load_objects_allowing_periods_in_identifiers # Create data source data_source = new_data_source(allow_periods_in_identifiers: true) # Create a fake class klass = Class.new do attr_reader :stuff def initialize(*stuff) @stuff = stuff end def ==(other) @stuff == other.stuff end end # Create sample files FileUtils.mkdir_p('foo') FileUtils.mkdir_p('foo/a/b') File.open('foo/a/b/c.yaml', 'w') { |io| io.write("---\nnum: 1\n") } File.open('foo/b.c.yaml', 'w') { |io| io.write("---\nnum: 2\n") } File.open('foo/b.c.html', 'w') { |io| io.write('test 2') } File.open('foo/car.html', 'w') { |io| io.write('test 3') } File.open('foo/ugly.yaml~', 'w') { |io| io.write('blah') } File.open('foo/ugly.html~', 'w') { |io| io.write('blah') } File.open('foo/ugly.html.orig', 'w') { |io| io.write('blah') } File.open('foo/ugly.html.rej', 'w') { |io| io.write('blah') } File.open('foo/ugly.html.bak', 'w') { |io| io.write('blah') } # Get expected output expected_out = [ klass.new( '', { 'num' => 1, :content_filename => nil, :meta_filename => 'foo/a/b/c.yaml', :extension => nil, :file => nil, mtime: File.mtime('foo/a/b/c.yaml'), }, '/a/b/c/', ), klass.new( 'test 2', { 'num' => 2, :content_filename => 'foo/b.c.html', :meta_filename => 'foo/b.c.yaml', :extension => 'html', :file => File.open('foo/b.c.html'), mtime: File.mtime('foo/b.c.html') > File.mtime('foo/b.c.yaml') ? File.mtime('foo/b.c.html') : File.mtime('foo/b.c.yaml'), }, '/b.c/', ), klass.new( 'test 3', { content_filename: 'foo/car.html', meta_filename: nil, extension: 'html', file: File.open('foo/car.html'), mtime: File.mtime('foo/car.html'), }, '/car/', ), ] # Get actual output ordered by identifier actual_out = data_source.send(:load_objects, 'foo', klass).sort_by { |i| i.stuff[2] } # Check (0..expected_out.size - 1).each do |i| assert_equal expected_out[i].stuff[0], actual_out[i].stuff[0].string, 'content must match' assert_equal expected_out[i].stuff[2], actual_out[i].stuff[2], 'identifier must match' ['num', :content_filename, :meta_filename, :extension, :mtime].each do |key| assert_equal expected_out[i].stuff[1][key], actual_out[i].stuff[1][key], "attribute key #{key} must match" end end end def test_load_objects_disallowing_periods_in_identifiers # Create data source data_source = new_data_source # Create a fake class klass = Class.new do attr_reader :stuff def initialize(*stuff) @stuff = stuff end def ==(other) @stuff == other.stuff end end # Create sample files FileUtils.mkdir_p('foo') FileUtils.mkdir_p('foo/a/b') File.open('foo/a/b/c.yaml', 'w') { |io| io.write("---\nnum: 1\n") } File.open('foo/b.yaml', 'w') { |io| io.write("---\nnum: 2\n") } File.open('foo/b.html.erb', 'w') { |io| io.write('test 2') } File.open('foo/car.html', 'w') { |io| io.write('test 3') } File.open('foo/ugly.yaml~', 'w') { |io| io.write('blah') } File.open('foo/ugly.html~', 'w') { |io| io.write('blah') } File.open('foo/ugly.html.orig', 'w') { |io| io.write('blah') } File.open('foo/ugly.html.rej', 'w') { |io| io.write('blah') } File.open('foo/ugly.html.bak', 'w') { |io| io.write('blah') } # Get expected output expected_out = [ klass.new( '', { 'num' => 1, :content_filename => nil, :meta_filename => 'foo/a/b/c.yaml', :extension => nil, :file => nil, mtime: File.mtime('foo/a/b/c.yaml'), }, '/a/b/c/', ), klass.new( 'test 2', { 'num' => 2, :content_filename => 'foo/b.html.erb', :meta_filename => 'foo/b.yaml', :extension => 'html.erb', :file => File.open('foo/b.html.erb'), mtime: File.mtime('foo/b.html.erb') > File.mtime('foo/b.yaml') ? File.mtime('foo/b.html.erb') : File.mtime('foo/b.yaml'), }, '/b/', ), klass.new( 'test 3', { content_filename: 'foo/car.html', meta_filename: nil, extension: 'html', file: File.open('foo/car.html'), mtime: File.mtime('foo/car.html'), }, '/car/', ), ] # Get actual output ordered by identifier actual_out = data_source.send(:load_objects, 'foo', klass).sort_by { |i| i.stuff[2] } # Check (0..expected_out.size - 1).each do |i| assert_equal expected_out[i].stuff[0], actual_out[i].stuff[0].string, 'content must match' assert_equal expected_out[i].stuff[2], actual_out[i].stuff[2], 'identifier must match' ['num', :content_filename, :meta_filename, :extension, :mtime].each do |key| assert_equal expected_out[i].stuff[1][key], actual_out[i].stuff[1][key], "attribute key #{key} must match" end end end def test_load_objects_correct_identifier_with_separate_yaml_file data_source = new_data_source(identifier_type: 'full') FileUtils.mkdir_p('foo') File.write('foo/donkey.jpeg', 'data') File.write('foo/donkey.yaml', "---\nalt: Donkey\n") objects = data_source.send(:load_objects, 'foo', Nanoc::Int::Item) assert_equal 1, objects.size assert_equal '/donkey.jpeg', objects.first.identifier.to_s end def test_filename_for data_source = new_data_source assert_equal '/foo.bar', data_source.send(:filename_for, '/foo', 'bar') assert_equal '/foo.bar.baz', data_source.send(:filename_for, '/foo', 'bar.baz') assert_equal '/foo', data_source.send(:filename_for, '/foo', '') assert_equal nil, data_source.send(:filename_for, '/foo', nil) end def test_compile_iso_8859_1_site # Check encoding unless ''.respond_to?(:encode) skip 'Test only works on 1.9.x' return end # Create data source data_source = new_data_source # Create item FileUtils.mkdir_p('content') File.open('content/foo.md', 'w') { |io| io << 'Hëllö' } # Parse begin original_default_external_encoding = Encoding.default_external Encoding.default_external = 'ISO-8859-1' items = data_source.items assert_equal 1, items.size assert_equal Encoding.find('UTF-8'), items[0].content.string.encoding ensure Encoding.default_external = original_default_external_encoding end end def test_compile_iso_8859_1_site_with_explicit_encoding # Check encoding unless ''.respond_to?(:encode) skip 'Test only works on 1.9.x' return end # Create data source data_source = new_data_source({}) data_source.config[:encoding] = 'ISO-8859-1' # Create item begin original_default_external_encoding = Encoding.default_external Encoding.default_external = 'ISO-8859-1' FileUtils.mkdir_p('content') File.open('content/foo.md', 'w') { |io| io << 'Hëllö' } ensure Encoding.default_external = original_default_external_encoding end # Parse items = data_source.items assert_equal 1, items.size assert_equal Encoding.find('UTF-8'), items[0].content.string.encoding end def test_all_split_files_in_allowing_periods_in_identifiers # Create data source data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, allow_periods_in_identifiers: true) # Write sample files FileUtils.mkdir_p('foo') %w(foo.html foo.yaml bar.entry.html foo/qux.yaml).each do |filename| File.open(filename, 'w') { |io| io.write('test') } end # Write stray files %w(foo.html~ foo.yaml.orig bar.entry.html.bak).each do |filename| File.open(filename, 'w') { |io| io.write('test') } end # Get all files output_expected = { './foo' => ['yaml', ['html']], './bar.entry' => [nil, ['html']], './foo/qux' => ['yaml', [nil]], } output_actual = data_source.send :all_split_files_in, '.' # Check assert_equal output_expected, output_actual end def test_all_split_files_in_disallowing_periods_in_identifiers # Create data source data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, nil) # Write sample files FileUtils.mkdir_p('foo') %w(foo.html foo.yaml bar.html.erb foo/qux.yaml).each do |filename| File.open(filename, 'w') { |io| io.write('test') } end # Write stray files %w(foo.html~ foo.yaml.orig bar.entry.html.bak).each do |filename| File.open(filename, 'w') { |io| io.write('test') } end # Get all files output_expected = { './foo' => ['yaml', ['html']], './bar' => [nil, ['html.erb']], './foo/qux' => ['yaml', [nil]], } output_actual = data_source.send :all_split_files_in, '.' # Check assert_equal output_expected, output_actual end def test_all_split_files_in_with_multiple_dirs # Create data source data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, nil) # Write sample files %w(aaa/foo.html bbb/foo.html ccc/foo.html).each do |filename| FileUtils.mkdir_p(File.dirname(filename)) File.open(filename, 'w') { |io| io.write('test') } end # Check expected = { './aaa/foo' => [nil, ['html']], './bbb/foo' => [nil, ['html']], './ccc/foo' => [nil, ['html']], } assert_equal expected, data_source.send(:all_split_files_in, '.') end def test_all_split_files_in_with_same_extensions # Create data source config = { identifier_type: 'full' } data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, config) # Write sample files %w(stuff/foo.html stuff/foo.md stuff/foo.yaml).each do |filename| FileUtils.mkdir_p(File.dirname(filename)) File.open(filename, 'w') { |io| io.write('test') } end # Check - { './stuff/foo' => ['yaml', ['html', 'md']] } res = data_source.send(:all_split_files_in, '.') assert_equal ['./stuff/foo'], res.keys assert_equal 2, res.values[0].size assert_equal 'yaml', res.values[0][0] assert_equal Array, res.values[0][1].class assert_equal %w(html md), res.values[0][1].sort end def test_all_split_files_in_with_multiple_content_files # Create data source data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, nil) # Write sample files %w(foo.html foo.xhtml foo.txt foo.yaml bar.html qux.yaml).each do |filename| File.open(filename, 'w') { |io| io.write('test') } end # Check assert_raises(Nanoc::DataSources::Filesystem::Errors::MultipleContentFiles) do data_source.send(:all_split_files_in, '.') end end def test_basename_of_allowing_periods_in_identifiers # Create data source data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, allow_periods_in_identifiers: true) # Get input and expected output expected = { '/' => '/', '/foo' => '/foo', '/foo.html' => '/foo', '/foo.xyz.html' => '/foo.xyz', '/foo/' => '/foo/', '/foo.xyz/' => '/foo.xyz/', '/foo/bar' => '/foo/bar', '/foo/bar.html' => '/foo/bar', '/foo/bar.xyz.html' => '/foo/bar.xyz', '/foo/bar/' => '/foo/bar/', '/foo/bar.xyz/' => '/foo/bar.xyz/', '/foo.xyz/bar.xyz/' => '/foo.xyz/bar.xyz/', } # Check expected.each_pair do |input, expected_output| actual_output = data_source.send(:basename_of, input) assert_equal( expected_output, actual_output, "basename_of(#{input.inspect}) should equal #{expected_output.inspect}, not #{actual_output.inspect}" ) end end def test_basename_of_disallowing_periods_in_identifiers # Create data source data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, nil) # Get input and expected output expected = { '/' => '/', '/foo' => '/foo', '/foo.html' => '/foo', '/foo.xyz.html' => '/foo', '/foo/' => '/foo/', '/foo.xyz/' => '/foo.xyz/', '/foo/bar' => '/foo/bar', '/foo/bar.html' => '/foo/bar', '/foo/bar.xyz.html' => '/foo/bar', '/foo/bar/' => '/foo/bar/', '/foo/bar.xyz/' => '/foo/bar.xyz/', '/foo.xyz/bar.xyz/' => '/foo.xyz/bar.xyz/', } # Check expected.each_pair do |input, expected_output| actual_output = data_source.send(:basename_of, input) assert_equal( expected_output, actual_output, "basename_of(#{input.inspect}) should equal #{expected_output.inspect}, not #{actual_output.inspect}" ) end end def test_ext_of_allowing_periods_in_identifiers # Create data source data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, allow_periods_in_identifiers: true) # Get input and expected output expected = { '/' => '', '/foo' => '', '/foo.html' => '.html', '/foo.xyz.html' => '.html', '/foo/' => '', '/foo.xyz/' => '', '/foo/bar' => '', '/foo/bar.html' => '.html', '/foo/bar.xyz.html' => '.html', '/foo/bar/' => '', '/foo/bar.xyz/' => '', '/foo.xyz/bar.xyz/' => '', } # Check expected.each_pair do |input, expected_output| actual_output = data_source.send(:ext_of, input) assert_equal( expected_output, actual_output, "basename_of(#{input.inspect}) should equal #{expected_output.inspect}, not #{actual_output.inspect}" ) end end def test_ext_of_disallowing_periods_in_identifiers # Create data source data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, nil) # Get input and expected output expected = { '/' => '', '/foo' => '', '/foo.html' => '.html', '/foo.xyz.html' => '.xyz.html', '/foo/' => '', '/foo.xyz/' => '', '/foo/bar' => '', '/foo/bar.html' => '.html', '/foo/bar.xyz.html' => '.xyz.html', '/foo/bar/' => '', '/foo/bar.xyz/' => '', '/foo.xyz/bar.xyz/' => '', } # Check expected.each_pair do |input, expected_output| actual_output = data_source.send(:ext_of, input) assert_equal( expected_output, actual_output, "basename_of(#{input.inspect}) should equal #{expected_output.inspect}, not #{actual_output.inspect}" ) end end def test_parse_embedded_meta_only_1 # Create a file File.open('test.html', 'w') do |io| io.write "-----\r\n" io.write "foo: bar\n" io.write "-----\n" end # Create data source data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, nil) # Parse it result = data_source.instance_eval { parse('test.html', nil) } assert_equal({ 'foo' => 'bar' }, result.attributes) assert_equal('', result.content) end def test_parse_embedded_meta_only_2 # Create a file File.open('test.html', 'w') do |io| io.write "-----\n" io.write "foo: bar\r\n" io.write "-----\r" end # Create data source data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, nil) # Parse it result = data_source.instance_eval { parse('test.html', nil) } assert_equal({ 'foo' => 'bar' }, result.attributes) assert_equal('', result.content) end def test_parse_embedded_meta_only_3 # Create a file File.open('test.html', 'w') do |io| io.write "-----\r\n" io.write "foo: bar\n" io.write '-----' end # Create data source data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, nil) # Parse it result = data_source.instance_eval { parse('test.html', nil) } assert_equal({ 'foo' => 'bar' }, result.attributes) assert_equal('', result.content) end def test_parse_embedded_invalid_2 # Create a file File.open('test.html', 'w') do |io| io.write "-----\n" io.write "blah blah\n" end # Create data source data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, nil) # Parse it assert_raises(Nanoc::DataSources::Filesystem::Errors::InvalidFormat) do data_source.instance_eval { parse('test.html', nil) } end end def test_parse_embedded_separators_but_not_metadata # Create a file File.open('test.html', 'w') do |io| io.write "blah blah\n" io.write "-----\n" io.write "blah blah\n" end # Create data source data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, nil) # Parse it result = data_source.instance_eval { parse('test.html', nil) } assert_equal(File.read('test.html'), result.content) assert_equal({}, result.attributes) end def test_parse_embedded_full_meta # Create a file File.open('test.html', 'w') do |io| io.write "-----\r\n" io.write "foo: bar\n" io.write "-----\n" io.write " \t\n blah blah\n" end # Create data source data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, nil) # Parse it result = data_source.instance_eval { parse('test.html', nil) } assert_equal({ 'foo' => 'bar' }, result.attributes) assert_equal(" \t\n blah blah\n", result.content) end def test_parse_embedded_with_extra_spaces # Create a file File.open('test.html', 'w') do |io| io.write "----- \n" io.write "foo: bar\n" io.write "-----\t\t\t\t\t\n" io.write " blah blah\n" end # Create data source data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, nil) # Parse it result = data_source.instance_eval { parse('test.html', nil) } assert_equal({ 'foo' => 'bar' }, result.attributes) assert_equal(" blah blah\n", result.content) end def test_parse_embedded_empty_meta # Create a file File.open('test.html', 'w') do |io| io.write "-----\n" io.write "-----\n" io.write "\nblah blah\n" io.write '-----' end # Create data source data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, nil) # Parse it result = data_source.instance_eval { parse('test.html', nil) } assert_equal({}, result.attributes) assert_equal("\nblah blah\n-----", result.content) end def test_parse_utf8_bom File.open('test.html', 'w') do |io| io.write [0xEF, 0xBB, 0xBF].map(&:chr).join io.write "-----\n" io.write "utf8bomawareness: high\n" io.write "-----\n" io.write "content goes here\n" end data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, encoding: 'utf-8') result = data_source.instance_eval { parse('test.html', nil) } assert_equal({ 'utf8bomawareness' => 'high' }, result.attributes) assert_equal("content goes here\n", result.content) end def test_parse_embedded_no_meta content = "blah\n" \ "blah blah blah\n" \ "blah blah\n" # Create a file File.open('test.html', 'w') { |io| io.write(content) } # Create data source data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, nil) # Parse it result = data_source.instance_eval { parse('test.html', nil) } assert_equal({}, result.attributes) assert_equal(content, result.content) end def test_parse_embedded_diff content = \ "--- a/foo\n" \ "+++ b/foo\n" \ "blah blah\n" # Create a file File.open('test.html', 'w') { |io| io.write(content) } # Create data source data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, nil) # Parse it result = data_source.instance_eval { parse('test.html', nil) } assert_equal({}, result.attributes) assert_equal(content, result.content) end def test_parse_external # Create a file File.open('test.html', 'w') { |io| io.write('blah blah') } File.open('test.yaml', 'w') { |io| io.write('foo: bar') } # Create data source data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, nil) # Parse it result = data_source.instance_eval { parse('test.html', 'test.yaml') } assert_equal({ 'foo' => 'bar' }, result.attributes) assert_equal('blah blah', result.content) end def test_parse_internal_bad_metadata content = \ "---\n" \ "Hello world!\n" \ "---\n" \ "blah blah\n" File.open('test.html', 'w') { |io| io.write(content) } data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, nil) assert_raises(Nanoc::DataSources::Filesystem::Errors::InvalidMetadata) do data_source.instance_eval { parse('test.html', nil) } end end def test_parse_external_bad_metadata File.open('test.html', 'w') { |io| io.write('blah blah') } File.open('test.yaml', 'w') { |io| io.write('Hello world!') } data_source = Nanoc::DataSources::Filesystem.new(nil, nil, nil, nil) assert_raises(Nanoc::DataSources::Filesystem::Errors::InvalidMetadata) do data_source.instance_eval { parse('test.html', 'test.yaml') } end end end nanoc-4.4.7/LICENSE0000644000004100000410000000207013033443476013667 0ustar www-datawww-dataCopyright (c) 2007-2017 Denis Defreyne and contributors Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. nanoc-4.4.7/Appraisals0000644000004100000410000000023413033443476014704 0ustar www-datawww-dataappraise 'rouge-1' do group :plugins do gem 'rouge', '~> 1.0' end end appraise 'rouge-2' do group :plugins do gem 'rouge', '~> 2.0' end endnanoc-4.4.7/README.md0000644000004100000410000000460613033443476014150 0ustar www-datawww-data[![Gem version](http://img.shields.io/gem/v/nanoc.svg)](http://rubygems.org/gems/nanoc) [![Build status](http://img.shields.io/travis/nanoc/nanoc.svg)](https://travis-ci.org/nanoc/nanoc) [![Code Climate](http://img.shields.io/codeclimate/github/nanoc/nanoc.svg)](https://codeclimate.com/github/nanoc/nanoc) [![Code Coverage](http://img.shields.io/coveralls/nanoc/nanoc.svg)](https://coveralls.io/r/nanoc/nanoc) ![Nanoc logo](https://avatars1.githubusercontent.com/u/3260163?s=140) # Nanoc Nanoc is a flexible static-site generator written in Ruby. See the [Nanoc web site](http://nanoc.ws) for more information. **Please take a moment and [donate](http://pledgie.com/campaigns/9282) to Nanoc. A lot of time has gone into developing Nanoc, and I would like to keep it going. Your support will ensure that Nanoc will continue to improve.** ## Contributing Contributions are greatly appreciated! Consult the [Development guidelines](http://nanoc.ws/development/) for information on how you can contribute. ### Contributors Many thanks to everyone who has contributed to Nanoc in one way or another: Ale Muñoz, Alexander Mankuta, Andy Drop, Arnau Siches, Ben Armston, Bil Bas, Brian Candler, Bruno Dufour, Cédric Boutillier, Chris Chapman, Chris Eppstein, Christian Plessl, Colin Barrett, Colin Seymour, Croath Liu, Damien Pollet, Dan Callahan, Daniel Hofstetter, Daniel Mendler, Daniel Wollschlaeger, David Alexander, David Everitt, Denis Defreyne, Dennis Sutch, Devon Luke Buchanan, Dmitry Bilunov, Eric Sunshine, Erik Hollensbe, Fabian Buch, Felix Hanley, Garen Torikian, Go Maeda, Grégory Karékinian, Gregory Pakosz, Guilherme Garnier, Jack Chu, Jake Benilov, Jasper Van der Jeugt, Jeff Forcier, Jim Mendenhall, John Nishinaga, Justin Clift, Justin Hileman, Kevin Lynagh, Lorin Werthen, Louis T., Lucas Vuotto, Mathias Bynens, Matt Keveney, Matthew Frazier, Matthias Beyer, Matthias Reitinger, Matthias Vallentin, Micha Rosenbaum, Michal Cichra, Michal Papis, Mike Pennisi, Nelson Chen, Nicky Peeters, Nikhil Marathe, Oliver Byford, Paul Boone, Peter Aronoff, Raphael von der Grün, Rémi Barraquand, Remko Tronçon, Riley Goodside, Ruben Verborgh, Scott Vokes, Šime Ramov, Simon South, Spencer Whitt, Stanley Rost, Starr Horne, Stefan Bühler, Stuart Montgomery, Takashi Uchibe, Toon Willems, Tuomas Kareinen, Ursula Kallio, Vincent Driessen, Vlatko Kosturjak, whitequark, Xavier Shay, Yannick Ihmels, Zaiste de Grengolada nanoc-4.4.7/Guardfile0000644000004100000410000000010413033443476014503 0ustar www-datawww-dataguard 'rake', task: 'default' do watch(%r{^(lib|test|spec)/}) end