Results for simple-custom-errors

Simple way to maintain custom error codes and there messages with I18n.

A simple plugin to handle, log, and customize production errors

A simple rails engine for customizing your error pages.

A simple hash validator that allows you to do complex validations with custom error messages.

Integrate the jQuery Validation plugin into the Rails asset pipeline

The Chimera http client offers an easy to learn interface and consistent error handling. It is lightweight, fast and enables you to queue HTTP requests to run them in parallel for better performance and simple aggregating of distributed data. Despite it's simple interface it allows for advanced features like using custom deserializers, loggers, caching requests individiually, and instrumentation support (soon to be implemented).

# Excel to Code [](https://travis-ci.org/tamc/excel_to_code) excel_to_c - roughly translate some Excel files into C. excel_to_ruby - roughly translate some Excel files into Ruby. This allows spreadsheets to be: 1. Embedded in other programs, such as web servers, or optimisers 2. Without depending on any Microsoft code For example, running [these commands](examples/simple/compile.sh) turns [this spreadsheet](examples/simple/simple.xlsx) into [this Ruby code](examples/simple/ruby/simple.rb) or [this C code](examples/simple/c/simple.c). # Install Requires Ruby. Install by: gem install excel_to_code # Run To just have a go: excel_to_c <excel_file_name> This will produce a file called excelspreadsheet.c For a more complex spreadsheet: excel_to_c --compile --run-tests --settable <name of input worksheet> --prune-except <name of output worksheet> <excel file name> See the full list of options: excel_to_c --help # Gotchas, limitations and bugs 0. No custom functions, no macros for generating results 1. Results are cached. So you must call reset(), then set values, then read values. 2. It must be possible to replace INDIRECT and OFFSET formula with standard references at compile time (e.g., INDIRECT("A"&"1") is fine, INDIRECT(userInput&"3") is not. 3. Doesn't implement all functions. [See which functions are implemented](docs/Which_functions_are_implemented.md). 4. Doesn't implement references that involve range unions and lists (but does implement standard ranges) 5. Sometimes gives cells as being empty, when excel would give the cell as having a numeric value of zero 6. The generated C version does not multithread and will give bad results if you try. 7. The generated code uses floating point, rather than fully precise arithmetic, so results can differ slightly. 8. The generated code uses the sprintf approach to rounding (even-odd) rather than excel's 0.5 rounds away from zero. 9. Ranges like this: Sheet1!A10:Sheet1!B20 and 3D ranges don't work. Report bugs: <https://github.com/tamc/excel_to_code/issues> # Changelog See [Changes](CHANGES.md). # License See [License](LICENSE.md) # Hacking Source code: <https://github.com/tamc/excel_to_code> Documentation: * [Installing from source](docs/installing_from_source.md) * [Structure of this project](docs/structure_of_this_project.md) * [How does the calculation work](docs/how_does_the_calculation_work.md) * [How to fix parsing errors](docs/How_to_fix_parsing_errors.md) * [How to implement a new Excel function](docs/How_to_add_a_missing_function.md) Some notes on how Excel works under the hood: * [The Excel file structure](docs/implementation/excel_file_structure.md) * [Relationships](docs/implementation/relationships.md) * [Workbooks](docs/implementation/workbook.md) * [Worksheets](docs/implementation/worksheets.md) * [Cells](docs/implementation/cell.md) * [Tables](docs/implementation/tables.md) * [Shared Strings](docs/implementation/shared_strings.md) * [Array formulae](docs/implementation/array_formulae.md)

= tagomatic Simple command-line mp3 tagger based on mp3info gem. Supports folder-specific configuration files. Another mp3 tagger the world does not need. But I needed it. I have a large collection of old mp3 files. From times when tagging was mostly based on the file and folder names. When v2 tags where nowhere close.. == Overview Modes of operation: * The tagger will try to guess the tags from the full file path by applying a set of known formats. * The tagger will apply specific tags given on the command-line. * The tagger will match specific formats given on the command-line. * Arbitrary combination of the before-mentioned modes. The scanner supports recursive folder handling. Of course. Right now v2 tags are the focus. It is probably best to call this alpha ware. == Usage For my genre/artist/album/track.mp3 collection I use this invocation pattern: tagomatic --underscores --guess --recurse --showtags --errorstops --cleantags /media/music/ Then I add folder-specific .tagomatic or .format= files whenever an error occurs. == The .tagomatic file You can put the (long version) of the command line options into folder-specific .tagomatic files. These options are then valid only for this folder and sub-folders. This is useful - for example - if you want to switch guessing off for sub-folders. == The .format= files You can add files named .format= to sub-folders. They will be picked up by tagomatic and added as custom formats just as if you would have passed them on the command line using the --format option. Because the slash is not allowed in file names you have to replace it with a vertical dash like in this example: .format=%g|%a|%b|%n - %t.mp3 These formats are valid only for this folder and sub-folders. == Copyright Copyright (c) 2009 Daniel Lukic. See LICENSE for details.

== What's this? {ComicFury}[https://comicfury.com] is an excellent no-bullshit webcomic hosting site created and maintained by the legend Kyo. You should support them on {Patreon}[https://www.patreon.com/comicfury]! {Jekyll}[https://jekyllrb.com] is a highly regarded and widespread static site generator. It builds simple slowly-changing content into HTML files using templates. RageRender allows you to use your ComicFury templates to generate a static version of your webcomic site using Jekyll. You just supply your templates, comics and blogs, and RageRender will output a site that mimics your ComicFury site. Well, I say "mimics". Output is a static site, which means all of the interactive elements of ComicFury don't work. This includes comments, subscriptions, search, and comic management. === But why?! RageRender allows those of us who work on making changes to ComicFury site templates to test our changes before we put them live. With RageRender, you can edit your CSS, HTML templates and site settings before you upload them to ComicFury. This makes the process of testing changes quicker and makes it much more likely that you catch mistakes before any comic readers have a chance to see them. RageRender doesn't compete with the most excellent ComicFury (who's Patreon you should contribute to, as I do!) – you should continue to use ComicFury for all your day-to-day artistic rage management needs. But if you find yourself making changes to a site design, RageRender may be able to help you. == Getting started First, you need to have {Ruby}[https://www.ruby-lang.org/] and {Bundler}[https://bundle.io/] installed. The Jekyll site has {good guides on how to do that}[https://jekyllrb.com/docs/installation/] depending on your operating system. To set up a new site, open a terminal and type: mkdir mycomic && cd mycomic bundle init bundle add jekyll bundle add ragerender --group=jekyll_plugins Now you can add comics! Add the image into an <tt>images</tt> folder: mkdir images cp 'cool comic.jpg' 'images/My first page.jpg' The file name of the image will be the title of your comic page. And that's it, you added your first comic! If you want to add an author note, create a text file in a folder called <tt>_comics</tt> that has the same file name, but with a <tt>.txt</tt> extension: mkdir _comics echo "Check out my cool comic y'all!" > '_comics/My first page.txt' Or use HTML: echo "This is my <strong>first</strong> page!" > '_comics/My first page.html' Generate the site using: bundle exec jekyll build Or start a local website to see it in your browser: bundle exec jekyll serve # Now visit http://localhost:4000! === Customising your site You'll notice a few things that might be off about your site, including that the webcomic title and author name are probably not what you were expecting. You can create a configuration file to tell RageRender the important details. Put something like this in your webcomic folder and call it <tt>_config.yml</tt>: title: "My awesome webcomic!" slogan: "It's the best!" description: > My epic story about how him and her fell into a romantic polycule with they and them status: active genres: - Comedy - Romance defaults: - scope: path: '' values: author: "John smith" theme: ragerender Your webcomic now has its basic information set up. === Adding your layouts If you want to use your own layout code, then create a <tt>_layouts</tt> directory and put the contents of each of your ComicFury layout tabs in there, and then put your CSS in the main folder. The easiest way is to go to your Webcomic Management, click "Edit Layout", then in the box labelled "Useful", click "Download Layout Backup". Pass this file to RageRender, which will <tt>unpack</tt> it for you: bundle exec jekyll unpack mycomic-2025-09-13.cflxml You should end up with a full set of files like: _layouts archive.html blog-archive.html blog-display.html comic-page.html error-page.html overall.html overview.html search.html layout.css Now when you build your site, your custom templates and styles will be used instead. === Adding blogs Add your blogs into a folder called <tt>_posts</tt>: cat _posts/2025-05-29-my-new-comic.md Hey guys, welcome to my new comic! It's gonna be so sick! Note that the name of your blog post has to include the date and the title, or it'll be ignored. === Customising comics and blogs You can add {Front Matter}[https://jekyllrb.com/docs/front-matter/] to set the details of your author notes and blogs manually: --- title: "spooky comic page" date: "2025-03-05 16:20" image: "images/ghost.png" author: "Jane doe" description: "Some spooky mouseover text" keywords: [excellent, comic page, spooky] custom: # use yes and no for tickbox settings spooky: yes # use text in quotes for short texts mantra: "live long and prosper" # use indented text for long texts haiku: > Testing webcomics Now easier than ever Thanks to RageRender transcript: > The transcript contains a machine-readable version of all the text in your comic image. comments: - author: "Skippy" date: "13 Mar 2025, 3.45 PM" comment: "Wow this is so sick!" --- Your author note still goes at the end, like this! === Adding extra pages You can add extra pages just by adding new HTML files to your webcomic folder. The name of the file becomes the URL that it will use. Pages by default won't be embedded into your 'Overall' layout. You can change that and more with optional Front Matter: --- # Include this line to set the page title title: "Bonus content" # Include this line to hide the page from the navigation menu hidden: yes # Include this line to embed this page in the overall layout layout: Overall --- <h1>yo check out my bonus content!</h1> === Controlling the front page As on ComicFury you have a few options for setting the front page of you site. You control this by setting a <tt>frontpage</tt> key in your site config. - <tt>latest</tt> will display the latest comic (also the default) - <tt>first</tt> will display the first comic - <tt>chapter</tt> will display the first comic in the latest chapter - <tt>blog</tt> will display the list of blog posts - <tt>archive</tt> will display the comic archive - <tt>overview</tt> will display the comic overview (blogs and latest page) - anything else will display the extra page that has the matching <tt>slug</tt> in its Front Matter === Comics with custom HTML code You can use custom HTML code in place of an image for your comic page. Instead of creating an image, just create an HTML file in your <tt>images</tt> folder: cat '<video src="/files/my-animation.webm"></video>" > images/1.html === Multi-image comics You can add up to 12 images to each comic page on ComicFury. To do that in RageRender, add each image to an <tt>images</tt> key in your comic page: --- title: "Comic with many pages" date: "2026-04-20 16:20" images: - /images/first.png - /images/second.png - /images/third.png --- === Testing search pages Live search does not work in RageRender, as your site is statically built and can't respond to new data from the browser. However, you can simulate a search when you build the site to help test search results designs. To do that, add a `searchterm` to the search page using defaults in your `_config.yml`: defaults: - scope: path: '' layout: search values: searchterm: "my character" The search that gets performed will be somewhat similar to how ComicFury will search your comic, but may not be exactly the same. === Putting changes on ComicFury Once you're done making changes, you can <tt>pack</tt> your layout: bundle exec jekyll pack The resulting file can be uploaded to ComicFury by going to your Webcomic Management, clicking "Edit Layout", then in the box labelled "Useful", click "Restore Layout Backup". === Stuff that doesn't work Here is a probably incomplete list of things you can expect to be different about your local site compared to ComicFury: - Any comments you specify in Front Matter will be present, but you can't add new ones - Search doesn't do anything at all - Saving and loading your place in the comic isn't implemented - GET and POST variables in templates are ignored and will always be blank - Random numbers in templates will be random only once per site build, not once per page call == Without Jekyll RageRender can also be used without Jekyll to turn ComicFury templates into templates in other languages. E.g: gem install ragerender echo "[c:iscomicpage]<div>[f:js|v:comictitle]</div>[/]" > template.html ruby $(gem which ragerender/to_liquid) template.html # {% if iscomicpage %}<div>{{ comictitle | escape }}</div>{% endif %} ruby $(gem which ragerender/to_erb) template.html # <% if iscomicpage %><div><%= js(comictitle) %></div><% end %> You still need to pass the correct variables to these templates; browse {this unofficial documentation}[https://github.com/heyeinin/comicfury-documentation] or RageRender::ComicDrop etc. to see which variables work on which templates. == Get help That's not a proclamation but an invitation! Reach out if you're having trouble by {raising an issue}[https://github.com/simonwo/ragerender/issues] or posting in the ComicFury forums.

Lookout Lookout is a unit testing framework for Ruby¹ that puts your results in focus. Tests (expectations) are written as follows expect 2 do 1 + 1 end expect ArgumentError do Integer('1 + 1') end expect Array do [1, 2, 3].select{ |i| i % 2 == 0 } end expect [2, 4, 6] do [1, 2, 3].map{ |i| i * 2 } end Lookout is designed to encourage – force, even – unit testing best practices such as • Setting up only one expectation per test • Not setting expectations on non-public APIs • Test isolation This is done by • Only allowing one expectation to be set per test • Providing no (additional) way of accessing private state • Providing no setup and tear-down methods, nor a method of providing test helpers Other important points are • Putting the expected outcome of a test in focus with the steps of the calculation of the actual result only as a secondary concern • A focus on code readability by providing no mechanism for describing an expectation other than the code in the expectation itself • A unified syntax for setting up both state-based and behavior-based expectations The way Lookout works has been heavily influenced by expectations², by {Jay Fields}³. The code base was once also heavily based on expectations, based at Subversion {revision 76}⁴. A lot has happened since then and all of the work past that revision are due to {Nikolai Weibull}⁵. ¹ Ruby: http://ruby-lang.org/ ² Expectations: http://expectations.rubyforge.org/ ³ Jay Fields’s blog: http://blog.jayfields.com/ ⁴ Lookout revision 76: https://github.com/now/lookout/commit/537bedf3e5b3eb4b31c066b3266f42964ac35ebe ⁵ Nikolai Weibull’s home page: http://disu.se/ § Installation Install Lookout with % gem install lookout § Usage Lookout allows you to set expectations on an object’s state or behavior. We’ll begin by looking at state expectations and then take a look at expectations on behavior. § Expectations on State: Literals An expectation can be made on the result of a computation: expect 2 do 1 + 1 end Most objects, in fact, have their state expectations checked by invoking ‹#==› on the expected value with the result as its argument. Checking that a result is within a given range is also simple: expect 0.099..0.101 do 0.4 - 0.3 end Here, the more general ‹#===› is being used on the ‹Range›. § Regexps ‹Strings› of course match against ‹Strings›: expect 'ab' do 'abc'[0..1] end but we can also match a ‹String› against a ‹Regexp›: expect %r{a substring} do 'a string with a substring' end (Note the use of ‹%r{…}› to avoid warnings that will be generated when Ruby parses ‹expect /…/›.) § Modules Checking that the result includes a certain module is done by expecting the ‹Module›. expect Enumerable do [] end This, due to the nature of Ruby, of course also works for classes (as they are also modules): expect String do 'a string' end This doesn’t hinder us from expecting the actual ‹Module› itself: expect Enumerable do Enumerable end or the ‹Class›: expect String do String end for obvious reasons. As you may have figured out yourself, this is accomplished by first trying ‹#==› and, if it returns ‹false›, then trying ‹#===› on the expected ‹Module›. This is also true of ‹Ranges› and ‹Regexps›. § Booleans Truthfulness is expected with ‹true› and ‹false›: expect true do 1 end expect false do nil end Results equaling ‹true› or ‹false› are slightly different: expect TrueClass do true end expect FalseClass do false end The rationale for this is that you should only care if the result of a computation evaluates to a value that Ruby considers to be either true or false, not the exact literals ‹true› or ‹false›. § IO Expecting output on an IO object is also common: expect output("abc\ndef\n") do |io| io.puts 'abc', 'def' end This can be used to capture the output of a formatter that takes an output object as a parameter. § Warnings Expecting warnings from code isn’t very common, but should be done: expect warning('this is your final one!') do warn 'this is your final one!' end expect warning('this is your final one!') do warn '%s:%d: warning: this is your final one!' % [__FILE__, __LINE__] end ‹$VERBOSE› is set to ‹true› during the execution of the block, so you don’t need to do so yourself. If you have other code that depends on the value of $VERBOSE, that can be done with ‹#with_verbose› expect nil do with_verbose nil do $VERBOSE end end § Errors You should always be expecting errors from – and in, but that’s a different story – your code: expect ArgumentError do Integer('1 + 1') end Often, not only the type of the error, but its description, is important to check: expect StandardError.new('message') do raise StandardError.new('message') end As with ‹Strings›, ‹Regexps› can be used to check the error description: expect StandardError.new(/mess/) do raise StandardError.new('message') end § Queries Through Symbols Symbols are generally matched against symbols, but as a special case, symbols ending with ‹?› are seen as expectations on the result of query methods on the result of the block, given that the method is of zero arity and that the result isn’t a Symbol itself. Simply expect a symbol ending with ‹?›: expect :empty? do [] end To expect it’s negation, expect the same symbol beginning with ‹not_›: expect :not_nil? do [1, 2, 3] end This is the same as expect true do [].empty? end and expect false do [1, 2, 3].empty? end but provides much clearer failure messages. It also makes the expectation’s intent a lot clearer. § Queries By Proxy There’s also a way to make the expectations of query methods explicit by invoking methods on the result of the block. For example, to check that the even elements of the Array ‹[1, 2, 3]› include ‹1› you could write expect result.to.include? 1 do [1, 2, 3].reject{ |e| e.even? } end You could likewise check that the result doesn’t include 2: expect result.not.to.include? 2 do [1, 2, 3].reject{ |e| e.even? } end This is the same as (and executes a little bit slower than) writing expect false do [1, 2, 3].reject{ |e| e.even? }.include? 2 end but provides much clearer failure messages. Given that these two last examples would fail, you’d get a message saying “[1, 2, 3]#include?(2)” instead of the terser “true≠false”. It also clearly separates the actual expectation from the set-up. The keyword for this kind of expectations is ‹result›. This may be followed by any of the methods • ‹#not› • ‹#to› • ‹#be› • ‹#have› or any other method you will want to call on the result. The methods ‹#to›, ‹#be›, and ‹#have› do nothing except improve readability. The ‹#not› method inverts the expectation. § Literal Literals If you need to literally check against any of the types of objects otherwise treated specially, that is, any instances of • ‹Module› • ‹Range› • ‹Regexp› • ‹Exception› • ‹Symbol›, given that it ends with ‹?› you can do so by wrapping it in ‹literal(…)›: expect literal(:empty?) do :empty? end You almost never need to do this, as, for all but symbols, instances will match accordingly as well. § Expectations on Behavior We expect our objects to be on their best behavior. Lookout allows you to make sure that they are. Reception expectations let us verify that a method is called in the way that we expect it to be: expect mock.to.receive.to_str(without_arguments){ '123' } do |o| o.to_str end Here, ‹#mock› creates a mock object, an object that doesn’t respond to anything unless you tell it to. We tell it to expect to receive a call to ‹#to_str› without arguments and have ‹#to_str› return ‹'123'› when called. The mock object is then passed in to the block so that the expectations placed upon it can be fulfilled. Sometimes we only want to make sure that a method is called in the way that we expect it to be, but we don’t care if any other methods are called on the object. A stub object, created with ‹#stub›, expects any method and returns a stub object that, again, expects any method, and thus fits the bill. expect stub.to.receive.to_str(without_arguments){ '123' } do |o| o.to_str if o.convertable? end You don’t have to use a mock object to verify that a method is called: expect Object.to.receive.name do Object.name end As you have figured out by now, the expected method call is set up by calling ‹#receive› after ‹#to›. ‹#Receive› is followed by a call to the method to expect with any expected arguments. The body of the expected method can be given as the block to the method. Finally, an expected invocation count may follow the method. Let’s look at this formal specification in more detail. The expected method arguments may be given in a variety of ways. Let’s introduce them by giving some examples: expect mock.to.receive.a do |m| m.a end Here, the method ‹#a› must be called with any number of arguments. It may be called any number of times, but it must be called at least once. If a method must receive exactly one argument, you can use ‹Object›, as the same matching rules apply for arguments as they do for state expectations: expect mock.to.receive.a(Object) do |m| m.a 0 end If a method must receive a specific argument, you can use that argument: expect mock.to.receive.a(1..2) do |m| m.a 1 end Again, the same matching rules apply for arguments as they do for state expectations, so the previous example expects a call to ‹#a› with 1, 2, or the Range 1..2 as an argument on ‹m›. If a method must be invoked without any arguments you can use ‹without_arguments›: expect mock.to.receive.a(without_arguments) do |m| m.a end You can of course use both ‹Object› and actual arguments: expect mock.to.receive.a(Object, 2, Object) do |m| m.a nil, 2, '3' end The body of the expected method may be given as the block. Here, calling ‹#a› on ‹m› will give the result ‹1›: expect mock.to.receive.a{ 1 } do |m| raise 'not 1' unless m.a == 1 end If no body has been given, the result will be a stub object. To take a block, grab a block parameter and ‹#call› it: expect mock.to.receive.a{ |&b| b.call(1) } do |m| j = 0 m.a{ |i| j = i } raise 'not 1' unless j == 1 end To simulate an ‹#each›-like method, ‹#call› the block several times. Invocation count expectations can be set if the default expectation of “at least once” isn’t good enough. The following expectations are possible • ‹#at_most_once› • ‹#once› • ‹#at_least_once› • ‹#twice› And, for a given ‹N›, • ‹#at_most(N)› • ‹#exactly(N)› • ‹#at_least(N)› § Utilities: Stubs Method stubs are another useful thing to have in a unit testing framework. Sometimes you need to override a method that does something a test shouldn’t do, like access and alter bank accounts. We can override – stub out – a method by using the ‹#stub› method. Let’s assume that we have an ‹Account› class that has two methods, ‹#slips› and ‹#total›. ‹#Slips› retrieves the bank slips that keep track of your deposits to the ‹Account› from a database. ‹#Total› sums the ‹#slips›. In the following test we want to make sure that ‹#total› does what it should do without accessing the database. We therefore stub out ‹#slips› and make it return something that we can easily control. expect 6 do |m| stub(Class.new{ def slips raise 'database not available' end def total slips.reduce(0){ |m, n| m.to_i + n.to_i } end }.new, :slips => [1, 2, 3]){ |account| account.total } end To make it easy to create objects with a set of stubbed methods there’s also a convenience method: expect 3 do s = stub(:a => 1, :b => 2) s.a + s.b end This short-hand notation can also be used for the expected value: expect stub(:a => 1, :b => 2).to.receive.a do |o| o.a + o.b end and also works for mock objects: expect mock(:a => 2, :b => 2).to.receive.a do |o| o.a + o.b end Blocks are also allowed when defining stub methods: expect 3 do s = stub(:a => proc{ |a, b| a + b }) s.a(1, 2) end If need be, we can stub out a specific method on an object: expect 'def' do stub('abc', :to_str => 'def'){ |a| a.to_str } end The stub is active during the execution of the block. § Overriding Constants Sometimes you need to override the value of a constant during the execution of some code. Use ‹#with_const› to do just that: expect 'hello' do with_const 'A::B::C', 'hello' do A::B::C end end Here, the constant ‹A::B::C› is set to ‹'hello'› during the execution of the block. None of the constants ‹A›, ‹B›, and ‹C› need to exist for this to work. If a constant doesn’t exist it’s created and set to a new, empty, ‹Module›. The value of ‹A::B::C›, if any, is restored after the block returns and any constants that didn’t previously exist are removed. § Overriding Environment Variables Another thing you often need to control in your tests is the value of environment variables. Depending on such global values is, of course, not a good practice, but is often unavoidable when working with external libraries. ‹#With_env› allows you to override the value of environment variables during the execution of a block by giving it a ‹Hash› of key/value pairs where the key is the name of the environment variable and the value is the value that it should have during the execution of that block: expect 'hello' do with_env 'INTRO' => 'hello' do ENV['INTRO'] end end Any overridden values are restored and any keys that weren’t previously a part of the environment are removed when the block returns. § Overriding Globals You may also want to override the value of a global temporarily: expect 'hello' do with_global :$stdout, StringIO.new do print 'hello' $stdout.string end end You thus provide the name of the global and a value that it should take during the execution of a block of code. The block gets passed the overridden value, should you need it: expect true do with_global :$stdout, StringIO.new do |overridden| $stdout != overridden end end § Integration Lookout can be used from Rake¹. Simply install Lookout-Rake²: % gem install lookout-rake and add the following code to your Rakefile require 'lookout-rake-3.0' Lookout::Rake::Tasks::Test.new Make sure to read up on using Lookout-Rake for further benefits and customization. ¹ Read more about Rake at http://rake.rubyforge.org/ ² Get information on Lookout-Rake at http://disu.se/software/lookout-rake/ § API Lookout comes with an API¹ that let’s you create things such as new expected values, difference reports for your types, and so on. ¹ See http://disu.se/software/lookout/api/ § Interface Design The default output of Lookout can Spartanly be described as Spartan. If no errors or failures occur, no output is generated. This is unconventional, as unit testing frameworks tend to dump a lot of information on the user, concerning things such as progress, test count summaries, and flamboyantly colored text telling you that your tests passed. None of this output is needed. Your tests should run fast enough to not require progress reports. The lack of output provides you with the same amount of information as reporting success. Test count summaries are only useful if you’re worried that your tests aren’t being run, but if you worry about that, then providing such output doesn’t really help. Testing your tests requires something beyond reporting some arbitrary count that you would have to verify by hand anyway. When errors or failures do occur, however, the relevant information is output in a format that can easily be parsed by an ‹'errorformat'› for Vim or with {Compilation Mode}¹ for Emacs². Diffs are generated for Strings, Arrays, Hashes, and I/O. ¹ Read up on Compilation mode for Emacs at http://www.emacswiki.org/emacs/CompilationMode ² Visit The GNU Foundation’s Emacs’ software page at http://www.gnu.org/software/emacs/ § External Design Let’s now look at some of the points made in the introduction in greater detail. Lookout only allows you to set one expectation per test. If you’re testing behavior with a reception expectation, then only one method-invocation expectation can be set. If you’re testing state, then only one result can be verified. It may seem like this would cause unnecessary duplication between tests. While this is certainly a possibility, when you actually begin to try to avoid such duplication you find that you often do so by improving your interfaces. This kind of restriction tends to encourage the use of value objects, which are easy to test, and more focused objects, which require simpler tests, as they have less behavior to test, per method. By keeping your interfaces focused you’re also keeping your tests focused. Keeping your tests focused improves, in itself, test isolation, but let’s look at something that hinders it: setup and tear-down methods. Most unit testing frameworks encourage test fragmentation by providing setup and tear-down methods. Setup methods create objects and, perhaps, just their behavior for a set of tests. This means that you have to look in two places to figure out what’s being done in a test. This may work fine for few methods with simple set-ups, but makes things complicated when the number of tests increases and the set-up is complex. Often, each test further adjusts the previously set-up object before performing any verifications, further complicating the process of figuring out what state an object has in a given test. Tear-down methods clean up after tests, perhaps by removing records from a database or deleting files from the file-system. The duplication that setup methods and tear-down methods hope to remove is better avoided by improving your interfaces. This can be done by providing better set-up methods for your objects and using idioms such as {Resource Acquisition Is Initialization}¹ for guaranteed clean-up, test or no test. By not using setup and tear-down methods we keep everything pertinent to a test in the test itself, thus improving test isolation. (You also won’t {slow down your tests}² by keeping unnecessary state.) Most unit test frameworks also allow you to create arbitrary test helper methods. Lookout doesn’t. The same rationale as that that has been crystallized in the preceding paragraphs applies. If you need helpers you’re interface isn’t good enough. It really is as simple as that. To clarify: there’s nothing inherently wrong with test helper methods, but they should be general enough that they reside in their own library. The support for mocks in Lookout is provided through a set of test helper methods that make it easier to create mocks than it would have been without them. Lookout-rack³ is another example of a library providing test helper methods (well, one method, actually) that are very useful in testing web applications that use Rack⁴. A final point at which some unit test frameworks try to fragment tests further is documentation. These frameworks provide ways of describing the whats and hows of what’s being tested, the rationale being that this will provide documentation of both the test and the code being tested. Describing how a stack data structure is meant to work is a common example. A stack is, however, a rather simple data structure, so such a description provides little, if any, additional information that can’t be extracted from the implementation and its tests themselves. The implementation and its tests is, in fact, its own best documentation. Taking the points made in the previous paragraphs into account, we should already have simple, self-describing, interfaces that have easily understood tests associated with them. Rationales for the use of a given data structure or system-design design documentation is better suited in separate documentation focused at describing exactly those issues. ¹ Read the Wikipedia entry for Resource Acquisition Is Initialization at http://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization ² Read how 37signals had problems with slow Test::Unit tests at http://37signals.com/svn/posts/2742-the-road-to-faster-tests/ ³ Visit the Lookout-rack home page at http://disu.se/software/lookout-rack/ ⁴ Visit the Rack Rubyforge project page at http://rack.rubyforge.org/ § Internal Design The internal design of Lookout has had a couple of goals. • As few external dependencies as possible • As few internal dependencies as possible • Internal extensibility provides external extensibility • As fast load times as possible • As high a ratio of value objects to mutable objects as possible • Each object must have a simple, obvious name • Use mix-ins, not inheritance for shared behavior • As few responsibilities per object as possible • Optimizing for speed can only be done when you have all the facts § External Dependencies Lookout used to depend on Mocha for mocks and stubs. While benchmarking I noticed that a method in Mocha was taking up more than 300 percent of the runtime. It turned out that Mocha’s method for cleaning up back-traces generated when a mock failed was doing something incredibly stupid: backtrace.reject{ |l| Regexp.new(@lib).match(File.expand_path(l)) } Here ‹@lib› is a ‹String› containing the path to the lib sub-directory in the Mocha installation directory. I reported it, provided a patch five days later, then waited. Nothing happened. {254 days later}¹, according to {Wolfram Alpha}², half of my patch was, apparently – I say “apparently”, as I received no notification – applied. By that time I had replaced the whole mocking-and-stubbing subsystem and dropped the dependency. Many Ruby developers claim that Ruby and its gems are too fast-moving for normal package-managing systems to keep up. This is testament to the fact that this isn’t the case and that the real problem is instead related to sloppy practices. Please note that I don’t want to single out the Mocha library nor its developers. I only want to provide an example where relying on external dependencies can be “considered harmful”. ¹ See the Wolfram Alpha calculation at http://www.wolframalpha.com/input/?i=days+between+march+17%2C+2010+and+november+26%2C+2010 ² Check out the Wolfram Alpha computational knowledge engine at http://www.wolframalpha.com/ § Internal Dependencies Lookout has been designed so as to keep each subsystem independent of any other. The diff subsystem is, for example, completely decoupled from any other part of the system as a whole and could be moved into its own library at a time where that would be of interest to anyone. What’s perhaps more interesting is that the diff subsystem is itself very modular. The data passes through a set of filters that depends on what kind of diff has been requested, each filter yielding modified data as it receives it. If you want to read some rather functional Ruby I can highly recommend looking at the code in the ‹lib/lookout/diff› directory. This lookout on the design of the library also makes it easy to extend Lookout. Lookout-rack was, for example, written in about four hours and about 5 of those 240 minutes were spent on setting up the interface between the two. § Optimizing For Speed The following paragraph is perhaps a bit personal, but might be interesting nonetheless. I’ve always worried about speed. The original Expectations library used ‹extend› a lot to add new behavior to objects. Expectations, for example, used to hold the result of their execution (what we now term “evaluation”) by being extended by a module representing success, failure, or error. For the longest time I used this same method, worrying about the increased performance cost that creating new objects for results would incur. I finally came to a point where I felt that the code was so simple and clean that rewriting this part of the code for a benchmark wouldn’t take more than perhaps ten minutes. Well, ten minutes later I had my results and they confirmed that creating new objects wasn’t harming performance. I was very pleased. § Naming I hate low lines (underscores). I try to avoid them in method names and I always avoid them in file names. Since the current “best practice” in the Ruby community is to put ‹BeginEndStorage› in a file called ‹begin_end_storage.rb›, I only name constants using a single noun. This has had the added benefit that classes seem to have acquired less behavior, as using a single noun doesn’t allow you to tack on additional behavior without questioning if it’s really appropriate to do so, given the rather limited range of interpretation for that noun. It also seems to encourage the creation of value objects, as something named ‹Range› feels a lot more like a value than ‹BeginEndStorage›. (To reach object-oriented-programming Nirvana you must achieve complete value.) § News § 3.0.0 The ‹xml› expectation has been dropped. It wasn’t documented, didn’t suit very many use cases, and can be better implemented by an external library. The ‹arg› argument matcher for mock method arguments has been removed, as it didn’t provide any benefit over using Object. The ‹#yield› and ‹#each› methods on stub and mock methods have been removed. They were slightly weird and their use case can be implemented using block parameters instead. The ‹stub› method inside ‹expect› blocks now stubs out the methods during the execution of a provided block instead of during the execution of the whole except block. When a mock method is called too many times, this is reported immediately, with a full backtrace. This makes it easier to pin down what’s wrong with the code. Query expectations were added. Explicit query expectations were added. Fluent boolean expectations, for example, ‹expect nil.to.be.nil?› have been replaced by query expectations (‹expect :nil? do nil end›) and explicit query expectations (‹expect result.to.be.nil? do nil end›). This was done to discourage creating objects as the expected value and creating objects that change during the course of the test. The ‹literal› expectation was added. Equality (‹#==›) is now checked before “caseity” (‹#===›) for modules, ranges, and regular expressions to match the documentation. § Financing Currently, most of my time is spent at my day job and in my rather busy private life. Please motivate me to spend time on this piece of software by donating some of your money to this project. Yeah, I realize that requesting money to develop software is a bit, well, capitalistic of me. But please realize that I live in a capitalistic society and I need money to have other people give me the things that I need to continue living under the rules of said society. So, if you feel that this piece of software has helped you out enough to warrant a reward, please PayPal a donation to now@disu.se¹. Thanks! Your support won’t go unnoticed! ¹ Send a donation: https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=now%40disu%2ese&item_name=Lookout § Reporting Bugs Please report any bugs that you encounter to the {issue tracker}¹. ¹ See https://github.com/now/lookout/issues § Contributors Contributors to the original expectations codebase are mentioned there. We hope no one on that list feels left out of this list. Please {let us know}¹ if you do. • Nikolai Weibull ¹ Add an issue to the Lookout issue tracker at https://github.com/now/lookout/issues § Licensing Lookout is free software: you may redistribute it and/or modify it under the terms of the {GNU Lesser General Public License, version 3}¹ or later², as published by the {Free Software Foundation}³. ¹ See http://disu.se/licenses/lgpl-3.0/ ² See http://gnu.org/licenses/ ³ See http://fsf.org/

Contentful API wrapper library exposing an ActiveRecord-like interface

No description provided.

No description provided.

No description provided.

No description provided.