├── .gitignore
├── Koans
    ├── example_file.txt
    ├── koans.watchr
    ├── .path_progress
    ├── Rakefile
    ├── about_extra_credit.rb
    ├── triangle.rb
    ├── about_triangle_project_2.rb
    ├── versioning_spec.rb
    ├── about_true_and_false.rb
    ├── about_triangle_project.rb
    ├── about_keyword_arguments.rb
    ├── about_open_classes.rb
    ├── about_asserts.rb
    ├── path_to_enlightenment.rb
    ├── about_nil.rb
    ├── about_modules.rb
    ├── about_to_str.rb
    ├── about_objects.rb
    ├── about_array_assignment.rb
    ├── about_dice_project.rb
    ├── about_exceptions.rb
    ├── about_inheritance.rb
    ├── about_arrays.rb
    ├── about_scope.rb
    ├── about_scoring_project.rb
    ├── about_constants.rb
    ├── GREED_RULES.txt
    ├── about_blocks.rb
    ├── about_variable_scope.rb
    ├── about_sandwich_code.rb
    ├── about_symbols.rb
    ├── about_hashes.rb
    ├── about_control_statements.rb
    ├── about_iteration.rb
    ├── about_proxy_object_project.rb
    ├── about_methods.rb
    ├── about_class_methods.rb
    ├── about_java_interop.rb
    ├── about_classes.rb
    ├── about_regular_expressions.rb
    ├── about_message_passing.rb
    ├── about_strings.rb
    ├── README.rdoc
    └── neo.rb
├── .DS_Store
├── coffeerun
    ├── .DS_Store
    ├── scripts
    │   ├── .DS_Store
    │   ├── main.js
    │   ├── datastore.js
    │   ├── truck.js
    │   └── formhandler.js
    └── index.html
├── ottergram
    ├── .DS_Store
    ├── favicon.ico
    ├── img
    │   ├── otter1.jpg
    │   ├── otter2.jpg
    │   ├── otter3.jpg
    │   ├── otter4.jpg
    │   └── otter5.jpg
    ├── stylesheets
    │   ├── .DS_Store
    │   ├── fonts
    │   │   ├── Airstream-webfont.eot
    │   │   ├── Airstream-webfont.ttf
    │   │   ├── LAKESHOR-webfont.eot
    │   │   ├── LAKESHOR-webfont.ttf
    │   │   ├── LAKESHOR-webfont.woff
    │   │   ├── Airstream-webfont.woff
    │   │   └── LAKESHOR-webfont.svg
    │   └── styles.css
    ├── sounds
    │   └── Groovy-disco-funky-sound-logo.mp3
    ├── scripts
    │   └── main.js
    └── index.html
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules


--------------------------------------------------------------------------------
/Koans/example_file.txt:
--------------------------------------------------------------------------------
1 | this
2 | is
3 | a
4 | test
5 | 


--------------------------------------------------------------------------------
/Koans/koans.watchr:
--------------------------------------------------------------------------------
1 | watch( '.*\.rb' ) do
2 |   system 'rake'
3 | end
4 | 


--------------------------------------------------------------------------------
/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/airbr/front-end-dev-book/HEAD/.DS_Store


--------------------------------------------------------------------------------
/Koans/.path_progress:
--------------------------------------------------------------------------------
1 | 0,1,2,3,4,5,5,5,5,5,6,6,6,6,7,7,7,7,7,7,7,8,8,9,9,10,12,11,12,13,13,14,14,15


--------------------------------------------------------------------------------
/coffeerun/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/airbr/front-end-dev-book/HEAD/coffeerun/.DS_Store


--------------------------------------------------------------------------------
/ottergram/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/airbr/front-end-dev-book/HEAD/ottergram/.DS_Store


--------------------------------------------------------------------------------
/ottergram/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/airbr/front-end-dev-book/HEAD/ottergram/favicon.ico


--------------------------------------------------------------------------------
/ottergram/img/otter1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/airbr/front-end-dev-book/HEAD/ottergram/img/otter1.jpg


--------------------------------------------------------------------------------
/ottergram/img/otter2.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/airbr/front-end-dev-book/HEAD/ottergram/img/otter2.jpg


--------------------------------------------------------------------------------
/ottergram/img/otter3.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/airbr/front-end-dev-book/HEAD/ottergram/img/otter3.jpg


--------------------------------------------------------------------------------
/ottergram/img/otter4.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/airbr/front-end-dev-book/HEAD/ottergram/img/otter4.jpg


--------------------------------------------------------------------------------
/ottergram/img/otter5.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/airbr/front-end-dev-book/HEAD/ottergram/img/otter5.jpg


--------------------------------------------------------------------------------
/coffeerun/scripts/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/airbr/front-end-dev-book/HEAD/coffeerun/scripts/.DS_Store


--------------------------------------------------------------------------------
/ottergram/stylesheets/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/airbr/front-end-dev-book/HEAD/ottergram/stylesheets/.DS_Store


--------------------------------------------------------------------------------
/ottergram/stylesheets/fonts/Airstream-webfont.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/airbr/front-end-dev-book/HEAD/ottergram/stylesheets/fonts/Airstream-webfont.eot


--------------------------------------------------------------------------------
/ottergram/stylesheets/fonts/Airstream-webfont.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/airbr/front-end-dev-book/HEAD/ottergram/stylesheets/fonts/Airstream-webfont.ttf


--------------------------------------------------------------------------------
/ottergram/stylesheets/fonts/LAKESHOR-webfont.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/airbr/front-end-dev-book/HEAD/ottergram/stylesheets/fonts/LAKESHOR-webfont.eot


--------------------------------------------------------------------------------
/ottergram/stylesheets/fonts/LAKESHOR-webfont.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/airbr/front-end-dev-book/HEAD/ottergram/stylesheets/fonts/LAKESHOR-webfont.ttf


--------------------------------------------------------------------------------
/ottergram/stylesheets/fonts/LAKESHOR-webfont.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/airbr/front-end-dev-book/HEAD/ottergram/stylesheets/fonts/LAKESHOR-webfont.woff


--------------------------------------------------------------------------------
/ottergram/sounds/Groovy-disco-funky-sound-logo.mp3:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/airbr/front-end-dev-book/HEAD/ottergram/sounds/Groovy-disco-funky-sound-logo.mp3


--------------------------------------------------------------------------------
/ottergram/stylesheets/fonts/Airstream-webfont.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/airbr/front-end-dev-book/HEAD/ottergram/stylesheets/fonts/Airstream-webfont.woff


--------------------------------------------------------------------------------
/Koans/Rakefile:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env ruby
 2 | # -*- ruby -*-
 3 | 
 4 | require 'rake/clean'
 5 | require 'rake/testtask'
 6 | 
 7 | task :default => :test
 8 | 
 9 | task :test do
10 |   ruby 'path_to_enlightenment.rb'
11 | end
12 | 
13 | 


--------------------------------------------------------------------------------
/Koans/about_extra_credit.rb:
--------------------------------------------------------------------------------
1 | # EXTRA CREDIT:
2 | #
3 | # Create a program that will play the Greed Game.
4 | # Rules for the game are in GREED_RULES.TXT.
5 | #
6 | # You already have a DiceSet class and score function you can use.
7 | # Write a player class and a Game class to complete the project.  This
8 | # is a free form assignment, so approach it however you desire.
9 | 


--------------------------------------------------------------------------------
/coffeerun/scripts/main.js:
--------------------------------------------------------------------------------
 1 | (function(window) {
 2 |   'use strict';
 3 |   var FORM_SELECTOR = '[data-coffee-order="form"]';
 4 |   var App = window.App;
 5 |   var Truck = App.Truck;
 6 |   var DataStore = App.DataStore;
 7 |   var FormHandler = App.FormHandler;
 8 | 
 9 |   var myTruck = new Truck('ncc-1701', new DataStore());
10 |   window.myTruck = myTruck;
11 |   var formHandler = new FormHandler(FORM_SELECTOR);
12 |   formHandler.addSubmitHandler(myTruck.createOrder.bind(myTruck));
13 | })(window);
14 | 


--------------------------------------------------------------------------------
/coffeerun/scripts/datastore.js:
--------------------------------------------------------------------------------
 1 | (function(window) {
 2 |   'use strict';
 3 |   var App = window.App || {};
 4 | 
 5 |   function DataStore() {
 6 |     this.data = {};
 7 |   }
 8 | 
 9 |   DataStore.prototype.add = function(key, val) {
10 |     this.data[key] = val;
11 |   };
12 |   DataStore.prototype.get = function(key) {
13 |     return this.data[key];
14 |   };
15 |   DataStore.prototype.getAll = function() {
16 |     return this.data;
17 |   };
18 |   DataStore.prototype.remove = function(key) {
19 |     delete this.data[key];
20 |   };
21 | 
22 |   App.DataStore = DataStore;
23 |   window.App = App;
24 | })(window);
25 | 


--------------------------------------------------------------------------------
/Koans/triangle.rb:
--------------------------------------------------------------------------------
 1 | # Triangle Project Code.
 2 | 
 3 | # Triangle analyzes the lengths of the sides of a triangle
 4 | # (represented by a, b and c) and returns the type of triangle.
 5 | #
 6 | # It returns:
 7 | #   :equilateral  if all sides are equal
 8 | #   :isosceles    if exactly 2 sides are equal
 9 | #   :scalene      if no sides are equal
10 | #
11 | # The tests for this method can be found in
12 | #   about_triangle_project.rb
13 | # and
14 | #   about_triangle_project_2.rb
15 | #
16 | def triangle(a, b, c)
17 |   # WRITE THIS CODE
18 | end
19 | 
20 | # Error class used in part 2.  No need to change this code.
21 | class TriangleError < StandardError
22 | end
23 | 


--------------------------------------------------------------------------------
/Koans/about_triangle_project_2.rb:
--------------------------------------------------------------------------------
 1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
 2 | 
 3 | # You need to write the triangle method in the file 'triangle.rb'
 4 | require './triangle.rb'
 5 | 
 6 | class AboutTriangleProject2 < Neo::Koan
 7 |   # The first assignment did not talk about how to handle errors.
 8 |   # Let's handle that part now.
 9 |   def test_illegal_triangles_throw_exceptions
10 |     assert_raise(TriangleError) do triangle(0, 0, 0) end
11 |     assert_raise(TriangleError) do triangle(3, 4, -5) end
12 |     assert_raise(TriangleError) do triangle(1, 1, 3) end
13 |     assert_raise(TriangleError) do triangle(2, 4, 2) end
14 |     # HINT: for tips, see http://stackoverflow.com/questions/3834203/ruby-koan-151-raising-exceptions
15 |   end
16 | end
17 | 


--------------------------------------------------------------------------------
/Koans/versioning_spec.rb:
--------------------------------------------------------------------------------
 1 | 
 2 | def version_ints(version)
 3 |   version.split(".").map { |v| v.to_i }
 4 | end
 5 | 
 6 | def at_least_ruby_version(version)
 7 |   vints = version_ints(version)
 8 |   ruby_vints = version_ints(RUBY_VERSION)
 9 |   vints.zip(ruby_vints).all? { |v, rv| v.nil? || rv.nil? || v >= rv }
10 | end
11 | 
12 | 
13 | require 'rspec/given'
14 | 
15 | describe "#version_ints" do
16 |   Then { version_ints("1.2") == [1, 2] }
17 |   Then { version_ints("2.1.20") == [2, 1, 20] }
18 | end
19 | 
20 | describe "at_least_ruby_version" do
21 |   Then { at_least_ruby_version("2") }
22 |   Then { at_least_ruby_version("2.0") }
23 |   Then { at_least_ruby_version("2.0.1") }
24 |   Then { at_least_ruby_version("2.1") }
25 |   Then { at_least_ruby_version("2.1.3.4.1") }
26 | 
27 |   Then { ! at_least_ruby_version("1.9") }
28 |   Then { ! at_least_ruby_version("1.9.9.9.9") }
29 | end
30 | 


--------------------------------------------------------------------------------
/Koans/about_true_and_false.rb:
--------------------------------------------------------------------------------
 1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
 2 | 
 3 | class AboutTrueAndFalse < Neo::Koan
 4 |   def truth_value(condition)
 5 |     if condition
 6 |       :true_stuff
 7 |     else
 8 |       :false_stuff
 9 |     end
10 |   end
11 | 
12 |   def test_true_is_treated_as_true
13 |     assert_equal __, truth_value(true)
14 |   end
15 | 
16 |   def test_false_is_treated_as_false
17 |     assert_equal __, truth_value(false)
18 |   end
19 | 
20 |   def test_nil_is_treated_as_false_too
21 |     assert_equal __, truth_value(nil)
22 |   end
23 | 
24 |   def test_everything_else_is_treated_as_true
25 |     assert_equal __, truth_value(1)
26 |     assert_equal __, truth_value(0)
27 |     assert_equal __, truth_value([])
28 |     assert_equal __, truth_value({})
29 |     assert_equal __, truth_value("Strings")
30 |     assert_equal __, truth_value("")
31 |   end
32 | 
33 | end
34 | 


--------------------------------------------------------------------------------
/coffeerun/scripts/truck.js:
--------------------------------------------------------------------------------
 1 | (function(window) {
 2 |   'use strict';
 3 |   var App = window.App || {};
 4 | 
 5 |   function Truck(truckId, db) {
 6 |     this.truckId = truckId;
 7 |     this.db = db;
 8 |   }
 9 |   Truck.prototype.createOrder = function(order) {
10 |     console.log('Adding order for ' + order.email);
11 |     this.db.add(order.email, order);
12 |   };
13 |   Truck.prototype.deliverOrder = function(customerId) {
14 |     console.log('Delivering order for ' + customerId);
15 |     this.db.remove(customerId);
16 |   };
17 |   Truck.prototype.printOrders = function() {
18 |     var customerIdArray = Object.keys(this.db.getAll());
19 |     console.log('Truck #' + this.truckId + ' has pending orders:');
20 |     customerIdArray.forEach(function(id) {
21 |       console.log(this.db.get(id));
22 |     }.bind(this));
23 |   };
24 | 
25 |   App.Truck = Truck;
26 |   window.App = App;
27 | })(window);
28 | 


--------------------------------------------------------------------------------
/Koans/about_triangle_project.rb:
--------------------------------------------------------------------------------
 1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
 2 | 
 3 | # You need to write the triangle method in the file 'triangle.rb'
 4 | require './triangle'
 5 | 
 6 | class AboutTriangleProject < Neo::Koan
 7 |   def test_equilateral_triangles_have_equal_sides
 8 |     assert_equal :equilateral, triangle(2, 2, 2)
 9 |     assert_equal :equilateral, triangle(10, 10, 10)
10 |   end
11 | 
12 |   def test_isosceles_triangles_have_exactly_two_sides_equal
13 |     assert_equal :isosceles, triangle(3, 4, 4)
14 |     assert_equal :isosceles, triangle(4, 3, 4)
15 |     assert_equal :isosceles, triangle(4, 4, 3)
16 |     assert_equal :isosceles, triangle(10, 10, 2)
17 |   end
18 | 
19 |   def test_scalene_triangles_have_no_equal_sides
20 |     assert_equal :scalene, triangle(3, 4, 5)
21 |     assert_equal :scalene, triangle(10, 11, 12)
22 |     assert_equal :scalene, triangle(5, 4, 2)
23 |   end
24 | end
25 | 


--------------------------------------------------------------------------------
/Koans/about_keyword_arguments.rb:
--------------------------------------------------------------------------------
 1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
 2 | 
 3 | class AboutKeywordArguments < Neo::Koan
 4 | 
 5 |   def method_with_keyword_arguments(one: 1, two: 'two')
 6 |     [one, two]
 7 |   end
 8 | 
 9 |   def test_keyword_arguments
10 |     assert_equal __, method_with_keyword_arguments.class
11 |     assert_equal __, method_with_keyword_arguments
12 |     assert_equal __, method_with_keyword_arguments(one: 'one')
13 |     assert_equal __, method_with_keyword_arguments(two: 2)
14 |   end
15 | 
16 |   def method_with_keyword_arguments_with_mandatory_argument(one, two: 2, three: 3)
17 |     [one, two, three]
18 |   end
19 | 
20 |   def test_keyword_arguments_with_wrong_number_of_arguments
21 |     exception = assert_raise (___) do
22 |       method_with_keyword_arguments_with_mandatory_argument
23 |     end
24 |     assert_match(/__/, exception.message)
25 |   end
26 | 
27 |   # THINK ABOUT IT:
28 |   #
29 |   # Keyword arguments always have a default value, making them optional to the caller
30 | 
31 | end
32 | 


--------------------------------------------------------------------------------
/Koans/about_open_classes.rb:
--------------------------------------------------------------------------------
 1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
 2 | 
 3 | class AboutOpenClasses < Neo::Koan
 4 |   class Dog
 5 |     def bark
 6 |       "WOOF"
 7 |     end
 8 |   end
 9 | 
10 |   def test_as_defined_dogs_do_bark
11 |     fido = Dog.new
12 |     assert_equal __, fido.bark
13 |   end
14 | 
15 |   # ------------------------------------------------------------------
16 | 
17 |   # Open the existing Dog class and add a new method.
18 |   class Dog
19 |     def wag
20 |       "HAPPY"
21 |     end
22 |   end
23 | 
24 |   def test_after_reopening_dogs_can_both_wag_and_bark
25 |     fido = Dog.new
26 |     assert_equal __, fido.wag
27 |     assert_equal __, fido.bark
28 |   end
29 | 
30 |   # ------------------------------------------------------------------
31 | 
32 |   class ::Integer
33 |     def even?
34 |       (self % 2) == 0
35 |     end
36 |   end
37 | 
38 |   def test_even_existing_built_in_classes_can_be_reopened
39 |     assert_equal __, 1.even?
40 |     assert_equal __, 2.even?
41 |   end
42 | 
43 |   # NOTE: To understand why we need the :: before Integer, you need to
44 |   # become enlightened about scope.
45 | end
46 | 


--------------------------------------------------------------------------------
/Koans/about_asserts.rb:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env ruby
 2 | # -*- ruby -*-
 3 | 
 4 | require File.expand_path(File.dirname(__FILE__) + '/neo')
 5 | 
 6 | class AboutAsserts < Neo::Koan
 7 | 
 8 |   # We shall contemplate truth by testing reality, via asserts.
 9 |   def test_assert_truth
10 |     assert true                # This should be true
11 |   end
12 | 
13 |   # Enlightenment may be more easily achieved with appropriate
14 |   # messages.
15 |   def test_assert_with_message
16 |     assert true, "This should be true -- Please fix this"
17 |   end
18 | 
19 |   # To understand reality, we must compare our expectations against
20 |   # reality.
21 |   def test_assert_equality
22 |     expected_value = 2
23 |     actual_value = 1 + 1
24 | 
25 |     assert expected_value == actual_value
26 |   end
27 | 
28 |   # Some ways of asserting equality are better than others.
29 |   def test_a_better_way_of_asserting_equality
30 |     expected_value = 2
31 |     actual_value = 1 + 1
32 | 
33 |     assert_equal expected_value, actual_value
34 |   end
35 | 
36 |   # Sometimes we will ask you to fill in the values
37 |   def test_fill_in_values
38 |     assert_equal 2, 1 + 1
39 |   end
40 | end
41 | 
42 | #Completed About Asserts


--------------------------------------------------------------------------------
/Koans/path_to_enlightenment.rb:
--------------------------------------------------------------------------------
 1 | # The path to Ruby Enlightenment starts with the following:
 2 | 
 3 | $LOAD_PATH << File.dirname(__FILE__)
 4 | 
 5 | require 'about_asserts'
 6 | require 'about_nil'
 7 | require 'about_objects'
 8 | require 'about_arrays'
 9 | require 'about_array_assignment'
10 | require 'about_hashes'
11 | require 'about_strings'
12 | require 'about_symbols'
13 | require 'about_regular_expressions'
14 | require 'about_methods'
15 | in_ruby_version("2") do
16 |   require 'about_keyword_arguments'
17 | end
18 | require 'about_constants'
19 | require 'about_control_statements'
20 | require 'about_true_and_false'
21 | require 'about_triangle_project'
22 | require 'about_exceptions'
23 | require 'about_triangle_project_2'
24 | require 'about_iteration'
25 | require 'about_blocks'
26 | require 'about_sandwich_code'
27 | require 'about_scoring_project'
28 | require 'about_classes'
29 | require 'about_open_classes'
30 | require 'about_dice_project'
31 | require 'about_inheritance'
32 | require 'about_modules'
33 | require 'about_scope'
34 | require 'about_class_methods'
35 | require 'about_message_passing'
36 | require 'about_proxy_object_project'
37 | require 'about_to_str'
38 | in_ruby_version("jruby") do
39 |   require 'about_java_interop'
40 | end
41 | require 'about_extra_credit'
42 | 


--------------------------------------------------------------------------------
/Koans/about_nil.rb:
--------------------------------------------------------------------------------
 1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
 2 | 
 3 | class AboutNil < Neo::Koan
 4 |   def test_nil_is_an_object
 5 |     assert_equal true, nil.is_a?(Object), "Unlike NULL in other languages"
 6 |   end
 7 | 
 8 |   def test_you_dont_get_null_pointer_errors_when_calling_methods_on_nil
 9 |     # What happens when you call a method that doesn't exist.  The
10 |     # following begin/rescue/end code block captures the exception and
11 |     # makes some assertions about it.
12 |     begin
13 |       nil.some_method_nil_doesnt_know_about
14 |     rescue Exception => ex
15 |       # What exception has been caught?
16 |       assert_equal NoMethodError, ex.class
17 | 
18 |       # What message was attached to the exception?
19 |       # (HINT: replace __ with part of the error message.)
20 |       assert_match(/undefined method `some_method_nil_doesnt_know_about' for nil:NilClass/, ex.message)
21 |     end
22 |   end
23 | 
24 |   def test_nil_has_a_few_methods_defined_on_it
25 |     assert_equal true, nil.nil? # Only method on nil returns true ?
26 |     assert_equal "", nil.to_s # Empty string..
27 |     assert_equal "nil", nil.inspect #String of nil 
28 | 
29 |     # THINK ABOUT IT:
30 |     #
31 |     # Is it better to use
32 |     #    obj.nil?
33 |     # or
34 |     #    obj == nil
35 |     # Why?
36 |   end
37 | 
38 | end
39 | 


--------------------------------------------------------------------------------
/Koans/about_modules.rb:
--------------------------------------------------------------------------------
 1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
 2 | 
 3 | class AboutModules < Neo::Koan
 4 |   module Nameable
 5 |     def set_name(new_name)
 6 |       @name = new_name
 7 |     end
 8 | 
 9 |     def here
10 |       :in_module
11 |     end
12 |   end
13 | 
14 |   def test_cant_instantiate_modules
15 |     assert_raise(___) do
16 |       Nameable.new
17 |     end
18 |   end
19 | 
20 |   # ------------------------------------------------------------------
21 | 
22 |   class Dog
23 |     include Nameable
24 | 
25 |     attr_reader :name
26 | 
27 |     def initialize
28 |       @name = "Fido"
29 |     end
30 | 
31 |     def bark
32 |       "WOOF"
33 |     end
34 | 
35 |     def here
36 |       :in_object
37 |     end
38 |   end
39 | 
40 |   def test_normal_methods_are_available_in_the_object
41 |     fido = Dog.new
42 |     assert_equal __, fido.bark
43 |   end
44 | 
45 |   def test_module_methods_are_also_available_in_the_object
46 |     fido = Dog.new
47 |     assert_nothing_raised do
48 |       fido.set_name("Rover")
49 |     end
50 |   end
51 | 
52 |   def test_module_methods_can_affect_instance_variables_in_the_object
53 |     fido = Dog.new
54 |     assert_equal __, fido.name
55 |     fido.set_name("Rover")
56 |     assert_equal __, fido.name
57 |   end
58 | 
59 |   def test_classes_can_override_module_methods
60 |     fido = Dog.new
61 |     assert_equal __, fido.here
62 |   end
63 | end
64 | 


--------------------------------------------------------------------------------
/coffeerun/scripts/formhandler.js:
--------------------------------------------------------------------------------
 1 | (function(window) {
 2 |   'use strict';
 3 |   var App = window.App || {};
 4 |   var $ = window.jQuery;
 5 | 
 6 |   function FormHandler(selector) {
 7 |     if (!selector) {
 8 |       throw new Error('No selector provided');
 9 |     }
10 | 
11 |     this.$formElement = $(selector);
12 |     if (this.$formElement.length === 0) {
13 |       throw new Error('Could not find element with selector: ' + selector);
14 |     }
15 | 
16 |     FormHandler.prototype.addSubmitHandler = function(fn) {
17 |       console.log('Setting submit handler for form');
18 |       this.$formElement.on('submit', function(event) {
19 |         event.preventDefault();
20 | 
21 |         // var data = {
22 |         //   coffee: this.elements.coffee.value,
23 |         //   email: this.elements.emailAddress.value,
24 |         //   size: this.elements.size.value,
25 |         //   flavor: this.elements.flavor.value,
26 |         //   strength: this.elements.strength.value
27 |         // };
28 |         var data = {};
29 |         $(this).serializeArray().forEach(function(item) {
30 |           data[item.name] = item.value;
31 |           console.log(item.name + ' is' + item.value);
32 |         });
33 | 
34 |         console.log(data);
35 |         fn(data);
36 |         this.reset();
37 |         this.elements[0].focus();
38 |       });
39 |     };
40 |   }
41 |   App.FormHandler = FormHandler;
42 |   window.App = App;
43 | })(window);
44 | 


--------------------------------------------------------------------------------
/Koans/about_to_str.rb:
--------------------------------------------------------------------------------
 1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
 2 | 
 3 | class AboutToStr < Neo::Koan
 4 | 
 5 |   class CanNotBeTreatedAsString
 6 |     def to_s
 7 |       "non-string-like"
 8 |     end
 9 |   end
10 | 
11 |   def test_to_s_returns_a_string_representation
12 |     not_like_a_string = CanNotBeTreatedAsString.new
13 |     assert_equal __, not_like_a_string.to_s
14 |   end
15 | 
16 |   def test_normally_objects_cannot_be_used_where_strings_are_expected
17 |     assert_raise(___) do
18 |       File.exist?(CanNotBeTreatedAsString.new)
19 |     end
20 |   end
21 | 
22 |   # ------------------------------------------------------------------
23 | 
24 |   class CanBeTreatedAsString
25 |     def to_s
26 |       "string-like"
27 |     end
28 | 
29 |     def to_str
30 |       to_s
31 |     end
32 |   end
33 | 
34 |   def test_to_str_also_returns_a_string_representation
35 |     like_a_string = CanBeTreatedAsString.new
36 |     assert_equal __, like_a_string.to_str
37 |   end
38 | 
39 |   def test_to_str_allows_objects_to_be_treated_as_strings
40 |     assert_equal __, File.exist?(CanBeTreatedAsString.new)
41 |   end
42 | 
43 |   # ------------------------------------------------------------------
44 | 
45 |   def acts_like_a_string?(string)
46 |     string = string.to_str if string.respond_to?(:to_str)
47 |     string.is_a?(String)
48 |   end
49 | 
50 |   def test_user_defined_code_can_check_for_to_str
51 |     assert_equal __, acts_like_a_string?(CanNotBeTreatedAsString.new)
52 |     assert_equal __,  acts_like_a_string?(CanBeTreatedAsString.new)
53 |   end
54 | end
55 | 


--------------------------------------------------------------------------------
/Koans/about_objects.rb:
--------------------------------------------------------------------------------
 1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
 2 | 
 3 | class AboutObjects < Neo::Koan
 4 |   def test_everything_is_an_object
 5 |     assert_equal true, 1.is_a?(Object)
 6 |     assert_equal true, 1.5.is_a?(Object)
 7 |     assert_equal true, "string".is_a?(Object)
 8 |     assert_equal true, nil.is_a?(Object)
 9 |     assert_equal true, Object.is_a?(Object)
10 |   end
11 | 
12 |   def test_objects_can_be_converted_to_strings
13 |     assert_equal "123", 123.to_s
14 |     assert_equal "", nil.to_s
15 |   end
16 | 
17 |   def test_objects_can_be_inspected
18 |     assert_equal "123", 123.inspect
19 |     assert_equal "nil", nil.inspect
20 |   end
21 | 
22 |   def test_every_object_has_an_id
23 |     obj = Object.new
24 |     assert_equal Fixnum, obj.object_id.class
25 |   end
26 | 
27 |   def test_every_object_has_different_id
28 |     obj = Object.new
29 |     another_obj = Object.new
30 |     assert_equal true, obj.object_id != another_obj.object_id
31 |   end
32 | 
33 |   def test_small_integers_have_fixed_ids
34 |     assert_equal 1, 0.object_id
35 |     assert_equal 3, 1.object_id
36 |     assert_equal 5, 2.object_id
37 |     assert_equal 201, 100.object_id
38 | 
39 |     # THINK ABOUT IT:
40 |     # What pattern do the object IDs for small integers follow?
41 |       # = Fibonnaci Sequence. Why? No idea. 
42 |   end
43 | 
44 |   def test_clone_creates_a_different_object
45 |     obj = Object.new
46 |     copy = obj.clone
47 | 
48 |     assert_equal true, obj           != copy
49 |     assert_equal true, obj.object_id != copy.object_id
50 |   end
51 | end
52 | 
53 | 


--------------------------------------------------------------------------------
/Koans/about_array_assignment.rb:
--------------------------------------------------------------------------------
 1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
 2 | 
 3 | class AboutArrayAssignment < Neo::Koan
 4 |   def test_non_parallel_assignment
 5 |     names = ["John", "Smith"]
 6 |     assert_equal __, names
 7 |   end
 8 | 
 9 |   def test_parallel_assignments
10 |     first_name, last_name = ["John", "Smith"]
11 |     assert_equal __, first_name
12 |     assert_equal __, last_name
13 |   end
14 | 
15 |   def test_parallel_assignments_with_extra_values
16 |     first_name, last_name = ["John", "Smith", "III"]
17 |     assert_equal __, first_name
18 |     assert_equal __, last_name
19 |   end
20 | 
21 |   def test_parallel_assignments_with_splat_operator
22 |     first_name, *last_name = ["John", "Smith", "III"]
23 |     assert_equal __, first_name
24 |     assert_equal __, last_name
25 |   end
26 | 
27 |   def test_parallel_assignments_with_too_few_variables
28 |     first_name, last_name = ["Cher"]
29 |     assert_equal __, first_name
30 |     assert_equal __, last_name
31 |   end
32 | 
33 |   def test_parallel_assignments_with_subarrays
34 |     first_name, last_name = [["Willie", "Rae"], "Johnson"]
35 |     assert_equal __, first_name
36 |     assert_equal __, last_name
37 |   end
38 | 
39 |   def test_parallel_assignment_with_one_variable
40 |     first_name, = ["John", "Smith"]
41 |     assert_equal __, first_name
42 |   end
43 | 
44 |   def test_swapping_with_parallel_assignment
45 |     first_name = "Roy"
46 |     last_name = "Rob"
47 |     first_name, last_name = last_name, first_name
48 |     assert_equal __, first_name
49 |     assert_equal __, last_name
50 |   end
51 | end
52 | 


--------------------------------------------------------------------------------
/Koans/about_dice_project.rb:
--------------------------------------------------------------------------------
 1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
 2 | 
 3 | # Implement a DiceSet Class here:
 4 | #
 5 | # class DiceSet
 6 | #   code ...
 7 | # end
 8 | 
 9 | class AboutDiceProject < Neo::Koan
10 |   def test_can_create_a_dice_set
11 |     dice = DiceSet.new
12 |     assert_not_nil dice
13 |   end
14 | 
15 |   def test_rolling_the_dice_returns_a_set_of_integers_between_1_and_6
16 |     dice = DiceSet.new
17 | 
18 |     dice.roll(5)
19 |     assert dice.values.is_a?(Array), "should be an array"
20 |     assert_equal 5, dice.values.size
21 |     dice.values.each do |value|
22 |       assert value >= 1 && value <= 6, "value #{value} must be between 1 and 6"
23 |     end
24 |   end
25 | 
26 |   def test_dice_values_do_not_change_unless_explicitly_rolled
27 |     dice = DiceSet.new
28 |     dice.roll(5)
29 |     first_time = dice.values
30 |     second_time = dice.values
31 |     assert_equal first_time, second_time
32 |   end
33 | 
34 |   def test_dice_values_should_change_between_rolls
35 |     dice = DiceSet.new
36 | 
37 |     dice.roll(5)
38 |     first_time = dice.values
39 | 
40 |     dice.roll(5)
41 |     second_time = dice.values
42 | 
43 |     assert_not_equal first_time, second_time,
44 |       "Two rolls should not be equal"
45 | 
46 |     # THINK ABOUT IT:
47 |     #
48 |     # If the rolls are random, then it is possible (although not
49 |     # likely) that two consecutive rolls are equal.  What would be a
50 |     # better way to test this?
51 |   end
52 | 
53 |   def test_you_can_roll_different_numbers_of_dice
54 |     dice = DiceSet.new
55 | 
56 |     dice.roll(3)
57 |     assert_equal 3, dice.values.size
58 | 
59 |     dice.roll(1)
60 |     assert_equal 1, dice.values.size
61 |   end
62 | 
63 | end
64 | 


--------------------------------------------------------------------------------
/Koans/about_exceptions.rb:
--------------------------------------------------------------------------------
 1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
 2 | 
 3 | class AboutExceptions < Neo::Koan
 4 | 
 5 |   class MySpecialError < RuntimeError
 6 |   end
 7 | 
 8 |   def test_exceptions_inherit_from_Exception
 9 |     assert_equal __, MySpecialError.ancestors[1]
10 |     assert_equal __, MySpecialError.ancestors[2]
11 |     assert_equal __, MySpecialError.ancestors[3]
12 |     assert_equal __, MySpecialError.ancestors[4]
13 |   end
14 | 
15 |   def test_rescue_clause
16 |     result = nil
17 |     begin
18 |       fail "Oops"
19 |     rescue StandardError => ex
20 |       result = :exception_handled
21 |     end
22 | 
23 |     assert_equal __, result
24 | 
25 |     assert_equal __, ex.is_a?(StandardError), "Should be a Standard Error"
26 |     assert_equal __, ex.is_a?(RuntimeError),  "Should be a Runtime Error"
27 | 
28 |     assert RuntimeError.ancestors.include?(StandardError),
29 |       "RuntimeError is a subclass of StandardError"
30 | 
31 |     assert_equal __, ex.message
32 |   end
33 | 
34 |   def test_raising_a_particular_error
35 |     result = nil
36 |     begin
37 |       # 'raise' and 'fail' are synonyms
38 |       raise MySpecialError, "My Message"
39 |     rescue MySpecialError => ex
40 |       result = :exception_handled
41 |     end
42 | 
43 |     assert_equal __, result
44 |     assert_equal __, ex.message
45 |   end
46 | 
47 |   def test_ensure_clause
48 |     result = nil
49 |     begin
50 |       fail "Oops"
51 |     rescue StandardError
52 |       # no code here
53 |     ensure
54 |       result = :always_run
55 |     end
56 | 
57 |     assert_equal __, result
58 |   end
59 | 
60 |   # Sometimes, we must know about the unknown
61 |   def test_asserting_an_error_is_raised
62 |     # A do-end is a block, a topic to explore more later
63 |     assert_raise(___) do
64 |       raise MySpecialError.new("New instances can be raised directly.")
65 |     end
66 |   end
67 | 
68 | end
69 | 


--------------------------------------------------------------------------------
/Koans/about_inheritance.rb:
--------------------------------------------------------------------------------
 1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
 2 | 
 3 | class AboutInheritance < Neo::Koan
 4 |   class Dog
 5 |     attr_reader :name
 6 | 
 7 |     def initialize(name)
 8 |       @name = name
 9 |     end
10 | 
11 |     def bark
12 |       "WOOF"
13 |     end
14 |   end
15 | 
16 |   class Chihuahua < Dog
17 |     def wag
18 |       :happy
19 |     end
20 | 
21 |     def bark
22 |       "yip"
23 |     end
24 |   end
25 | 
26 |   def test_subclasses_have_the_parent_as_an_ancestor
27 |     assert_equal __, Chihuahua.ancestors.include?(Dog)
28 |   end
29 | 
30 |   def test_all_classes_ultimately_inherit_from_object
31 |     assert_equal __, Chihuahua.ancestors.include?(Object)
32 |   end
33 | 
34 |   def test_subclasses_inherit_behavior_from_parent_class
35 |     chico = Chihuahua.new("Chico")
36 |     assert_equal __, chico.name
37 |   end
38 | 
39 |   def test_subclasses_add_new_behavior
40 |     chico = Chihuahua.new("Chico")
41 |     assert_equal __, chico.wag
42 | 
43 |     assert_raise(___) do
44 |       fido = Dog.new("Fido")
45 |       fido.wag
46 |     end
47 |   end
48 | 
49 |   def test_subclasses_can_modify_existing_behavior
50 |     chico = Chihuahua.new("Chico")
51 |     assert_equal __, chico.bark
52 | 
53 |     fido = Dog.new("Fido")
54 |     assert_equal __, fido.bark
55 |   end
56 | 
57 |   # ------------------------------------------------------------------
58 | 
59 |   class BullDog < Dog
60 |     def bark
61 |       super + ", GROWL"
62 |     end
63 |   end
64 | 
65 |   def test_subclasses_can_invoke_parent_behavior_via_super
66 |     ralph = BullDog.new("Ralph")
67 |     assert_equal __, ralph.bark
68 |   end
69 | 
70 |   # ------------------------------------------------------------------
71 | 
72 |   class GreatDane < Dog
73 |     def growl
74 |       super.bark + ", GROWL"
75 |     end
76 |   end
77 | 
78 |   def test_super_does_not_work_cross_method
79 |     george = GreatDane.new("George")
80 |     assert_raise(___) do
81 |       george.growl
82 |     end
83 |   end
84 | 
85 | end
86 | 


--------------------------------------------------------------------------------
/Koans/about_arrays.rb:
--------------------------------------------------------------------------------
 1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
 2 | 
 3 | class AboutArrays < Neo::Koan
 4 |   def test_creating_arrays
 5 |     empty_array = Array.new
 6 |     assert_equal __, empty_array.class
 7 |     assert_equal __, empty_array.size
 8 |   end
 9 | 
10 |   def test_array_literals
11 |     array = Array.new
12 |     assert_equal [], array
13 | 
14 |     array[0] = 1
15 |     assert_equal [1], array
16 | 
17 |     array[1] = 2
18 |     assert_equal [1, __], array
19 | 
20 |     array << 333
21 |     assert_equal __, array
22 |   end
23 | 
24 |   def test_accessing_array_elements
25 |     array = [:peanut, :butter, :and, :jelly]
26 | 
27 |     assert_equal __, array[0]
28 |     assert_equal __, array.first
29 |     assert_equal __, array[3]
30 |     assert_equal __, array.last
31 |     assert_equal __, array[-1]
32 |     assert_equal __, array[-3]
33 |   end
34 | 
35 |   def test_slicing_arrays
36 |     array = [:peanut, :butter, :and, :jelly]
37 | 
38 |     assert_equal __, array[0,1]
39 |     assert_equal __, array[0,2]
40 |     assert_equal __, array[2,2]
41 |     assert_equal __, array[2,20]
42 |     assert_equal __, array[4,0]
43 |     assert_equal __, array[4,100]
44 |     assert_equal __, array[5,0]
45 |   end
46 | 
47 |   def test_arrays_and_ranges
48 |     assert_equal __, (1..5).class
49 |     assert_not_equal [1,2,3,4,5], (1..5)
50 |     assert_equal __, (1..5).to_a
51 |     assert_equal __, (1...5).to_a
52 |   end
53 | 
54 |   def test_slicing_with_ranges
55 |     array = [:peanut, :butter, :and, :jelly]
56 | 
57 |     assert_equal __, array[0..2]
58 |     assert_equal __, array[0...2]
59 |     assert_equal __, array[2..-1]
60 |   end
61 | 
62 |   def test_pushing_and_popping_arrays
63 |     array = [1,2]
64 |     array.push(:last)
65 | 
66 |     assert_equal __, array
67 | 
68 |     popped_value = array.pop
69 |     assert_equal __, popped_value
70 |     assert_equal __, array
71 |   end
72 | 
73 |   def test_shifting_arrays
74 |     array = [1,2]
75 |     array.unshift(:first)
76 | 
77 |     assert_equal __, array
78 | 
79 |     shifted_value = array.shift
80 |     assert_equal __, shifted_value
81 |     assert_equal __, array
82 |   end
83 | 
84 | end
85 | 


--------------------------------------------------------------------------------
/Koans/about_scope.rb:
--------------------------------------------------------------------------------
 1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
 2 | 
 3 | class AboutScope < Neo::Koan
 4 |   module Jims
 5 |     class Dog
 6 |       def identify
 7 |         :jims_dog
 8 |       end
 9 |     end
10 |   end
11 | 
12 |   module Joes
13 |     class Dog
14 |       def identify
15 |         :joes_dog
16 |       end
17 |     end
18 |   end
19 | 
20 |   def test_dog_is_not_available_in_the_current_scope
21 |     assert_raise(___) do
22 |       Dog.new
23 |     end
24 |   end
25 | 
26 |   def test_you_can_reference_nested_classes_using_the_scope_operator
27 |     fido = Jims::Dog.new
28 |     rover = Joes::Dog.new
29 |     assert_equal __, fido.identify
30 |     assert_equal __, rover.identify
31 | 
32 |     assert_equal __, fido.class != rover.class
33 |     assert_equal __, Jims::Dog != Joes::Dog
34 |   end
35 | 
36 |   # ------------------------------------------------------------------
37 | 
38 |   class String
39 |   end
40 | 
41 |   def test_bare_bones_class_names_assume_the_current_scope
42 |     assert_equal __, AboutScope::String == String
43 |   end
44 | 
45 |   def test_nested_string_is_not_the_same_as_the_system_string
46 |     assert_equal __, String == "HI".class
47 |   end
48 | 
49 |   def test_use_the_prefix_scope_operator_to_force_the_global_scope
50 |     assert_equal __, ::String == "HI".class
51 |   end
52 | 
53 |   # ------------------------------------------------------------------
54 | 
55 |   PI = 3.1416
56 | 
57 |   def test_constants_are_defined_with_an_initial_uppercase_letter
58 |     assert_equal __, PI
59 |   end
60 | 
61 |   # ------------------------------------------------------------------
62 | 
63 |   MyString = ::String
64 | 
65 |   def test_class_names_are_just_constants
66 |     assert_equal __, MyString == ::String
67 |     assert_equal __, MyString == "HI".class
68 |   end
69 | 
70 |   def test_constants_can_be_looked_up_explicitly
71 |     assert_equal __, PI == AboutScope.const_get("PI")
72 |     assert_equal __, MyString == AboutScope.const_get("MyString")
73 |   end
74 | 
75 |   def test_you_can_get_a_list_of_constants_for_any_class_or_module
76 |     assert_equal __, Jims.constants
77 |     assert Object.constants.size > _n_
78 |   end
79 | end
80 | 


--------------------------------------------------------------------------------
/Koans/about_scoring_project.rb:
--------------------------------------------------------------------------------
 1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
 2 | 
 3 | # Greed is a dice game where you roll up to five dice to accumulate
 4 | # points.  The following "score" function will be used to calculate the
 5 | # score of a single roll of the dice.
 6 | #
 7 | # A greed roll is scored as follows:
 8 | #
 9 | # * A set of three ones is 1000 points
10 | #
11 | # * A set of three numbers (other than ones) is worth 100 times the
12 | #   number. (e.g. three fives is 500 points).
13 | #
14 | # * A one (that is not part of a set of three) is worth 100 points.
15 | #
16 | # * A five (that is not part of a set of three) is worth 50 points.
17 | #
18 | # * Everything else is worth 0 points.
19 | #
20 | #
21 | # Examples:
22 | #
23 | # score([1,1,1,5,1]) => 1150 points
24 | # score([2,3,4,6,2]) => 0 points
25 | # score([3,4,5,3,3]) => 350 points
26 | # score([1,5,1,2,4]) => 250 points
27 | #
28 | # More scoring examples are given in the tests below:
29 | #
30 | # Your goal is to write the score method.
31 | 
32 | def score(dice)
33 |   # You need to write this method
34 | end
35 | 
36 | class AboutScoringProject < Neo::Koan
37 |   def test_score_of_an_empty_list_is_zero
38 |     assert_equal 0, score([])
39 |   end
40 | 
41 |   def test_score_of_a_single_roll_of_5_is_50
42 |     assert_equal 50, score([5])
43 |   end
44 | 
45 |   def test_score_of_a_single_roll_of_1_is_100
46 |     assert_equal 100, score([1])
47 |   end
48 | 
49 |   def test_score_of_multiple_1s_and_5s_is_the_sum_of_individual_scores
50 |     assert_equal 300, score([1,5,5,1])
51 |   end
52 | 
53 |   def test_score_of_single_2s_3s_4s_and_6s_are_zero
54 |     assert_equal 0, score([2,3,4,6])
55 |   end
56 | 
57 |   def test_score_of_a_triple_1_is_1000
58 |     assert_equal 1000, score([1,1,1])
59 |   end
60 | 
61 |   def test_score_of_other_triples_is_100x
62 |     assert_equal 200, score([2,2,2])
63 |     assert_equal 300, score([3,3,3])
64 |     assert_equal 400, score([4,4,4])
65 |     assert_equal 500, score([5,5,5])
66 |     assert_equal 600, score([6,6,6])
67 |   end
68 | 
69 |   def test_score_of_mixed_is_sum
70 |     assert_equal 250, score([2,5,2,2,3])
71 |     assert_equal 550, score([5,5,5,5])
72 |     assert_equal 1100, score([1,1,1,1])
73 |     assert_equal 1200, score([1,1,1,1,1])
74 |     assert_equal 1150, score([1,1,1,5,1])
75 |   end
76 | 
77 | end
78 | 


--------------------------------------------------------------------------------
/Koans/about_constants.rb:
--------------------------------------------------------------------------------
 1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
 2 | 
 3 | C = "top level"
 4 | 
 5 | class AboutConstants < Neo::Koan
 6 | 
 7 |   C = "nested"
 8 | 
 9 |   def test_nested_constants_may_also_be_referenced_with_relative_paths
10 |     assert_equal __, C
11 |   end
12 | 
13 |   def test_top_level_constants_are_referenced_by_double_colons
14 |     assert_equal __, ::C
15 |   end
16 | 
17 |   def test_nested_constants_are_referenced_by_their_complete_path
18 |     assert_equal __, AboutConstants::C
19 |     assert_equal __, ::AboutConstants::C
20 |   end
21 | 
22 |   # ------------------------------------------------------------------
23 | 
24 |   class Animal
25 |     LEGS = 4
26 |     def legs_in_animal
27 |       LEGS
28 |     end
29 | 
30 |     class NestedAnimal
31 |       def legs_in_nested_animal
32 |         LEGS
33 |       end
34 |     end
35 |   end
36 | 
37 |   def test_nested_classes_inherit_constants_from_enclosing_classes
38 |     assert_equal __, Animal::NestedAnimal.new.legs_in_nested_animal
39 |   end
40 | 
41 |   # ------------------------------------------------------------------
42 | 
43 |   class Reptile < Animal
44 |     def legs_in_reptile
45 |       LEGS
46 |     end
47 |   end
48 | 
49 |   def test_subclasses_inherit_constants_from_parent_classes
50 |     assert_equal __, Reptile.new.legs_in_reptile
51 |   end
52 | 
53 |   # ------------------------------------------------------------------
54 | 
55 |   class MyAnimals
56 |     LEGS = 2
57 | 
58 |     class Bird < Animal
59 |       def legs_in_bird
60 |         LEGS
61 |       end
62 |     end
63 |   end
64 | 
65 |   def test_who_wins_with_both_nested_and_inherited_constants
66 |     assert_equal __, MyAnimals::Bird.new.legs_in_bird
67 |   end
68 | 
69 |   # QUESTION: Which has precedence: The constant in the lexical scope,
70 |   # or the constant from the inheritance hierarchy?
71 | 
72 |   # ------------------------------------------------------------------
73 | 
74 |   class MyAnimals::Oyster < Animal
75 |     def legs_in_oyster
76 |       LEGS
77 |     end
78 |   end
79 | 
80 |   def test_who_wins_with_explicit_scoping_on_class_definition
81 |     assert_equal __, MyAnimals::Oyster.new.legs_in_oyster
82 |   end
83 | 
84 |   # QUESTION: Now which has precedence: The constant in the lexical
85 |   # scope, or the constant from the inheritance hierarchy?  Why is it
86 |   # different than the previous answer?
87 | end
88 | 


--------------------------------------------------------------------------------
/Koans/GREED_RULES.txt:
--------------------------------------------------------------------------------
 1 | = Playing Greed
 2 | 
 3 | Greed is a dice game played among 2 or more players, using 5
 4 | six-sided dice.
 5 | 
 6 | == Playing Greed
 7 | 
 8 | Each player takes a turn consisting of one or more rolls of the dice.
 9 | On the first roll of the game, a player rolls all five dice which are
10 | scored according to the following:
11 | 
12 |   Three 1's => 1000 points
13 |   Three 6's =>  600 points
14 |   Three 5's =>  500 points
15 |   Three 4's =>  400 points
16 |   Three 3's =>  300 points
17 |   Three 2's =>  200 points
18 |   One   1   =>  100 points
19 |   One   5   =>   50 points
20 | 
21 | A single die can only be counted once in each roll.  For example,
22 | a "5" can only count as part of a triplet (contributing to the 500
23 | points) or as a single 50 points, but not both in the same roll.
24 | 
25 | Example Scoring
26 | 
27 |    Throw       Score
28 |    ---------   ------------------
29 |    5 1 3 4 1   50 + 2 * 100 = 250
30 |    1 1 1 3 1   1000 + 100 = 1100
31 |    2 4 4 5 4   400 + 50 = 450
32 | 
33 | The dice not contributing to the score are called the non-scoring
34 | dice.  "3" and "4" are non-scoring dice in the first example.  "3" is
35 | a non-scoring die in the second, and "2" is a non-score die in the
36 | final example.
37 | 
38 | After a player rolls and the score is calculated, the scoring dice are
39 | removed and the player has the option of rolling again using only the
40 | non-scoring dice. If all of the thrown dice are scoring, then the
41 | player may roll all 5 dice in the next roll.
42 | 
43 | The player may continue to roll as long as each roll scores points. If
44 | a roll has zero points, then the player loses not only their turn, but
45 | also accumulated score for that turn. If a player decides to stop
46 | rolling before rolling a zero-point roll, then the accumulated points
47 | for the turn is added to his total score.
48 | 
49 | == Getting "In The Game"
50 | 
51 | Before a player is allowed to accumulate points, they must get at
52 | least 300 points in a single turn. Once they have achieved 300 points
53 | in a single turn, the points earned in that turn and each following
54 | turn will be counted toward their total score.
55 | 
56 | == End Game
57 | 
58 | Once a player reaches 3000 (or more) points, the game enters the final
59 | round where each of the other players gets one more turn. The winner
60 | is the player with the highest score after the final round.
61 | 
62 | == References
63 | 
64 | Greed is described on Wikipedia at
65 | http://en.wikipedia.org/wiki/Greed_(dice_game), however the rules are
66 | a bit different from the rules given here.
67 | 


--------------------------------------------------------------------------------
/ottergram/scripts/main.js:
--------------------------------------------------------------------------------
 1 | var DETAIL_IMAGE_SELECTOR = '[data-image-role="target"]';
 2 | var DETAIL_TITLE_SELECTOR = '[data-image-role="title"]';
 3 | var DETAIL_FRAME_SELECTOR = '[data-image-role="frame"]';
 4 | var THUMBNAIL_LINK_SELECTOR = '[data-image-role="trigger"]';
 5 | var HIDDEN_DETAIL_CLASS = 'hidden-detail';
 6 | var TINY_EFFECT_CLASS = 'is-tiny';
 7 | var ESC_KEY = 27;
 8 | 
 9 | function setDetails(imageUrl, titleText) {
10 |   'use strict';
11 |   var detailImage = document.querySelector(DETAIL_IMAGE_SELECTOR);
12 |   detailImage.setAttribute('src', imageUrl);
13 | 
14 |   var detailImage = document.querySelector(DETAIL_TITLE_SELECTOR);
15 |   detailImage.textContent = titleText;
16 | }
17 | function imageFromThumb(thumbnail) {
18 |   'use strict';
19 |   return thumbnail.getAttribute('data-image-url');
20 | }
21 | function titleFromThumb(thumbnail) {
22 |   'use strict';
23 |   return thumbnail.getAttribute('data-image-title');
24 | }
25 | function setDetailsFromThumb(thumbnail) {
26 |   'use strict';
27 |   setDetails(imageFromThumb(thumbnail), titleFromThumb(thumbnail));
28 | }
29 | function addThumbClickHandler(thumb) {
30 |   'use strict';
31 |   thumb.addEventListener('click', function (event) {
32 |     event.preventDefault();
33 |     setDetailsFromThumb(thumb);
34 |     showDetails();
35 |   });
36 | }
37 | function getThumbnailsArray() {
38 |   'use strict';
39 |   // gets nodelist of all anchors with data-image-role="trigger"
40 |   var thumbnails = document.querySelectorAll(THUMBNAIL_LINK_SELECTOR);
41 |   // makes array from an empty array that is sliced/called with the values of thumbnails as this values
42 |   var thumbnailArray = [].slice.call(thumbnails);
43 |   return thumbnailArray;
44 | }
45 | function hideDetails(){
46 |   'use strict';
47 |   document.body.classList.add(HIDDEN_DETAIL_CLASS);
48 | }
49 | function showDetails(){
50 |   'use strict';
51 |   var frame = document.querySelector(DETAIL_FRAME_SELECTOR);
52 |   document.body.classList.remove(HIDDEN_DETAIL_CLASS);
53 |   frame.classList.add(TINY_EFFECT_CLASS);
54 |   setTimeout(function () {
55 |     frame.classList.remove(TINY_EFFECT_CLASS);
56 |   }, 50);
57 | }
58 | function addKeyPressHandler(){
59 |   'use strict';
60 |   document.body.addEventListener('keyup', function(event) {
61 |     event.preventDefault();
62 |     // console.log(event.keyCode);
63 |     if (event.keyCode === ESC_KEY) {
64 |       hideDetails();
65 |     }
66 |   });
67 | }
68 | function initializeEvents() {
69 |   'use strict';
70 |   var thumbnails = getThumbnailsArray();
71 |   thumbnails.forEach(addThumbClickHandler);
72 |   addKeyPressHandler();
73 | }
74 | initializeEvents();
75 | 


--------------------------------------------------------------------------------
/Koans/about_blocks.rb:
--------------------------------------------------------------------------------
 1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
 2 | 
 3 | class AboutBlocks < Neo::Koan
 4 |   def method_with_block
 5 |     result = yield
 6 |     result
 7 |   end
 8 | 
 9 |   def test_methods_can_take_blocks
10 |     yielded_result = method_with_block { 1 + 2 }
11 |     assert_equal __, yielded_result
12 |   end
13 | 
14 |   def test_blocks_can_be_defined_with_do_end_too
15 |     yielded_result = method_with_block do 1 + 2 end
16 |     assert_equal __, yielded_result
17 |   end
18 | 
19 |   # ------------------------------------------------------------------
20 | 
21 |   def method_with_block_arguments
22 |     yield("Jim")
23 |   end
24 | 
25 |   def test_blocks_can_take_arguments
26 |     method_with_block_arguments do |argument|
27 |       assert_equal __, argument
28 |     end
29 |   end
30 | 
31 |   # ------------------------------------------------------------------
32 | 
33 |   def many_yields
34 |     yield(:peanut)
35 |     yield(:butter)
36 |     yield(:and)
37 |     yield(:jelly)
38 |   end
39 | 
40 |   def test_methods_can_call_yield_many_times
41 |     result = []
42 |     many_yields { |item| result << item }
43 |     assert_equal __, result
44 |   end
45 | 
46 |   # ------------------------------------------------------------------
47 | 
48 |   def yield_tester
49 |     if block_given?
50 |       yield
51 |     else
52 |       :no_block
53 |     end
54 |   end
55 | 
56 |   def test_methods_can_see_if_they_have_been_called_with_a_block
57 |     assert_equal __, yield_tester { :with_block }
58 |     assert_equal __, yield_tester
59 |   end
60 | 
61 |   # ------------------------------------------------------------------
62 | 
63 |   def test_block_can_affect_variables_in_the_code_where_they_are_created
64 |     value = :initial_value
65 |     method_with_block { value = :modified_in_a_block }
66 |     assert_equal __, value
67 |   end
68 | 
69 |   def test_blocks_can_be_assigned_to_variables_and_called_explicitly
70 |     add_one = lambda { |n| n + 1 }
71 |     assert_equal __, add_one.call(10)
72 | 
73 |     # Alternative calling syntax
74 |     assert_equal __, add_one[10]
75 |   end
76 | 
77 |   def test_stand_alone_blocks_can_be_passed_to_methods_expecting_blocks
78 |     make_upper = lambda { |n| n.upcase }
79 |     result = method_with_block_arguments(&make_upper)
80 |     assert_equal __, result
81 |   end
82 | 
83 |   # ------------------------------------------------------------------
84 | 
85 |   def method_with_explicit_block(&block)
86 |     block.call(10)
87 |   end
88 | 
89 |   def test_methods_can_take_an_explicit_block_argument
90 |     assert_equal __, method_with_explicit_block { |n| n * 2 }
91 | 
92 |     add_one = lambda { |n| n + 1 }
93 |     assert_equal __, method_with_explicit_block(&add_one)
94 |   end
95 | 
96 | end
97 | 


--------------------------------------------------------------------------------
/coffeerun/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <title>coffeerun</title>
 6 |     <link rel="stylesheet"
 7 |       href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.6/css/bootstrap.min.css">
 8 |   </head>
 9 |   <body class="container">
10 |     <header>
11 |       <h1>CoffeeRun</h1>
12 |     </header>
13 |     <section>
14 |       <div class="panel panel-default">
15 |         <div class="panel-body">
16 |           <form data-coffee-order="form">
17 |             <div class="form-group">
18 |               <label for="coffeeOrder">Coffee Order</label>
19 |               <input class="form-control" name="coffee" id="coffeeOrder" autofocus />
20 |             </div>
21 |             <div class="form-group">
22 |               <label for="emailInput">Email</label>
23 |               <input class="form-control" type="email" name="emailAddress" id="emailInput" value="" placeholder="dr@who.com" />
24 |             </div>
25 |             <div class="radio">
26 |               <label>
27 |                 <input type="radio" name="size" value="short">
28 |                 Short
29 |               </label>
30 |             </div>
31 |             <div class="radio">
32 |               <label>
33 |                 <input type="radio" name="size" value="tall" checked>
34 |                 Tall
35 |               </label>
36 |             </div>
37 |             <div class="radio">
38 |               <label>
39 |                 <input type="radio" name="size" value="grande">
40 |                 Grande
41 |               </label>
42 |             </div>
43 |             <div class="form-group">
44 |               <label for="flavorShot">Flavor Shot</label>
45 |               <select id="flavorShot" class="form-control" name="flavor">
46 |                 <option value="">None</option>
47 |                 <option value="caramel">Caramel</option>
48 |                 <option value="almond">Almond</option>
49 |                 <option value="mocha">Mocha</option>
50 |               </select>
51 |             </div>
52 |             <div class="form-group">
53 |               <label for="strengthLevel">Caffeine Rating</label>
54 |               <input name="strength" id="strengthLevel" type="range" value="30">
55 |             </div>
56 |             <button type="submit" class="btn btn-default">Submit</button>
57 |             <button type="reset" class="btn btn-default">Reset</button>
58 |           </form>
59 |         </div>
60 |       </div>
61 |     </section>
62 |     <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/2.1.4/jquery.js" charset="utf-8"></script>
63 |     <script src="scripts/formhandler.js" charset="utf-8"></script>
64 |     <script src="scripts/datastore.js" charset="utf-8"></script>
65 |     <script src="scripts/truck.js" charset="utf-8"></script>
66 |     <script src="scripts/main.js" charset="utf-8"></script>
67 |   </body>
68 | </html>
69 | 


--------------------------------------------------------------------------------
/Koans/about_variable_scope.rb:
--------------------------------------------------------------------------------
  1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
  2 | 
  3 | class AboutVariableScope < Neo::Koan
  4 | 
  5 |   def bark
  6 |     noise = "RUFF"
  7 |   end
  8 | 
  9 |   def test_noise_is_not_available_in_the_current_scope
 10 | 
 11 |     assert_raise(___) do
 12 |       noise
 13 |     end
 14 | 
 15 |   end
 16 | 
 17 |   def test_we_can_get_noise_by_calling_method
 18 |     assert_equal __, bark
 19 |   end
 20 | 
 21 |   inaccessible = "Outside our universe"
 22 |   def test_defs_cannot_access_variables_outside_scope
 23 |     # defined? does not return true or false
 24 |     assert_equal __, defined? inaccesible
 25 |   end
 26 | 
 27 |   # ------------------------------------------------------
 28 | 
 29 |   def test_blocks_can_access_variables_outside_scope 
 30 |     test = "Hi"
 31 |     (1..2).each do
 32 |       test = "Hey"
 33 |     end
 34 | 
 35 |     assert_equal __, test    
 36 |   end
 37 | 
 38 |   def test_block_variables_cannot_be_accessed_outside_scope
 39 |     (1..2).each do
 40 |       x = 0 
 41 |     end
 42 |     assert_equal __, defined? x
 43 |   end
 44 | 
 45 |   # ------------------------------------------------------
 46 | 
 47 |   class Mouse
 48 |     @@total = 0
 49 |     # Class variables are prefixed with two '@' characters.
 50 | 
 51 |     def initialize(n)
 52 |       @name = n
 53 |       # Instance variables are prefixed with one '@' character.
 54 |       @@total += 1 
 55 |     end
 56 | 
 57 |     def name
 58 |       @name
 59 |     end
 60 | 
 61 |     def Mouse.count
 62 |       @@total
 63 |     end
 64 |   end
 65 | 
 66 |   def test_instance_variable 
 67 |     oscar = Mouse.new("Oscar")
 68 |     assert_equal __, oscar.name 
 69 |   end
 70 | 
 71 |   def test_class_variable
 72 |     (1..9).each { |i| Mouse.new("#{i}") }
 73 |     # Things may appear easier than they actually are.  
 74 |     assert_equal __, Mouse.count
 75 |   end
 76 | 
 77 |   # Meditate on the following: 
 78 |   # What is the difference between a class variable and instance variable?
 79 | 
 80 |   # ------------------------------------------------------
 81 |   
 82 |   $anywhere = "Anywhere"
 83 |   # Global variables are prefixed with the '$' character.
 84 | 
 85 |   def test_global_variables_can_be_accessed_from_any_scope
 86 |     assert_equal __, $anywhere    
 87 |   end
 88 | 
 89 |   def test_global_variables_can_be_changed_from_any_scope
 90 |     # From within a method
 91 |     $anywhere = "Here"
 92 |     assert_equal __, $anywhere
 93 |   end
 94 | 
 95 |   def test_global_variables_retain_value_from_last_change
 96 |     # What is $anywhere?
 97 |     assert_equal __, $anywhere
 98 |   end
 99 | 
100 |   def test_global_variables_can_be_changed_from_any_scope_2
101 |     # From within a block
102 |     (1..2).each do
103 |       $anywhere = "Hey"
104 |     end
105 | 
106 |     assert_equal __, $anywhere
107 |   end
108 | 
109 | end
110 | 
111 | # THINK ABOUT IT:
112 | # 
113 | # What will $anywhere be down here, outside of the scope of the
114 | # AboutVariableScope class?
115 | 


--------------------------------------------------------------------------------
/Koans/about_sandwich_code.rb:
--------------------------------------------------------------------------------
  1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
  2 | 
  3 | class AboutSandwichCode < Neo::Koan
  4 | 
  5 |   def count_lines(file_name)
  6 |     file = open(file_name)
  7 |     count = 0
  8 |     while file.gets
  9 |       count += 1
 10 |     end
 11 |     count
 12 |   ensure
 13 |     file.close if file
 14 |   end
 15 | 
 16 |   def test_counting_lines
 17 |     assert_equal __, count_lines("example_file.txt")
 18 |   end
 19 | 
 20 |   # ------------------------------------------------------------------
 21 | 
 22 |   def find_line(file_name)
 23 |     file = open(file_name)
 24 |     while line = file.gets
 25 |       return line if line.match(/e/)
 26 |     end
 27 |   ensure
 28 |     file.close if file
 29 |   end
 30 | 
 31 |   def test_finding_lines
 32 |     assert_equal __, find_line("example_file.txt")
 33 |   end
 34 | 
 35 |   # ------------------------------------------------------------------
 36 |   # THINK ABOUT IT:
 37 |   #
 38 |   # The count_lines and find_line are similar, and yet different.
 39 |   # They both follow the pattern of "sandwich code".
 40 |   #
 41 |   # Sandwich code is code that comes in three parts: (1) the top slice
 42 |   # of bread, (2) the meat, and (3) the bottom slice of bread.  The
 43 |   # bread part of the sandwich almost always goes together, but
 44 |   # the meat part changes all the time.
 45 |   #
 46 |   # Because the changing part of the sandwich code is in the middle,
 47 |   # abstracting the top and bottom bread slices to a library can be
 48 |   # difficult in many languages.
 49 |   #
 50 |   # (Aside for C++ programmers: The idiom of capturing allocated
 51 |   # pointers in a smart pointer constructor is an attempt to deal with
 52 |   # the problem of sandwich code for resource allocation.)
 53 |   #
 54 |   # Consider the following code:
 55 |   #
 56 | 
 57 |   def file_sandwich(file_name)
 58 |     file = open(file_name)
 59 |     yield(file)
 60 |   ensure
 61 |     file.close if file
 62 |   end
 63 | 
 64 |   # Now we write:
 65 | 
 66 |   def count_lines2(file_name)
 67 |     file_sandwich(file_name) do |file|
 68 |       count = 0
 69 |       while file.gets
 70 |         count += 1
 71 |       end
 72 |       count
 73 |     end
 74 |   end
 75 | 
 76 |   def test_counting_lines2
 77 |     assert_equal __, count_lines2("example_file.txt")
 78 |   end
 79 | 
 80 |   # ------------------------------------------------------------------
 81 | 
 82 |   def find_line2(file_name)
 83 |     # Rewrite find_line using the file_sandwich library function.
 84 |   end
 85 | 
 86 |   def test_finding_lines2
 87 |     assert_equal __, find_line2("example_file.txt")
 88 |   end
 89 | 
 90 |   # ------------------------------------------------------------------
 91 | 
 92 |   def count_lines3(file_name)
 93 |     open(file_name) do |file|
 94 |       count = 0
 95 |       while file.gets
 96 |         count += 1
 97 |       end
 98 |       count
 99 |     end
100 |   end
101 | 
102 |   def test_open_handles_the_file_sandwich_when_given_a_block
103 |     assert_equal __, count_lines3("example_file.txt")
104 |   end
105 | 
106 | end
107 | 


--------------------------------------------------------------------------------
/Koans/about_symbols.rb:
--------------------------------------------------------------------------------
  1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
  2 | 
  3 | class AboutSymbols < Neo::Koan
  4 |   def test_symbols_are_symbols
  5 |     symbol = :ruby
  6 |     assert_equal __, symbol.is_a?(Symbol)
  7 |   end
  8 | 
  9 |   def test_symbols_can_be_compared
 10 |     symbol1 = :a_symbol
 11 |     symbol2 = :a_symbol
 12 |     symbol3 = :something_else
 13 | 
 14 |     assert_equal __, symbol1 == symbol2
 15 |     assert_equal __, symbol1 == symbol3
 16 |   end
 17 | 
 18 |   def test_identical_symbols_are_a_single_internal_object
 19 |     symbol1 = :a_symbol
 20 |     symbol2 = :a_symbol
 21 | 
 22 |     assert_equal __, symbol1           == symbol2
 23 |     assert_equal __, symbol1.object_id == symbol2.object_id
 24 |   end
 25 | 
 26 |   def test_method_names_become_symbols
 27 |     symbols_as_strings = Symbol.all_symbols.map { |x| x.to_s }
 28 |     assert_equal __, symbols_as_strings.include?("test_method_names_become_symbols")
 29 |   end
 30 | 
 31 |   # THINK ABOUT IT:
 32 |   #
 33 |   # Why do we convert the list of symbols to strings and then compare
 34 |   # against the string value rather than against symbols?
 35 | 
 36 |   in_ruby_version("mri") do
 37 |     RubyConstant = "What is the sound of one hand clapping?"
 38 |     def test_constants_become_symbols
 39 |       all_symbols_as_strings = Symbol.all_symbols.map { |x| x.to_s }
 40 | 
 41 |       assert_equal __, all_symbols_as_strings.include?(__)
 42 |     end
 43 |   end
 44 | 
 45 |   def test_symbols_can_be_made_from_strings
 46 |     string = "catsAndDogs"
 47 |     assert_equal __, string.to_sym
 48 |   end
 49 | 
 50 |   def test_symbols_with_spaces_can_be_built
 51 |     symbol = :"cats and dogs"
 52 | 
 53 |     assert_equal __.to_sym, symbol
 54 |   end
 55 | 
 56 |   def test_symbols_with_interpolation_can_be_built
 57 |     value = "and"
 58 |     symbol = :"cats #{value} dogs"
 59 | 
 60 |     assert_equal __.to_sym, symbol
 61 |   end
 62 | 
 63 |   def test_to_s_is_called_on_interpolated_symbols
 64 |     symbol = :cats
 65 |     string = "It is raining #{symbol} and dogs."
 66 | 
 67 |     assert_equal __, string
 68 |   end
 69 | 
 70 |   def test_symbols_are_not_strings
 71 |     symbol = :ruby
 72 |     assert_equal __, symbol.is_a?(String)
 73 |     assert_equal __, symbol.eql?("ruby")
 74 |   end
 75 | 
 76 |   def test_symbols_do_not_have_string_methods
 77 |     symbol = :not_a_string
 78 |     assert_equal __, symbol.respond_to?(:each_char)
 79 |     assert_equal __, symbol.respond_to?(:reverse)
 80 |   end
 81 | 
 82 |   # It's important to realize that symbols are not "immutable
 83 |   # strings", though they are immutable. None of the
 84 |   # interesting string operations are available on symbols.
 85 | 
 86 |   def test_symbols_cannot_be_concatenated
 87 |     # Exceptions will be pondered further down the path
 88 |     assert_raise(___) do
 89 |       :cats + :dogs
 90 |     end
 91 |   end
 92 | 
 93 |   def test_symbols_can_be_dynamically_created
 94 |     assert_equal __, ("cats" + "dogs").to_sym
 95 |   end
 96 | 
 97 |   # THINK ABOUT IT:
 98 |   #
 99 |   # Why is it not a good idea to dynamically create a lot of symbols?
100 | end
101 | 


--------------------------------------------------------------------------------
/Koans/about_hashes.rb:
--------------------------------------------------------------------------------
  1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
  2 | 
  3 | class AboutHashes < Neo::Koan
  4 |   def test_creating_hashes
  5 |     empty_hash = Hash.new
  6 |     assert_equal __, empty_hash.class
  7 |     assert_equal(__, empty_hash)
  8 |     assert_equal __, empty_hash.size
  9 |   end
 10 | 
 11 |   def test_hash_literals
 12 |     hash = { :one => "uno", :two => "dos" }
 13 |     assert_equal __, hash.size
 14 |   end
 15 | 
 16 |   def test_accessing_hashes
 17 |     hash = { :one => "uno", :two => "dos" }
 18 |     assert_equal __, hash[:one]
 19 |     assert_equal __, hash[:two]
 20 |     assert_equal __, hash[:doesnt_exist]
 21 |   end
 22 | 
 23 |   def test_accessing_hashes_with_fetch
 24 |     hash = { :one => "uno" }
 25 |     assert_equal __, hash.fetch(:one)
 26 |     assert_raise(___) do
 27 |       hash.fetch(:doesnt_exist)
 28 |     end
 29 | 
 30 |     # THINK ABOUT IT:
 31 |     #
 32 |     # Why might you want to use #fetch instead of #[] when accessing hash keys?
 33 |   end
 34 | 
 35 |   def test_changing_hashes
 36 |     hash = { :one => "uno", :two => "dos" }
 37 |     hash[:one] = "eins"
 38 | 
 39 |     expected = { :one => __, :two => "dos" }
 40 |     assert_equal __, hash
 41 | 
 42 |     # Bonus Question: Why was "expected" broken out into a variable
 43 |     # rather than used as a literal?
 44 |   end
 45 | 
 46 |   def test_hash_is_unordered
 47 |     hash1 = { :one => "uno", :two => "dos" }
 48 |     hash2 = { :two => "dos", :one => "uno" }
 49 | 
 50 |     assert_equal __, hash1 == hash2
 51 |   end
 52 | 
 53 |   def test_hash_keys
 54 |     hash = { :one => "uno", :two => "dos" }
 55 |     assert_equal __, hash.keys.size
 56 |     assert_equal __, hash.keys.include?(:one)
 57 |     assert_equal __, hash.keys.include?(:two)
 58 |     assert_equal __, hash.keys.class
 59 |   end
 60 | 
 61 |   def test_hash_values
 62 |     hash = { :one => "uno", :two => "dos" }
 63 |     assert_equal __, hash.values.size
 64 |     assert_equal __, hash.values.include?("uno")
 65 |     assert_equal __, hash.values.include?("dos")
 66 |     assert_equal __, hash.values.class
 67 |   end
 68 | 
 69 |   def test_combining_hashes
 70 |     hash = { "jim" => 53, "amy" => 20, "dan" => 23 }
 71 |     new_hash = hash.merge({ "jim" => 54, "jenny" => 26 })
 72 | 
 73 |     assert_equal __, hash != new_hash
 74 | 
 75 |     expected = { "jim" => __, "amy" => 20, "dan" => 23, "jenny" => __ }
 76 |     assert_equal __, expected == new_hash
 77 |   end
 78 | 
 79 |   def test_default_value
 80 |     hash1 = Hash.new
 81 |     hash1[:one] = 1
 82 | 
 83 |     assert_equal __, hash1[:one]
 84 |     assert_equal __, hash1[:two]
 85 | 
 86 |     hash2 = Hash.new("dos")
 87 |     hash2[:one] = 1
 88 | 
 89 |     assert_equal __, hash2[:one]
 90 |     assert_equal __, hash2[:two]
 91 |   end
 92 | 
 93 |   def test_default_value_is_the_same_object
 94 |     hash = Hash.new([])
 95 | 
 96 |     hash[:one] << "uno"
 97 |     hash[:two] << "dos"
 98 | 
 99 |     assert_equal __, hash[:one]
100 |     assert_equal __, hash[:two]
101 |     assert_equal __, hash[:three]
102 | 
103 |     assert_equal __, hash[:one].object_id == hash[:two].object_id
104 |   end
105 | 
106 |   def test_default_value_with_block
107 |     hash = Hash.new {|hash, key| hash[key] = [] }
108 | 
109 |     hash[:one] << "uno"
110 |     hash[:two] << "dos"
111 | 
112 |     assert_equal __, hash[:one]
113 |     assert_equal __, hash[:two]
114 |     assert_equal __, hash[:three]
115 |   end
116 | end
117 | 


--------------------------------------------------------------------------------
/Koans/about_control_statements.rb:
--------------------------------------------------------------------------------
  1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
  2 | 
  3 | class AboutControlStatements < Neo::Koan
  4 | 
  5 |   def test_if_then_else_statements
  6 |     if true
  7 |       result = :true_value
  8 |     else
  9 |       result = :false_value
 10 |     end
 11 |     assert_equal __, result
 12 |   end
 13 | 
 14 |   def test_if_then_statements
 15 |     result = :default_value
 16 |     if true
 17 |       result = :true_value
 18 |     end
 19 |     assert_equal __, result
 20 |   end
 21 | 
 22 |   def test_if_statements_return_values
 23 |     value = if true
 24 |               :true_value
 25 |             else
 26 |               :false_value
 27 |             end
 28 |     assert_equal __, value
 29 | 
 30 |     value = if false
 31 |               :true_value
 32 |             else
 33 |               :false_value
 34 |             end
 35 |     assert_equal __, value
 36 | 
 37 |     # NOTE: Actually, EVERY statement in Ruby will return a value, not
 38 |     # just if statements.
 39 |   end
 40 | 
 41 |   def test_if_statements_with_no_else_with_false_condition_return_value
 42 |     value = if false
 43 |               :true_value
 44 |             end
 45 |     assert_equal __, value
 46 |   end
 47 | 
 48 |   def test_condition_operators
 49 |     assert_equal __, (true ? :true_value : :false_value)
 50 |     assert_equal __, (false ? :true_value : :false_value)
 51 |   end
 52 | 
 53 |   def test_if_statement_modifiers
 54 |     result = :default_value
 55 |     result = :true_value if true
 56 | 
 57 |     assert_equal __, result
 58 |   end
 59 | 
 60 |   def test_unless_statement
 61 |     result = :default_value
 62 |     unless false    # same as saying 'if !false', which evaluates as 'if true'
 63 |       result = :false_value
 64 |     end
 65 |     assert_equal __, result
 66 |   end
 67 | 
 68 |   def test_unless_statement_evaluate_true
 69 |     result = :default_value
 70 |     unless true    # same as saying 'if !true', which evaluates as 'if false'
 71 |       result = :true_value
 72 |     end
 73 |     assert_equal __, result
 74 |   end
 75 | 
 76 |   def test_unless_statement_modifier
 77 |     result = :default_value
 78 |     result = :false_value unless false
 79 | 
 80 |     assert_equal __, result
 81 |   end
 82 | 
 83 |   def test_while_statement
 84 |     i = 1
 85 |     result = 1
 86 |     while i <= 10
 87 |       result = result * i
 88 |       i += 1
 89 |     end
 90 |     assert_equal __, result
 91 |   end
 92 | 
 93 |   def test_break_statement
 94 |     i = 1
 95 |     result = 1
 96 |     while true
 97 |       break unless i <= 10
 98 |       result = result * i
 99 |       i += 1
100 |     end
101 |     assert_equal __, result
102 |   end
103 | 
104 |   def test_break_statement_returns_values
105 |     i = 1
106 |     result = while i <= 10
107 |       break i if i % 2 == 0
108 |       i += 1
109 |     end
110 | 
111 |     assert_equal __, result
112 |   end
113 | 
114 |   def test_next_statement
115 |     i = 0
116 |     result = []
117 |     while i < 10
118 |       i += 1
119 |       next if (i % 2) == 0
120 |       result << i
121 |     end
122 |     assert_equal __, result
123 |   end
124 | 
125 |   def test_for_statement
126 |     array = ["fish", "and", "chips"]
127 |     result = []
128 |     for item in array
129 |       result << item.upcase
130 |     end
131 |     assert_equal [__, __, __], result
132 |   end
133 | 
134 |   def test_times_statement
135 |     sum = 0
136 |     10.times do
137 |       sum += 1
138 |     end
139 |     assert_equal __, sum
140 |   end
141 | 
142 | end
143 | 


--------------------------------------------------------------------------------
/Koans/about_iteration.rb:
--------------------------------------------------------------------------------
  1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
  2 | 
  3 | class AboutIteration < Neo::Koan
  4 | 
  5 |   # -- An Aside ------------------------------------------------------
  6 |   # Ruby 1.8 stores names as strings. Ruby 1.9 and later stores names
  7 |   # as symbols. So we use a version dependent method "as_name" to
  8 |   # convert to the right format in the koans. We will use "as_name"
  9 |   # whenever comparing to lists of methods.
 10 | 
 11 |   in_ruby_version("1.8") do
 12 |     def as_name(name)
 13 |       name.to_s
 14 |     end
 15 |   end
 16 | 
 17 |   in_ruby_version("1.9", "2") do
 18 |     def as_name(name)
 19 |       name.to_sym
 20 |     end
 21 |   end
 22 | 
 23 |   # Ok, now back to the Koans.
 24 |   # -------------------------------------------------------------------
 25 | 
 26 |   def test_each_is_a_method_on_arrays
 27 |     assert_equal __, [].methods.include?(as_name(:each))
 28 |   end
 29 | 
 30 |   def test_iterating_with_each
 31 |     array = [1, 2, 3]
 32 |     sum = 0
 33 |     array.each do |item|
 34 |       sum += item
 35 |     end
 36 |     assert_equal __, sum
 37 |   end
 38 | 
 39 |   def test_each_can_use_curly_brace_blocks_too
 40 |     array = [1, 2, 3]
 41 |     sum = 0
 42 |     array.each { |item| sum += item }
 43 |     assert_equal __, sum
 44 |   end
 45 | 
 46 |   def test_break_works_with_each_style_iterations
 47 |     array = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 48 |     sum = 0
 49 |     array.each do |item|
 50 |       break if item > 3
 51 |       sum += item
 52 |     end
 53 |     assert_equal __, sum
 54 |   end
 55 | 
 56 |   def test_collect_transforms_elements_of_an_array
 57 |     array = [1, 2, 3]
 58 |     new_array = array.collect { |item| item + 10 }
 59 |     assert_equal __, new_array
 60 | 
 61 |     # NOTE: 'map' is another name for the 'collect' operation
 62 |     another_array = array.map { |item| item + 10 }
 63 |     assert_equal __, another_array
 64 |   end
 65 | 
 66 |   def test_select_selects_certain_items_from_an_array
 67 |     array = [1, 2, 3, 4, 5, 6]
 68 | 
 69 |     even_numbers = array.select { |item| (item % 2) == 0 }
 70 |     assert_equal __, even_numbers
 71 | 
 72 |     # NOTE: 'find_all' is another name for the 'select' operation
 73 |     more_even_numbers = array.find_all { |item| (item % 2) == 0 }
 74 |     assert_equal __, more_even_numbers
 75 |   end
 76 | 
 77 |   def test_find_locates_the_first_element_matching_a_criteria
 78 |     array = ["Jim", "Bill", "Clarence", "Doug", "Eli"]
 79 | 
 80 |     assert_equal __, array.find { |item| item.size > 4 }
 81 |   end
 82 | 
 83 |   def test_inject_will_blow_your_mind
 84 |     result = [2, 3, 4].inject(0) { |sum, item| sum + item }
 85 |     assert_equal __, result
 86 | 
 87 |     result2 = [2, 3, 4].inject(1) { |product, item| product * item }
 88 |     assert_equal __, result2
 89 | 
 90 |     # Extra Credit:
 91 |     # Describe in your own words what inject does.
 92 |   end
 93 | 
 94 |   def test_all_iteration_methods_work_on_any_collection_not_just_arrays
 95 |     # Ranges act like a collection
 96 |     result = (1..3).map { |item| item + 10 }
 97 |     assert_equal __, result
 98 | 
 99 |     # Files act like a collection of lines
100 |     File.open("example_file.txt") do |file|
101 |       upcase_lines = file.map { |line| line.strip.upcase }
102 |       assert_equal __, upcase_lines
103 |     end
104 | 
105 |     # NOTE: You can create your own collections that work with each,
106 |     # map, select, etc.
107 |   end
108 | 
109 |   # Bonus Question:  In the previous koan, we saw the construct:
110 |   #
111 |   #   File.open(filename) do |file|
112 |   #     # code to read 'file'
113 |   #   end
114 |   #
115 |   # Why did we do it that way instead of the following?
116 |   #
117 |   #   file = File.open(filename)
118 |   #   # code to read 'file'
119 |   #
120 |   # When you get to the "AboutSandwichCode" koan, recheck your answer.
121 | 
122 | end
123 | 


--------------------------------------------------------------------------------
/Koans/about_proxy_object_project.rb:
--------------------------------------------------------------------------------
  1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
  2 | 
  3 | # Project: Create a Proxy Class
  4 | #
  5 | # In this assignment, create a proxy class (one is started for you
  6 | # below).  You should be able to initialize the proxy object with any
  7 | # object.  Any messages sent to the proxy object should be forwarded
  8 | # to the target object.  As each message is sent, the proxy should
  9 | # record the name of the method sent.
 10 | #
 11 | # The proxy class is started for you.  You will need to add a method
 12 | # missing handler and any other supporting methods.  The specification
 13 | # of the Proxy class is given in the AboutProxyObjectProject koan.
 14 | 
 15 | class Proxy
 16 |   def initialize(target_object)
 17 |     @object = target_object
 18 |     # ADD MORE CODE HERE
 19 |   end
 20 | 
 21 |   # WRITE CODE HERE
 22 | end
 23 | 
 24 | # The proxy object should pass the following Koan:
 25 | #
 26 | class AboutProxyObjectProject < Neo::Koan
 27 |   def test_proxy_method_returns_wrapped_object
 28 |     # NOTE: The Television class is defined below
 29 |     tv = Proxy.new(Television.new)
 30 | 
 31 |     # HINT: Proxy class is defined above, may need tweaking...
 32 | 
 33 |     assert tv.instance_of?(Proxy)
 34 |   end
 35 | 
 36 |   def test_tv_methods_still_perform_their_function
 37 |     tv = Proxy.new(Television.new)
 38 | 
 39 |     tv.channel = 10
 40 |     tv.power
 41 | 
 42 |     assert_equal 10, tv.channel
 43 |     assert tv.on?
 44 |   end
 45 | 
 46 |   def test_proxy_records_messages_sent_to_tv
 47 |     tv = Proxy.new(Television.new)
 48 | 
 49 |     tv.power
 50 |     tv.channel = 10
 51 | 
 52 |     assert_equal [:power, :channel=], tv.messages
 53 |   end
 54 | 
 55 |   def test_proxy_handles_invalid_messages
 56 |     tv = Proxy.new(Television.new)
 57 | 
 58 |     assert_raise(NoMethodError) do
 59 |       tv.no_such_method
 60 |     end
 61 |   end
 62 | 
 63 |   def test_proxy_reports_methods_have_been_called
 64 |     tv = Proxy.new(Television.new)
 65 | 
 66 |     tv.power
 67 |     tv.power
 68 | 
 69 |     assert tv.called?(:power)
 70 |     assert ! tv.called?(:channel)
 71 |   end
 72 | 
 73 |   def test_proxy_counts_method_calls
 74 |     tv = Proxy.new(Television.new)
 75 | 
 76 |     tv.power
 77 |     tv.channel = 48
 78 |     tv.power
 79 | 
 80 |     assert_equal 2, tv.number_of_times_called(:power)
 81 |     assert_equal 1, tv.number_of_times_called(:channel=)
 82 |     assert_equal 0, tv.number_of_times_called(:on?)
 83 |   end
 84 | 
 85 |   def test_proxy_can_record_more_than_just_tv_objects
 86 |     proxy = Proxy.new("Code Mash 2009")
 87 | 
 88 |     proxy.upcase!
 89 |     result = proxy.split
 90 | 
 91 |     assert_equal ["CODE", "MASH", "2009"], result
 92 |     assert_equal [:upcase!, :split], proxy.messages
 93 |   end
 94 | end
 95 | 
 96 | 
 97 | # ====================================================================
 98 | # The following code is to support the testing of the Proxy class.  No
 99 | # changes should be necessary to anything below this comment.
100 | 
101 | # Example class using in the proxy testing above.
102 | class Television
103 |   attr_accessor :channel
104 | 
105 |   def power
106 |     if @power == :on
107 |       @power = :off
108 |     else
109 |       @power = :on
110 |     end
111 |   end
112 | 
113 |   def on?
114 |     @power == :on
115 |   end
116 | end
117 | 
118 | # Tests for the Television class.  All of theses tests should pass.
119 | class TelevisionTest < Neo::Koan
120 |   def test_it_turns_on
121 |     tv = Television.new
122 | 
123 |     tv.power
124 |     assert tv.on?
125 |   end
126 | 
127 |   def test_it_also_turns_off
128 |     tv = Television.new
129 | 
130 |     tv.power
131 |     tv.power
132 | 
133 |     assert ! tv.on?
134 |   end
135 | 
136 |   def test_edge_case_on_off
137 |     tv = Television.new
138 | 
139 |     tv.power
140 |     tv.power
141 |     tv.power
142 | 
143 |     assert tv.on?
144 | 
145 |     tv.power
146 | 
147 |     assert ! tv.on?
148 |   end
149 | 
150 |   def test_can_set_the_channel
151 |     tv = Television.new
152 | 
153 |     tv.channel = 11
154 |     assert_equal 11, tv.channel
155 |   end
156 | end
157 | 


--------------------------------------------------------------------------------
/ottergram/stylesheets/styles.css:
--------------------------------------------------------------------------------
  1 | /* browser reads selector syntax from right to left
  2 |  order of font sources important keep for reference 'bulletproof fontsprint' */

  3 | @font-face {
  4 |   font-family: 'lakeshore';
  5 |   src: url('fonts/LAKESHOR-webfont.eot/');
  6 |   src: url('fonts/LAKESHOR-webfont.eot?#iefix') format('embedded-opentype'),
  7 |        url('fonts/LAKESHOR-webfont.woff') format('woff'),
  8 |        url('fonts/LAKESHOR-webfont.ttf') format('truetype'),
  9 |        url('donts/LAKESHOR-webfont.svg#lakeshore') format('svg');
 10 |   font-weight: normal;
 11 |   font-style: normal;
 12 | }
 13 | /*@font-face {*/
 14 |   /*font-family: 'airstreamregular';*/
 15 |   /*src: url('fonts/Airstream-webfont.eot/');*/
 16 |   /*src: url('fonts/Airstream-webfont.eot?#iefix') format('embedded-opentype'),*/
 17 |        /*url('fonts/Airstream-webfont.woff') format('woff'),*/
 18 |        /*url('fonts/Airstream-webfont.ttf') format('truetype'),*/
 19 |        /*url('donts/Airstream-webfont.svg#lakeshore') format('svg');*/
 20 |   /*font-weight: normal;*/
 21 |   /*font-style: normal;*/
 22 | /*}*/
 23 | html, body {
 24 |   height: 100%;
 25 | }
 26 | body {
 27 |   display: flex;
 28 |   font-size: 10px;
 29 |   background-color: rgb(149, 194, 215);
 30 |   flex-direction: column;
 31 | }
 32 | a {
 33 |   /* Declaration- negating default property */
 34 |   text-decoration: none;
 35 | }
 36 | .logo-text {
 37 |   background: white;
 38 | 
 39 |   text-align: center;
 40 |   text-transform: uppercase;
 41 |   font-family: lakeshore;
 42 |   font-size: 37px;
 43 | }
 44 | .main-content {
 45 |   flex: 1 1 auto;
 46 |   display: flex;
 47 |   flex-direction: column;
 48 | }
 49 | /*.thumbnail-item + .thumbnail-item {
 50 |   margin-top: 10px;
 51 | }*/
 52 | .thumbnail-item {
 53 |   display: inline-block;
 54 |   min-width: 120px;
 55 |   max-width: 120px;
 56 |   /*Fallback values*/
 57 |   border: 1px solid rgb(100%, 100%, 100%);
 58 |   border: 1px solid rgba(100%, 100%, 100%, 0.8);
 59 | 
 60 |   transition: transform 133ms ease-in-out;
 61 | }
 62 | .thumbnail-item:hover {
 63 |   transform: scale(1.2);
 64 | }
 65 | .thumbnail-list {
 66 |   flex: 0 1 auto;
 67 |   order: 2;
 68 |   display: flex;
 69 |   justify-content: space-between;
 70 |   list-style: none;
 71 |   padding: 20px 0;
 72 | 
 73 |   white-space: nowrap;
 74 |   overflow-x: auto;
 75 | }
 76 | .thumbnail-image {
 77 |   display: block;
 78 |   width: 100%;
 79 | }
 80 | .thumbnail-title {
 81 |   display: block;
 82 |   margin: 0;
 83 |   padding: 4px 10px;
 84 | 
 85 | 
 86 |   background: rgb(96, 125, 139);
 87 |   color: rgb(202, 238, 255);
 88 | 
 89 |   font-size: 18px;
 90 | }
 91 | .detail-image-container {
 92 |   flex: 1 1 auto;
 93 |   display: flex;
 94 |   justify-content: center;
 95 |   align-items: center;
 96 | }
 97 | .detail-image-frame {
 98 |   position: relative;
 99 |   text-align: center;
100 | 
101 |   transition: transform 333ms cubic-bezier(1,.06,.28,1);
102 | 
103 | }
104 | .is-tiny {
105 |   transform: scale(0.001);
106 |   transition: 0ms;
107 | }
108 | .detail-image {
109 | width: 90%;
110 | }
111 | .detail-image-title {
112 |   position: absolute;
113 |   bottom: -16px;
114 |   left: 4px;
115 | 
116 |   font-family: Helvetica;
117 |   color: white;
118 |   text-shadow: rgba(0, 0, 0, 0.9) 1px 2px 9px;
119 |   font-size: 40px;
120 | }
121 | .hidden-detail .detail-image-container {
122 |   display: none;
123 | }
124 | .hidden-detail .thumbnail-list {
125 |   flex-direction: column;
126 |   align-items: center;
127 | }
128 | .hidden-detail .thumbnail-item {
129 |   max-width: 80%;
130 | }
131 | /* Use type all always for media queries - few exceptions including print
132 | for print settings nb orientation:portrait / landscape diff vs. min-width: 768px*/
133 | 
134 | @media all and (min-width: 768px) {
135 |   .main-content {
136 |     flex-direction: row;
137 |     overflow: hidden;
138 |   }
139 | 
140 |   .thumbnail-list {
141 |     flex-direction: column;
142 |     order: 0;
143 |     margin-left: 20px;
144 | 
145 |     padding: 0 35px;
146 |   }
147 | 
148 |   .thumbnail-item {
149 |     max-width: 260px;
150 |   }
151 | 
152 |   .thumbnail-item + .thumbnail-item {
153 |     margin-top: 20px;
154 |   }
155 | }
156 | 


--------------------------------------------------------------------------------
/Koans/about_methods.rb:
--------------------------------------------------------------------------------
  1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
  2 | 
  3 | def my_global_method(a,b)
  4 |   a + b
  5 | end
  6 | 
  7 | class AboutMethods < Neo::Koan
  8 | 
  9 |   def test_calling_global_methods
 10 |     assert_equal __, my_global_method(2,3)
 11 |   end
 12 | 
 13 |   def test_calling_global_methods_without_parentheses
 14 |     result = my_global_method 2, 3
 15 |     assert_equal __, result
 16 |   end
 17 | 
 18 |   # (NOTE: We are Using eval below because the example code is
 19 |   # considered to be syntactically invalid).
 20 |   def test_sometimes_missing_parentheses_are_ambiguous
 21 |     eval "assert_equal 5, my_global_method 2, 3" # ENABLE CHECK
 22 |     #
 23 |     # Ruby doesn't know if you mean:
 24 |     #
 25 |     #   assert_equal(5, my_global_method(2), 3)
 26 |     # or
 27 |     #   assert_equal(5, my_global_method(2, 3))
 28 |     #
 29 |     # Rewrite the eval string to continue.
 30 |     #
 31 |   end
 32 | 
 33 |   # NOTE: wrong number of arguments is not a SYNTAX error, but a
 34 |   # runtime error.
 35 |   def test_calling_global_methods_with_wrong_number_of_arguments
 36 |     exception = assert_raise(___) do
 37 |       my_global_method
 38 |     end
 39 |     assert_match(/__/, exception.message)
 40 | 
 41 |     exception = assert_raise(___) do
 42 |       my_global_method(1,2,3)
 43 |     end
 44 |     assert_match(/__/, exception.message)
 45 |   end
 46 | 
 47 |   # ------------------------------------------------------------------
 48 | 
 49 |   def method_with_defaults(a, b=:default_value)
 50 |     [a, b]
 51 |   end
 52 | 
 53 |   def test_calling_with_default_values
 54 |     assert_equal [1, __], method_with_defaults(1)
 55 |     assert_equal [1, __], method_with_defaults(1, 2)
 56 |   end
 57 | 
 58 |   # ------------------------------------------------------------------
 59 | 
 60 |   def method_with_var_args(*args)
 61 |     args
 62 |   end
 63 | 
 64 |   def test_calling_with_variable_arguments
 65 |     assert_equal __, method_with_var_args.class
 66 |     assert_equal __, method_with_var_args
 67 |     assert_equal __, method_with_var_args(:one)
 68 |     assert_equal __, method_with_var_args(:one, :two)
 69 |   end
 70 | 
 71 |   # ------------------------------------------------------------------
 72 | 
 73 |   def method_with_explicit_return
 74 |     :a_non_return_value
 75 |     return :return_value
 76 |     :another_non_return_value
 77 |   end
 78 | 
 79 |   def test_method_with_explicit_return
 80 |     assert_equal __, method_with_explicit_return
 81 |   end
 82 | 
 83 |   # ------------------------------------------------------------------
 84 | 
 85 |   def method_without_explicit_return
 86 |     :a_non_return_value
 87 |     :return_value
 88 |   end
 89 | 
 90 |   def test_method_without_explicit_return
 91 |     assert_equal __, method_without_explicit_return
 92 |   end
 93 | 
 94 |   # ------------------------------------------------------------------
 95 | 
 96 |   def my_method_in_the_same_class(a, b)
 97 |     a * b
 98 |   end
 99 | 
100 |   def test_calling_methods_in_same_class
101 |     assert_equal __, my_method_in_the_same_class(3,4)
102 |   end
103 | 
104 |   def test_calling_methods_in_same_class_with_explicit_receiver
105 |     assert_equal __, self.my_method_in_the_same_class(3,4)
106 |   end
107 | 
108 |   # ------------------------------------------------------------------
109 | 
110 |   def my_private_method
111 |     "a secret"
112 |   end
113 |   private :my_private_method
114 | 
115 |   def test_calling_private_methods_without_receiver
116 |     assert_equal __, my_private_method
117 |   end
118 | 
119 |   def test_calling_private_methods_with_an_explicit_receiver
120 |     exception = assert_raise(___) do
121 |       self.my_private_method
122 |     end
123 |     assert_match /__/, exception.message
124 |   end
125 | 
126 |   # ------------------------------------------------------------------
127 | 
128 |   class Dog
129 |     def name
130 |       "Fido"
131 |     end
132 | 
133 |     private
134 | 
135 |     def tail
136 |       "tail"
137 |     end
138 |   end
139 | 
140 |   def test_calling_methods_in_other_objects_require_explicit_receiver
141 |     rover = Dog.new
142 |     assert_equal __, rover.name
143 |   end
144 | 
145 |   def test_calling_private_methods_in_other_objects
146 |     rover = Dog.new
147 |     assert_raise(___) do
148 |       rover.tail
149 |     end
150 |   end
151 | end
152 | 


--------------------------------------------------------------------------------
/Koans/about_class_methods.rb:
--------------------------------------------------------------------------------
  1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
  2 | 
  3 | class AboutClassMethods < Neo::Koan
  4 |   class Dog
  5 |   end
  6 | 
  7 |   def test_objects_are_objects
  8 |     fido = Dog.new
  9 |     assert_equal __, fido.is_a?(Object)
 10 |   end
 11 | 
 12 |   def test_classes_are_classes
 13 |     assert_equal __, Dog.is_a?(Class)
 14 |   end
 15 | 
 16 |   def test_classes_are_objects_too
 17 |     assert_equal __, Dog.is_a?(Object)
 18 |   end
 19 | 
 20 |   def test_objects_have_methods
 21 |     fido = Dog.new
 22 |     assert fido.methods.size > _n_
 23 |   end
 24 | 
 25 |   def test_classes_have_methods
 26 |     assert Dog.methods.size > _n_
 27 |   end
 28 | 
 29 |   def test_you_can_define_methods_on_individual_objects
 30 |     fido = Dog.new
 31 |     def fido.wag
 32 |       :fidos_wag
 33 |     end
 34 |     assert_equal __, fido.wag
 35 |   end
 36 | 
 37 |   def test_other_objects_are_not_affected_by_these_singleton_methods
 38 |     fido = Dog.new
 39 |     rover = Dog.new
 40 |     def fido.wag
 41 |       :fidos_wag
 42 |     end
 43 | 
 44 |     assert_raise(___) do
 45 |       rover.wag
 46 |     end
 47 |   end
 48 | 
 49 |   # ------------------------------------------------------------------
 50 | 
 51 |   class Dog2
 52 |     def wag
 53 |       :instance_level_wag
 54 |     end
 55 |   end
 56 | 
 57 |   def Dog2.wag
 58 |     :class_level_wag
 59 |   end
 60 | 
 61 |   def test_since_classes_are_objects_you_can_define_singleton_methods_on_them_too
 62 |     assert_equal __, Dog2.wag
 63 |   end
 64 | 
 65 |   def test_class_methods_are_independent_of_instance_methods
 66 |     fido = Dog2.new
 67 |     assert_equal __, fido.wag
 68 |     assert_equal __, Dog2.wag
 69 |   end
 70 | 
 71 |   # ------------------------------------------------------------------
 72 | 
 73 |   class Dog
 74 |     attr_accessor :name
 75 |   end
 76 | 
 77 |   def Dog.name
 78 |     @name
 79 |   end
 80 | 
 81 |   def test_classes_and_instances_do_not_share_instance_variables
 82 |     fido = Dog.new
 83 |     fido.name = "Fido"
 84 |     assert_equal __, fido.name
 85 |     assert_equal __, Dog.name
 86 |   end
 87 | 
 88 |   # ------------------------------------------------------------------
 89 | 
 90 |   class Dog
 91 |     def Dog.a_class_method
 92 |       :dogs_class_method
 93 |     end
 94 |   end
 95 | 
 96 |   def test_you_can_define_class_methods_inside_the_class
 97 |     assert_equal __, Dog.a_class_method
 98 |   end
 99 | 
100 |   # ------------------------------------------------------------------
101 | 
102 |   LastExpressionInClassStatement = class Dog
103 |                                      21
104 |                                    end
105 | 
106 |   def test_class_statements_return_the_value_of_their_last_expression
107 |     assert_equal __, LastExpressionInClassStatement
108 |   end
109 | 
110 |   # ------------------------------------------------------------------
111 | 
112 |   SelfInsideOfClassStatement = class Dog
113 |                                  self
114 |                                end
115 | 
116 |   def test_self_while_inside_class_is_class_object_not_instance
117 |     assert_equal __, Dog == SelfInsideOfClassStatement
118 |   end
119 | 
120 |   # ------------------------------------------------------------------
121 | 
122 |   class Dog
123 |     def self.class_method2
124 |       :another_way_to_write_class_methods
125 |     end
126 |   end
127 | 
128 |   def test_you_can_use_self_instead_of_an_explicit_reference_to_dog
129 |     assert_equal __, Dog.class_method2
130 |   end
131 | 
132 |   # ------------------------------------------------------------------
133 | 
134 |   class Dog
135 |     class << self
136 |       def another_class_method
137 |         :still_another_way
138 |       end
139 |     end
140 |   end
141 | 
142 |   def test_heres_still_another_way_to_write_class_methods
143 |     assert_equal __, Dog.another_class_method
144 |   end
145 | 
146 |   # THINK ABOUT IT:
147 |   #
148 |   # The two major ways to write class methods are:
149 |   #   class Demo
150 |   #     def self.method
151 |   #     end
152 |   #
153 |   #     class << self
154 |   #       def class_methods
155 |   #       end
156 |   #     end
157 |   #   end
158 |   #
159 |   # Which do you prefer and why?
160 |   # Are there times you might prefer one over the other?
161 | 
162 |   # ------------------------------------------------------------------
163 | 
164 |   def test_heres_an_easy_way_to_call_class_methods_from_instance_methods
165 |     fido = Dog.new
166 |     assert_equal __, fido.class.another_class_method
167 |   end
168 | 
169 | end
170 | 


--------------------------------------------------------------------------------
/Koans/about_java_interop.rb:
--------------------------------------------------------------------------------
  1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
  2 | 
  3 | include Java
  4 | 
  5 | # Concepts
  6 | # * Pull in a java class
  7 | # * calling a method, Camel vs snake
  8 | # * Resolving module/class name conflicts
  9 | # * Showing what gets returned
 10 | # * Ruby Strings  VS Java Strings
 11 | # * Calling custom java class
 12 | # * Calling Ruby from java???
 13 | 
 14 | class AboutJavaInterop < Neo::Koan
 15 |   def test_using_a_java_library_class
 16 |     java_array = java.util.ArrayList.new
 17 |     assert_equal __, java_array.class
 18 |   end
 19 | 
 20 |   def test_java_class_can_be_referenced_using_both_ruby_and_java_like_syntax
 21 |     assert_equal __, Java::JavaUtil::ArrayList == java.util.ArrayList
 22 |   end
 23 | 
 24 |   def test_include_class_includes_class_in_module_scope
 25 |     assert_nil defined?(TreeSet)
 26 |     include_class "java.util.TreeSet"
 27 |     assert_equal __, defined?(TreeSet)
 28 |   end
 29 | 
 30 |   # THINK ABOUT IT:
 31 |   #
 32 |   # What if we use:
 33 |   #
 34 |   #   include_class "java.lang.String"
 35 |   #
 36 |   # What would be the value of the String constant after this
 37 |   # include_class is run?  Would it be useful to provide a way of
 38 |   # aliasing java classes to different names?
 39 | 
 40 |   JString = java.lang.String
 41 |   def test_also_java_class_can_be_given_ruby_aliases
 42 |     java_string = JString.new("A Java String")
 43 |     assert_equal __, java_string.class
 44 |     assert_equal __, JString
 45 |   end
 46 | 
 47 |   def test_can_directly_call_java_methods_on_java_objects
 48 |     java_string = JString.new("A Java String")
 49 |     assert_equal __, java_string.toLowerCase
 50 |   end
 51 | 
 52 |   def test_jruby_provides_snake_case_versions_of_java_methods
 53 |     java_string = JString.new("A Java String")
 54 |     assert_equal __, java_string.to_lower_case
 55 |   end
 56 | 
 57 |   def test_jruby_provides_question_mark_versions_of_boolean_methods
 58 |     java_string = JString.new("A Java String")
 59 |     assert_equal __, java_string.endsWith("String")
 60 |     assert_equal __, java_string.ends_with("String")
 61 |     assert_equal __, java_string.ends_with?("String")
 62 |   end
 63 | 
 64 |   def test_java_string_are_not_ruby_strings
 65 |     ruby_string = "A Java String"
 66 |     java_string = java.lang.String.new(ruby_string)
 67 |     assert_equal __, java_string.is_a?(java.lang.String)
 68 |     assert_equal __, java_string.is_a?(String)
 69 |   end
 70 | 
 71 |   def test_java_strings_can_be_compared_to_ruby_strings_maybe
 72 |     ruby_string = "A Java String"
 73 |     java_string = java.lang.String.new(ruby_string)
 74 |     assert_equal __, ruby_string == java_string
 75 |     assert_equal __, java_string == ruby_string
 76 | 
 77 |     # THINK ABOUT IT:
 78 |     #
 79 |     # Is there any possible way for this to be more wrong?
 80 |     #
 81 |     # SERIOUSLY, THINK ABOUT IT:
 82 |     #
 83 |     # Why do you suppose that Ruby and Java strings compare like that?
 84 |     #
 85 |     # ADVANCED THINK ABOUT IT:
 86 |     #
 87 |     # Is there a way to make Ruby/Java string comparisons commutative?
 88 |     # How would you do it?
 89 |   end
 90 | 
 91 |   def test_however_most_methods_returning_strings_return_ruby_strings
 92 |     java_array = java.util.ArrayList.new
 93 |     assert_equal __, java_array.toString
 94 |     assert_equal __, java_array.toString.is_a?(String)
 95 |     assert_equal __, java_array.toString.is_a?(java.lang.String)
 96 |   end
 97 | 
 98 |   def test_some_ruby_objects_can_be_coerced_to_java
 99 |     assert_equal __, "ruby string".to_java.class
100 |     assert_equal __, 1.to_java.class
101 |     assert_equal __, 9.32.to_java.class
102 |     assert_equal __, false.to_java.class
103 |   end
104 | 
105 |   def test_some_ruby_objects_are_not_coerced_to_what_you_might_expect
106 |     assert_equal __, [].to_java.class == Java::JavaUtil::ArrayList
107 |     assert_equal __, {}.to_java.class == Java::JavaUtil::HashMap
108 |     assert_equal __, Object.new.to_java.class == Java::JavaLang::Object
109 |   end
110 | 
111 |   def test_java_collections_are_enumerable
112 |     java_array = java.util.ArrayList.new
113 |     java_array << "one" << "two" << "three"
114 |     assert_equal __, java_array.map { |item| item.upcase }
115 |   end
116 | 
117 |   # ------------------------------------------------------------------
118 | 
119 |   # Open the Java ArrayList class and add a new method.
120 |   class Java::JavaUtil::ArrayList
121 |     def multiply_all
122 |       result = 1
123 |       each do |item|
124 |         result *= item
125 |       end
126 |       result
127 |     end
128 |   end
129 | 
130 |   def test_java_class_are_open_from_ruby
131 |     java_array = java.util.ArrayList.new
132 |     java_array.add_all([1,2,3,4,5])
133 | 
134 |     assert_equal __, java_array.multiply_all
135 |   end
136 | 
137 | end
138 | 


--------------------------------------------------------------------------------
/Koans/about_classes.rb:
--------------------------------------------------------------------------------
  1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
  2 | 
  3 | class AboutClasses < Neo::Koan
  4 |   class Dog
  5 |   end
  6 | 
  7 |   def test_instances_of_classes_can_be_created_with_new
  8 |     fido = Dog.new
  9 |     assert_equal __, fido.class
 10 |   end
 11 | 
 12 |   # ------------------------------------------------------------------
 13 | 
 14 |   class Dog2
 15 |     def set_name(a_name)
 16 |       @name = a_name
 17 |     end
 18 |   end
 19 | 
 20 |   def test_instance_variables_can_be_set_by_assigning_to_them
 21 |     fido = Dog2.new
 22 |     assert_equal __, fido.instance_variables
 23 | 
 24 |     fido.set_name("Fido")
 25 |     assert_equal __, fido.instance_variables
 26 |   end
 27 | 
 28 |   def test_instance_variables_cannot_be_accessed_outside_the_class
 29 |     fido = Dog2.new
 30 |     fido.set_name("Fido")
 31 | 
 32 |     assert_raise(___) do
 33 |       fido.name
 34 |     end
 35 | 
 36 |     assert_raise(___) do
 37 |       eval "fido.@name"
 38 |       # NOTE: Using eval because the above line is a syntax error.
 39 |     end
 40 |   end
 41 | 
 42 |   def test_you_can_politely_ask_for_instance_variable_values
 43 |     fido = Dog2.new
 44 |     fido.set_name("Fido")
 45 | 
 46 |     assert_equal __, fido.instance_variable_get("@name")
 47 |   end
 48 | 
 49 |   def test_you_can_rip_the_value_out_using_instance_eval
 50 |     fido = Dog2.new
 51 |     fido.set_name("Fido")
 52 | 
 53 |     assert_equal __, fido.instance_eval("@name")  # string version
 54 |     assert_equal __, fido.instance_eval { @name } # block version
 55 |   end
 56 | 
 57 |   # ------------------------------------------------------------------
 58 | 
 59 |   class Dog3
 60 |     def set_name(a_name)
 61 |       @name = a_name
 62 |     end
 63 |     def name
 64 |       @name
 65 |     end
 66 |   end
 67 | 
 68 |   def test_you_can_create_accessor_methods_to_return_instance_variables
 69 |     fido = Dog3.new
 70 |     fido.set_name("Fido")
 71 | 
 72 |     assert_equal __, fido.name
 73 |   end
 74 | 
 75 |   # ------------------------------------------------------------------
 76 | 
 77 |   class Dog4
 78 |     attr_reader :name
 79 | 
 80 |     def set_name(a_name)
 81 |       @name = a_name
 82 |     end
 83 |   end
 84 | 
 85 | 
 86 |   def test_attr_reader_will_automatically_define_an_accessor
 87 |     fido = Dog4.new
 88 |     fido.set_name("Fido")
 89 | 
 90 |     assert_equal __, fido.name
 91 |   end
 92 | 
 93 |   # ------------------------------------------------------------------
 94 | 
 95 |   class Dog5
 96 |     attr_accessor :name
 97 |   end
 98 | 
 99 | 
100 |   def test_attr_accessor_will_automatically_define_both_read_and_write_accessors
101 |     fido = Dog5.new
102 | 
103 |     fido.name = "Fido"
104 |     assert_equal __, fido.name
105 |   end
106 | 
107 |   # ------------------------------------------------------------------
108 | 
109 |   class Dog6
110 |     attr_reader :name
111 |     def initialize(initial_name)
112 |       @name = initial_name
113 |     end
114 |   end
115 | 
116 |   def test_initialize_provides_initial_values_for_instance_variables
117 |     fido = Dog6.new("Fido")
118 |     assert_equal __, fido.name
119 |   end
120 | 
121 |   def test_args_to_new_must_match_initialize
122 |     assert_raise(___) do
123 |       Dog6.new
124 |     end
125 |     # THINK ABOUT IT:
126 |     # Why is this so?
127 |   end
128 | 
129 |   def test_different_objects_have_different_instance_variables
130 |     fido = Dog6.new("Fido")
131 |     rover = Dog6.new("Rover")
132 | 
133 |     assert_equal __, rover.name != fido.name
134 |   end
135 | 
136 |   # ------------------------------------------------------------------
137 | 
138 |   class Dog7
139 |     attr_reader :name
140 | 
141 |     def initialize(initial_name)
142 |       @name = initial_name
143 |     end
144 | 
145 |     def get_self
146 |       self
147 |     end
148 | 
149 |     def to_s
150 |       @name
151 |     end
152 | 
153 |     def inspect
154 |       "<Dog named '#{name}'>"
155 |     end
156 |   end
157 | 
158 |   def test_inside_a_method_self_refers_to_the_containing_object
159 |     fido = Dog7.new("Fido")
160 | 
161 |     fidos_self = fido.get_self
162 |     assert_equal __, fidos_self
163 |   end
164 | 
165 |   def test_to_s_provides_a_string_version_of_the_object
166 |     fido = Dog7.new("Fido")
167 |     assert_equal __, fido.to_s
168 |   end
169 | 
170 |   def test_to_s_is_used_in_string_interpolation
171 |     fido = Dog7.new("Fido")
172 |     assert_equal __, "My dog is #{fido}"
173 |   end
174 | 
175 |   def test_inspect_provides_a_more_complete_string_version
176 |     fido = Dog7.new("Fido")
177 |     assert_equal __, fido.inspect
178 |   end
179 | 
180 |   def test_all_objects_support_to_s_and_inspect
181 |     array = [1,2,3]
182 | 
183 |     assert_equal __, array.to_s
184 |     assert_equal __, array.inspect
185 | 
186 |     assert_equal __, "STRING".to_s
187 |     assert_equal __, "STRING".inspect
188 |   end
189 | 
190 | end
191 | 


--------------------------------------------------------------------------------
/ottergram/index.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1">
 6 |     <title>ottergram</title>
 7 |     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/normalize/5.0.0/normalize.min.css">
 8 |     <link rel="stylesheet" href="stylesheets/styles.css">
 9 |   </head>
10 |   <body>
11 |     <header class="main-header">
12 |       <h1 class="logo-text">Ottergram</h1>
13 |       <audio class="audio-controls" controls autoplay>
14 | 	  <source src="sounds/Groovy-disco-funky-sound-logo.mp3" type="audio/mpeg">
15 | 	  Your browser does not support the audio element.
16 | 	  </audio>
17 |     </header>
18 |       <main class="main-content">
19 |         <ul class="thumbnail-list">
20 |           <li class="thumbnail-item">
21 |             <a href="img/otter1.jpg" data-image-role="trigger" data-image-title="Stayin' Alive" data-image-url="img/otter1.jpg">
22 |               <img class="thumbnail-image" src="img/otter1.jpg" alt="Barry the Otter">
23 |               <span class="thumbnail-title">Barry</span>
24 |             </a>
25 |           </li>
26 |           <li class="thumbnail-item">
27 |             <a href="img/otter2.jpg" data-image-role="trigger" data-image-title="How Deep Is Your Love" data-image-url="img/otter2.jpg">
28 |               <img class="thumbnail-image" src="img/otter2.jpg" alt="Robin the Otter">
29 |               <span class="thumbnail-title">Robin</span>
30 |             </a>
31 |           </li>
32 |           <li class="thumbnail-item">
33 |             <a href="img/otter3.jpg" data-image-role="trigger" data-image-title="You Should Be Dancing" data-image-url="img/otter3.jpg">
34 |               <img class="thumbnail-image" src="img/otter3.jpg" alt="Maurice the Otter">
35 |               <span class="thumbnail-title">Maurice</span>
36 |             </a>
37 |           </li>
38 |           <li class="thumbnail-item">
39 |             <a href="img/otter4.jpg" data-image-role="trigger" data-image-title="Night Fever" data-image-url="img/otter4.jpg">
40 |               <img class="thumbnail-image" src="img/otter4.jpg" alt="Lesley the Otter">
41 |               <span class="thumbnail-title">Lesley</span>
42 |             </a>
43 |           </li>
44 |           <li class="thumbnail-item">
45 |             <a href="img/otter5.jpg" data-image-role="trigger" data-image-title="To Love Somebody" data-image-url="img/otter5.jpg">
46 |               <img class="thumbnail-image" src="img/otter5.jpg" alt="Barbara the Otter">
47 |               <span class="thumbnail-title">Barbara</span>
48 |             </a>
49 |           </li>
50 |           <li class="thumbnail-item">
51 |             <a href="img/otter1.jpg" data-image-role="trigger" data-image-title="Stayin' Alive" data-image-url="img/otter1.jpg">
52 |               <img class="thumbnail-image" src="img/otter1.jpg" alt="Barry the Otter">
53 |               <span class="thumbnail-title">Barry</span>
54 |             </a>
55 |           </li>
56 |           <li class="thumbnail-item">
57 |             <a href="img/otter2.jpg" data-image-role="trigger" data-image-title="How Deep Is Your Love" data-image-url="img/otter2.jpg">
58 |               <img class="thumbnail-image" src="img/otter2.jpg" alt="Robin the Otter">
59 |               <span class="thumbnail-title">Robin</span>
60 |             </a>
61 |           </li>
62 |           <li class="thumbnail-item">
63 |             <a href="img/otter3.jpg" data-image-role="trigger" data-image-title="You Should Be Dancing" data-image-url="img/otter3.jpg">
64 |               <img class="thumbnail-image" src="img/otter3.jpg" alt="Maurice the Otter">
65 |               <span class="thumbnail-title">Maurice</span>
66 |             </a>
67 |           </li>
68 |           <li class="thumbnail-item">
69 |             <a href="img/otter4.jpg" data-image-role="trigger" data-image-title="Night Fever" data-image-url="img/otter4.jpg">
70 |               <img class="thumbnail-image" src="img/otter4.jpg" alt="Lesley the Otter">
71 |               <span class="thumbnail-title">Lesley</span>
72 |             </a>
73 |           </li>
74 |           <li class="thumbnail-item">
75 |             <a href="img/otter5.jpg" data-image-role="trigger" data-image-title="To Love Somebody" data-image-url="img/otter5.jpg">
76 |               <img class="thumbnail-image" src="img/otter5.jpg" alt="Barbara the Otter">
77 |               <span class="thumbnail-title">Barbara</span>
78 |             </a>
79 |           </li>
80 |         </ul>
81 | 
82 |       <div class="detail-image-container">
83 |         <div class="detail-image-frame" data-image-role="frame">
84 |           <img class="detail-image" data-image-role="target" src="img/otter1.jpg" alt="">
85 |           <span class="detail-image-title" data-image-role="title">Stayin' Alive</span>
86 |         </div>
87 |       </div>
88 | 
89 |     </main>
90 |     <script src="scripts/main.js" charset="utf-8"></script>
91 |   </body>
92 | </html>
93 | 


--------------------------------------------------------------------------------
/Koans/about_regular_expressions.rb:
--------------------------------------------------------------------------------
  1 | # -*- coding: utf-8 -*-
  2 | require File.expand_path(File.dirname(__FILE__) + '/neo')
  3 | 
  4 | class AboutRegularExpressions < Neo::Koan
  5 |   def test_a_pattern_is_a_regular_expression
  6 |     assert_equal __, /pattern/.class
  7 |   end
  8 | 
  9 |   def test_a_regexp_can_search_a_string_for_matching_content
 10 |     assert_equal __, "some matching content"[/match/]
 11 |   end
 12 | 
 13 |   def test_a_failed_match_returns_nil
 14 |     assert_equal __, "some matching content"[/missing/]
 15 |   end
 16 | 
 17 |   # ------------------------------------------------------------------
 18 | 
 19 |   def test_question_mark_means_optional
 20 |     assert_equal __, "abbcccddddeeeee"[/ab?/]
 21 |     assert_equal __, "abbcccddddeeeee"[/az?/]
 22 |   end
 23 | 
 24 |   def test_plus_means_one_or_more
 25 |     assert_equal __, "abbcccddddeeeee"[/bc+/]
 26 |   end
 27 | 
 28 |   def test_asterisk_means_zero_or_more
 29 |     assert_equal __, "abbcccddddeeeee"[/ab*/]
 30 |     assert_equal __, "abbcccddddeeeee"[/az*/]
 31 |     assert_equal __, "abbcccddddeeeee"[/z*/]
 32 | 
 33 |     # THINK ABOUT IT:
 34 |     #
 35 |     # When would * fail to match?
 36 |   end
 37 | 
 38 |   # THINK ABOUT IT:
 39 |   #
 40 |   # We say that the repetition operators above are "greedy."
 41 |   #
 42 |   # Why?
 43 | 
 44 |   # ------------------------------------------------------------------
 45 | 
 46 |   def test_the_left_most_match_wins
 47 |     assert_equal __, "abbccc az"[/az*/]
 48 |   end
 49 | 
 50 |   # ------------------------------------------------------------------
 51 | 
 52 |   def test_character_classes_give_options_for_a_character
 53 |     animals = ["cat", "bat", "rat", "zat"]
 54 |     assert_equal __, animals.select { |a| a[/[cbr]at/] }
 55 |   end
 56 | 
 57 |   def test_slash_d_is_a_shortcut_for_a_digit_character_class
 58 |     assert_equal __, "the number is 42"[/[0123456789]+/]
 59 |     assert_equal __, "the number is 42"[/\d+/]
 60 |   end
 61 | 
 62 |   def test_character_classes_can_include_ranges
 63 |     assert_equal __, "the number is 42"[/[0-9]+/]
 64 |   end
 65 | 
 66 |   def test_slash_s_is_a_shortcut_for_a_whitespace_character_class
 67 |     assert_equal __, "space: \t\n"[/\s+/]
 68 |   end
 69 | 
 70 |   def test_slash_w_is_a_shortcut_for_a_word_character_class
 71 |     # NOTE:  This is more like how a programmer might define a word.
 72 |     assert_equal __, "variable_1 = 42"[/[a-zA-Z0-9_]+/]
 73 |     assert_equal __, "variable_1 = 42"[/\w+/]
 74 |   end
 75 | 
 76 |   def test_period_is_a_shortcut_for_any_non_newline_character
 77 |     assert_equal __, "abc\n123"[/a.+/]
 78 |   end
 79 | 
 80 |   def test_a_character_class_can_be_negated
 81 |     assert_equal __, "the number is 42"[/[^0-9]+/]
 82 |   end
 83 | 
 84 |   def test_shortcut_character_classes_are_negated_with_capitals
 85 |     assert_equal __, "the number is 42"[/\D+/]
 86 |     assert_equal __, "space: \t\n"[/\S+/]
 87 |     # ... a programmer would most likely do
 88 |     assert_equal __, "variable_1 = 42"[/[^a-zA-Z0-9_]+/]
 89 |     assert_equal __, "variable_1 = 42"[/\W+/]
 90 |   end
 91 | 
 92 |   # ------------------------------------------------------------------
 93 | 
 94 |   def test_slash_a_anchors_to_the_start_of_the_string
 95 |     assert_equal __, "start end"[/\Astart/]
 96 |     assert_equal __, "start end"[/\Aend/]
 97 |   end
 98 | 
 99 |   def test_slash_z_anchors_to_the_end_of_the_string
100 |     assert_equal __, "start end"[/end\z/]
101 |     assert_equal __, "start end"[/start\z/]
102 |   end
103 | 
104 |   def test_caret_anchors_to_the_start_of_lines
105 |     assert_equal __, "num 42\n2 lines"[/^\d+/]
106 |   end
107 | 
108 |   def test_dollar_sign_anchors_to_the_end_of_lines
109 |     assert_equal __, "2 lines\nnum 42"[/\d+$/]
110 |   end
111 | 
112 |   def test_slash_b_anchors_to_a_word_boundary
113 |     assert_equal __, "bovine vines"[/\bvine./]
114 |   end
115 | 
116 |   # ------------------------------------------------------------------
117 | 
118 |   def test_parentheses_group_contents
119 |     assert_equal __, "ahahaha"[/(ha)+/]
120 |   end
121 | 
122 |   # ------------------------------------------------------------------
123 | 
124 |   def test_parentheses_also_capture_matched_content_by_number
125 |     assert_equal __, "Gray, James"[/(\w+), (\w+)/, 1]
126 |     assert_equal __, "Gray, James"[/(\w+), (\w+)/, 2]
127 |   end
128 | 
129 |   def test_variables_can_also_be_used_to_access_captures
130 |     assert_equal __, "Name:  Gray, James"[/(\w+), (\w+)/]
131 |     assert_equal __, $1
132 |     assert_equal __, $2
133 |   end
134 | 
135 |   # ------------------------------------------------------------------
136 | 
137 |   def test_a_vertical_pipe_means_or
138 |     grays = /(James|Dana|Summer) Gray/
139 |     assert_equal __, "James Gray"[grays]
140 |     assert_equal __, "Summer Gray"[grays, 1]
141 |     assert_equal __, "Jim Gray"[grays, 1]
142 |   end
143 | 
144 |   # THINK ABOUT IT:
145 |   #
146 |   # Explain the difference between a character class ([...]) and alternation (|).
147 | 
148 |   # ------------------------------------------------------------------
149 | 
150 |   def test_scan_is_like_find_all
151 |     assert_equal __, "one two-three".scan(/\w+/)
152 |   end
153 | 
154 |   def test_sub_is_like_find_and_replace
155 |     assert_equal __, "one two-three".sub(/(t\w*)/) { $1[0, 1] }
156 |   end
157 | 
158 |   def test_gsub_is_like_find_and_replace_all
159 |     assert_equal __, "one two-three".gsub(/(t\w*)/) { $1[0, 1] }
160 |   end
161 | end
162 | 


--------------------------------------------------------------------------------
/Koans/about_message_passing.rb:
--------------------------------------------------------------------------------
  1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
  2 | 
  3 | class AboutMessagePassing < Neo::Koan
  4 | 
  5 |   class MessageCatcher
  6 |     def caught?
  7 |       true
  8 |     end
  9 |   end
 10 | 
 11 |   def test_methods_can_be_called_directly
 12 |     mc = MessageCatcher.new
 13 | 
 14 |     assert mc.caught?
 15 |   end
 16 | 
 17 |   def test_methods_can_be_invoked_by_sending_the_message
 18 |     mc = MessageCatcher.new
 19 | 
 20 |     assert mc.send(:caught?)
 21 |   end
 22 | 
 23 |   def test_methods_can_be_invoked_more_dynamically
 24 |     mc = MessageCatcher.new
 25 | 
 26 |     assert mc.send("caught?")
 27 |     assert mc.send("caught" + __ )    # What do you need to add to the first string?
 28 |     assert mc.send("CAUGHT?".____ )      # What would you need to do to the string?
 29 |   end
 30 | 
 31 |   def test_send_with_underscores_will_also_send_messages
 32 |     mc = MessageCatcher.new
 33 | 
 34 |     assert_equal __, mc.__send__(:caught?)
 35 | 
 36 |     # THINK ABOUT IT:
 37 |     #
 38 |     # Why does Ruby provide both send and __send__ ?
 39 |   end
 40 | 
 41 |   def test_classes_can_be_asked_if_they_know_how_to_respond
 42 |     mc = MessageCatcher.new
 43 | 
 44 |     assert_equal __, mc.respond_to?(:caught?)
 45 |     assert_equal __, mc.respond_to?(:does_not_exist)
 46 |   end
 47 | 
 48 |   # ------------------------------------------------------------------
 49 | 
 50 |   class MessageCatcher
 51 |     def add_a_payload(*args)
 52 |       args
 53 |     end
 54 |   end
 55 | 
 56 |   def test_sending_a_message_with_arguments
 57 |     mc = MessageCatcher.new
 58 | 
 59 |     assert_equal __, mc.add_a_payload
 60 |     assert_equal __, mc.send(:add_a_payload)
 61 | 
 62 |     assert_equal __, mc.add_a_payload(3, 4, nil, 6)
 63 |     assert_equal __, mc.send(:add_a_payload, 3, 4, nil, 6)
 64 |   end
 65 | 
 66 |   # NOTE:
 67 |   #
 68 |   # Both obj.msg and obj.send(:msg) sends the message named :msg to
 69 |   # the object. We use "send" when the name of the message can vary
 70 |   # dynamically (e.g. calculated at run time), but by far the most
 71 |   # common way of sending a message is just to say: obj.msg.
 72 | 
 73 |   # ------------------------------------------------------------------
 74 | 
 75 |   class TypicalObject
 76 |   end
 77 | 
 78 |   def test_sending_undefined_messages_to_a_typical_object_results_in_errors
 79 |     typical = TypicalObject.new
 80 | 
 81 |     exception = assert_raise(___) do
 82 |       typical.foobar
 83 |     end
 84 |     assert_match(/foobar/, exception.message)
 85 |   end
 86 | 
 87 |   def test_calling_method_missing_causes_the_no_method_error
 88 |     typical = TypicalObject.new
 89 | 
 90 |     exception = assert_raise(___) do
 91 |       typical.method_missing(:foobar)
 92 |     end
 93 |     assert_match(/foobar/, exception.message)
 94 | 
 95 |     # THINK ABOUT IT:
 96 |     #
 97 |     # If the method :method_missing causes the NoMethodError, then
 98 |     # what would happen if we redefine method_missing?
 99 |     #
100 |     # NOTE:
101 |     #
102 |     # In Ruby 1.8 the method_missing method is public and can be
103 |     # called as shown above. However, in Ruby 1.9 (and later versions)
104 |     # the method_missing method is private. We explicitly made it
105 |     # public in the testing framework so this example works in both
106 |     # versions of Ruby. Just keep in mind you can't call
107 |     # method_missing like that after Ruby 1.9 normally.
108 |     #
109 |     # Thanks.  We now return you to your regularly scheduled Ruby
110 |     # Koans.
111 |   end
112 | 
113 |   # ------------------------------------------------------------------
114 | 
115 |   class AllMessageCatcher
116 |     def method_missing(method_name, *args, &block)
117 |       "Someone called #{method_name} with <#{args.join(", ")}>"
118 |     end
119 |   end
120 | 
121 |   def test_all_messages_are_caught
122 |     catcher = AllMessageCatcher.new
123 | 
124 |     assert_equal __, catcher.foobar
125 |     assert_equal __, catcher.foobaz(1)
126 |     assert_equal __, catcher.sum(1,2,3,4,5,6)
127 |   end
128 | 
129 |   def test_catching_messages_makes_respond_to_lie
130 |     catcher = AllMessageCatcher.new
131 | 
132 |     assert_nothing_raised do
133 |       catcher.any_method
134 |     end
135 |     assert_equal __, catcher.respond_to?(:any_method)
136 |   end
137 | 
138 |   # ------------------------------------------------------------------
139 | 
140 |   class WellBehavedFooCatcher
141 |     def method_missing(method_name, *args, &block)
142 |       if method_name.to_s[0,3] == "foo"
143 |         "Foo to you too"
144 |       else
145 |         super(method_name, *args, &block)
146 |       end
147 |     end
148 |   end
149 | 
150 |   def test_foo_method_are_caught
151 |     catcher = WellBehavedFooCatcher.new
152 | 
153 |     assert_equal __, catcher.foo_bar
154 |     assert_equal __, catcher.foo_baz
155 |   end
156 | 
157 |   def test_non_foo_messages_are_treated_normally
158 |     catcher = WellBehavedFooCatcher.new
159 | 
160 |     assert_raise(___) do
161 |       catcher.normal_undefined_method
162 |     end
163 |   end
164 | 
165 |   # ------------------------------------------------------------------
166 | 
167 |   # (note: just reopening class from above)
168 |   class WellBehavedFooCatcher
169 |     def respond_to?(method_name)
170 |       if method_name.to_s[0,3] == "foo"
171 |         true
172 |       else
173 |         super(method_name)
174 |       end
175 |     end
176 |   end
177 | 
178 |   def test_explicitly_implementing_respond_to_lets_objects_tell_the_truth
179 |     catcher = WellBehavedFooCatcher.new
180 | 
181 |     assert_equal __, catcher.respond_to?(:foo_bar)
182 |     assert_equal __, catcher.respond_to?(:something_else)
183 |   end
184 | 
185 | end
186 | 


--------------------------------------------------------------------------------
/Koans/about_strings.rb:
--------------------------------------------------------------------------------
  1 | require File.expand_path(File.dirname(__FILE__) + '/neo')
  2 | 
  3 | class AboutStrings < Neo::Koan
  4 |   def test_double_quoted_strings_are_strings
  5 |     string = "Hello, World"
  6 |     assert_equal __, string.is_a?(String)
  7 |   end
  8 | 
  9 |   def test_single_quoted_strings_are_also_strings
 10 |     string = 'Goodbye, World'
 11 |     assert_equal __, string.is_a?(String)
 12 |   end
 13 | 
 14 |   def test_use_single_quotes_to_create_string_with_double_quotes
 15 |     string = 'He said, "Go Away."'
 16 |     assert_equal __, string
 17 |   end
 18 | 
 19 |   def test_use_double_quotes_to_create_strings_with_single_quotes
 20 |     string = "Don't"
 21 |     assert_equal __, string
 22 |   end
 23 | 
 24 |   def test_use_backslash_for_those_hard_cases
 25 |     a = "He said, \"Don't\""
 26 |     b = 'He said, "Don\'t"'
 27 |     assert_equal __, a == b
 28 |   end
 29 | 
 30 |   def test_use_flexible_quoting_to_handle_really_hard_cases
 31 |     a = %(flexible quotes can handle both ' and " characters)
 32 |     b = %!flexible quotes can handle both ' and " characters!
 33 |     c = %{flexible quotes can handle both ' and " characters}
 34 |     assert_equal __, a == b
 35 |     assert_equal __, a == c
 36 |   end
 37 | 
 38 |   def test_flexible_quotes_can_handle_multiple_lines
 39 |     long_string = %{
 40 | It was the best of times,
 41 | It was the worst of times.
 42 | }
 43 |     assert_equal __, long_string.length
 44 |     assert_equal __, long_string.lines.count
 45 |     assert_equal __, long_string[0,1]
 46 |   end
 47 | 
 48 |   def test_here_documents_can_also_handle_multiple_lines
 49 |     long_string = <<EOS
 50 | It was the best of times,
 51 | It was the worst of times.
 52 | EOS
 53 |     assert_equal __, long_string.length
 54 |     assert_equal __, long_string.lines.count
 55 |     assert_equal __, long_string[0,1]
 56 |   end
 57 | 
 58 |   def test_plus_will_concatenate_two_strings
 59 |     string = "Hello, " + "World"
 60 |     assert_equal __, string
 61 |   end
 62 | 
 63 |   def test_plus_concatenation_will_leave_the_original_strings_unmodified
 64 |     hi = "Hello, "
 65 |     there = "World"
 66 |     string = hi + there
 67 |     assert_equal __, hi
 68 |     assert_equal __, there
 69 |   end
 70 | 
 71 |   def test_plus_equals_will_concatenate_to_the_end_of_a_string
 72 |     hi = "Hello, "
 73 |     there = "World"
 74 |     hi += there
 75 |     assert_equal __, hi
 76 |   end
 77 | 
 78 |   def test_plus_equals_also_will_leave_the_original_string_unmodified
 79 |     original_string = "Hello, "
 80 |     hi = original_string
 81 |     there = "World"
 82 |     hi += there
 83 |     assert_equal __, original_string
 84 |   end
 85 | 
 86 |   def test_the_shovel_operator_will_also_append_content_to_a_string
 87 |     hi = "Hello, "
 88 |     there = "World"
 89 |     hi << there
 90 |     assert_equal __, hi
 91 |     assert_equal __, there
 92 |   end
 93 | 
 94 |   def test_the_shovel_operator_modifies_the_original_string
 95 |     original_string = "Hello, "
 96 |     hi = original_string
 97 |     there = "World"
 98 |     hi << there
 99 |     assert_equal __, original_string
100 | 
101 |     # THINK ABOUT IT:
102 |     #
103 |     # Ruby programmers tend to favor the shovel operator (<<) over the
104 |     # plus equals operator (+=) when building up strings.  Why?
105 |   end
106 | 
107 |   def test_double_quoted_string_interpret_escape_characters
108 |     string = "\n"
109 |     assert_equal __, string.size
110 |   end
111 | 
112 |   def test_single_quoted_string_do_not_interpret_escape_characters
113 |     string = '\n'
114 |     assert_equal __, string.size
115 |   end
116 | 
117 |   def test_single_quotes_sometimes_interpret_escape_characters
118 |     string = '\\\''
119 |     assert_equal __, string.size
120 |     assert_equal __, string
121 |   end
122 | 
123 |   def test_double_quoted_strings_interpolate_variables
124 |     value = 123
125 |     string = "The value is #{value}"
126 |     assert_equal __, string
127 |   end
128 | 
129 |   def test_single_quoted_strings_do_not_interpolate
130 |     value = 123
131 |     string = 'The value is #{value}'
132 |     assert_equal __, string
133 |   end
134 | 
135 |   def test_any_ruby_expression_may_be_interpolated
136 |     string = "The square root of 5 is #{Math.sqrt(5)}"
137 |     assert_equal __, string
138 |   end
139 | 
140 |   def test_you_can_get_a_substring_from_a_string
141 |     string = "Bacon, lettuce and tomato"
142 |     assert_equal __, string[7,3]
143 |     assert_equal __, string[7..9]
144 |   end
145 | 
146 |   def test_you_can_get_a_single_character_from_a_string
147 |     string = "Bacon, lettuce and tomato"
148 |     assert_equal __, string[1]
149 | 
150 |     # Surprised?
151 |   end
152 | 
153 |   in_ruby_version("1.8") do
154 |     def test_in_older_ruby_single_characters_are_represented_by_integers
155 |       assert_equal __, ?a
156 |       assert_equal __, ?a == 97
157 | 
158 |       assert_equal __, ?b == (?a + 1)
159 |     end
160 |   end
161 | 
162 |   in_ruby_version("1.9", "2") do
163 |     def test_in_modern_ruby_single_characters_are_represented_by_strings
164 |       assert_equal __, ?a
165 |       assert_equal __, ?a == 97
166 |     end
167 |   end
168 | 
169 |   def test_strings_can_be_split
170 |     string = "Sausage Egg Cheese"
171 |     words = string.split
172 |     assert_equal [__, __, __], words
173 |   end
174 | 
175 |   def test_strings_can_be_split_with_different_patterns
176 |     string = "the:rain:in:spain"
177 |     words = string.split(/:/)
178 |     assert_equal [__, __, __, __], words
179 | 
180 |     # NOTE: Patterns are formed from Regular Expressions.  Ruby has a
181 |     # very powerful Regular Expression library.  We will become
182 |     # enlightened about them soon.
183 |   end
184 | 
185 |   def test_strings_can_be_joined
186 |     words = ["Now", "is", "the", "time"]
187 |     assert_equal __, words.join(" ")
188 |   end
189 | 
190 |   def test_strings_are_unique_objects
191 |     a = "a string"
192 |     b = "a string"
193 | 
194 |     assert_equal __, a           == b
195 |     assert_equal __, a.object_id == b.object_id
196 |   end
197 | end
198 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | #### Web development material I have worked through with some commentary
  2 | 
  3 | Includes sections from:
  4 | 
  5 | * [The Big Nerd Ranch Guide to Front End Web Development](https://www.bignerdranch.com/books/front-end-web-development/)
  6 | * [Javscript30 by Wes Bos](https://javascript30.com/)
  7 | * [Ruby Koans](http://rubykoans.com/)
  8 |   
  9 | 
 10 | 
 11 | 
 12 | 
 13 | 
 14 | 
 15 | 
 16 | 
 17 | 
 18 | 
 19 | # Notes/Commentary -
 20 | ----
 21 | 
 22 | 
 23 | 
 24 | 
 25 | `1/1/2017- Preface`
 26 | 
 27 | This repo started from working through the Front-End Web Development Guide by the Big Nerd Ranch. As I went along I figured I might as well add work/solutions from other great resources in to one repository to keep things organized. 
 28 | 
 29 | The later additions have been:
 30 | 
 31 | The Ruby Koans exercises approaches Ruby from the perspective of edge cases and unit-testing.
 32 | 
 33 | Wes Bos's Javascript30 course does an excellent job of zoning in on applying new and modern JavaScript techniques.
 34 | 
 35 | ##BNR
 36 | 
 37 | `Chapter 1-2: Getting started`
 38 | --
 39 | I have completed Chapters 1 and 2 with relative ease and quickly. I have gained some benefit from becoming familiar with Atom as I have previously only used Sublime Text. 
 40 | 
 41 | As embarassing as it is to admit after 12 weeks of intensive full time development... I only now have learned once and for all the proper way to add a favicon to a web page. Feels good to banish that missing favicon error forever.
 42 | 
 43 | Learning to use Browsersync has also been a bonus, I definitely think I will be incorporating this in future development.
 44 | 
 45 | `Chapter 3: Styles`
 46 | --
 47 | *Atomized styling.* was another seemingly simple but important turn of approach. Heretofore I have approached problems as a process of scaffolding a framework first - like setting our rows or columns or major shapes - and then placing the specific objects within the scaffold.
 48 | 
 49 | From my very brief introduction to atomized styling I can see how from a process of development starting from the more specific, interesting elements and then building them up into a scaffold could make a difference. It seems much more fluid and adaptable.
 50 | 
 51 | This chapter was also a reminder to choose HTML tags based on what they are i.e. unordered list elements for an actually unorded list - and not something else dependent how the browser will style them by default- something that might be easy to forget when you mentally feel you have 'moved past basic HTML'. 
 52 | 
 53 | HSLA values for color which are not always supported are a thing I had forgot existed. 
 54 | 
 55 | `Chapter 4: Flexbox`
 56 | --
 57 | Learning [Flexbox in WDI 7](https://github.com/ATL-WDI-Curriculum/css-flexbox) supplemented with games such as [Flexbox froggy](http://flexboxfroggy.com/) turned out to be very memorable. This was because I went home one day and  was surprised as I talked to some very senior/experienced IT friends who were just as new Flexbox as I was. As it turns out, some problems just before Flexbox really seem like the ['bad old days'](https://github.com/philipwalton/solved-by-flexbox).
 58 | 
 59 | This chapter in the BNR book much like the WDI class is invaluable and accurately represents the state of the 'art' in this area.
 60 | 
 61 | **Highlights/gaps in my knowledge:**
 62 | 
 63 | * Overflow-x - A simple and useful scrolling property I had overlooked.
 64 | * The [flex shorthand property](https://developer.mozilla.org/en-US/docs/Web/CSS/flex). Used flexbox a fair bit but under-used this sh property.
 65 | * Absolute positioning. A well known "Gotcha" and sometimes interview question:
 66 | 
 67 | > **An absolute position must have:**
 68 | 
 69 | >* a property position: absolute (fair enough...)
 70 | * coordinates such as top/right/bottom/left, pixels or relatives lengths (ok..)
 71 | * **an ancestor element with an explicitly declared position property with a value of relative or absolute - if no ancestor has a declared position property, the absolutley defined positioned element with be placed relevative to the <html> element (Yikes!)**
 72 | 
 73 | `Chapter 5: Adaptive Layouts with Media Queries`
 74 | --
 75 | 
 76 | This chapter was a breeze - and relatively short - but quality. I particularly appreciate the way the authors pepper in a little bit of detail to explain things, such as why media queries almost always use 'all':
 77 | 
 78 | `@media all and ... {
 79 | 	/*Styles go here*/
 80 | }`
 81 | 
 82 | When media queries were first being introduced it was planned that in the place of 'all' would eventually be device specific tags such as `phone` or `tv` ...  or just as likely `toaster` or `refridgerator` these days it seems. These device specific tags haven't really worked out as planned so 'all' is the catch-all.
 83 | 
 84 | I always find little bits of context or explanation like this help me remember things.
 85 | 
 86 | `Chapter 6: Handling Events in Javascript`
 87 | --
 88 | 
 89 | "Bottom up approach". Another reminder to start small and work up. A reminder that Nodelist's existed and generally should always be transmuted into a regular JS Array. 
 90 | 
 91 | Generally a good practice/refresher chapter.
 92 | 
 93 | `Chapter 7: Visual Effects with CSS`
 94 | --
 95 | After a short break from finishing the book due to work and commitments, what can I say, this chapter blew my socks of (with [cubic-bezier transitions](http://cubic-bezier.com/#.17,.67,.83,.67) you might even say).
 96 | 
 97 | One 'aha' moment was being exposed to the keycode event objects that are easily loggable. This made a bunch of code I had seen before including early hard-coded games involving playing keyboards to music immediately make more sense.
 98 | 
 99 | `Chapters 8, 9, 10`
100 | --
101 | TBC. Chapter 8 on Modules is one of the longer and more difficult and most valuable to revise. I am happy to say that the chapters on Bootstrap and Jquery/Form Handling that followed were relatively a breeze. 
102 | 
103 | 
104 | ``Javascript30``
105 | --
106 | 1. WesBos starts outs with a fun challenge focused on using keyevents to interact with DOM elements to play music. Keywords:
107 |  * ES6 Template Strings
108 |  * classList.add(`css class goes here`)
109 |  * Drawbacks of using set-timeouts with css transition effects
110 |  * `data-*` data attribute practices
111 | 
112 | 
113 | ``Koans``
114 | --
115 | `0-15`
116 | 
117 | * Every object has a unique object id's, small integers have fixed object id's... and these folow the fibonnaci sequence for some reason. 
118 | * `assert_equal true, nil.nil?`is apparently the only method on nil that returns true


--------------------------------------------------------------------------------
/Koans/README.rdoc:
--------------------------------------------------------------------------------
  1 | = Neo Ruby Koans
  2 | 
  3 | The Ruby Koans walk you along the path to enlightenment in order to learn Ruby.
  4 | The goal is to learn the Ruby language, syntax, structure, and some common
  5 | functions and libraries. We also teach you culture by basing the koans on tests.
  6 | Testing is not just something we pay lip service to, but something we
  7 | live.  Testing is essential in your quest to learn and do great things in Ruby.
  8 | 
  9 | == The Structure
 10 | 
 11 | The koans are broken out into areas by file, hashes are covered in +about_hashes.rb+,
 12 | modules are introduced in +about_modules.rb+, <em>etc</em>.  They are presented in
 13 | order in the +path_to_enlightenment.rb+ file.
 14 | 
 15 | Each koan builds up your knowledge of Ruby and builds upon itself. It will stop at
 16 | the first place you need to correct.
 17 | 
 18 | Some koans simply need to have the correct answer substituted for an incorrect one.
 19 | Some, however, require you to supply your own answer.  If you see the method +__+ (a
 20 | double underscore) listed, it is a hint to you to supply your own code in order to
 21 | make it work correctly.
 22 | 
 23 | == Installing Ruby
 24 | 
 25 | If you do not have Ruby setup, please visit http://ruby-lang.org/en/downloads/ for
 26 | operating specific instructions.  In order to run the koans you need +ruby+ and
 27 | +rake+ installed. To check your installations simply type:
 28 | 
 29 | *nix platforms from any terminal window:
 30 | 
 31 |    [~] $ ruby --version
 32 |    [~] $ rake --version
 33 | 
 34 | Windows from the command prompt (+cmd.exe+)
 35 | 
 36 |    c:\ruby --version
 37 |    c:\rake --version
 38 | 
 39 | If you don't have +rake+ installed, just run <code>gem install rake</code>
 40 | 
 41 | Any response for Ruby with a version number greater than 1.8 is fine (should be
 42 | around 1.8.6 or more). Any version of +rake+ will do.
 43 | 
 44 | == Generating the Koans
 45 | 
 46 | A fresh checkout will not include the koans, you will need to generate
 47 | them.
 48 | 
 49 |     [ruby_koans] $ rake gen                       # generates the koans directory
 50 | 
 51 | If you need to regenerate the koans, thus wiping your current `koans`,
 52 | 
 53 |     [ruby_koans] $ rake regen                     # regenerates the koans directory, wiping the original
 54 | 
 55 | == The Path To Enlightenment
 56 | 
 57 | You can run the tests through +rake+ or by calling the file itself (+rake+ is the
 58 | recommended way to run them as we might build more functionality into this task).
 59 | 
 60 | *nix platforms, from the +ruby_koans+ directory
 61 | 
 62 |     [ruby_koans] $ rake                           # runs the default target :walk_the_path
 63 |     [ruby_koans] $ ruby path_to_enlightenment.rb  # simply call the file directly
 64 | 
 65 | Windows is the same thing
 66 | 
 67 |     c:\ruby_koans\rake                             # runs the default target :walk_the_path
 68 |     c:\ruby_koans\ruby path_to_enlightenment.rb    # simply call the file directly
 69 | 
 70 | === Red, Green, Refactor
 71 | 
 72 | In test-driven development the mantra has always been <em>red, green, refactor</em>.
 73 | Write a failing test and run it (<em>red</em>), make the test pass (<em>green</em>),
 74 | then look at the code and consider if you can make it any better (<em>refactor</em>).
 75 | 
 76 | While walking the path to Ruby enlightenment you will need to run the koan and
 77 | see it fail (<em>red</em>), make the test pass (<em>green</em>), then take a moment
 78 | and reflect upon the test to see what it is teaching you and improve the code to
 79 | better communicate its intent (<em>refactor</em>).
 80 | 
 81 | The very first time you run the koans you will see the following output:
 82 | 
 83 |     [ ruby_koans ] $ rake
 84 |     (in /Users/person/dev/ruby_koans)
 85 |     /usr/bin/ruby1.8 path_to_enlightenment.rb
 86 | 
 87 |     AboutAsserts#test_assert_truth has damaged your karma.
 88 | 
 89 |     The Master says:
 90 |     You have not yet reached enlightenment.
 91 | 
 92 |     The answers you seek...
 93 |     <false> is not true.
 94 | 
 95 |     Please meditate on the following code:
 96 |     ./about_asserts.rb:10:in `test_assert_truth'
 97 |     path_to_enlightenment.rb:38:in `each_with_index'
 98 |     path_to_enlightenment.rb:38
 99 | 
100 |     mountains are merely mountains
101 |     your path thus far [X_________________________________________________] 0/280
102 | 
103 | You have come to your first stage. Notice it is telling you where to look for
104 | the first solution:
105 | 
106 |     Please meditate on the following code:
107 |     ./about_asserts.rb:10:in `test_assert_truth'
108 |     path_to_enlightenment.rb:38:in `each_with_index'
109 |     path_to_enlightenment.rb:38
110 | 
111 | Open the +about_asserts.rb+ file and look at the first test:
112 | 
113 |     # We shall contemplate truth by testing reality, via asserts.
114 |     def test_assert_truth
115 |       assert false                # This should be true
116 |     end
117 | 
118 | Change the +false+ to +true+ and re-run the test.  After you are
119 | done, think about what you are learning.  In this case, ignore everything except
120 | the method name (+test_assert_truth+) and the parts inside the method (everything
121 | before the +end+).
122 | 
123 | In this case the goal is for you to see that if you pass a value to the +assert+
124 | method, it will either ensure it is +true+ and continue on, or fail if
125 | the statement is +false+.
126 | 
127 | === Running the Koans automatically
128 | 
129 | <em>This section is optional.</em>
130 | 
131 | Normally the path to enlightenment looks like this:
132 | 
133 |     cd ruby_koans
134 |     rake
135 |     # edit
136 |     rake
137 |     # edit
138 |     rake
139 |     # etc
140 | 
141 | If you prefer, you can keep the koans running in the background so that after you
142 | make a change in your editor, the koans will immediately run again. This will
143 | hopefully keep your focus on learning Ruby instead of on the command line.
144 | 
145 | Install the Ruby gem (library) called +watchr+ and then ask it to
146 | "watch" the koans for changes:
147 | 
148 |     cd ruby_koans
149 |     rake
150 |     # decide to run rake automatically from now on as you edit
151 |     gem install watchr
152 |     watchr ./koans/koans.watchr
153 | 
154 | == Inspiration
155 | 
156 | A special thanks to Mike Clark and Ara Howard for inspiring this
157 | project.  Mike Clark wrote an excellent blog post about learning Ruby
158 | through unit testing. This sparked an idea that has taken a bit to
159 | solidify, that of bringing new rubyists into the community through
160 | testing. Ara Howard then gave us the idea for the Koans in his ruby
161 | quiz entry on Meta Koans (a must for any rubyist wanting to improve
162 | their skills).  Also, "The Little Lisper" taught us all the value of
163 | the short questions/simple answers style of learning.
164 | 
165 | Mike Clark's post ::  http://www.clarkware.com/cgi/blosxom/2005/03/18
166 | Meta Koans        ::  http://rubyquiz.com/quiz67.html
167 | The Little Lisper ::  http://www.amazon.com/Little-LISPer-Third-Daniel-Friedman/dp/0023397632
168 | 
169 | == Other Resources
170 | 
171 | The Ruby Language               ::  http://ruby-lang.org
172 | Try Ruby in your browser        ::  http://tryruby.org
173 | 
174 | Dave Thomas' introduction to Ruby Programming Ruby (the Pick Axe) ::  http://pragprog.com/titles/ruby/programming-ruby
175 | 
176 | Brian Marick's fantastic guide for beginners Everyday Scripting with Ruby    ::  http://pragprog.com/titles/bmsft/everyday-scripting-with-ruby
177 | 
178 | = Other stuff
179 | 
180 | Author         :: Jim Weirich <jim@neo.org>
181 | Author         :: Joe O'Brien <joe@objo.com>
182 | Issue Tracker  :: http://www.pivotaltracker.com/projects/48111
183 | Requires       :: Ruby 1.8.x or later and Rake (any recent version)
184 | 
185 | = License
186 | 
187 | http://i.creativecommons.org/l/by-nc-sa/3.0/88x31.png
188 | 
189 | RubyKoans is released under a Creative Commons,
190 | Attribution-NonCommercial-ShareAlike, Version 3.0
191 | (http://creativecommons.org/licenses/by-nc-sa/3.0/) License.
192 | 


--------------------------------------------------------------------------------
/Koans/neo.rb:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env ruby
  2 | # -*- ruby -*-
  3 | 
  4 | begin
  5 |   require 'win32console'
  6 | rescue LoadError
  7 | end
  8 | 
  9 | # --------------------------------------------------------------------
 10 | # Support code for the Ruby Koans.
 11 | # --------------------------------------------------------------------
 12 | 
 13 | class FillMeInError < StandardError
 14 | end
 15 | 
 16 | def ruby_version?(version)
 17 |   RUBY_VERSION =~ /^#{version}/ ||
 18 |     (version == 'jruby' && defined?(JRUBY_VERSION)) ||
 19 |     (version == 'mri' && ! defined?(JRUBY_VERSION))
 20 | end
 21 | 
 22 | def in_ruby_version(*versions)
 23 |   yield if versions.any? { |v| ruby_version?(v) }
 24 | end
 25 | 
 26 | in_ruby_version("1.8") do
 27 |   class KeyError < StandardError
 28 |   end
 29 | end
 30 | 
 31 | # Standard, generic replacement value.
 32 | # If value19 is given, it is used in place of value for Ruby 1.9.
 33 | def __(value="FILL ME IN", value19=:mu)
 34 |   if RUBY_VERSION < "1.9"
 35 |     value
 36 |   else
 37 |     (value19 == :mu) ? value : value19
 38 |   end
 39 | end
 40 | 
 41 | # Numeric replacement value.
 42 | def _n_(value=999999, value19=:mu)
 43 |   if RUBY_VERSION < "1.9"
 44 |     value
 45 |   else
 46 |     (value19 == :mu) ? value : value19
 47 |   end
 48 | end
 49 | 
 50 | # Error object replacement value.
 51 | def ___(value=FillMeInError, value19=:mu)
 52 |   if RUBY_VERSION < "1.9"
 53 |     value
 54 |   else
 55 |     (value19 == :mu) ? value : value19
 56 |   end
 57 | end
 58 | 
 59 | # Method name replacement.
 60 | class Object
 61 |   def ____(method=nil)
 62 |     if method
 63 |       self.send(method)
 64 |     end
 65 |   end
 66 | 
 67 |   in_ruby_version("1.9", "2") do
 68 |     public :method_missing
 69 |   end
 70 | end
 71 | 
 72 | class String
 73 |   def side_padding(width)
 74 |     extra = width - self.size
 75 |     if width < 0
 76 |       self
 77 |     else
 78 |       left_padding = extra / 2
 79 |       right_padding = (extra+1)/2
 80 |       (" " * left_padding) + self + (" " *right_padding)
 81 |     end
 82 |   end
 83 | end
 84 | 
 85 | module Neo
 86 |   class << self
 87 |     def simple_output
 88 |       ENV['SIMPLE_KOAN_OUTPUT'] == 'true'
 89 |     end
 90 |   end
 91 | 
 92 |   module Color
 93 |     #shamelessly stolen (and modified) from redgreen
 94 |     COLORS = {
 95 |       :clear   => 0,  :black   => 30, :red   => 31,
 96 |       :green   => 32, :yellow  => 33, :blue  => 34,
 97 |       :magenta => 35, :cyan    => 36,
 98 |     }
 99 | 
100 |     module_function
101 | 
102 |     COLORS.each do |color, value|
103 |       module_eval "def #{color}(string); colorize(string, #{value}); end"
104 |       module_function color
105 |     end
106 | 
107 |     def colorize(string, color_value)
108 |       if use_colors?
109 |         color(color_value) + string + color(COLORS[:clear])
110 |       else
111 |         string
112 |       end
113 |     end
114 | 
115 |     def color(color_value)
116 |       "\e[#{color_value}m"
117 |     end
118 | 
119 |     def use_colors?
120 |       return false if ENV['NO_COLOR']
121 |       if ENV['ANSI_COLOR'].nil?
122 |         if using_windows?
123 |           using_win32console
124 |         else
125 |           return true
126 |         end
127 |       else
128 |         ENV['ANSI_COLOR'] =~ /^(t|y)/i
129 |       end
130 |     end
131 | 
132 |     def using_windows?
133 |       File::ALT_SEPARATOR
134 |     end
135 | 
136 |     def using_win32console
137 |       defined? Win32::Console
138 |     end
139 |   end
140 | 
141 |   module Assertions
142 |     FailedAssertionError = Class.new(StandardError)
143 | 
144 |     def flunk(msg)
145 |       raise FailedAssertionError, msg
146 |     end
147 | 
148 |     def assert(condition, msg=nil)
149 |       msg ||= "Failed assertion."
150 |       flunk(msg) unless condition
151 |       true
152 |     end
153 | 
154 |     def assert_equal(expected, actual, msg=nil)
155 |       msg ||= "Expected #{expected.inspect} to equal #{actual.inspect}"
156 |       assert(expected == actual, msg)
157 |     end
158 | 
159 |     def assert_not_equal(expected, actual, msg=nil)
160 |       msg ||= "Expected #{expected.inspect} to not equal #{actual.inspect}"
161 |       assert(expected != actual, msg)
162 |     end
163 | 
164 |     def assert_nil(actual, msg=nil)
165 |       msg ||= "Expected #{actual.inspect} to be nil"
166 |       assert(nil == actual, msg)
167 |     end
168 | 
169 |     def assert_not_nil(actual, msg=nil)
170 |       msg ||= "Expected #{actual.inspect} to not be nil"
171 |       assert(nil != actual, msg)
172 |     end
173 | 
174 |     def assert_match(pattern, actual, msg=nil)
175 |       msg ||= "Expected #{actual.inspect} to match #{pattern.inspect}"
176 |       assert pattern =~ actual, msg
177 |     end
178 | 
179 |     def assert_raise(exception)
180 |       begin
181 |         yield
182 |       rescue Exception => ex
183 |         expected = ex.is_a?(exception)
184 |         assert(expected, "Exception #{exception.inspect} expected, but #{ex.inspect} was raised")
185 |         return ex
186 |       end
187 |       flunk "Exception #{exception.inspect} expected, but nothing raised"
188 |     end
189 | 
190 |     def assert_nothing_raised
191 |       begin
192 |         yield
193 |       rescue Exception => ex
194 |         flunk "Expected nothing to be raised, but exception #{exception.inspect} was raised"
195 |       end
196 |     end
197 |   end
198 | 
199 |   class Sensei
200 |     attr_reader :failure, :failed_test, :pass_count
201 | 
202 |     FailedAssertionError = Assertions::FailedAssertionError
203 | 
204 |     def initialize
205 |       @pass_count = 0
206 |       @failure = nil
207 |       @failed_test = nil
208 |       @observations = []
209 |     end
210 | 
211 |     PROGRESS_FILE_NAME = '.path_progress'
212 | 
213 |     def add_progress(prog)
214 |       @_contents = nil
215 |       exists = File.exists?(PROGRESS_FILE_NAME)
216 |       File.open(PROGRESS_FILE_NAME,'a+') do |f|
217 |         f.print "#{',' if exists}#{prog}"
218 |       end
219 |     end
220 | 
221 |     def progress
222 |       if @_contents.nil?
223 |         if File.exists?(PROGRESS_FILE_NAME)
224 |           File.open(PROGRESS_FILE_NAME,'r') do |f|
225 |             @_contents = f.read.to_s.gsub(/\s/,'').split(',')
226 |           end
227 |         else
228 |           @_contents = []
229 |         end
230 |       end
231 |       @_contents
232 |     end
233 | 
234 |     def observe(step)
235 |       if step.passed?
236 |         @pass_count += 1
237 |         if @pass_count > progress.last.to_i
238 |           @observations << Color.green("#{step.koan_file}##{step.name} has expanded your awareness.")
239 |         end
240 |       else
241 |         @failed_test = step
242 |         @failure = step.failure
243 |         add_progress(@pass_count)
244 |         @observations << Color.red("#{step.koan_file}##{step.name} has damaged your karma.")
245 |         throw :neo_exit
246 |       end
247 |     end
248 | 
249 |     def failed?
250 |       ! @failure.nil?
251 |     end
252 | 
253 |     def assert_failed?
254 |       failure.is_a?(FailedAssertionError)
255 |     end
256 | 
257 |     def instruct
258 |       if failed?
259 |         @observations.each{|c| puts c }
260 |         encourage
261 |         guide_through_error
262 |         a_zenlike_statement
263 |         show_progress
264 |       else
265 |         end_screen
266 |       end
267 |     end
268 | 
269 |     def show_progress
270 |       bar_width = 50
271 |       total_tests = Neo::Koan.total_tests
272 |       scale = bar_width.to_f/total_tests
273 |       print Color.green("your path thus far [")
274 |       happy_steps = (pass_count*scale).to_i
275 |       happy_steps = 1 if happy_steps == 0 && pass_count > 0
276 |       print Color.green('.'*happy_steps)
277 |       if failed?
278 |         print Color.red('X')
279 |         print Color.cyan('_'*(bar_width-1-happy_steps))
280 |       end
281 |       print Color.green(']')
282 |       print " #{pass_count}/#{total_tests}"
283 |       puts
284 |     end
285 | 
286 |     def end_screen
287 |       if Neo.simple_output
288 |         boring_end_screen
289 |       else
290 |         artistic_end_screen
291 |       end
292 |     end
293 | 
294 |     def boring_end_screen
295 |       puts "Mountains are again merely mountains"
296 |     end
297 | 
298 |     def artistic_end_screen
299 |       "JRuby 1.9.x Koans"
300 |       ruby_version = "(in #{'J' if defined?(JRUBY_VERSION)}Ruby #{defined?(JRUBY_VERSION) ? JRUBY_VERSION : RUBY_VERSION})"
301 |       ruby_version = ruby_version.side_padding(54)
302 |         completed = <<-ENDTEXT
303 |                                   ,,   ,  ,,
304 |                                 :      ::::,    :::,
305 |                    ,        ,,: :::::::::::::,,  ::::   :  ,
306 |                  ,       ,,,   ,:::::::::::::::::::,  ,:  ,: ,,
307 |             :,        ::,  , , :, ,::::::::::::::::::, :::  ,::::
308 |            :   :    ::,                          ,:::::::: ::, ,::::
309 |           ,     ,:::::                                  :,:::::::,::::,
310 |       ,:     , ,:,,:                                       :::::::::::::
311 |      ::,:   ,,:::,                                           ,::::::::::::,
312 |     ,:::, :,,:::                                               ::::::::::::,
313 |    ,::: :::::::,       Mountains are again merely mountains     ,::::::::::::
314 |    :::,,,::::::                                                   ::::::::::::
315 |  ,:::::::::::,                                                    ::::::::::::,
316 |  :::::::::::,                                                     ,::::::::::::
317 | :::::::::::::                                                     ,::::::::::::
318 | ::::::::::::                      Ruby Koans                       ::::::::::::
319 | ::::::::::::#{                  ruby_version                     },::::::::::::
320 | :::::::::::,                                                      , :::::::::::
321 | ,:::::::::::::,                brought to you by                 ,,::::::::::::
322 | ::::::::::::::                                                    ,::::::::::::
323 |  ::::::::::::::,                                                 ,:::::::::::::
324 |  ::::::::::::,               Neo Software Artisans              , ::::::::::::
325 |   :,::::::::: ::::                                               :::::::::::::
326 |    ,:::::::::::  ,:                                          ,,:::::::::::::,
327 |      ::::::::::::                                           ,::::::::::::::,
328 |       :::::::::::::::::,                                  ::::::::::::::::
329 |        :::::::::::::::::::,                             ::::::::::::::::
330 |         ::::::::::::::::::::::,                     ,::::,:, , ::::,:::
331 |           :::::::::::::::::::::::,               ::,: ::,::, ,,: ::::
332 |               ,::::::::::::::::::::              ::,,  , ,,  ,::::
333 |                  ,::::::::::::::::              ::,, ,   ,:::,
334 |                       ,::::                         , ,,
335 |                                                   ,,,
336 | ENDTEXT
337 |         puts completed
338 |     end
339 | 
340 |     def encourage
341 |       puts
342 |       puts "The Master says:"
343 |       puts Color.cyan("  You have not yet reached enlightenment.")
344 |       if ((recents = progress.last(5)) && recents.size == 5 && recents.uniq.size == 1)
345 |         puts Color.cyan("  I sense frustration. Do not be afraid to ask for help.")
346 |       elsif progress.last(2).size == 2 && progress.last(2).uniq.size == 1
347 |         puts Color.cyan("  Do not lose hope.")
348 |       elsif progress.last.to_i > 0
349 |         puts Color.cyan("  You are progressing. Excellent. #{progress.last} completed.")
350 |       end
351 |     end
352 | 
353 |     def guide_through_error
354 |       puts
355 |       puts "The answers you seek..."
356 |       puts Color.red(indent(failure.message).join)
357 |       puts
358 |       puts "Please meditate on the following code:"
359 |       puts embolden_first_line_only(indent(find_interesting_lines(failure.backtrace)))
360 |       puts
361 |     end
362 | 
363 |     def embolden_first_line_only(text)
364 |       first_line = true
365 |       text.collect { |t|
366 |         if first_line
367 |           first_line = false
368 |           Color.red(t)
369 |         else
370 |           Color.cyan(t)
371 |         end
372 |       }
373 |     end
374 | 
375 |     def indent(text)
376 |       text = text.split(/\n/) if text.is_a?(String)
377 |       text.collect{|t| "  #{t}"}
378 |     end
379 | 
380 |     def find_interesting_lines(backtrace)
381 |       backtrace.reject { |line|
382 |         line =~ /neo\.rb/
383 |       }
384 |     end
385 | 
386 |     # Hat's tip to Ara T. Howard for the zen statements from his
387 |     # metakoans Ruby Quiz (http://rubyquiz.com/quiz67.html)
388 |     def a_zenlike_statement
389 |       if !failed?
390 |         zen_statement =  "Mountains are again merely mountains"
391 |       else
392 |         zen_statement = case (@pass_count % 10)
393 |         when 0
394 |           "mountains are merely mountains"
395 |         when 1, 2
396 |           "learn the rules so you know how to break them properly"
397 |         when 3, 4
398 |           "remember that silence is sometimes the best answer"
399 |         when 5, 6
400 |           "sleep is the best meditation"
401 |         when 7, 8
402 |           "when you lose, don't lose the lesson"
403 |         else
404 |           "things are not what they appear to be: nor are they otherwise"
405 |         end
406 |       end
407 |       puts Color.green(zen_statement)
408 |     end
409 |   end
410 | 
411 |   class Koan
412 |     include Assertions
413 | 
414 |     attr_reader :name, :failure, :koan_count, :step_count, :koan_file
415 | 
416 |     def initialize(name, koan_file=nil, koan_count=0, step_count=0)
417 |       @name = name
418 |       @failure = nil
419 |       @koan_count = koan_count
420 |       @step_count = step_count
421 |       @koan_file = koan_file
422 |     end
423 | 
424 |     def passed?
425 |       @failure.nil?
426 |     end
427 | 
428 |     def failed(failure)
429 |       @failure = failure
430 |     end
431 | 
432 |     def setup
433 |     end
434 | 
435 |     def teardown
436 |     end
437 | 
438 |     def meditate
439 |       setup
440 |       begin
441 |         send(name)
442 |       rescue StandardError, Neo::Sensei::FailedAssertionError => ex
443 |         failed(ex)
444 |       ensure
445 |         begin
446 |           teardown
447 |         rescue StandardError, Neo::Sensei::FailedAssertionError => ex
448 |           failed(ex) if passed?
449 |         end
450 |       end
451 |       self
452 |     end
453 | 
454 |     # Class methods for the Neo test suite.
455 |     class << self
456 |       def inherited(subclass)
457 |         subclasses << subclass
458 |       end
459 | 
460 |       def method_added(name)
461 |         testmethods << name if !tests_disabled? && Koan.test_pattern =~ name.to_s
462 |       end
463 | 
464 |       def end_of_enlightenment
465 |         @tests_disabled = true
466 |       end
467 | 
468 |       def command_line(args)
469 |         args.each do |arg|
470 |           case arg
471 |           when /^-n\/(.*)\/$/
472 |             @test_pattern = Regexp.new($1)
473 |           when /^-n(.*)$/
474 |             @test_pattern = Regexp.new(Regexp.quote($1))
475 |           else
476 |             if File.exist?(arg)
477 |               load(arg)
478 |             else
479 |               fail "Unknown command line argument '#{arg}'"
480 |             end
481 |           end
482 |         end
483 |       end
484 | 
485 |       # Lazy initialize list of subclasses
486 |       def subclasses
487 |         @subclasses ||= []
488 |       end
489 | 
490 |        # Lazy initialize list of test methods.
491 |       def testmethods
492 |         @test_methods ||= []
493 |       end
494 | 
495 |       def tests_disabled?
496 |         @tests_disabled ||= false
497 |       end
498 | 
499 |       def test_pattern
500 |         @test_pattern ||= /^test_/
501 |       end
502 | 
503 |       def total_tests
504 |         self.subclasses.inject(0){|total, k| total + k.testmethods.size }
505 |       end
506 |     end
507 |   end
508 | 
509 |   class ThePath
510 |     def walk
511 |       sensei = Neo::Sensei.new
512 |       each_step do |step|
513 |         sensei.observe(step.meditate)
514 |       end
515 |       sensei.instruct
516 |     end
517 | 
518 |     def each_step
519 |       catch(:neo_exit) {
520 |         step_count = 0
521 |         Neo::Koan.subclasses.each_with_index do |koan,koan_index|
522 |           koan.testmethods.each do |method_name|
523 |             step = koan.new(method_name, koan.to_s, koan_index+1, step_count+=1)
524 |             yield step
525 |           end
526 |         end
527 |       }
528 |     end
529 |   end
530 | end
531 | 
532 | END {
533 |   Neo::Koan.command_line(ARGV)
534 |   Neo::ThePath.new.walk
535 | }
536 | 


--------------------------------------------------------------------------------
/ottergram/stylesheets/fonts/LAKESHOR-webfont.svg:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" standalone="no"?>
  2 | <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" >
  3 | <svg xmlns="http://www.w3.org/2000/svg">
  4 | <metadata></metadata>
  5 | <defs>
  6 | <font id="lakeshoredriveregular" horiz-adv-x="500" >
  7 | <font-face units-per-em="1000" ascent="800" descent="-200" />
  8 | <missing-glyph horiz-adv-x="222" />
  9 | <glyph horiz-adv-x="1000" />
 10 | <glyph horiz-adv-x="1000" />
 11 | <glyph unicode="&#xd;" horiz-adv-x="1000" />
 12 | <glyph unicode=" "  horiz-adv-x="222" />
 13 | <glyph unicode="&#x09;" horiz-adv-x="222" />
 14 | <glyph unicode="&#xa0;" horiz-adv-x="222" />
 15 | <glyph unicode="!" horiz-adv-x="279" d="M233 52q0 -26 -27.5 -44.5t-65.5 -18.5q-39 0 -66.5 18.5t-27.5 44.5t27.5 44.5t66.5 18.5q38 0 65.5 -18.5t27.5 -44.5v0zM266 657l-72 -515h-109l-72 515h253v0z" />
 16 | <glyph unicode="&#x22;" horiz-adv-x="315" d="M303 687l-44 -163h-67l-36 133l-6 -20.5t-12 -45.5q-7 -25 -13 -46l-6 -21h-67l-44 163h295v0z" />
 17 | <glyph unicode="#" />
 18 | <glyph unicode="$" horiz-adv-x="397" d="M362 140q-2 -63 -50 -96t-105 -41q-2 0 -4.5 -0.5t-4.5 -0.5v-175h-54v173h-55.5h-55.5v107h55.5h55.5v36q-1 0 -1.5 0.5t-1.5 0.5q-52 17 -96 57t-44 98v3.5t1 2.5v3.5v2.5q5 56 47.5 86.5t94.5 38.5v88h54v-84h95v-107h-95v-31q3 0 5.5 -1t5.5 -1q57 -13 105 -52.5 t48 -103.5v-0.5v-1.5v-1.5v-0.5v0z" />
 19 | <glyph unicode="%" />
 20 | <glyph unicode="&#x26;" horiz-adv-x="755" d="M721 414h-105q24 -32 37.5 -71t13.5 -83q0 -22 -4 -43.5t-12 -41.5q-29 -75 -107.5 -125t-196.5 -50t-214.5 67.5t-98.5 163.5q2 70 29 108.5t74 66.5q-15 22 -22 45.5t-7 47.5q0 65 46.5 116.5t119.5 51.5h152v-107h-70h-4h-4q-27 -3 -49 -18t-22 -44v0v0v-1v0 q0 -22 19.5 -35t43.5 -18q8 -2 16.5 -3t16.5 -1l1 -107q-36 -1 -68.5 -14.5t-47.5 -50.5q-5 -13 -8 -26t-2 -25q0 -50 41.5 -80t97.5 -30q69 0 121 38.5t52 114.5q0 70 -48.5 112t-114.5 42v107h9v0h1h314v-107v0z" />
 21 | <glyph unicode="'" horiz-adv-x="171" d="M163 687l-44 -163h-67l-44 163h155v0z" />
 22 | <glyph unicode="(" horiz-adv-x="317" d="M303 -250q-111 2 -175 83t-91 178q-12 42 -17.5 83.5t-5.5 75.5v160q0 34 5.5 75.5t17.5 83.5q28 98 92 179t174 82v-100q-18 -2 -30 -23t-19 -46q-5 -18 -7 -35t-2 -26v-540q0 -8 2 -25t7 -35q7 -25 19 -46t30 -23v-101v0z" />
 23 | <glyph unicode=")" horiz-adv-x="317" d="M13 -250v100q18 3 30 24t19 46q5 18 7 35t2 26v539q0 9 -2 26t-7 35q-7 25 -19 46t-30 23v100q110 -1 174 -82t92 -179q12 -42 17.5 -83.5t5.5 -75.5v-160q0 -34 -5.5 -75.5t-17.5 -83.5q-27 -97 -91 -178t-175 -82v-1z" />
 24 | <glyph unicode="*" horiz-adv-x="245" d="M233 535l-35 -61l-40 22v-46h-71v47l-40 -23l-36 61l40 23l-40 23l36 62l40 -23v46h71v-46l40 23l35 -62l-40 -23l40 -23v0z" />
 25 | <glyph unicode="+" />
 26 | <glyph unicode="," horiz-adv-x="209" d="M194 52q0 -9 -4 -17t-10 -16l-103 -124l-67 80l26 31q-13 8 -21 20.5t-8 25.5q0 26 27.5 44.5t65.5 18.5q39 0 66.5 -18.5t27.5 -44.5v0z" />
 27 | <glyph unicode="-" horiz-adv-x="236" d="M226 241h-215v107h215v-107v0z" />
 28 | <glyph unicode="." horiz-adv-x="206" d="M200 52q0 -26 -27.5 -44.5t-65.5 -18.5q-39 0 -66.5 18.5t-27.5 44.5t27.5 44.5t66.5 18.5q38 0 65.5 -18.5t27.5 -44.5v0z" />
 29 | <glyph unicode="/" />
 30 | <glyph unicode="0" horiz-adv-x="623" d="M569 220q0 -90 -67.5 -143.5t-148.5 -69.5q-17 -4 -34 -5.5t-33 -1.5t-32.5 1.5t-32.5 4.5q-82 16 -150.5 70t-68.5 144t68.5 144t150.5 70q16 3 32.5 4.5t32.5 1.5t33 -1.5t34 -5.5q81 -16 148.5 -69.5t67.5 -143.5v0zM350 220q0 9 -1.5 21.5t-5.5 25.5q-6 25 -20 45.5 t-37 20.5t-37 -20.5t-21 -44.5q-4 -13 -5.5 -26t-1.5 -22t1.5 -22t5.5 -26q7 -24 21 -44.5t37 -20.5t37 20.5t20 45.5q4 13 5.5 25.5t1.5 21.5v0z" />
 31 | <glyph unicode="1" horiz-adv-x="490" d="M440 0h-437v107h108v131l-68 -34l-48 96l338 169v-362h107v-107v0z" />
 32 | <glyph unicode="2" horiz-adv-x="486" d="M442 0h-442v100q52 30 103.5 60t102.5 61q14 8 26 23.5t16 32.5q1 4 1.5 7.5t0.5 7.5q0 8 -2 14.5t-7 12.5q-4 5 -8 8t-9 5q-2 1 -5 1.5t-6 0.5q-12 0 -21 -9.5t-10 -25.5h-181q1 57 45.5 89.5t97.5 44.5q17 3 33 5t31 2q16 0 35 -1.5t39 -4.5q26 -4 50.5 -11.5 t42.5 -19.5q32 -22 48.5 -52.5t16.5 -68.5q0 -51 -31 -79t-78 -52q-6 -3 -12.5 -6t-12.5 -6q-7 -4 -18 -7.5t-23 -7.5t-23.5 -8.5t-18.5 -8.5h219v-107v0z" />
 33 | <glyph unicode="3" horiz-adv-x="595" d="M466 -167q-40 -28 -91.5 -43t-104.5 -15h-6h-7q-44 2 -86.5 14t-77.5 36q-40 25 -63.5 62t-24.5 81q-1 13 -1 26.5v26.5h199q0 -3 0.5 -6t0.5 -6q1 -6 1.5 -10.5t0.5 -9.5q3 -24 9 -46t21 -41q9 -11 18 -15.5t18 -4.5q11 0 21 6.5t19 18.5q13 18 19 41t6 48v4v4 q-1 21 -7.5 41t-17.5 36q-8 12 -18 19t-21 7h-56v107h38q28 0 39.5 17.5t12.5 39.5v2.5v2.5v2.5v2.5q-1 12 -4 23.5t-8 17.5q-4 7 -12.5 10t-18.5 2h-2.5h-2.5q-13 -1 -24 -8.5t-12 -20.5h-163v1.5v1.5v0.5v1.5q0 49 40.5 78t88.5 41q22 6 42.5 8.5t37.5 2.5q7 0 13.5 -0.5 t13.5 -0.5q33 -3 65.5 -13t60.5 -28q36 -24 55.5 -57.5t18.5 -68.5q0 -28 -12 -55t-38 -50q53 -32 81 -78.5t28 -95.5v-6v-5q-3 -40 -25 -78.5t-64 -69.5v-1z" />
 34 | <glyph unicode="4" horiz-adv-x="645" d="M599 -107h-116v-119h-222v119h-260l338 547h144v-440h116v-107v0zM261 0v104l-70 -104h70v0z" />
 35 | <glyph unicode="5" horiz-adv-x="601" d="M548 -6q0 -89 -67.5 -142.5t-148.5 -69.5q-17 -4 -34 -5.5t-33 -1.5q-18 0 -37 2t-38 6q-71 16 -130.5 61t-60.5 124l-2 53h199q0 -3 0.5 -6t0.5 -6q1 -6 1.5 -10.5t0.5 -9.5q3 -24 9 -46t21 -41q9 -11 18 -15.5t18 -4.5q11 0 21 6.5t19 18.5q13 18 19 41t6 48v4v4 q-1 21 -7.5 41t-17.5 36q-7 10 -17 18t-23 8h-240v333h434v-107h-228v-119h8.5h8.5h8.5h8.5q56 0 106 -16t88 -43q41 -30 65 -71.5t24 -88.5v-1z" />
 36 | <glyph unicode="6" horiz-adv-x="621" d="M567 230v-9.5t-1 -9.5q-3 -44 -22 -84.5t-57 -67.5q-40 -29 -89 -44t-99 -15q-54 0 -105.5 17.5t-93.5 52.5q-51 43 -74.5 105t-23.5 129v9.5v9.5q3 59 23 115.5t54 99.5q39 49 86 75.5t95 38.5q40 10 78.5 12.5t72.5 2.5h60v-107h-60q-68 0 -121 -30.5t-79 -96.5 q20 3 39.5 5t38.5 2q53 0 104 -14t94 -45q42 -30 61 -66.5t19 -84.5v0zM293 107q32 0 48 35.5t16 78.5q0 42 -16 77t-48 35q-31 0 -47 -35.5t-16 -78.5q0 -42 16 -77t47 -35v0z" />
 37 | <glyph unicode="7" horiz-adv-x="583" d="M549 440l-290 -666h-233l253 559h-282v107h552v0z" />
 38 | <glyph unicode="8" horiz-adv-x="622" d="M479 59q-41 -30 -91.5 -44.5t-103.5 -14.5h-6h-6q-49 2 -96 16.5t-85 42.5q-42 30 -64 69.5t-25 80.5v4.5v5.5q0 49 26.5 95t78.5 78q-24 20 -36.5 44t-15.5 48q-1 4 -1 7.5v6.5q0 36 20 69.5t57 57.5q30 20 70 31t84 11q9 0 18.5 -0.5t18.5 -1.5q31 -4 61 -13.5 t57 -26.5q37 -23 57 -56.5t20 -69.5q-1 -28 -14 -56t-40 -51q52 -32 78.5 -78t26.5 -95q0 -43 -22 -85t-67 -75v0zM285 107q32 0 47.5 34.5t16.5 75.5v1.5v1.5q0 43 -16.5 78t-48.5 35q-22 0 -36 -20t-21 -44q-3 -14 -5 -27t-2 -22t2 -22t5 -26q7 -24 21 -44.5t37 -20.5v0z M285 440q21 0 31.5 19t10.5 42v1.5v1.5q-1 21 -11.5 38.5t-30.5 17.5q-21 0 -31.5 -19t-10.5 -42v-1.5v-1.5q1 -21 11.5 -38.5t30.5 -17.5v0z" />
 39 | <glyph unicode="9" horiz-adv-x="621" d="M490 -98q-39 -48 -86 -74.5t-95 -38.5q-40 -10 -78.5 -12.5t-72.5 -2.5l-59 -1v107h59q68 1 121 31.5t79 95.5q-19 -3 -38.5 -5t-39.5 -2q-53 0 -104 14t-94 45q-41 30 -60.5 66.5t-19.5 84.5v9.5t1 9.5q3 44 22.5 84.5t56.5 67.5q41 29 89.5 44t98.5 15 q54 0 105.5 -17.5t93.5 -52.5q51 -43 74.5 -105t23.5 -129v-9.5v-9.5q-3 -59 -23 -115t-54 -99v-1zM276 107q32 0 47.5 35.5t15.5 78.5q0 42 -15.5 77t-47.5 35t-48 -35.5t-16 -78.5q0 -42 16.5 -77t47.5 -35v0z" />
 40 | <glyph unicode=":" horiz-adv-x="206" d="M200 52q0 -26 -27.5 -44.5t-65.5 -18.5q-39 0 -66.5 18.5t-27.5 44.5t27.5 44.5t66.5 18.5q38 0 65.5 -18.5t27.5 -44.5v0zM200 282q0 -26 -27.5 -45t-65.5 -19q-39 0 -66.5 19t-27.5 45t27.5 44.5t66.5 18.5q38 0 65.5 -18.5t27.5 -44.5v0z" />
 41 | <glyph unicode=";" horiz-adv-x="209" d="M194 52q0 -9 -4 -17t-10 -16l-103 -124l-67 80l26 31q-13 8 -21 20.5t-8 25.5q0 26 27.5 44.5t65.5 18.5q39 0 66.5 -18.5t27.5 -44.5v0zM200 282q0 -26 -27.5 -45t-65.5 -19q-39 0 -66.5 19t-27.5 45t27.5 44.5t66.5 18.5q38 0 65.5 -18.5t27.5 -44.5v0z" />
 42 | <glyph unicode="&#x3c;" />
 43 | <glyph unicode="=" />
 44 | <glyph unicode="&#x3e;" />
 45 | <glyph unicode="?" horiz-adv-x="585" d="M310 52q0 -26 -27.5 -44.5t-65.5 -18.5q-39 0 -66.5 18.5t-27.5 44.5t27.5 44.5t66.5 18.5q38 0 65.5 -18.5t27.5 -44.5v0zM521 352q-27 -52 -84 -92.5t-143 -51.5q-14 -2 -20.5 -13.5t-8.5 -25.5q-2 -7 -2.5 -13t-1.5 -11h-106v5t-1 9q-2 19 -3.5 37t-1.5 34 q0 49 22 89.5t93 74.5l4 2t3 2q23 13 41.5 35t17.5 50v3.5v3.5t-0.5 3.5t-0.5 3.5q-5 28 -26.5 41t-46.5 13h-4h-5q-13 -2 -25 -7t-22 -14q-13 -12 -16.5 -28.5t-3.5 -33.5v-10t1 -10v-10v-10h-176v15.5t1 14.5v15.5v14.5q2 71 53 111.5t112 56.5q23 6 44.5 8.5t40.5 2.5 q95 0 158 -31.5t95 -78.5q18 -25 26.5 -53.5t8.5 -57.5q0 -24 -6 -47.5t-17 -46.5v0z" />
 46 | <glyph unicode="@" />
 47 | <glyph unicode="A" horiz-adv-x="643" d="M584 0h-229v333h-124v-333h-231q0 47 0.5 94t0.5 94t0.5 94t0.5 94q1 119 86 205t205 86q119 0 205 -85.5t86 -206.5v-375v0zM355 440v58q0 26 -18 44t-44 18q-25 0 -43.5 -18t-18.5 -44v-58h124v0z" />
 48 | <glyph unicode="B" horiz-adv-x="651" d="M604 220q0 -91 -64.5 -155.5t-155.5 -64.5h-383v667h363q50 0 88.5 -25.5t58.5 -63.5q10 -19 15 -39t5 -41q0 -6 -0.5 -12t-1.5 -11q-2 -18 -9 -35.5t-18 -33.5q47 -30 74.5 -80t27.5 -106v0zM346 157v63.5v62.5q0 23 -16 36.5t-37 13.5h-78v-226h81q21 0 35.5 14.5 t14.5 35.5v0zM316 500q0 23 -12.5 41.5t-38.5 18.5h-50v-120h51q25 0 37.5 19t12.5 41v0z" />
 49 | <glyph unicode="C" horiz-adv-x="596" d="M543 0h-259q-116 0 -199.5 83t-83.5 200v118q0 117 83.5 200.5t200.5 83.5h10.5t10.5 -1q88 -7 161.5 -66t74.5 -155v-54h-199v110q0 24 -17 41.5t-41 17.5q-25 0 -42 -17.5t-17 -41.5v-354q0 -24 17 -41t41 -17h259v-107v0z" />
 50 | <glyph unicode="D" horiz-adv-x="618" d="M566 283q0 -115 -82.5 -198.5t-198.5 -84.5h-1.5h-0.5h-284v667h284q116 0 199.5 -83.5t83.5 -200.5v-49.5v-50.5v0zM341 165v168v168q0 24 -17 41.5t-41 17.5h-59v-453h59q24 0 41 17t17 41v0z" />
 51 | <glyph unicode="E" horiz-adv-x="605" d="M551 0h-329q-91 0 -156 64.5t-65 155.5q0 56 28 106t75 80q-15 23 -22.5 46.5t-6.5 47.5q0 20 5 39.5t14 37.5q21 39 59.5 64.5t88.5 25.5h309v-107h-193q-25 0 -37.5 -18.5t-12.5 -41.5q0 -22 12.5 -41t37.5 -19h193v-107h-193q-49 0 -73.5 -35t-24.5 -78t24.5 -78 t73.5 -35h193v-107v0z" />
 52 | <glyph unicode="F" horiz-adv-x="613" d="M560 333h-216v-212q0 -49 -35.5 -85t-85.5 -36h-206v107h103v226h-118v107h118v227h426v-107h-202v-120h216v-107v0z" />
 53 | <glyph unicode="G" horiz-adv-x="610" d="M551 440h-212v79q0 24 -17.5 41.5t-41.5 17.5t-41 -17.5t-17 -41.5v-354q0 -24 17 -41t41 -17t41.5 17t17.5 41v209h211v-479q0 -49 -35 -84.5t-85 -35.5l-207 -1v107h117v125q-14 -3 -29 -4.5t-31 -1.5q-117 0 -199.5 83t-82.5 200l-1 118q1 117 83.5 200.5t199.5 83.5 q11 0 22.5 -0.5t23.5 -2.5q85 -10 155.5 -59.5t69.5 -146.5v-36v0z" />
 54 | <glyph unicode="H" horiz-adv-x="609" d="M556 0h-226v333h-103v-333h-225v667h225v-227h103v227h226v-667v0z" />
 55 | <glyph unicode="I" horiz-adv-x="285" d="M224 0h-226v667h226v-667v0z" />
 56 | <glyph unicode="J" horiz-adv-x="379" d="M314 -106q0 -49 -35.5 -84t-85.5 -35l-206 -1v107h103v679h-90v107h314v-773v0z" />
 57 | <glyph unicode="K" horiz-adv-x="717" d="M664 0h-205q-53 0 -91.5 38t-38.5 92v203h-105v-333h-222v665h222v-187l231 187h170l-278 -225h82q53 0 91.5 -38t38.5 -92v-203h105v-107v0z" />
 58 | <glyph unicode="L" horiz-adv-x="566" d="M514 0h-514v665h222v-558h292v-107v0z" />
 59 | <glyph unicode="M" horiz-adv-x="860" d="M802 0h-226v135v138v138v135q0 16 -9.5 24t-21.5 8t-21.5 -8t-9.5 -24v-546h-225v546q0 16 -10 24t-22 8h-1.5h-1.5q-10 -1 -19 -9t-9 -23v-546h-226v429q0 78 39.5 136.5t99.5 89.5q28 14 58.5 21.5t61.5 7.5q9 0 18 -0.5t18 -2.5q28 -3 54.5 -13.5t51.5 -27.5 q28 19 59 30t63 13q5 1 10.5 1h10.5q32 0 62 -7.5t57 -21.5q60 -30 99.5 -88.5t39.5 -137.5v-429v0z" />
 60 | <glyph unicode="N" horiz-adv-x="611" d="M556 0h-226v273l-103 124v-397h-225v667h142l186 -226v226h226v-667v0z" />
 61 | <glyph unicode="O" horiz-adv-x="624" d="M566 265q0 -116 -83 -199t-200 -83t-200 83t-83 199l-1 136q1 117 84 200.5t200 83.5q116 0 199.5 -83t83.5 -201v-136v0zM341 147v372q0 24 -17 41.5t-41 17.5t-41.5 -17.5t-17.5 -41.5v-372q0 -24 17.5 -41t41.5 -17t41 17t17 41v0z" />
 62 | <glyph unicode="P" horiz-adv-x="603" d="M560 447q0 -91 -64.5 -155.5t-155.5 -64.5h-111v-227h-227v667h84.5h84.5h84.5h84.5q91 0 155.5 -64.5t64.5 -155.5v0zM316 384v63.5v62.5q0 20 -15 35t-35 15h-37v-226h37q20 0 35 14.5t15 35.5v0z" />
 63 | <glyph unicode="Q" horiz-adv-x="624" d="M569 265q0 -97 -59.5 -173t-150.5 -99v-11h112v-107h-139q-49 1 -83.5 35t-36.5 83q-91 24 -150.5 99.5t-59.5 172.5v136q0 117 83.5 200.5t200.5 83.5q116 0 199.5 -83t83.5 -201v-136v0zM344 147v372q0 24 -17 41.5t-41 17.5t-41.5 -17.5t-17.5 -41.5v-372 q0 -24 17.5 -41t41.5 -17t41 17t17 41v0z" />
 64 | <glyph unicode="R" horiz-adv-x="655" d="M607 0h-164q-54 0 -92 38.5t-38 91.5v97h-84v-227h-228v667h339q90 0 155 -64.5t65 -155.5q0 -43 -15.5 -81t-42.5 -68l0.5 -0.5t1.5 -0.5l0.5 -0.5l0.5 -0.5q17 -18 27.5 -41.5t10.5 -50.5v-97h64v-107v0zM315 384v63.5v62.5q0 20 -14.5 35t-35.5 15h-36v-226h40 q20 2 33 16.5t13 33.5v0z" />
 65 | <glyph unicode="S" horiz-adv-x="599" d="M524 281q10 -16 15.5 -33.5t7.5 -35.5q1 -5 1.5 -11t0.5 -12q0 -28 -8.5 -54t-26.5 -50q-32 -44 -97.5 -73t-164.5 -29q-20 0 -42 2.5t-45 8.5q-61 14 -111.5 51.5t-52.5 102.5v53h176v-8.5v-8.5q-1 -5 -1 -9v-9q0 -16 3.5 -31t16.5 -26q10 -9 24 -14t29 -6h3h4 q23 0 43 8t32 24q5 6 7.5 13t2.5 14v4t-1 4q0 2 -1 4l-2 4q-7 15 -26 28t-52 20q-70 16 -121 52.5t-82 77.5q-7 10 -13 19.5t-11 18.5q-11 21 -16.5 43.5t-5.5 44.5q0 29 10.5 57.5t31.5 53.5q34 39 94 63.5t147 24.5h188v-107h-188q-28 0 -46.5 -17.5t-20.5 -44.5v-2.5 v-2.5q0 -22 13 -35t37 -18q94 -17 156.5 -62t91.5 -97v0z" />
 66 | <glyph unicode="T" horiz-adv-x="512" d="M464 560h-119v-560h-226v560h-120v107h465v-107v0z" />
 67 | <glyph unicode="U" horiz-adv-x="641" d="M583 251q0 -122 -87 -195t-205 -73q-116 0 -203.5 72t-87.5 196v416h229v-516q0 -25 18.5 -43.5t43.5 -18.5q26 0 44.5 18.5t18.5 43.5v516h229v-416v0z" />
 68 | <glyph unicode="V" horiz-adv-x="631" d="M572 375q0 -84 -31.5 -152.5t-86.5 -118.5q-56 -51 -131.5 -78t-161.5 -27h-40.5h-40.5h-41.5h-39.5l-1 668h222v-558q60 10 94.5 45t34.5 114v399h223v-292v0z" />
 69 | <glyph unicode="W" horiz-adv-x="858" d="M800 238q0 -115 -80 -185t-179 -70q-37 0 -73 10.5t-69 32.5q-25 -17 -51.5 -26.5t-54.5 -13.5q-9 -2 -18 -2.5t-18 -0.5q-100 0 -179 70t-79 185l-1 428h226v-546q0 -16 10 -24t22 -7q12 0 21.5 7.5t9.5 23.5v546h225v-546q0 -16 10 -24t22 -7q11 0 20.5 7.5t9.5 23.5 v135v138v138v135h226v-428v0z" />
 70 | <glyph unicode="X" horiz-adv-x="641" d="M586 0h-229v271q0 26 -18 44t-44 18q-25 0 -44 -18t-19 -44v-271h-229v171q0 65 29.5 122t82.5 94q-53 37 -82.5 93t-29.5 122v65h229v-82.5v-82.5q0 -25 18.5 -43.5t43.5 -18.5q26 0 44.5 18.5t18.5 43.5v165h229v-65q0 -65 -29.5 -121.5t-82.5 -93.5q53 -37 82.5 -93.5 t29.5 -122.5v-171v0z" />
 71 | <glyph unicode="Y" horiz-adv-x="624" d="M566 -105q0 -49 -35 -84.5t-85 -35.5l-220 -1v107h116v107q-16 -3 -33 -4.5t-35 -1.5q-9 0 -17.5 0.5t-17.5 1.5q-45 4 -87 18.5t-73 39.5q-37 29 -58 73.5t-21 105.5l-1 446h226v-520q0 -24 17 -41t42 -17q23 0 40.5 16.5t17.5 40.5v521h224v-772v0z" />
 72 | <glyph unicode="Z" horiz-adv-x="703" d="M659 667l-288 -560h251v-107h-620l288 560h-224v107h593v0z" />
 73 | <glyph unicode="[" />
 74 | <glyph unicode="\" />
 75 | <glyph unicode="]" />
 76 | <glyph unicode="^" />
 77 | <glyph unicode="_" d="M506 -89h-505v87h505v-87v0z" />
 78 | <glyph unicode="`" horiz-adv-x="310" d="M248 750l-29 -68l-208 69l47 111l190 -112v0z" />
 79 | <glyph unicode="a" horiz-adv-x="789" d="M814 107q0 -44 -32 -75.5t-76 -31.5h-221q-21 0 -40.5 7t-34.5 20q-3 -1 -5.5 -2t-4.5 -2q-2 -2 -4.5 -3t-5.5 -2q-25 -9 -52 -13.5t-55 -4.5h-10.5t-10.5 1q-46 2 -91 17t-81 41q-41 30 -65 71.5t-24 89.5t24 89.5t65 71.5q36 26 81 41t91 18h10.5h10.5q21 0 42 -2.5 t40 -7.5v9h214v-332h235v0zM365 123v194q-16 8 -30.5 11.5t-28.5 2.5q-42 0 -64.5 -32t-22.5 -79q0 -46 22.5 -79t65.5 -32q13 0 27.5 3.5t30.5 10.5v0z" />
 80 | <glyph unicode="b" horiz-adv-x="799" d="M826 440q0 -44 -31.5 -75.5t-75.5 -31.5h-186q14 -18 23 -41t13 -47q2 -9 2.5 -17.5t0.5 -16.5v-6.5t-1 -7.5q-3 -44 -26.5 -86t-61.5 -70q-41 -30 -88 -43t-96 -15h-8h-8q-34 0 -67.5 4.5t-65.5 12.5q-34 7 -64 18.5t-59 27.5q-6 4 -12.5 7.5t-13.5 7.5v607h215v-235 q3 0 5.5 0.5t4.5 1.5q11 2 22 3.5t22 1.5h556v0zM357 211v8v8q-2 38 -18.5 70.5t-60.5 35.5q-16 -1 -32 -3.5t-30 -6.5v-228q13 -2 27 -4t28 -2q18 0 34.5 5.5t28.5 18.5q11 14 16.5 39.5t6.5 53.5v2.5v2.5v0z" />
 81 | <glyph unicode="c" horiz-adv-x="763" d="M786 107q-1 -44 -32.5 -75.5t-75.5 -31.5h-362h-8.5h-9.5q-52 2 -103.5 14t-96.5 42q-46 31 -71.5 73t-25.5 91t25.5 91t71.5 73q45 30 96.5 42.5t103.5 13.5h9.5h8.5q24 0 47 -4t44 -10v36l153 -1v-222h-91q-11 36 -40.5 65.5t-94.5 28.5q-46 0 -80 -32.5t-34 -80.5 q0 -46 32.5 -79t78.5 -34h2h453v0z" />
 82 | <glyph unicode="d" horiz-adv-x="815" d="M850 107q0 -44 -31.5 -75.5t-75.5 -31.5h-243q-22 0 -41.5 7.5t-35.5 20.5q-7 -3 -13.5 -6t-14.5 -5q-26 -8 -54 -12.5t-57 -4.5q-52 0 -101.5 14.5t-90.5 44.5t-65.5 71.5t-24.5 89.5t24.5 89.5t65.5 71.5q39 28 85 42.5t93 16.5h7.5h6.5q25 0 49 -3t47 -10v238h215 v-558h255v0zM380 125v190q-20 8 -38 12.5t-35 3.5q-42 0 -66.5 -28.5t-24.5 -82.5t24.5 -83t67.5 -28q16 0 34 4t38 12v0z" />
 83 | <glyph unicode="e" horiz-adv-x="694" d="M734 107q-1 -44 -32.5 -75.5t-75.5 -31.5h-310h-1q-61 0 -117 11t-107 48q-45 32 -67.5 74.5t-22.5 86.5t22.5 86.5t67.5 74.5q35 26 81 41.5t94 17.5h9.5h9.5q50 0 96 -14t83 -44q37 -31 56.5 -73t19.5 -89v-31.5v-32.5h-308q11 -25 32.5 -37t49.5 -12h420v0zM346 263 q-2 15 -6.5 27.5t-10.5 22.5q-7 9 -17.5 14t-21.5 6h-3.5h-2.5q-13 0 -24.5 -5t-18.5 -15t-11.5 -22.5t-6.5 -27.5h123v0z" />
 84 | <glyph unicode="f" horiz-adv-x="732" d="M761 471q-1 -43 -32.5 -75.5t-75.5 -32.5h-206q13 -7 24.5 -15.5t21.5 -19.5q31 -31 48.5 -71.5t17.5 -87.5v-144q0 -91 -65.5 -157t-158.5 -66t-159 66t-66 157v338h-110v108h110v26q0 93 66 159.5t158 66.5h108v-108h-79q-16 -4 -27 -17.5t-11 -30.5v-96h436v0zM424 -4 v228q0 20 -15 35t-35 15h-49v-278q0 -19 14.5 -34t34.5 -15t35 15t15 35v-1z" />
 85 | <glyph unicode="g" horiz-adv-x="747" d="M777 107q-1 -44 -32.5 -75.5t-75.5 -31.5h-110v-62q0 -37 -19.5 -69.5t-53.5 -54.5q-32 -22 -71 -32.5t-80 -10.5q-40 0 -78 11t-70 32q-35 23 -54.5 56.5t-19.5 69.5q0 22 8.5 44t24.5 43q-58 25 -101.5 75t-43.5 117q0 48 24 89.5t65 71.5q42 30 92 44.5t102 14.5 q19 0 37 -1.5t36 -5.5v7h202v-332h218v0zM357 -122v121q-29 1 -57 -3t-54 -20q-13 -9 -19.5 -18.5t-5.5 -19.5q0 -9 6 -18t19 -18q15 -10 33 -15.5t36 -7.5q5 0 10.5 -0.5t10.5 -0.5h10.5t10.5 1v-1zM357 116v206q-14 5 -27.5 7t-25.5 1q-44 0 -67 -29t-23 -82q0 -52 23 -82 t68 -29q12 0 25 2t27 6v0z" />
 86 | <glyph unicode="h" horiz-adv-x="698" d="M730 107q0 -44 -31.5 -75.5t-75.5 -31.5h-265v239q0 7 -0.5 15t-1.5 17q-2 14 -6.5 27t-13.5 22q-7 7 -16.5 10t-20.5 3q-5 0 -10 -0.5t-10 -1.5q-10 -2 -20 -5.5t-19 -6.5q-5 -2 -9 -3.5t-8 -3.5v-312h-222v665h222v-239q28 8 57 13t58 5q40 0 78 -9.5t71 -31.5 q38 -25 61.5 -63t23.5 -84v-149h158v0z" />
 87 | <glyph unicode="i" horiz-adv-x="370" d="M403 107q-1 -44 -32.5 -75.5t-75.5 -31.5h-174q-50 0 -85.5 35.5t-35.5 85.5v318h215v-332h188v0zM230 586q0 -32 -34 -55.5t-82 -23.5t-81.5 23.5t-33.5 55.5q0 33 33.5 56t81.5 23t82 -23t34 -56v0z" />
 88 | <glyph unicode="j" horiz-adv-x="611" d="M649 107q0 -44 -31.5 -75.5t-75.5 -31.5h-95v-62q0 -37 -19.5 -69.5t-53.5 -54.5q-32 -22 -71 -32.5t-80 -10.5h-6h-6q-37 2 -72.5 13t-64.5 30q-37 25 -55 57.5t-18 67.5q0 34 18.5 66.5t54.5 57.5q39 26 82 34.5t89 8.5v333h202v-332h202v0zM245 -122v121q-29 1 -57 -3 t-54 -20q-13 -9 -19.5 -18t-5.5 -19q0 -10 6 -19t19 -18q15 -10 33 -15.5t36 -7.5q5 0 10.5 -0.5t10.5 -0.5h10.5t10.5 1v-1zM455 586q0 -32 -34 -55.5t-82 -23.5t-82 23.5t-34 55.5q0 33 34 56t82 23t82 -23t34 -56v0z" />
 89 | <glyph unicode="k" horiz-adv-x="660" d="M708 107q0 -44 -31.5 -75.5t-76.5 -31.5h-186q-49 0 -84.5 35.5t-35.5 85.5v73h-72v-194h-222v665h222v-339l172 114h193l-208 -139h9q50 0 85 -35t35 -85v-74h200v0z" />
 90 | <glyph unicode="l" horiz-adv-x="442" d="M479 107q0 -44 -32 -75.5t-76 -31.5h-252q-49 0 -84.5 35.5t-35.5 85.5l-1 543h215v-557h266v0z" />
 91 | <glyph unicode="m" horiz-adv-x="1046" d="M1086 107q0 -44 -31.5 -75.5t-75.5 -31.5h-149.5h-148.5v239q0 7 -0.5 15t-1.5 17q-2 14 -6.5 27t-13.5 22q-7 7 -16.5 10t-20.5 3q-4 0 -8 -0.5t-8 -1.5q-11 -2 -22 -5t-20 -7q-5 -2 -9 -3.5t-8 -3.5l4 -14t3 -14t1.5 -14t0.5 -14v-256h-213v239q0 7 -0.5 15t-1.5 17 q-2 14 -6.5 27t-13.5 22q-7 7 -16.5 10t-20.5 3h-4t-4 -1q-11 -1 -21.5 -4t-19.5 -6q-4 -1 -6.5 -2t-5.5 -2v-318h-222v440h222v-10q18 5 37 8.5t38 4.5q7 1 13.5 1h12.5q41 0 81.5 -11t74.5 -35q36 20 78.5 32t85.5 14h8h8q41 0 79 -10t71 -31q38 -25 61.5 -63t23.5 -84 v-149h191v0z" />
 92 | <glyph unicode="n" horiz-adv-x="743" d="M781 107q-1 -44 -32.5 -75.5t-75.5 -31.5h-316v239q0 7 -0.5 15t-1.5 17q-1 14 -6 27t-14 22q-7 7 -16.5 10t-20.5 3q-4 0 -8 -0.5t-8 -1.5q-11 -2 -22 -5t-20 -7q-5 -2 -9 -3.5t-8 -3.5v-312h-222v440h222v-14q27 8 56 13t58 5q40 0 78 -9.5t72 -31.5q38 -25 61 -63 t23 -84v-149h210v0z" />
 93 | <glyph unicode="o" horiz-adv-x="732" d="M775 440q-1 -44 -32.5 -75.5t-75.5 -31.5h-137q20 -26 30 -56t10 -62v-4v-3q-2 -48 -25.5 -92.5t-64.5 -74.5t-91.5 -44t-103.5 -14q-52 0 -101.5 14.5t-90.5 43.5q-44 32 -67 77.5t-23 93.5q0 47 22.5 92t67.5 77q38 27 88 43t105 16h489v0zM351 211q0 10 -2 24.5 t-6 29.5q-7 25 -20.5 46.5t-35.5 21.5t-36 -21t-21 -47q-4 -15 -6 -29.5t-2 -24.5t2 -24.5t6 -29.5q7 -25 20.5 -46.5t35.5 -21.5h1v0q22 0 35.5 21.5t20.5 46.5q4 15 6 29.5t2 24.5v0z" />
 94 | <glyph unicode="p" horiz-adv-x="713" d="M757 107q0 -44 -31.5 -75.5t-75.5 -31.5h-31h-78h-52.5h-56.5h-144.5h-72.5v-228l-215 1v667h215v-7q18 4 36.5 5.5t37.5 1.5h6.5h7.5q47 -2 93.5 -16.5t84.5 -42.5q42 -30 66 -71.5t24 -89.5q0 -31 -10.5 -59.5t-29.5 -53.5h226v0zM356 220q0 53 -22.5 82.5t-66.5 29.5 q-11 0 -24.5 -2t-27.5 -7v-210q11 -1 21.5 -2.5t20.5 -1.5q50 1 74.5 27.5t24.5 83.5v0z" />
 95 | <glyph unicode="q" horiz-adv-x="789" d="M840 107q0 -44 -31.5 -75.5t-75.5 -31.5h-162v-227h-215v232l-18 -2t-17 -2q-9 0 -18 -0.5t-18 -0.5q-52 0 -101.5 13.5t-93.5 45.5q-42 30 -66 71.5t-24 89.5t24 89.5t66 71.5q36 26 80 40.5t89 17.5q6 1 12 1h12q19 0 37 -1.5t36 -5.5v7h215v-333h269v0zM356 113v210 q-15 5 -28 7t-25 2q-43 0 -65.5 -29.5t-22.5 -82.5q0 -57 25.5 -84t75.5 -27q9 1 19.5 2t20.5 2v0z" />
 96 | <glyph unicode="r" horiz-adv-x="736" d="M781 107q0 -44 -31.5 -75.5t-75.5 -31.5h-208q-49 0 -85 35.5t-36 85.5v212h-132v-212q0 -49 -35 -85t-85 -36h-94v107h94q5 0 9 4t4 10v212h-98v107h552v-333h221v0z" />
 97 | <glyph unicode="s" horiz-adv-x="754" d="M796 107q0 -44 -32 -75.5t-76 -31.5h-429q-32 0 -51 5.5t-32 11.5q-5 3 -10 5.5l-9 4.5l-3 -4l-15 -23h-141v107h85l264 384l88 -61l-17 -24q7 -3 14 -6.5t14 -7.5q55 -30 100.5 -81t45.5 -114q0 -25 -8.5 -47.5t-24.5 -42.5h237v0zM373 131q5 7 7 15.5t2 18.5 q0 8 -1.5 17t-3.5 18q-3 13 -8.5 26.5t-10.5 24.5q-4 8 -8 14.5t-7 11.5l-2 2t-1 3l-2 2l-2 2l-117 -170q19 -7 39 -8t40 -1q7 0 14.5 0.5t14.5 1.5q14 2 26.5 7t19.5 15v0z" />
 98 | <glyph unicode="t" horiz-adv-x="457" d="M497 107q0 -44 -31.5 -75.5t-75.5 -31.5h-269q-49 0 -84.5 35.5t-35.5 85.5v543h215v-224h102v-107h-102v-226h281v0z" />
 99 | <glyph unicode="u" horiz-adv-x="704" d="M761 107q0 -44 -32 -75.5t-76 -31.5h-307v14q-31 -10 -63.5 -14t-65.5 -4q-9 0 -18.5 0.5t-19.5 1.5q-62 6 -115 38t-64 100q0 8 -0.5 14t-0.5 12l-1 278h214v-262q0 -25 4 -40.5t12 -22.5q6 -5 14.5 -7.5t18.5 -2.5q6 0 12.5 1t12.5 2q10 2 20 5t18 6q7 3 12.5 5t9.5 4 v312h222v-333h193v0z" />
100 | <glyph unicode="v" horiz-adv-x="756" d="M782 440q0 -44 -32 -75.5t-76 -31.5h-115l-85 -212q-19 -46 -65.5 -83.5t-114.5 -37.5h-295v440h222v-333h29l85 212q19 47 49 84t97 37h301v0z" />
101 | <glyph unicode="w" horiz-adv-x="1066" d="M1104 440q0 -44 -31.5 -75.5t-75.5 -31.5h-106v-167q0 -46 -23 -84t-62 -63q-30 -19 -68 -29.5t-82 -10.5h-7.5h-6.5q-53 2 -104 18.5t-94 45.5q-40 -27 -90 -43.5t-101 -19.5q-6 -1 -11.5 -1h-10.5q-40 0 -78 10t-71 30q-38 25 -61 63t-23 84l-1 274h214v-257 q0 -7 0.5 -15t1.5 -17q2 -14 6.5 -27t13.5 -22q8 -7 17.5 -10t19.5 -3q4 0 8.5 0.5t9.5 1.5l16 4t15 5l6 2l6 2v336h222v-334q3 -1 6 -2.5t7 -2.5q7 -3 16 -5.5t18 -4.5q5 -1 9.5 -1.5t9.5 -0.5q11 0 20 3t16 10q9 9 13.5 22t6.5 27q1 9 1.5 17t0.5 15v257h427v0z" />
102 | <glyph unicode="x" horiz-adv-x="862" d="M823 107q-1 -44 -32.5 -75.5t-75.5 -31.5h-211q-6 0 -12.5 0.5t-12.5 1.5q-39 7 -75.5 32t-58.5 55l-17 22l-103 -111h-145l184 198l-100 135h-125v107h215q7 0 13.5 -0.5t13.5 -2.5q37 -7 72 -30t57 -51l78 84h146l-159 -171l119 -162h229v0z" />
103 | <glyph unicode="y" horiz-adv-x="742" d="M792 107q-1 -44 -32.5 -75.5t-75.5 -31.5h-127v-61q0 -37 -19.5 -69.5t-53.5 -54.5q-32 -22 -71 -32.5t-80 -10.5q-40 0 -78 11t-70 32q-35 23 -54.5 56.5t-19.5 69.5q0 22 8.5 44t24.5 43q-58 25 -101 75t-43 117v220h213v-54.5v-55.5v-55.5v-54.5q0 -29 5.5 -52 t18.5 -37q11 -13 27 -18.5t33 -5.5h6t6 1q12 1 24 3.5t22 5.5v323h202v-333h235v0zM355 -121v121q-29 0 -57 -3.5t-54 -19.5q-13 -9 -19.5 -18t-5.5 -19q0 -3 0.5 -6t2.5 -6q2 -6 8 -12.5t14 -11.5q15 -11 33 -16.5t36 -7.5q5 0 10.5 -0.5t10.5 -0.5h10.5t10.5 1v-1z" />
104 | <glyph unicode="z" horiz-adv-x="785" d="M826 107q-1 -44 -32.5 -75.5t-75.5 -31.5h-716l214 333h-215v107h613l-214 -333h426v0z" />
105 | <glyph unicode="{" />
106 | <glyph unicode="|" />
107 | <glyph unicode="}" />
108 | <glyph unicode="~" />
109 | <glyph unicode="&#xa1;" horiz-adv-x="279" d="M12 -203l72 515h109l72 -515h-253v0zM45 402q0 26 27.5 45t65.5 19q39 0 66.5 -19t27.5 -45t-27.5 -44.5t-66.5 -18.5q-38 0 -65.5 18.5t-27.5 44.5v0z" />
110 | <glyph unicode="&#xa2;" horiz-adv-x="385" d="M354 380l-67 -83q-4 3 -9 6l-10 6q-2 1 -3.5 1.5t-3.5 1.5v-94h30h31v-107h-61v-111h-54v111q-40 1 -74.5 11.5t-60.5 27.5q-33 22 -51 52.5t-18 66.5t18 66.5t51 52.5q27 18 57.5 26.5t61.5 10.5q4 1 8 1h8v98h54v-102q26 -4 49.5 -14.5t43.5 -27.5v0zM207 221v96 q-8 -4 -13.5 -12.5t-8.5 -17.5q-2 -5 -2.5 -9.5t-0.5 -8.5t0.5 -8t1.5 -8q3 -10 8.5 -19t14.5 -13v0z" />
111 | <glyph unicode="&#xa3;" horiz-adv-x="443" d="M403 0h-398v107h51v136h-56v53h56v75q0 50 35.5 85.5t84.5 35.5h206v-107h-112v-89h72v-53h-72v-37q0 -25 -9 -46.5t-26 -38.5l-4 -4t-4 -3q-2 -2 -4 -3.5t-4 -3.5h184v-107v0z" />
112 | <glyph unicode="&#xa4;" horiz-adv-x="492" d="M469 415l-74 -135q-2 4 -4.5 8t-5.5 8q-9 14 -20.5 25.5t-28.5 11.5q-27 0 -41.5 -18.5t-19.5 -42.5h115l-29 -54h-92v-4t1 -4v-4v-4h82l-30 -54h-41q8 -17 21 -29t35 -12h67v-107h-67q-56 0 -105.5 16t-87.5 43q-25 18 -44.5 41t-30.5 48h-68l30 54h24q0 2 -0.5 4 t-0.5 4v4v4h-46l30 54h24q10 32 31 59.5t51 49.5q38 27 87.5 43t105.5 16h1v0h1v0h12t12 -1q12 -1 24.5 -2.5t23.5 -4.5q16 -3 30.5 -7.5t27.5 -9.5v0z" />
113 | <glyph unicode="&#xa5;" horiz-adv-x="567" d="M515 148h-157v-148h-201v148h-157v54h104q-4 3 -8.5 6.5t-9.5 7.5v0.5t-1 0.5l-0.5 0.5l-0.5 0.5h-84v54h43q-13 23 -20 49.5t-7 56.5v62h204v-141q0 -16 11 -27t27 -11q15 0 26.5 11t11.5 27v141h203v-62q0 -30 -6.5 -56.5t-19.5 -49.5h42v-54h-84l-0.5 -0.5l-0.5 -0.5 q-1 0 -1 -0.5v-0.5q-4 -4 -8.5 -7.5t-9.5 -6.5h104v-54v0z" />
114 | <glyph unicode="&#xa6;" />
115 | <glyph unicode="&#xa7;" />
116 | <glyph unicode="&#xa8;" horiz-adv-x="310" d="M108 672h-91v90h91v-90v0zM225 672h-90v90h90v-90v0z" />
117 | <glyph unicode="&#xa9;" />
118 | <glyph unicode="&#xaa;" horiz-adv-x="456" d="M451 482q0 -25 -17.5 -42t-42.5 -17h-121q-12 0 -22.5 4t-18.5 11q-1 -1 -2.5 -1.5t-3.5 -0.5q-1 -1 -2.5 -1.5t-2.5 -1.5q-14 -5 -29 -7.5t-31 -2.5h-9.5t-9.5 1q-23 2 -45.5 10t-40.5 21q-23 17 -36 40t-13 49t13 49.5t36 39.5q20 14 45 22.5t51 10.5h4.5h5.5 q12 0 23.5 -1.5t21.5 -4.5v4h117v-182h130v0zM204 491v106q-9 5 -17 6.5t-16 1.5q-23 0 -35.5 -17.5t-12.5 -43.5q0 -25 13 -43t36 -18q7 0 15 2t17 6v0z" />
119 | <glyph unicode="&#xab;" horiz-adv-x="465" d="M278 195l-75 -75l-190 189l190 190l75 -76l-113 -114l113 -114v0zM458 195l-75 -75l-190 189l190 190l75 -76l-113 -114l113 -114v0z" />
120 | <glyph unicode="&#xac;" />
121 | <glyph unicode="&#xad;" />
122 | <glyph unicode="&#xae;" />
123 | <glyph unicode="&#xaf;" horiz-adv-x="222" />
124 | <glyph unicode="&#xb0;" />
125 | <glyph unicode="&#xb1;" />
126 | <glyph unicode="&#xb2;" />
127 | <glyph unicode="&#xb3;" />
128 | <glyph unicode="&#xb4;" horiz-adv-x="310" d="M257 751l-208 -69l-29 68l190 112l47 -111v0z" />
129 | <glyph unicode="&#xb5;" />
130 | <glyph unicode="&#xb6;" />
131 | <glyph unicode="&#xb7;" horiz-adv-x="222" />
132 | <glyph unicode="&#xb8;" horiz-adv-x="310" d="M277 -133q0 -47 -31 -81.5t-81 -34.5q-22 0 -42 8.5t-34 22.5l14 57q3 0 6.5 -1.5t7.5 -3.5q2 -1 4.5 -2t5.5 -2q4 -1 8.5 -2t8.5 -1q20 0 29.5 12t9.5 29t-9.5 31t-29.5 14l-51 -1v112h72v-41q50 1 81 -32.5t31 -82.5v-1z" />
133 | <glyph unicode="&#xb9;" />
134 | <glyph unicode="&#xba;" horiz-adv-x="440" d="M426 672q0 -24 -17.5 -41.5t-41.5 -17.5h-75q9 -11 14 -24t7 -27q1 -3 1 -6.5v-6.5q0 -28 -13.5 -53.5t-36.5 -42.5q-20 -15 -45 -23t-51 -10h-5h-6q-28 0 -55.5 8.5t-50.5 24.5q-25 17 -37 42t-12 52v4v5q2 23 14 45.5t35 38.5q21 14 48.5 23t57.5 9h269v0zM193 546 q0 5 -1 13t-3 17q-4 14 -11.5 25.5t-19.5 11.5q-13 0 -20.5 -11.5t-11.5 -25.5q-2 -9 -3 -17t-1 -13t1 -13t3 -17q4 -14 11.5 -25.5t19.5 -11.5h1v0q12 0 19.5 12t11.5 25q2 9 3 17t1 13v0z" />
135 | <glyph unicode="&#xbb;" horiz-adv-x="473" d="M12 195l113 114l-113 114l75 76l190 -190l-190 -189l-75 75v0zM192 195l113 114l-113 114l75 76l190 -190l-190 -189l-75 75v0z" />
136 | <glyph unicode="&#xbc;" />
137 | <glyph unicode="&#xbd;" />
138 | <glyph unicode="&#xbe;" />
139 | <glyph unicode="&#xbf;" horiz-adv-x="585" d="M27 102q27 53 84.5 93t142.5 51q14 2 20.5 13.5t8.5 25.5q2 7 2.5 13t1.5 11h106v-5t1 -9q2 -19 3.5 -36.5t1.5 -34.5q0 -49 -22 -89t-93 -75l-4 -2t-3 -2q-23 -13 -41.5 -34.5t-17.5 -49.5v-3.5v-3.5t0.5 -3.5t0.5 -3.5q5 -28 26.5 -41t46.5 -13h4h5q13 2 25 7t22 14 q13 12 16.5 28.5t3.5 33.5v9.5v9.5q-1 5 -1 10v10h176v-14.5v-14.5q-1 -8 -1 -15.5v-14.5q-2 -71 -53 -111.5t-112 -56.5q-23 -6 -44.5 -8.5t-40.5 -2.5q-94 0 -157.5 31.5t-95.5 78.5q-18 25 -26.5 53.5t-8.5 56.5q0 24 6 48t17 46v0zM238 402q0 26 27.5 45t65.5 19 q39 0 66.5 -19t27.5 -45t-27.5 -44.5t-66.5 -18.5q-38 0 -65.5 18.5t-27.5 44.5v0z" />
140 | <glyph unicode="&#xc0;" horiz-adv-x="643" d="M584 0h-229v333h-124v-333h-231q0 47 0.5 94t0.5 94t0.5 94t0.5 94q1 119 86 205t205 86q119 0 205 -85.5t86 -206.5v-375v0zM355 440v58q0 26 -18 44t-44 18q-25 0 -43.5 -18t-18.5 -44v-58h124v0zM358 750l-29 -68l-208 69l47 111l190 -112v0z" />
141 | <glyph unicode="&#xc1;" horiz-adv-x="643" d="M584 0h-229v333h-124v-333h-231q0 47 0.5 94t0.5 94t0.5 94t0.5 94q1 119 86 205t205 86q119 0 205 -85.5t86 -206.5v-375v0zM355 440v58q0 26 -18 44t-44 18q-25 0 -43.5 -18t-18.5 -44v-58h124v0zM487 751l-208 -69l-29 68l190 112l47 -111v0z" />
142 | <glyph unicode="&#xc2;" horiz-adv-x="643" d="M584 0h-229v333h-124v-333h-231q0 47 0.5 94t0.5 94t0.5 94t0.5 94q1 119 86 205t205 86q119 0 205 -85.5t86 -206.5v-375v0zM355 440v58q0 26 -18 44t-44 18q-25 0 -43.5 -18t-18.5 -44v-58h124v0zM425 684h-96l-34 25l-33 -25h-95v23l128 112l130 -113v-22v0z" />
143 | <glyph unicode="&#xc3;" horiz-adv-x="643" d="M584 0h-229v333h-124v-333h-231q0 47 0.5 94t0.5 94t0.5 94t0.5 94q1 119 86 205t205 86q119 0 205 -85.5t86 -206.5v-375v0zM355 440v58q0 26 -18 44t-44 18q-25 0 -43.5 -18t-18.5 -44v-58h124v0zM436 733q0 -4 -0.5 -8.5t-1.5 -9.5q-3 -9 -8 -17t-13 -13t-17 -8 t-19 -3q-4 0 -8.5 1t-9.5 2l-139 42v-36h-66v78q0 14 6 27t18 21q8 6 16.5 8.5t17.5 2.5q5 0 10 -0.5t9 -2.5l140 -42v36h65v-78v0z" />
144 | <glyph unicode="&#xc4;" horiz-adv-x="643" d="M584 0h-229v333h-124v-333h-231q0 47 0.5 94t0.5 94t0.5 94t0.5 94q1 119 86 205t205 86q119 0 205 -85.5t86 -206.5v-375v0zM355 440v58q0 26 -18 44t-44 18q-25 0 -43.5 -18t-18.5 -44v-58h124v0zM288 682h-91v90h91v-90v0zM405 682h-90v90h90v-90v0z" />
145 | <glyph unicode="&#xc5;" horiz-adv-x="643" d="M584 0h-229v333h-124v-333h-231q0 47 0.5 94t0.5 94t0.5 94t0.5 94q1 119 86 205t205 86q119 0 205 -85.5t86 -206.5v-375v0zM355 440v58q0 26 -18 44t-44 18q-25 0 -43.5 -18t-18.5 -44v-58h124v0zM378 758q0 -32 -23 -55.5t-56 -23.5q-32 0 -55.5 23.5t-23.5 55.5 q0 33 23.5 56.5t55.5 23.5q33 0 56 -23.5t23 -56.5v0zM324 758q0 11 -7 18t-18 7q-10 0 -17 -7t-7 -18q0 -10 7 -17t17 -7q11 0 18 7t7 17v0z" />
146 | <glyph unicode="&#xc6;" horiz-adv-x="987" d="M922 0h-565v333h-124v-333h-231q0 47 0.5 94t0.5 94t0.5 94t0.5 94q0 119 85.5 205t205.5 86q53 0 100 -17.5t85 -49.5q22 30 56 48.5t77 18.5h309v-107h-193q-25 0 -38 -19t-12 -42v-1.5v-1.5q1 -21 13.5 -38.5t36.5 -17.5h193v-107h-193q-48 0 -72.5 -34.5t-25.5 -75.5 v-1.5v-1.5q0 -43 24.5 -78t73.5 -35h193v-107v0zM357 440v58q0 26 -18 44t-44 18q-25 0 -43.5 -18t-18.5 -44v-58h124v0z" />
147 | <glyph unicode="&#xc7;" horiz-adv-x="596" d="M457 -133q0 -47 -31 -81.5t-81 -34.5q-22 0 -42 8.5t-34 22.5l14 57q3 0 6.5 -1.5t7.5 -3.5q2 -1 4.5 -2t5.5 -2q5 -1 9 -2t8 -1q20 0 29.5 12t9.5 29t-9.5 31t-29.5 14l-51 -1v112h72v-41q50 1 81 -32.5t31 -82.5v-1zM543 0h-259q-116 0 -199.5 83t-83.5 200v118 q0 117 83.5 200.5t200.5 83.5h10.5t10.5 -1q88 -7 161.5 -66t74.5 -155v-54h-199v110q0 24 -17 41.5t-41 17.5q-25 0 -42 -17.5t-17 -41.5v-354q0 -24 17 -41t41 -17h259v-107v0z" />
148 | <glyph unicode="&#xc8;" horiz-adv-x="605" d="M551 0h-329q-91 0 -156 64.5t-65 155.5q0 56 28 106t75 80q-15 23 -22.5 46.5t-6.5 47.5q0 20 5 39.5t14 37.5q21 39 59.5 64.5t88.5 25.5h309v-107h-193q-25 0 -37.5 -18.5t-12.5 -41.5q0 -22 12.5 -41t37.5 -19h193v-107h-193q-49 0 -73.5 -35t-24.5 -78t24.5 -78 t73.5 -35h193v-107v0zM398 750l-29 -68l-208 69l47 111l190 -112v0z" />
149 | <glyph unicode="&#xc9;" horiz-adv-x="605" d="M551 0h-329q-91 0 -156 64.5t-65 155.5q0 56 28 106t75 80q-15 23 -22.5 46.5t-6.5 47.5q0 20 5 39.5t14 37.5q21 39 59.5 64.5t88.5 25.5h309v-107h-193q-25 0 -37.5 -18.5t-12.5 -41.5q0 -22 12.5 -41t37.5 -19h193v-107h-193q-49 0 -73.5 -35t-24.5 -78t24.5 -78 t73.5 -35h193v-107v0zM537 751l-208 -69l-29 68l190 112l47 -111v0z" />
150 | <glyph unicode="&#xca;" horiz-adv-x="605" d="M551 0h-329q-91 0 -156 64.5t-65 155.5q0 56 28 106t75 80q-15 23 -22.5 46.5t-6.5 47.5q0 20 5 39.5t14 37.5q21 39 59.5 64.5t88.5 25.5h309v-107h-193q-25 0 -37.5 -18.5t-12.5 -41.5q0 -22 12.5 -41t37.5 -19h193v-107h-193q-49 0 -73.5 -35t-24.5 -78t24.5 -78 t73.5 -35h193v-107v0zM465 684h-96l-34 25l-33 -25h-95v23l128 112l130 -113v-22v0z" />
151 | <glyph unicode="&#xcb;" horiz-adv-x="605" d="M551 0h-329q-91 0 -156 64.5t-65 155.5q0 56 28 106t75 80q-15 23 -22.5 46.5t-6.5 47.5q0 20 5 39.5t14 37.5q21 39 59.5 64.5t88.5 25.5h309v-107h-193q-25 0 -37.5 -18.5t-12.5 -41.5q0 -22 12.5 -41t37.5 -19h193v-107h-193q-49 0 -73.5 -35t-24.5 -78t24.5 -78 t73.5 -35h193v-107v0zM338 682h-91v90h91v-90v0zM455 682h-90v90h90v-90v0z" />
152 | <glyph unicode="&#xcc;" horiz-adv-x="285" d="M224 0h-226v667h226v-667v0zM168 750l-29 -68l-208 69l47 111l190 -112v0z" />
153 | <glyph unicode="&#xcd;" horiz-adv-x="285" d="M224 0h-226v667h226v-667v0zM257 751l-208 -69l-29 68l190 112l47 -111v0z" />
154 | <glyph unicode="&#xce;" horiz-adv-x="285" d="M224 0h-226v667h226v-667v0zM245 684h-96l-34 25l-33 -25h-95v23l128 112l130 -113v-22v0z" />
155 | <glyph unicode="&#xcf;" horiz-adv-x="285" d="M224 0h-226v667h226v-667v0zM101 685h-91v90h91v-90v0zM218 685h-90v90h90v-90v0z" />
156 | <glyph unicode="&#xd0;" horiz-adv-x="665" d="M616 283q0 -115 -82.5 -198.5t-198.5 -84.5h-1.5h-0.5h-284v241h-48v107h48v319h284q116 0 199.5 -83.5t83.5 -200.5v-49.5v-50.5v0zM391 165v168v168q0 24 -17 41.5t-41 17.5h-59v-212h52v-107h-52v-134h59q24 0 41 17t17 41v0z" />
157 | <glyph unicode="&#xd1;" horiz-adv-x="611" d="M556 0h-226v273l-103 124v-397h-225v667h142l186 -226v226h226v-667v0zM396 733q0 -4 -0.5 -8.5t-1.5 -9.5q-3 -9 -8 -17t-13 -13t-17 -8t-19 -3q-4 0 -8.5 1t-9.5 2l-139 42v-36h-66v78q0 14 6 27t18 21q8 6 16.5 8.5t17.5 2.5q5 0 10 -0.5t9 -2.5l140 -42v36h65v-78v0z " />
158 | <glyph unicode="&#xd2;" horiz-adv-x="222" />
159 | <glyph unicode="&#xd3;" horiz-adv-x="624" d="M566 265q0 -116 -83 -199t-200 -83t-200 83t-83 199l-1 136q1 117 84 200.5t200 83.5q116 0 199.5 -83t83.5 -201v-136v0zM341 147v372q0 24 -17 41.5t-41 17.5t-41.5 -17.5t-17.5 -41.5v-372q0 -24 17.5 -41t41.5 -17t41 17t17 41v0zM467 771l-208 -69l-29 68l190 112 l47 -111v0z" />
160 | <glyph unicode="&#xd4;" horiz-adv-x="624" d="M566 265q0 -116 -83 -199t-200 -83t-200 83t-83 199l-1 136q1 117 84 200.5t200 83.5q116 0 199.5 -83t83.5 -201v-136v0zM341 147v372q0 24 -17 41.5t-41 17.5t-41.5 -17.5t-17.5 -41.5v-372q0 -24 17.5 -41t41.5 -17t41 17t17 41v0zM415 704h-96l-34 25l-33 -25h-95v23 l128 112l130 -113v-22v0z" />
161 | <glyph unicode="&#xd5;" horiz-adv-x="624" d="M566 265q0 -116 -83 -199t-200 -83t-200 83t-83 199l-1 136q1 117 84 200.5t200 83.5q116 0 199.5 -83t83.5 -201v-136v0zM341 147v372q0 24 -17 41.5t-41 17.5t-41.5 -17.5t-17.5 -41.5v-372q0 -24 17.5 -41t41.5 -17t41 17t17 41v0zM422 751q0 -4 -0.5 -8.5t-1.5 -9.5 q-3 -9 -8 -17t-13 -13t-17 -8t-19 -3q-4 0 -8.5 1t-9.5 2l-139 42v-36h-66v78q0 14 6 27t18 21q8 6 16.5 8.5t17.5 2.5q5 0 10 -0.5t9 -2.5l140 -42v36h65v-78v0z" />
162 | <glyph unicode="&#xd6;" horiz-adv-x="624" d="M566 265q0 -116 -83 -199t-200 -83t-200 83t-83 199l-1 136q1 117 84 200.5t200 83.5q116 0 199.5 -83t83.5 -201v-136v0zM341 147v372q0 24 -17 41.5t-41 17.5t-41.5 -17.5t-17.5 -41.5v-372q0 -24 17.5 -41t41.5 -17t41 17t17 41v0zM277 707h-91v90h91v-90v0zM394 707 h-90v90h90v-90v0z" />
163 | <glyph unicode="&#xd7;" />
164 | <glyph unicode="&#xd8;" horiz-adv-x="624" d="M566 263q0 -116 -83 -199t-200 -83q-37 0 -71.5 9t-65.5 25l-31 -57h-51l44 82q-49 39 -78.5 97.5t-29.5 125.5l-1 120q1 117 84 200.5t200 83.5q37 0 71.5 -9.5t64.5 -26.5l32 58h51l-45 -83q50 -39 79.5 -97t29.5 -126v-120v0zM341 145v248l-117 -234v-14 q0 -24 17.5 -41t41.5 -17t41 17t17 41v0zM341 488v13q0 24 -17 41.5t-41 17.5t-41.5 -17.5t-17.5 -41.5v-248l117 235v0z" />
165 | <glyph unicode="&#xd9;" horiz-adv-x="641" d="M583 251q0 -122 -87 -195t-205 -73q-116 0 -203.5 72t-87.5 196v416h229v-516q0 -25 18.5 -43.5t43.5 -18.5q26 0 44.5 18.5t18.5 43.5v516h229v-416v0zM338 750l-29 -68l-208 69l47 111l190 -112v0z" />
166 | <glyph unicode="&#xda;" horiz-adv-x="641" d="M583 251q0 -122 -87 -195t-205 -73q-116 0 -203.5 72t-87.5 196v416h229v-516q0 -25 18.5 -43.5t43.5 -18.5q26 0 44.5 18.5t18.5 43.5v516h229v-416v0zM477 751l-208 -69l-29 68l190 112l47 -111v0z" />
167 | <glyph unicode="&#xdb;" horiz-adv-x="641" d="M583 251q0 -122 -87 -195t-205 -73q-116 0 -203.5 72t-87.5 196v416h229v-516q0 -25 18.5 -43.5t43.5 -18.5q26 0 44.5 18.5t18.5 43.5v516h229v-416v0zM425 684h-96l-34 25l-33 -25h-95v23l128 112l130 -113v-22v0z" />
168 | <glyph unicode="&#xdc;" horiz-adv-x="641" d="M583 251q0 -122 -87 -195t-205 -73q-116 0 -203.5 72t-87.5 196v416h229v-516q0 -25 18.5 -43.5t43.5 -18.5q26 0 44.5 18.5t18.5 43.5v516h229v-416v0zM278 682h-91v90h91v-90v0zM395 682h-90v90h90v-90v0z" />
169 | <glyph unicode="&#xdd;" horiz-adv-x="222" />
170 | <glyph unicode="&#xde;" horiz-adv-x="614" d="M586 324q0 -91 -64.5 -155.5t-155.5 -64.5h-111v-104h-227v667h227v-123h55.5h55.5q91 0 155.5 -64.5t64.5 -155.5v0zM342 260v64v63q0 20 -15 35t-35 15h-37v-226h37q20 0 35 14.5t15 34.5v0z" />
171 | <glyph unicode="&#xdf;" horiz-adv-x="778" d="M821 107q0 -44 -31.5 -75.5t-75.5 -31.5h-447v107h130q21 0 31.5 6.5t11.5 14.5v2t-1 3q-2 7 -12.5 14.5t-28.5 11.5q-3 1 -6.5 2t-7.5 1q-48 14 -92 42.5t-65 74.5v-279h-226v369q0 117 83.5 200t200.5 83q66 0 115.5 -47t49.5 -115q0 -31 -12 -60t-34 -51 q-4 -5 -7 -10.5t-3 -10.5v-1.5t1 -1.5v-1.5v-0.5q2 -6 7 -10.5t14 -5.5t18 -2.5t18 -4.5q63 -15 115.5 -58t51.5 -112v-1.5v-0.5v-1.5v-1.5q-1 -13 -3 -25t-7 -23h212v0zM343 490q0 23 -17.5 39t-40.5 16q-24 0 -41 -17t-17 -41v-22v-22v-22v-22q16 32 44.5 52.5t62.5 30.5 h1.5t0.5 1q3 0 5 2t2 5v0z" />
172 | <glyph unicode="&#xe0;" horiz-adv-x="789" d="M814 107q0 -44 -32 -75.5t-76 -31.5h-221q-21 0 -40.5 7t-34.5 20q-3 -1 -5.5 -2t-4.5 -2q-2 -2 -4.5 -3t-5.5 -2q-25 -9 -52 -13.5t-55 -4.5h-10.5t-10.5 1q-46 2 -91 17t-81 41q-41 30 -65 71.5t-24 89.5t24 89.5t65 71.5q36 26 81 41t91 18h10.5h10.5q21 0 42 -2.5 t40 -7.5v9h214v-332h235v0zM365 123v194q-16 8 -30.5 11.5t-28.5 2.5q-42 0 -64.5 -32t-22.5 -79q0 -46 22.5 -79t65.5 -32q13 0 27.5 3.5t30.5 10.5v0zM416 528l-29 -68l-208 69l47 111l190 -112v0z" />
173 | <glyph unicode="&#xe1;" horiz-adv-x="789" d="M814 107q0 -44 -32 -75.5t-76 -31.5h-221q-21 0 -40.5 7t-34.5 20q-3 -1 -5.5 -2t-4.5 -2q-2 -2 -4.5 -3t-5.5 -2q-25 -9 -52 -13.5t-55 -4.5h-10.5t-10.5 1q-46 2 -91 17t-81 41q-41 30 -65 71.5t-24 89.5t24 89.5t65 71.5q36 26 81 41t91 18h10.5h10.5q21 0 42 -2.5 t40 -7.5v9h214v-332h235v0zM365 123v194q-16 8 -30.5 11.5t-28.5 2.5q-42 0 -64.5 -32t-22.5 -79q0 -46 22.5 -79t65.5 -32q13 0 27.5 3.5t30.5 10.5v0zM512 529l-208 -69l-29 68l190 112l47 -111v0z" />
174 | <glyph unicode="&#xe2;" horiz-adv-x="789" d="M814 107q0 -44 -32 -75.5t-76 -31.5h-221q-21 0 -40.5 7t-34.5 20q-3 -1 -5.5 -2t-4.5 -2q-2 -2 -4.5 -3t-5.5 -2q-25 -9 -52 -13.5t-55 -4.5h-10.5t-10.5 1q-46 2 -91 17t-81 41q-41 30 -65 71.5t-24 89.5t24 89.5t65 71.5q36 26 81 41t91 18h10.5h10.5q21 0 42 -2.5 t40 -7.5v9h214v-332h235v0zM365 123v194q-16 8 -30.5 11.5t-28.5 2.5q-42 0 -64.5 -32t-22.5 -79q0 -46 22.5 -79t65.5 -32q13 0 27.5 3.5t30.5 10.5v0zM426 462h-96l-34 25l-33 -25h-95v23l128 112l130 -113v-22v0z" />
175 | <glyph unicode="&#xe3;" horiz-adv-x="789" d="M814 107q0 -44 -32 -75.5t-76 -31.5h-221q-21 0 -40.5 7t-34.5 20q-3 -1 -5.5 -2t-4.5 -2q-2 -2 -4.5 -3t-5.5 -2q-25 -9 -52 -13.5t-55 -4.5h-10.5t-10.5 1q-46 2 -91 17t-81 41q-41 30 -65 71.5t-24 89.5t24 89.5t65 71.5q36 26 81 41t91 18h10.5h10.5q21 0 42 -2.5 t40 -7.5v9h214v-332h235v0zM365 123v194q-16 8 -30.5 11.5t-28.5 2.5q-42 0 -64.5 -32t-22.5 -79q0 -46 22.5 -79t65.5 -32q13 0 27.5 3.5t30.5 10.5v0zM437 523q0 -4 -0.5 -8.5t-1.5 -9.5q-3 -9 -8 -17t-13 -13t-17 -8t-19 -3q-4 0 -8.5 1t-9.5 2l-139 42v-36h-66v78 q0 14 6 27t18 21q8 6 16.5 8.5t17.5 2.5q5 0 10 -0.5t9 -2.5l140 -42v36h65v-78v0z" />
176 | <glyph unicode="&#xe4;" horiz-adv-x="789" d="M814 107q0 -44 -32 -75.5t-76 -31.5h-221q-21 0 -40.5 7t-34.5 20q-3 -1 -5.5 -2t-4.5 -2q-2 -2 -4.5 -3t-5.5 -2q-25 -9 -52 -13.5t-55 -4.5h-10.5t-10.5 1q-46 2 -91 17t-81 41q-41 30 -65 71.5t-24 89.5t24 89.5t65 71.5q36 26 81 41t91 18h10.5h10.5q21 0 42 -2.5 t40 -7.5v9h214v-332h235v0zM365 123v194q-16 8 -30.5 11.5t-28.5 2.5q-42 0 -64.5 -32t-22.5 -79q0 -46 22.5 -79t65.5 -32q13 0 27.5 3.5t30.5 10.5v0zM333 465h-91v90h91v-90v0zM450 465h-90v90h90v-90v0z" />
177 | <glyph unicode="&#xe5;" horiz-adv-x="789" d="M814 107q0 -44 -32 -75.5t-76 -31.5h-221q-21 0 -40.5 7t-34.5 20q-3 -1 -5.5 -2t-4.5 -2q-2 -2 -4.5 -3t-5.5 -2q-25 -9 -52 -13.5t-55 -4.5h-10.5t-10.5 1q-46 2 -91 17t-81 41q-41 30 -65 71.5t-24 89.5t24 89.5t65 71.5q36 26 81 41t91 18h10.5h10.5q21 0 42 -2.5 t40 -7.5v9h214v-332h235v0zM365 123v194q-16 8 -30.5 11.5t-28.5 2.5q-42 0 -64.5 -32t-22.5 -79q0 -46 22.5 -79t65.5 -32q13 0 27.5 3.5t30.5 10.5v0zM363 538q0 -32 -23 -55.5t-56 -23.5q-32 0 -55.5 23.5t-23.5 55.5q0 33 23.5 56.5t55.5 23.5q33 0 56 -23.5t23 -56.5v0 zM309 538q0 11 -7 18t-18 7q-10 0 -17 -7t-7 -18q0 -10 7 -17t17 -7q11 0 18 7t7 17v0z" />
178 | <glyph unicode="&#xe6;" horiz-adv-x="1055" d="M1106 107q0 -44 -32 -75.5t-76 -31.5h-322v0h-1q-58 0 -112.5 10t-104.5 44q-6 -3 -12 -6.5t-12 -6.5q-12 -6 -23.5 -12t-24.5 -11q-25 -9 -52 -13.5t-55 -4.5h-10.5t-10.5 1q-46 2 -91 17t-81 41q-41 30 -65 71.5t-24 89.5t24 89.5t65 71.5q34 25 76.5 40t86.5 18 q7 1 14.5 1h14.5q21 0 42 -2.5t40 -7.5v9h215v-6q17 4 35 5.5t36 1.5q49 0 95.5 -14t82.5 -44q37 -31 56.5 -73t19.5 -89v-31.5v-32.5h-308q11 -25 33 -37t50 -12h431v0zM360 123v194q-16 8 -30.5 11.5t-27.5 2.5q-42 0 -64.5 -32t-22.5 -79q0 -46 22.5 -79t64.5 -32 q13 0 27.5 3.5t30.5 10.5v0zM707 263q-3 15 -7 27.5t-11 22.5q-7 11 -19 15.5t-26 4.5q-13 0 -24.5 -5t-18.5 -15t-11.5 -22.5t-6.5 -27.5h124v0z" />
179 | <glyph unicode="&#xe7;" horiz-adv-x="763" d="M467 -133q0 -47 -31 -81.5t-81 -34.5q-22 0 -42 8.5t-34 22.5l14 57q3 0 6.5 -1.5t7.5 -3.5q2 -1 4.5 -2t5.5 -2q5 -1 9 -2t8 -1q20 0 29.5 12t9.5 29t-9.5 31t-29.5 14l-51 -1v112h72v-41q50 1 81 -32.5t31 -82.5v-1zM786 107q-1 -44 -32.5 -75.5t-75.5 -31.5h-362h-8.5 h-9.5q-52 2 -103.5 14t-96.5 42q-46 31 -71.5 73t-25.5 91t25.5 91t71.5 73q45 30 96.5 42.5t103.5 13.5h9.5h8.5q24 0 47 -4t44 -10v36l153 -1v-222h-91q-11 36 -40.5 65.5t-94.5 28.5q-46 0 -80 -32.5t-34 -80.5q0 -46 32.5 -79t78.5 -34h2h453v0z" />
180 | <glyph unicode="&#xe8;" horiz-adv-x="694" d="M734 107q-1 -44 -32.5 -75.5t-75.5 -31.5h-310h-1q-61 0 -117 11t-107 48q-45 32 -67.5 74.5t-22.5 86.5t22.5 86.5t67.5 74.5q35 26 81 41.5t94 17.5h9.5h9.5q50 0 96 -14t83 -44q37 -31 56.5 -73t19.5 -89v-31.5v-32.5h-308q11 -25 32.5 -37t49.5 -12h420v0zM346 263 q-2 15 -6.5 27.5t-10.5 22.5q-7 9 -17.5 14t-21.5 6h-3.5h-2.5q-13 0 -24.5 -5t-18.5 -15t-11.5 -22.5t-6.5 -27.5h123v0zM311 528l-29 -68l-208 69l47 111l190 -112v0z" />
181 | <glyph unicode="&#xe9;" horiz-adv-x="694" d="M734 107q-1 -44 -32.5 -75.5t-75.5 -31.5h-310h-1q-61 0 -117 11t-107 48q-45 32 -67.5 74.5t-22.5 86.5t22.5 86.5t67.5 74.5q35 26 81 41.5t94 17.5h9.5h9.5q50 0 96 -14t83 -44q37 -31 56.5 -73t19.5 -89v-31.5v-32.5h-308q11 -25 32.5 -37t49.5 -12h420v0zM346 263 q-2 15 -6.5 27.5t-10.5 22.5q-7 9 -17.5 14t-21.5 6h-3.5h-2.5q-13 0 -24.5 -5t-18.5 -15t-11.5 -22.5t-6.5 -27.5h123v0zM488 529l-208 -69l-29 68l190 112l47 -111v0z" />
182 | <glyph unicode="&#xea;" horiz-adv-x="694" d="M734 107q-1 -44 -32.5 -75.5t-75.5 -31.5h-310h-1q-61 0 -117 11t-107 48q-45 32 -67.5 74.5t-22.5 86.5t22.5 86.5t67.5 74.5q35 26 81 41.5t94 17.5h9.5h9.5q50 0 96 -14t83 -44q37 -31 56.5 -73t19.5 -89v-31.5v-32.5h-308q11 -25 32.5 -37t49.5 -12h420v0zM346 263 q-2 15 -6.5 27.5t-10.5 22.5q-7 9 -17.5 14t-21.5 6h-3.5h-2.5q-13 0 -24.5 -5t-18.5 -15t-11.5 -22.5t-6.5 -27.5h123v0zM414 462h-96l-34 25l-33 -25h-95v23l128 112l130 -113v-22v0z" />
183 | <glyph unicode="&#xeb;" horiz-adv-x="694" d="M734 107q-1 -44 -32.5 -75.5t-75.5 -31.5h-310h-1q-61 0 -117 11t-107 48q-45 32 -67.5 74.5t-22.5 86.5t22.5 86.5t67.5 74.5q35 26 81 41.5t94 17.5h9.5h9.5q50 0 96 -14t83 -44q37 -31 56.5 -73t19.5 -89v-31.5v-32.5h-308q11 -25 32.5 -37t49.5 -12h420v0zM346 263 q-2 15 -6.5 27.5t-10.5 22.5q-7 9 -17.5 14t-21.5 6h-3.5h-2.5q-13 0 -24.5 -5t-18.5 -15t-11.5 -22.5t-6.5 -27.5h123v0zM285 459h-91v90h91v-90v0zM402 459h-90v90h90v-90v0z" />
184 | <glyph unicode="&#xec;" horiz-adv-x="370" d="M403 107q-1 -44 -32.5 -75.5t-75.5 -31.5h-174q-50 0 -85.5 35.5t-35.5 85.5v318h215v-332h188v0zM158 528l-29 -68l-208 69l47 111l190 -112v0z" />
185 | <glyph unicode="&#xed;" horiz-adv-x="370" d="M403 107q-1 -44 -32.5 -75.5t-75.5 -31.5h-174q-50 0 -85.5 35.5t-35.5 85.5v318h215v-332h188v0zM314 526l-208 -69l-29 68l190 112l47 -111v0z" />
186 | <glyph unicode="&#xee;" horiz-adv-x="370" d="M403 107q-1 -44 -32.5 -75.5t-75.5 -31.5h-174q-50 0 -85.5 35.5t-35.5 85.5v318h215v-332h188v0zM240 460h-96l-34 25l-33 -25h-95v23l128 112l130 -113v-22v0z" />
187 | <glyph unicode="&#xef;" horiz-adv-x="370" d="M403 107q-1 -44 -32.5 -75.5t-75.5 -31.5h-174q-50 0 -85.5 35.5t-35.5 85.5v318h215v-332h188v0zM94 459h-91v90h91v-90v0zM211 459h-90v90h90v-90v0z" />
188 | <glyph unicode="&#xf0;" horiz-adv-x="705" d="M755 107q0 -42 -28 -74.5t-69 -32.5h-186q-19 0 -35.5 6t-30.5 16q-24 -9 -50.5 -14.5t-53.5 -6.5q-6 -1 -11.5 -1h-10.5h-6h-6q-49 2 -96 16.5t-85 42.5q-42 30 -64 70t-24 82v5.5v4.5q0 44 21.5 86t66.5 74q38 27 88 43t106 16h68v51h-91l22 34h69v32h-112v107h206 q50 0 85.5 -35.5t35.5 -85.5v-18h86l-22 -34h-64v-273q-1 -30 -11 -58t-29 -53h231v0zM346 220q0 9 -2 22t-5 26q-7 24 -21 44.5t-37 20.5t-37 -20t-21 -44q-3 -14 -5 -27t-2 -22t1.5 -22t5.5 -26q7 -24 21 -44.5t37 -20.5h1v0q22 0 36 20t21 44q3 14 5 27t2 22v0z" />
189 | <glyph unicode="&#xf1;" horiz-adv-x="743" d="M781 107q-1 -44 -32.5 -75.5t-75.5 -31.5h-316v239q0 7 -0.5 15t-1.5 17q-1 14 -6 27t-14 22q-7 7 -16.5 10t-20.5 3q-4 0 -8 -0.5t-8 -1.5q-11 -2 -22 -5t-20 -7q-5 -2 -9 -3.5t-8 -3.5v-312h-222v440h222v-14q27 8 56 13t58 5q40 0 78 -9.5t72 -31.5q38 -25 61 -63 t23 -84v-149h210v0zM410 520q0 -4 -0.5 -8.5t-1.5 -9.5q-3 -9 -8 -17t-13 -13t-17 -8t-19 -3q-4 0 -8.5 1t-9.5 2l-139 42v-36h-66v78q0 14 6 27t18 21q8 6 16.5 8.5t17.5 2.5q5 0 10 -0.5t9 -2.5l140 -42v36h65v-78v0z" />
190 | <glyph unicode="&#xf2;" horiz-adv-x="732" d="M775 440q-1 -44 -32.5 -75.5t-75.5 -31.5h-137q20 -26 30 -56t10 -62v-4v-3q-2 -48 -25.5 -92.5t-64.5 -74.5t-91.5 -44t-103.5 -14q-52 0 -101.5 14.5t-90.5 43.5q-44 32 -67 77.5t-23 93.5q0 47 22.5 92t67.5 77q38 27 88 43t105 16h489v0zM351 211q0 10 -2 24.5 t-6 29.5q-7 25 -20.5 46.5t-35.5 21.5t-36 -21t-21 -47q-4 -15 -6 -29.5t-2 -24.5t2 -24.5t6 -29.5q7 -25 20.5 -46.5t35.5 -21.5h1v0q22 0 35.5 21.5t20.5 46.5q4 15 6 29.5t2 24.5v0zM356 528l-29 -68l-208 69l47 111l190 -112v0z" />
191 | <glyph unicode="&#xf3;" horiz-adv-x="732" d="M775 440q-1 -44 -32.5 -75.5t-75.5 -31.5h-137q20 -26 30 -56t10 -62v-4v-3q-2 -48 -25.5 -92.5t-64.5 -74.5t-91.5 -44t-103.5 -14q-52 0 -101.5 14.5t-90.5 43.5q-44 32 -67 77.5t-23 93.5q0 47 22.5 92t67.5 77q38 27 88 43t105 16h489v0zM351 211q0 10 -2 24.5 t-6 29.5q-7 25 -20.5 46.5t-35.5 21.5t-36 -21t-21 -47q-4 -15 -6 -29.5t-2 -24.5t2 -24.5t6 -29.5q7 -25 20.5 -46.5t35.5 -21.5h1v0q22 0 35.5 21.5t20.5 46.5q4 15 6 29.5t2 24.5v0zM521 529l-208 -69l-29 68l190 112l47 -111v0z" />
192 | <glyph unicode="&#xf4;" horiz-adv-x="732" d="M775 440q-1 -44 -32.5 -75.5t-75.5 -31.5h-137q20 -26 30 -56t10 -62v-4v-3q-2 -48 -25.5 -92.5t-64.5 -74.5t-91.5 -44t-103.5 -14q-52 0 -101.5 14.5t-90.5 43.5q-44 32 -67 77.5t-23 93.5q0 47 22.5 92t67.5 77q38 27 88 43t105 16h489v0zM351 211q0 10 -2 24.5 t-6 29.5q-7 25 -20.5 46.5t-35.5 21.5t-36 -21t-21 -47q-4 -15 -6 -29.5t-2 -24.5t2 -24.5t6 -29.5q7 -25 20.5 -46.5t35.5 -21.5h1v0q22 0 35.5 21.5t20.5 46.5q4 15 6 29.5t2 24.5v0zM423 462h-96l-34 25l-33 -25h-95v23l128 112l130 -113v-22v0z" />
193 | <glyph unicode="&#xf5;" horiz-adv-x="732" d="M775 440q-1 -44 -32.5 -75.5t-75.5 -31.5h-137q20 -26 30 -56t10 -62v-4v-3q-2 -48 -25.5 -92.5t-64.5 -74.5t-91.5 -44t-103.5 -14q-52 0 -101.5 14.5t-90.5 43.5q-44 32 -67 77.5t-23 93.5q0 47 22.5 92t67.5 77q38 27 88 43t105 16h489v0zM351 211q0 10 -2 24.5 t-6 29.5q-7 25 -20.5 46.5t-35.5 21.5t-36 -21t-21 -47q-4 -15 -6 -29.5t-2 -24.5t2 -24.5t6 -29.5q7 -25 20.5 -46.5t35.5 -21.5h1v0q22 0 35.5 21.5t20.5 46.5q4 15 6 29.5t2 24.5v0zM437 520q0 -4 -0.5 -8.5t-1.5 -9.5q-3 -9 -8 -17t-13 -13t-17 -8t-19 -3q-4 0 -8.5 1 t-9.5 2l-139 42v-36h-66v78q0 14 6 27t18 21q8 6 16.5 8.5t17.5 2.5q5 0 10 -0.5t9 -2.5l140 -42v36h65v-78v0z" />
194 | <glyph unicode="&#xf6;" horiz-adv-x="732" d="M775 440q-1 -44 -32.5 -75.5t-75.5 -31.5h-137q20 -26 30 -56t10 -62v-4v-3q-2 -48 -25.5 -92.5t-64.5 -74.5t-91.5 -44t-103.5 -14q-52 0 -101.5 14.5t-90.5 43.5q-44 32 -67 77.5t-23 93.5q0 47 22.5 92t67.5 77q38 27 88 43t105 16h489v0zM351 211q0 10 -2 24.5 t-6 29.5q-7 25 -20.5 46.5t-35.5 21.5t-36 -21t-21 -47q-4 -15 -6 -29.5t-2 -24.5t2 -24.5t6 -29.5q7 -25 20.5 -46.5t35.5 -21.5h1v0q22 0 35.5 21.5t20.5 46.5q4 15 6 29.5t2 24.5v0zM297 459h-91v90h91v-90v0zM414 459h-90v90h90v-90v0z" />
195 | <glyph unicode="&#xf7;" />
196 | <glyph unicode="&#xf8;" horiz-adv-x="733" d="M774 440q0 -44 -31.5 -75.5t-75.5 -31.5h-140q16 -21 25.5 -43.5t12.5 -45.5q1 -6 1.5 -11.5t0.5 -11.5q0 -46 -23.5 -88.5t-66.5 -73.5q-41 -29 -91.5 -44t-103.5 -15q-40 0 -78 8.5t-73 25.5l-87 -87h-60l109 109l-1.5 1.5t-2.5 1.5q-44 32 -66.5 74.5t-22.5 87.5v5.5 v4.5q3 41 25 80.5t64 69.5q38 27 88 43t106 16h194l86 86h59l-85 -86h237v0zM348 220q0 6 -0.5 13.5t-2.5 14.5l-107 -107q8 -15 19 -24.5t27 -9.5q22 0 36 20t21 44q3 14 5 27t2 22v0zM331 294q-7 17 -19 28t-29 11q-22 0 -36 -20t-21 -44q-4 -14 -6 -27t-2 -22 q0 -7 1.5 -16t2.5 -19l109 109v0z" />
197 | <glyph unicode="&#xf9;" horiz-adv-x="704" d="M761 107q0 -44 -32 -75.5t-76 -31.5h-307v14q-31 -10 -63.5 -14t-65.5 -4q-9 0 -18.5 0.5t-19.5 1.5q-62 6 -115 38t-64 100q0 8 -0.5 14t-0.5 12l-1 278h214v-262q0 -25 4 -40.5t12 -22.5q6 -5 14.5 -7.5t18.5 -2.5q6 0 12.5 1t12.5 2q10 2 20 5t18 6q7 3 12.5 5t9.5 4 v312h222v-333h193v0zM329 528l-29 -68l-208 69l47 111l190 -112v0z" />
198 | <glyph unicode="&#xfa;" horiz-adv-x="704" d="M761 107q0 -44 -32 -75.5t-76 -31.5h-307v14q-31 -10 -63.5 -14t-65.5 -4q-9 0 -18.5 0.5t-19.5 1.5q-62 6 -115 38t-64 100q0 8 -0.5 14t-0.5 12l-1 278h214v-262q0 -25 4 -40.5t12 -22.5q6 -5 14.5 -7.5t18.5 -2.5q6 0 12.5 1t12.5 2q10 2 20 5t18 6q7 3 12.5 5t9.5 4 v312h222v-333h193v0zM476 526l-208 -69l-29 68l190 112l47 -111v0z" />
199 | <glyph unicode="&#xfb;" horiz-adv-x="704" d="M761 107q0 -44 -32 -75.5t-76 -31.5h-307v14q-31 -10 -63.5 -14t-65.5 -4q-9 0 -18.5 0.5t-19.5 1.5q-62 6 -115 38t-64 100q0 8 -0.5 14t-0.5 12l-1 278h214v-262q0 -25 4 -40.5t12 -22.5q6 -5 14.5 -7.5t18.5 -2.5q6 0 12.5 1t12.5 2q10 2 20 5t18 6q7 3 12.5 5t9.5 4 v312h222v-333h193v0zM408 462h-96l-34 25l-33 -25h-95v23l128 112l130 -113v-22v0z" />
200 | <glyph unicode="&#xfc;" horiz-adv-x="704" d="M761 107q0 -44 -32 -75.5t-76 -31.5h-307v14q-31 -10 -63.5 -14t-65.5 -4q-9 0 -18.5 0.5t-19.5 1.5q-62 6 -115 38t-64 100q0 8 -0.5 14t-0.5 12l-1 278h214v-262q0 -25 4 -40.5t12 -22.5q6 -5 14.5 -7.5t18.5 -2.5q6 0 12.5 1t12.5 2q10 2 20 5t18 6q7 3 12.5 5t9.5 4 v312h222v-333h193v0zM267 465h-91v90h91v-90v0zM384 465h-90v90h90v-90v0z" />
201 | <glyph unicode="&#xfd;" horiz-adv-x="222" />
202 | <glyph unicode="&#xfe;" horiz-adv-x="717" d="M770 107q0 -44 -31.5 -75.5t-76.5 -31.5h-449v-228l-214 1v892h214v-232q18 4 36.5 5.5t37.5 1.5h7.5h7.5q47 -2 93 -16.5t85 -42.5q41 -30 65.5 -71.5t24.5 -89.5q0 -31 -10 -59.5t-30 -53.5h240v0zM355 220q0 53 -22.5 82.5t-67.5 29.5q-11 0 -24.5 -2t-27.5 -7v-210 q11 -1 21.5 -2.5t20.5 -1.5q50 1 75 27.5t25 83.5v0z" />
203 | <glyph unicode="&#xff;" horiz-adv-x="742" d="M792 107q-1 -44 -32.5 -75.5t-75.5 -31.5h-127v-61q0 -37 -19.5 -69.5t-53.5 -54.5q-32 -22 -71 -32.5t-80 -10.5q-40 0 -78 11t-70 32q-35 23 -54.5 56.5t-19.5 69.5q0 22 8.5 44t24.5 43q-58 25 -101 75t-43 117v220h213v-54.5v-55.5v-55.5v-54.5q0 -29 5.5 -52 t18.5 -37q11 -13 27 -18.5t33 -5.5h6t6 1q12 1 24 3.5t22 5.5v323h202v-333h235v0zM355 -121v121q-29 0 -57 -3.5t-54 -19.5q-13 -9 -19.5 -18t-5.5 -19q0 -3 0.5 -6t2.5 -6q2 -6 8 -12.5t14 -11.5q15 -11 33 -16.5t36 -7.5q5 0 10.5 -0.5t10.5 -0.5h10.5t10.5 1v-1z M279 462h-91v90h91v-90v0zM396 462h-90v90h90v-90v0z" />
204 | <glyph unicode="&#x152;" horiz-adv-x="952" d="M896 0h-329q-37 0 -70.5 11.5t-61.5 32.5q-33 -21 -71 -32.5t-80 -11.5q-117 0 -200 83t-83 200v100q0 117 83 200.5t200 83.5q50 0 94 -16t81 -45q22 27 55 44t73 17h309v-107h-193q-25 0 -38 -19t-12 -42v-1.5v-1.5q1 -21 13.5 -38.5t36.5 -17.5h193v-107h-193 q-49 0 -74 -35.5t-24 -78.5q0 -42 24.5 -77t73.5 -35h193v-107v0zM343 165v336q0 24 -17.5 41.5t-41.5 17.5t-41 -17.5t-17 -41.5v-336q0 -24 17 -41t41 -17t41.5 17t17.5 41v0z" />
205 | <glyph unicode="&#x153;" horiz-adv-x="1057" d="M1115 107q0 -44 -32 -75.5t-76 -31.5h-335q-56 0 -108 9t-100 39q-36 -22 -77.5 -34t-83.5 -14h-8h-8q-52 0 -102 15t-91 44q-44 32 -67 74.5t-23 87.5v5.5v4.5q3 41 25.5 80.5t64.5 69.5q38 27 87.5 43t105.5 16h389q41 0 77.5 -16.5t66.5 -41.5q37 -31 56.5 -73 t19.5 -89v-31.5v-32.5h-308q11 -25 33 -37t50 -12h444v0zM352 220q0 9 -1.5 22t-5.5 26q-7 24 -21 44.5t-37 20.5q-22 0 -36 -20t-21 -44q-3 -14 -5 -27t-2 -22t1.5 -22t5.5 -26q7 -24 20.5 -44.5t36.5 -20.5h1v0q22 0 36 20t21 44q3 14 5 27t2 22v0zM703 263q-3 15 -7 27.5 t-11 22.5t-18 14.5t-23 5.5h-6q-12 -1 -23 -5.5t-18 -14.5t-11 -22.5t-7 -27.5h124v0z" />
206 | <glyph unicode="&#x178;" horiz-adv-x="624" d="M566 -105q0 -49 -35 -84.5t-85 -35.5l-220 -1v107h116v107q-16 -3 -33 -4.5t-35 -1.5q-9 0 -17.5 0.5t-17.5 1.5q-45 4 -87 18.5t-73 39.5q-37 29 -58 73.5t-21 105.5l-1 446h226v-520q0 -24 17 -41t42 -17q23 0 40.5 16.5t17.5 40.5v521h224v-772v0zM288 672h-91v90h91 v-90v0zM405 672h-90v90h90v-90v0z" />
207 | <glyph unicode="&#x2c6;" horiz-adv-x="310" d="M296 733q0 -4 -0.5 -8.5t-1.5 -9.5q-3 -9 -8 -17t-13 -13t-17 -8t-19 -3q-4 0 -8.5 1t-9.5 2l-139 42v-36h-66v78q0 14 6 27t18 21q8 6 16.5 8.5t17.5 2.5q5 0 10 -0.5t9 -2.5l140 -42v36h65v-78v0z" />
208 | <glyph unicode="&#x2dc;" horiz-adv-x="310" d="M285 684h-96l-34 25l-33 -25h-95v23l128 112l130 -113v-22v0z" />
209 | <glyph unicode="&#x2000;" horiz-adv-x="441" />
210 | <glyph unicode="&#x2001;" horiz-adv-x="882" />
211 | <glyph unicode="&#x2002;" horiz-adv-x="441" />
212 | <glyph unicode="&#x2003;" horiz-adv-x="882" />
213 | <glyph unicode="&#x2004;" horiz-adv-x="294" />
214 | <glyph unicode="&#x2005;" horiz-adv-x="220" />
215 | <glyph unicode="&#x2006;" horiz-adv-x="147" />
216 | <glyph unicode="&#x2007;" horiz-adv-x="147" />
217 | <glyph unicode="&#x2008;" horiz-adv-x="110" />
218 | <glyph unicode="&#x2009;" horiz-adv-x="176" />
219 | <glyph unicode="&#x200a;" horiz-adv-x="49" />
220 | <glyph unicode="&#x2010;" horiz-adv-x="236" d="M226 241h-215v107h215v-107v0z" />
221 | <glyph unicode="&#x2011;" horiz-adv-x="236" d="M226 241h-215v107h215v-107v0z" />
222 | <glyph unicode="&#x2012;" horiz-adv-x="236" d="M226 241h-215v107h215v-107v0z" />
223 | <glyph unicode="&#x2013;" horiz-adv-x="453" d="M444 241h-430v107h430v-107v0z" />
224 | <glyph unicode="&#x2014;" horiz-adv-x="845" d="M859 241h-860v107h860v-107v0z" />
225 | <glyph unicode="&#x2018;" horiz-adv-x="184" d="M5 548q0 9 4 17.5t9 15.5l90 124l59 -80l-23 -31q12 -8 19 -20t7 -26q0 -26 -24 -44.5t-58 -18.5t-58.5 18.5t-24.5 44.5v0z" />
226 | <glyph unicode="&#x2019;" horiz-adv-x="184" d="M171 622q0 -9 -4 -17t-9 -16l-90 -124l-59 80l23 31q-12 8 -19 20.5t-7 25.5q0 26 24 44.5t58 18.5q35 0 59 -18.5t24 -44.5v0z" />
227 | <glyph unicode="&#x201a;" horiz-adv-x="184" d="M171 42q0 -9 -4 -17t-9 -16l-90 -124l-59 80l23 31q-12 8 -19 20.5t-7 25.5q0 26 24 44.5t58 18.5q35 0 59 -18.5t24 -44.5v0z" />
228 | <glyph unicode="&#x201c;" horiz-adv-x="371" d="M171 622q0 -9 -4 -17t-9 -16l-90 -124l-59 80l23 31q-12 8 -19 20.5t-7 25.5q0 26 24 44.5t58 18.5q35 0 59 -18.5t24 -44.5v0zM351 622q0 -9 -4 -17t-9 -16l-90 -124l-59 80l23 31q-12 8 -19 20.5t-7 25.5q0 26 24 44.5t58 18.5q35 0 59 -18.5t24 -44.5v0z" />
229 | <glyph unicode="&#x201d;" horiz-adv-x="361" d="M5 548q0 9 4 17.5t9 15.5l90 124l59 -80l-23 -31q12 -8 19 -20t7 -26q0 -26 -24 -44.5t-58 -18.5t-58.5 18.5t-24.5 44.5v0zM185 548q0 9 4 17.5t9 15.5l90 124l59 -80l-23 -31q12 -8 19 -20t7 -26q0 -26 -24 -44.5t-58 -18.5t-58.5 18.5t-24.5 44.5v0z" />
230 | <glyph unicode="&#x201e;" horiz-adv-x="365" d="M171 32q0 -9 -4 -17t-9 -15l-90 -125l-59 80l23 31q-12 9 -19 21t-7 25q0 26 24 44.5t58 18.5q35 0 59 -18.5t24 -44.5v0zM351 32q0 -9 -4 -17t-9 -15l-90 -125l-59 80l23 31q-12 9 -19 21t-7 25q0 26 24 44.5t58 18.5q35 0 59 -18.5t24 -44.5v0z" />
231 | <glyph unicode="&#x2022;" horiz-adv-x="270" d="M252 294q0 -47 -33.5 -80.5t-80.5 -33.5t-80.5 33.5t-33.5 80.5t33.5 80.5t80.5 33.5t80.5 -33.5t33.5 -80.5v0z" />
232 | <glyph unicode="&#x2026;" horiz-adv-x="512" d="M172 52q0 -26 -20.5 -44.5t-49.5 -18.5t-50 18.5t-21 44.5t21 44.5t50 18.5t49.5 -18.5t20.5 -44.5v0zM337 52q0 -26 -20.5 -44.5t-49.5 -18.5t-50 18.5t-21 44.5t21 44.5t50 18.5t49.5 -18.5t20.5 -44.5v0zM502 52q0 -26 -20.5 -44.5t-49.5 -18.5t-50 18.5t-21 44.5 t21 44.5t50 18.5t49.5 -18.5t20.5 -44.5v0z" />
233 | <glyph unicode="&#x202f;" horiz-adv-x="176" />
234 | <glyph unicode="&#x2039;" horiz-adv-x="292" d="M278 195l-75 -75l-190 189l190 190l75 -76l-113 -114l113 -114v0z" />
235 | <glyph unicode="&#x203a;" horiz-adv-x="292" d="M12 195l113 114l-113 114l75 76l190 -190l-190 -189l-75 75v0z" />
236 | <glyph unicode="&#x205f;" horiz-adv-x="220" />
237 | <glyph unicode="&#x2122;" />
238 | <glyph unicode="&#xe000;" horiz-adv-x="440" d="M0 440h440v-440h-440v440z" />
239 | <hkern u1="F" u2="a" k="48" />
240 | <hkern u1="K" u2="a" k="22" />
241 | <hkern u1="P" u2="a" k="29" />
242 | <hkern u1="T" u2="y" k="83" />
243 | <hkern u1="T" u2="u" k="87" />
244 | <hkern u1="T" u2="r" k="89" />
245 | <hkern u1="T" u2="o" k="96" />
246 | <hkern u1="T" u2="e" k="93" />
247 | <hkern u1="T" u2="a" k="89" />
248 | </font>
249 | </defs></svg> 


--------------------------------------------------------------------------------