marty 2.5.2 → 2.5.4

data/spec/lib/delorean_query_spec.rb

@@ -1,14 +1,13 @@
-require "spec_helper"
+require 'spec_helper'
 
 module Marty
-
-bud_cats =<<EOF
+bud_cats = <<EOF
 name
 Conv Fixed 30
 Conv Fixed 20
 EOF
 
-fannie_bup =<<EOF
+fannie_bup = <<EOF
 bud_category	note_rate	buy_up	buy_down	settlement_mm	settlement_yy
 Conv Fixed 30	2.250	4.42000	7.24000	12	2012
 Conv Fixed 30	2.375	4.42000	7.24000	12	2012
@@ -19,7 +18,7 @@ Conv Fixed 20	2.875	4.24800	6.95900	12	2012
 Conv Fixed 20	2.875	4.24800	6.95900	11	2012
 EOF
 
-script =<<EOF
+script = <<EOF
 A:
     c = Gemini::FannieBup.
       joins("bud_category").
@@ -75,119 +74,118 @@ A:
       mcfly_pt('01-01-2003').count
 EOF
 
-  describe 'DeloreanQuery' do
-    before(:all) do
-      @clean_file = "/tmp/clean_#{Process.pid}.psql"
-      save_clean_db(@clean_file)
-    end
-
-    before(:each) do
-      marty_whodunnit
-      Marty::DataImporter.do_import_summary(Gemini::BudCategory, bud_cats)
-      Marty::DataImporter.do_import_summary(Gemini::FannieBup, fannie_bup)
-
-      Marty::Script.load_script_bodies(
-        {
-          "A" => script,
-        }, Date.today)
-
-      @engine = Marty::ScriptSet.new.get_engine("A")
-    end
-
-    after(:all) do
-      restore_clean_db(@clean_file)
-      Marty::ScriptSet.clear_cache
-    end
-
-    it "perfroms join+count" do
-      res = @engine.evaluate("A", "c", {})
-
-      expect(res).to eq Gemini::FannieBup.
-                          joins("bud_category").
-                          where("name LIKE '%30'").
-                          count
-
-    end
-
-    it "perfroms select+distinct" do
-      res = @engine.evaluate("A", "s", {})
-
-      expect(res).to eq Gemini::FannieBup.
-                          joins("bud_category").
-                          select("name").
-                          distinct("name").
-                          pluck("name")
-    end
-
-    it "perfroms mcfly_pt" do
-      res = @engine.evaluate("A", ["m", "mm"], {})
-
-      expect(res).to eq [
-                       Gemini::FannieBup.
-                         joins("bud_category").
-                         mcfly_pt('infinity').
-                         select("name").
-                         pluck("name"),
-                       Gemini::FannieBup.
-                         mcfly_pt('01-01-2003').count,
-                     ]
-    end
-
-    it "perfroms order+first" do
-      res = @engine.evaluate("A", "o", {})
-
-      expect(res).to eq Gemini::FannieBup.
-                          order("note_rate DESC", "buy_down ASC").
-                          select("note_rate").
-                          first.note_rate
-    end
-
-    it "perfroms order+find_by" do
-      res = @engine.evaluate("A", "oo", {})
-
-      expect(res).to eq Gemini::FannieBup.
-                          order("note_rate", "buy_down ASC").
-                          select("note_rate").
-                          find_by("obsoleted_dt = 'infinity'").
-                          note_rate
-    end
-
-    it "perfroms find_by on class" do
-      res = @engine.evaluate("A", "ooo", {})
-
-      expect(res).to eq Gemini::FannieBup.find_by(id: -1)
-    end
-
-    it "perfroms group+count" do
-      res = @engine.evaluate("A", "gg", {})
-
-      expect(res).
-        to eq Gemini::FannieBup.
-                select("settlement_yy*settlement_mm AS x, count(*) AS c").
-                group("settlement_mm", "settlement_yy").
-                order("settlement_mm").
-                map(&:attributes)
-    end
-
-    it "perfroms where+not" do
-      res = @engine.evaluate("A", "n", {})
-
-      expect(res).to eq Gemini::FannieBup.where.not("settlement_mm < 12").count
-    end
-
-    it "perfroms query+query" do
-      res = @engine.evaluate("A", ["q1", "q2"], {})
-
-      expect(res).to eq [
-                       [2.25, 2.375, 2.5, 2.625, 2.75, 2.875],
-                       [2.875, 2.75, 2.625, 2.5, 2.375, 2.25],
-                     ]
-    end
-
-    it "handle query params" do
-      res = @engine.evaluate("A", "pq",
-                             {"settlement_mm" => 12, "note_rate" => 2.5})
-      expect(res).to eq [2.625, 2.75, 2.875]
-    end
+describe 'DeloreanQuery' do
+  before(:all) do
+    @clean_file = "/tmp/clean_#{Process.pid}.psql"
+    save_clean_db(@clean_file)
+  end
+
+  before(:each) do
+    marty_whodunnit
+    Marty::DataImporter.do_import_summary(Gemini::BudCategory, bud_cats)
+    Marty::DataImporter.do_import_summary(Gemini::FannieBup, fannie_bup)
+
+    Marty::Script.load_script_bodies(
+      {
+        'A' => script,
+      }, Date.today)
+
+    @engine = Marty::ScriptSet.new.get_engine('A')
+  end
+
+  after(:all) do
+    restore_clean_db(@clean_file)
+    Marty::ScriptSet.clear_cache
+  end
+
+  it 'perfroms join+count' do
+    res = @engine.evaluate('A', 'c', {})
+
+    expect(res).to eq Gemini::FannieBup.
+                        joins('bud_category').
+                        where("name LIKE '%30'").
+                        count
+  end
+
+  it 'perfroms select+distinct' do
+    res = @engine.evaluate('A', 's', {})
+
+    expect(res).to eq Gemini::FannieBup.
+                        joins('bud_category').
+                        select('name').
+                        distinct('name').
+                        pluck('name')
+  end
+
+  it 'perfroms mcfly_pt' do
+    res = @engine.evaluate('A', ['m', 'mm'], {})
+
+    expect(res).to eq [
+      Gemini::FannieBup.
+        joins('bud_category').
+        mcfly_pt('infinity').
+        select('name').
+        pluck('name'),
+      Gemini::FannieBup.
+        mcfly_pt('01-01-2003').count,
+    ]
+  end
+
+  it 'perfroms order+first' do
+    res = @engine.evaluate('A', 'o', {})
+
+    expect(res).to eq Gemini::FannieBup.
+                        order('note_rate DESC', 'buy_down ASC').
+                        select('note_rate').
+                        first.note_rate
   end
+
+  it 'perfroms order+find_by' do
+    res = @engine.evaluate('A', 'oo', {})
+
+    expect(res).to eq Gemini::FannieBup.
+                        order('note_rate', 'buy_down ASC').
+                        select('note_rate').
+                        find_by("obsoleted_dt = 'infinity'").
+                        note_rate
+  end
+
+  it 'perfroms find_by on class' do
+    res = @engine.evaluate('A', 'ooo', {})
+
+    expect(res).to eq Gemini::FannieBup.find_by(id: -1)
+  end
+
+  it 'perfroms group+count' do
+    res = @engine.evaluate('A', 'gg', {})
+
+    expect(res).
+      to eq Gemini::FannieBup.
+              select('settlement_yy*settlement_mm AS x, count(*) AS c').
+              group('settlement_mm', 'settlement_yy').
+              order('settlement_mm').
+              map(&:attributes)
+  end
+
+  it 'perfroms where+not' do
+    res = @engine.evaluate('A', 'n', {})
+
+    expect(res).to eq Gemini::FannieBup.where.not('settlement_mm < 12').count
+  end
+
+  it 'perfroms query+query' do
+    res = @engine.evaluate('A', ['q1', 'q2'], {})
+
+    expect(res).to eq [
+      [2.25, 2.375, 2.5, 2.625, 2.75, 2.875],
+      [2.875, 2.75, 2.625, 2.5, 2.375, 2.25],
+    ]
+  end
+
+  it 'handle query params' do
+    res = @engine.evaluate('A', 'pq',
+                           'settlement_mm' => 12, 'note_rate' => 2.5)
+    expect(res).to eq [2.625, 2.75, 2.875]
+  end
+end
 end

data/spec/lib/json_schema_spec.rb

@@ -1,55 +1,52 @@
 require 'spec_helper'
 
 class MammalEnum
-  VALUES=Set['Dog','Cat','Human','Cow','Bear']
+  VALUES = Set['Dog', 'Cat', 'Human', 'Cow', 'Bear']
 end
 
 class ElectronicsEnum
-  VALUES=Set['Phone','Keyboard','Terminator']
+  VALUES = Set['Phone', 'Keyboard', 'Terminator']
 end
 
 class NotAnEnum
-  HI = "MOM"
+  HI = 'MOM'
 end
 
 module Marty
-
   describe JsonSchema do
-
     ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ###
     ###                      Generic, simple data               ###
     ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ###
 
     simple_schema = {
-      "$schema" => "http://json-schema.org/marty-draft/schema#",
-      "properties" => {
-        "a" => {
-          "type" => "integer"
+      '$schema' => 'http://json-schema.org/marty-draft/schema#',
+      'properties' => {
+        'a' => {
+          'type' => 'integer'
         },
       }
     }
-    opt = { :validate_schema    => true,
+    opt = { :validate_schema => true,
                 :errors_as_objects  => false,
                 :version            => Marty::JsonSchema::RAW_URI }
 
-    it "returns no error on correct simple data" do
-      data = {"a" => 5}
+    it 'returns no error on correct simple data' do
+      data = { 'a' => 5 }
       expect(JSON::Validator.fully_validate(simple_schema, data, opt)).to eq([])
     end
 
-    it "returns error on incorrect simple data -- 1" do
-      data = {"a" => 5.2}
+    it 'returns error on incorrect simple data -- 1' do
+      data = { 'a' => 5.2 }
       expect(JSON::Validator.
               fully_validate(simple_schema, data, opt)[0]).to include(
-      "property '#/a' of type number did not match the following type: integer")
+                "property '#/a' of type number did not match the following type: integer")
     end
 
-    it "returns error on incorrect simple data -- 2" do
-      data = {"a" => "Kangaroo"}
+    it 'returns error on incorrect simple data -- 2' do
+      data = { 'a' => 'Kangaroo' }
       expect(JSON::Validator.
               fully_validate(simple_schema, data, opt)[0]).to include(
-      "property '#/a' of type string did not match the following type: integer")
-
+                "property '#/a' of type string did not match the following type: integer")
     end
 
     ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ###
@@ -57,99 +54,99 @@ module Marty
     ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ###
 
     pg_schema_opt = {
-      "$schema" => "http://json-schema.org/marty-draft/schema#",
-      "properties" => {
-        "a" => {
-          "pg_enum" => "MammalEnum"
+      '$schema' => 'http://json-schema.org/marty-draft/schema#',
+      'properties' => {
+        'a' => {
+          'pg_enum' => 'MammalEnum'
         },
       }
     }
 
-    it "returns no error on correct existing enums" do
-      data = {"a" => 'Dog'}
+    it 'returns no error on correct existing enums' do
+      data = { 'a' => 'Dog' }
       expect(JSON::Validator.fully_validate(pg_schema_opt, data, opt)).to eq([])
     end
 
-    it "vacuously returns no error on a field not validated" do
-      data = {"b" => 'Dawg'}
+    it 'vacuously returns no error on a field not validated' do
+      data = { 'b' => 'Dawg' }
       expect(JSON::Validator.fully_validate(pg_schema_opt, data, opt)).to eq([])
     end
 
-    it "returns error on non-existant enums" do
-      data = {"a" => 'Beer'}
+    it 'returns error on non-existant enums' do
+      data = { 'a' => 'Beer' }
       expect(JSON::Validator.
               fully_validate(pg_schema_opt, data, opt)[0]).to include(
-         "property '#/a' value 'Beer' not contained in MammalEnum")
+                "property '#/a' value 'Beer' not contained in MammalEnum")
     end
 
-    it "returns no error when a optional field is not suppplied" do
+    it 'returns no error when a optional field is not suppplied' do
       data = {}
       expect(JSON::Validator.fully_validate(pg_schema_opt, data, opt)).to eq([])
     end
 
-    it "returns error when a nil enum is passed even when enum is optional" do
-      data = {"a" => nil}
+    it 'returns error when a nil enum is passed even when enum is optional' do
+      data = { 'a' => nil }
       expect(JSON::Validator.
               fully_validate(pg_schema_opt, data, opt)[0]).to include(
-        "property '#/a' value '' not contained in MammalEnum")
+                "property '#/a' value '' not contained in MammalEnum")
     end
 
     pg_schema_req = {
-      "$schema" => "http://json-schema.org/marty-draft/schema#",
-      "required" => ["a"],
-      "properties" => {
-        "a" => {
-          "pg_enum" => "MammalEnum"
+      '$schema' => 'http://json-schema.org/marty-draft/schema#',
+      'required' => ['a'],
+      'properties' => {
+        'a' => {
+          'pg_enum' => 'MammalEnum'
         },
       }
     }
 
-    it "returns error when a required field is not supplied" do
+    it 'returns error when a required field is not supplied' do
       data = {}
       expect(JSON::Validator.
               fully_validate(pg_schema_req, data, opt)[0]).to include(
-         "property '#/' did not contain a required property of 'a'")
+                "property '#/' did not contain a required property of 'a'")
     end
 
-    it "returns error when a nil enum is passed when enum is required" do
-      data = {"a" => nil}
+    it 'returns error when a nil enum is passed when enum is required' do
+      data = { 'a' => nil }
       expect(JSON::Validator.
               fully_validate(pg_schema_req, data, opt)[0]).to include(
-       "property '#/a' value '' not contained in MammalEnum")
+                "property '#/a' value '' not contained in MammalEnum")
     end
 
     pg_schema_req_bad = {
-      "$schema" => "http://json-schema.org/marty-draft/schema#",
-      "required" => ["a"],
-      "properties" => {
-        "a" => {
-          "pg_enum" => "NotAnEnum"
+      '$schema' => 'http://json-schema.org/marty-draft/schema#',
+      'required' => ['a'],
+      'properties' => {
+        'a' => {
+          'pg_enum' => 'NotAnEnum'
         },
       }
     }
 
-    it "returns raises meaningful error on schema enum error"  do
-      data = {"a" => nil}
+    it 'returns raises meaningful error on schema enum error'  do
+      data = { 'a' => nil }
       expect(JSON::Validator.
               fully_validate(pg_schema_req_bad, data, opt)[0]).to include(
-        "property '#/a': 'NotAnEnum' is not a pg_enum class")
+                "property '#/a': 'NotAnEnum' is not a pg_enum class")
     end
 
     pg_schema_req_bad2 = {
-      "$schema" => "http://json-schema.org/marty-draft/schema#",
-      "required" => ["a"],
-      "properties" => {
-        "a" => {
-          "pg_enum" => "NotEvenAClass"
+      '$schema' => 'http://json-schema.org/marty-draft/schema#',
+      'required' => ['a'],
+      'properties' => {
+        'a' => {
+          'pg_enum' => 'NotEvenAClass'
         },
       }
     }
 
-    it "returns raises meaningful error on schema enum error"  do
-      data = {"a" => nil}
+    it 'returns raises meaningful error on schema enum error'  do
+      data = { 'a' => nil }
       expect(JSON::Validator.
               fully_validate(pg_schema_req_bad2, data, opt)[0]).to include(
-         "property '#/a': 'NotEvenAClass' is not a pg_enum class")
+                "property '#/a': 'NotEvenAClass' is not a pg_enum class")
     end
 
     ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ###
@@ -157,74 +154,74 @@ module Marty
     ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ###
 
     date_schema_opt = {
-      "$schema" => "http://json-schema.org/marty-draft/schema#",
-      "properties" => {
-        "a" => {
-          "type"   => "string",
-          "format" => "date"
+      '$schema' => 'http://json-schema.org/marty-draft/schema#',
+      'properties' => {
+        'a' => {
+          'type'   => 'string',
+          'format' => 'date'
         }
       }
     }
 
-    it "returns true on a properly formatted date" do
-      data = {"a" => '2017-05-22'}
+    it 'returns true on a properly formatted date' do
+      data = { 'a' => '2017-05-22' }
       expect(JSON::Validator.validate(date_schema_opt, data)).to be true
     end
 
-    it "vacuously returns true on a field not validated" do
-      data = {"b" => 'Today is May 22nd'}
+    it 'vacuously returns true on a field not validated' do
+      data = { 'b' => 'Today is May 22nd' }
       expect(JSON::Validator.validate(date_schema_opt, data)).to be true
     end
 
-    it "returns error on an improperly formatted date" do
-      data = {"a" => '2017-05-32'}
+    it 'returns error on an improperly formatted date' do
+      data = { 'a' => '2017-05-32' }
       expect(JSON::Validator.
               fully_validate(date_schema_opt, data, opt)[0]).to include(
-        "property '#/a' must be a date in the format of YYYY-MM-DD")
+                "property '#/a' must be a date in the format of YYYY-MM-DD")
     end
 
-    it "returns error on an properly formatted datetime" do
-      data = {"a" => '2017-05-22T14:51:44Z'}
+    it 'returns error on an properly formatted datetime' do
+      data = { 'a' => '2017-05-22T14:51:44Z' }
       expect(JSON::Validator.
               fully_validate(date_schema_opt, data, opt)[0]).to include(
-        "property '#/a' must be a date in the format of YYYY-MM-DD")
+                "property '#/a' must be a date in the format of YYYY-MM-DD")
     end
 
-    it "returns true when an optional date is not supplied" do
+    it 'returns true when an optional date is not supplied' do
       data = {}
       expect(JSON::Validator.validate(date_schema_opt, data)).to be true
     end
 
-    it "returns error when a nil date is passed even when date is optional" do
-      data = {"a" => nil}
+    it 'returns error when a nil date is passed even when date is optional' do
+      data = { 'a' => nil }
       expect(JSON::Validator.
               fully_validate(date_schema_opt, data, opt)[0]).to include(
-         "property '#/a' of type null did not match the following type: string")
+                "property '#/a' of type null did not match the following type: string")
     end
 
     date_schema_req = {
-      "$schema" => "http://json-schema.org/marty-draft/schema#",
-      "required" => ["a"],
-      "properties" => {
-        "a" => {
-          "type"   => "string",
-          "format" => "date"
+      '$schema' => 'http://json-schema.org/marty-draft/schema#',
+      'required' => ['a'],
+      'properties' => {
+        'a' => {
+          'type'   => 'string',
+          'format' => 'date'
         }
       }
     }
 
-    it "returns error when a required date field is not supplied" do
+    it 'returns error when a required date field is not supplied' do
       data = {}
       expect(JSON::Validator.
               fully_validate(date_schema_req, data, opt)[0]).to include(
-         "property '#/' did not contain a required property of 'a'")
+                "property '#/' did not contain a required property of 'a'")
     end
 
-    it "returns error when a nil date is passed when date is required" do
-      data = {"a" => nil}
+    it 'returns error when a nil date is passed when date is required' do
+      data = { 'a' => nil }
       expect(JSON::Validator.
               fully_validate(date_schema_req, data, opt)[0]).to include(
-         "property '#/a' of type null did not match the following type: string")
+                "property '#/a' of type null did not match the following type: string")
     end
 
     ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ###
@@ -232,67 +229,67 @@ module Marty
     ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ###
 
     datetime_schema_opt = {
-      "$schema" => "http://json-schema.org/marty-draft/schema#",
-      "properties" => {
-        "a" => {
-          "type"   => "string",
-          "format" => "date-time"
+      '$schema' => 'http://json-schema.org/marty-draft/schema#',
+      'properties' => {
+        'a' => {
+          'type'   => 'string',
+          'format' => 'date-time'
         }
       }
     }
 
-    it "returns true on a properly formatted datetime" do
-      data = {"a" => '2017-05-22T14:51:44Z'}
+    it 'returns true on a properly formatted datetime' do
+      data = { 'a' => '2017-05-22T14:51:44Z' }
       expect(JSON::Validator.validate(datetime_schema_opt, data)).to be true
     end
 
-    it "vacuously returns true on a field not validated" do
-      data = {"b" => 'Today is May 22nd'}
+    it 'vacuously returns true on a field not validated' do
+      data = { 'b' => 'Today is May 22nd' }
       expect(JSON::Validator.validate(datetime_schema_opt, data)).to be true
     end
 
-    it "returns error on an improperly formatted datetime" do
-      data = {"a" => '2017-30-22T14:51:44Z'}
+    it 'returns error on an improperly formatted datetime' do
+      data = { 'a' => '2017-30-22T14:51:44Z' }
       expect(JSON::Validator.
               fully_validate(datetime_schema_opt, data, opt)[0]).to include(
-        "property '#/a' must be a date/time in the ISO-8601 format")
+                "property '#/a' must be a date/time in the ISO-8601 format")
     end
 
-    it "returns true when an opt field is not supplied" do
+    it 'returns true when an opt field is not supplied' do
       data = {}
       expect(JSON::Validator.validate(datetime_schema_opt, data)).to be true
     end
 
-    it "returns error when a nil dt is passed even when dt is opt" do
-      data = {"a" => nil}
+    it 'returns error when a nil dt is passed even when dt is opt' do
+      data = { 'a' => nil }
       expect(JSON::Validator.
               fully_validate(datetime_schema_opt, data, opt)[0]).to include(
-           "property '#/a' of type null did not match the following type: string")
+                "property '#/a' of type null did not match the following type: string")
     end
 
     datetime_schema_req = {
-      "$schema" => "http://json-schema.org/marty-draft/schema#",
-      "required" => ["a"],
-      "properties" => {
-        "a" => {
-          "type"   => "string",
-          "format" => "date-time"
+      '$schema' => 'http://json-schema.org/marty-draft/schema#',
+      'required' => ['a'],
+      'properties' => {
+        'a' => {
+          'type'   => 'string',
+          'format' => 'date-time'
         }
       }
     }
 
-    it "returns error when a required field is not supplied" do
+    it 'returns error when a required field is not supplied' do
       data = {}
       expect(JSON::Validator.
               fully_validate(datetime_schema_req, data, opt)[0]).to include(
-           "property '#/' did not contain a required property of 'a'")
+                "property '#/' did not contain a required property of 'a'")
     end
 
-    it "returns error when a nil dt is passed when dt is required" do
-      data = {"a" => nil}
+    it 'returns error when a nil dt is passed when dt is required' do
+      data = { 'a' => nil }
       expect(JSON::Validator.
               fully_validate(datetime_schema_req, data, opt)[0]).to include(
-        "property '#/a' of type null did not match the following type: string")
+                "property '#/a' of type null did not match the following type: string")
     end
 
     ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ###
@@ -300,119 +297,119 @@ module Marty
     ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ###
 
     pg_dt_schema = {
-      "$schema" => "http://json-schema.org/marty-draft/schema#",
-      "properties" => {
-        "a" => {
-          "pg_enum" => "MammalEnum"
+      '$schema' => 'http://json-schema.org/marty-draft/schema#',
+      'properties' => {
+        'a' => {
+          'pg_enum' => 'MammalEnum'
         },
-        "b" => {
-          "type"   => "string",
-          "format" => "date-time"
+        'b' => {
+          'type'   => 'string',
+          'format' => 'date-time'
         },
       }
     }
 
-    it "validates both pg_enum and dt format when both are correct" do
-      data = {"a" => 'Dog', "b" => '2017-05-22T14:51:44Z'}
+    it 'validates both pg_enum and dt format when both are correct' do
+      data = { 'a' => 'Dog', 'b' => '2017-05-22T14:51:44Z' }
       expect(JSON::Validator.validate(pg_dt_schema, data)).to be true
     end
 
-    it "validates both pg_enum and dt format when only enum is correct" do
-      data = {"a" => 'Dog', "b" => '2017-55-22T14:51:44Z'}
+    it 'validates both pg_enum and dt format when only enum is correct' do
+      data = { 'a' => 'Dog', 'b' => '2017-55-22T14:51:44Z' }
       expect(JSON::Validator.validate(pg_dt_schema, data)).to be false
     end
 
-    it "validates both pg_enum and dt format when only dt is correct" do
-      data = {"a" => 'Dogg', "b" => '2017-05-22T14:51:44Z'}
+    it 'validates both pg_enum and dt format when only dt is correct' do
+      data = { 'a' => 'Dogg', 'b' => '2017-05-22T14:51:44Z' }
       expect(JSON::Validator.validate(pg_dt_schema, data)).to be false
     end
 
-    it "validates both pg_enum and dt format when neither is correct" do
-      data = {"a" => 'Dogg', "b" => '2017-55-22T14:51:44Z'}
+    it 'validates both pg_enum and dt format when neither is correct' do
+      data = { 'a' => 'Dogg', 'b' => '2017-55-22T14:51:44Z' }
       expect(JSON::Validator.validate(pg_dt_schema, data)).to be false
     end
 
     pg_dt_int_schema = {
-      "$schema" => "http://json-schema.org/marty-draft/schema#",
-      "properties" => {
-        "a" => {
-          "pg_enum" => "MammalEnum"
+      '$schema' => 'http://json-schema.org/marty-draft/schema#',
+      'properties' => {
+        'a' => {
+          'pg_enum' => 'MammalEnum'
         },
-        "b" => {
-          "type"   => "string",
-          "format" => "date-time"
+        'b' => {
+          'type'   => 'string',
+          'format' => 'date-time'
         },
-        "c" => {
-          "type" => "integer"
+        'c' => {
+          'type' => 'integer'
         },
       }
     }
 
-    it "validates pg_enum, dt format and int when they are correct" do
-      data = {"a" => 'Dog', "b" => '2017-05-22T14:51:44Z', "c" => 5}
+    it 'validates pg_enum, dt format and int when they are correct' do
+      data = { 'a' => 'Dog', 'b' => '2017-05-22T14:51:44Z', 'c' => 5 }
       expect(JSON::Validator.validate(pg_dt_int_schema, data)).to be true
     end
 
-    it "validates pg_enum, dt format and int when one is incorrect" do
-      data = {"a" => 'Chair', "b" => '2017-05-22T14:51:44Z', "c" => 5}
+    it 'validates pg_enum, dt format and int when one is incorrect' do
+      data = { 'a' => 'Chair', 'b' => '2017-05-22T14:51:44Z', 'c' => 5 }
       expect(JSON::Validator.validate(pg_dt_int_schema, data)).to be false
     end
 
     pg_dt_int_schema_req = {
-      "$schema" => "http://json-schema.org/marty-draft/schema#",
-      "required" => ["b"],
-      "properties" => {
-        "a" => {
-          "pg_enum" => "MammalEnum"
+      '$schema' => 'http://json-schema.org/marty-draft/schema#',
+      'required' => ['b'],
+      'properties' => {
+        'a' => {
+          'pg_enum' => 'MammalEnum'
         },
-        "b" => {
-          "type"   => "string",
-          "format" => "date-time"
+        'b' => {
+          'type'   => 'string',
+          'format' => 'date-time'
         },
-        "c" => {
-          "type" => "integer"
+        'c' => {
+          'type' => 'integer'
         },
       }
     }
 
-    it "validates pg_enum, dt format and int when dt is required" do
-      data = {"a" => 'Dog', "d" => '2017-05-22T14:51:44Z', "c" => 5}
+    it 'validates pg_enum, dt format and int when dt is required' do
+      data = { 'a' => 'Dog', 'd' => '2017-05-22T14:51:44Z', 'c' => 5 }
       expect(JSON::Validator.validate(pg_dt_int_schema_req, data)).to be false
     end
 
     pg_dt_pg_int_schema = {
-      "$schema" => "http://json-schema.org/marty-draft/schema#",
-      "required" => ["c"],
-      "properties" => {
-        "a" => {
-          "pg_enum" => "MammalEnum"
+      '$schema' => 'http://json-schema.org/marty-draft/schema#',
+      'required' => ['c'],
+      'properties' => {
+        'a' => {
+          'pg_enum' => 'MammalEnum'
         },
-        "b" => {
-          "type"   => "string",
-          "format" => "date-time"
+        'b' => {
+          'type'   => 'string',
+          'format' => 'date-time'
         },
-        "c" => {
-          "pg_enum" => "ElectronicsEnum"
+        'c' => {
+          'pg_enum' => 'ElectronicsEnum'
         },
-        "d" => {
-          "type" => "integer"
+        'd' => {
+          'type' => 'integer'
         },
       }
     }
 
-    it "validates a schema containing 2 pg_enums, one that is required" do
-      data = { "a" => 'Dog',
-               "b" => '2017-05-22T14:51:44Z',
-               "c" => 'Phone',
-               "d" => 5 }
+    it 'validates a schema containing 2 pg_enums, one that is required' do
+      data = { 'a' => 'Dog',
+               'b' => '2017-05-22T14:51:44Z',
+               'c' => 'Phone',
+               'd' => 5 }
       expect(JSON::Validator.validate(pg_dt_pg_int_schema, data)).to be true
     end
 
-    it "validates a schema containing 2 pg_enums, one that is required" do
-      data = { "a" => 'Dog',
-               "b" => '2017-05-22T14:51:44Z',
-               "e" => 'Phone',
-               "d" => 5 }
+    it 'validates a schema containing 2 pg_enums, one that is required' do
+      data = { 'a' => 'Dog',
+               'b' => '2017-05-22T14:51:44Z',
+               'e' => 'Phone',
+               'd' => 5 }
       expect(JSON::Validator.validate(pg_dt_pg_int_schema, data)).to be false
     end
 
@@ -421,207 +418,206 @@ module Marty
     ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ###
 
     nested_schema = {
-      "$schema" => "http://json-schema.org/marty-draft/schema#",
-      "required" => ["a", "b", "c", "d", "root1", "root2"],
-      "properties" => {
-        "a" => {
-          "pg_enum" => "MammalEnum"
+      '$schema' => 'http://json-schema.org/marty-draft/schema#',
+      'required' => ['a', 'b', 'c', 'd', 'root1', 'root2'],
+      'properties' => {
+        'a' => {
+          'pg_enum' => 'MammalEnum'
         },
-        "b" => {
-          "type"   => "string",
-          "format" => "date-time"
+        'b' => {
+          'type'   => 'string',
+          'format' => 'date-time'
         },
-        "c" => {
-          "pg_enum" => "ElectronicsEnum"
+        'c' => {
+          'pg_enum' => 'ElectronicsEnum'
         },
-        "d" => {
-          "type" => "integer"
+        'd' => {
+          'type' => 'integer'
         },
-        "root1" => {
-          "type" => "array",
-          "minItems" => 3,
-          "items" => {
-            "required" => ["x", "y"],
-            "properties" => {
-              "x" => { "type"   => "object",
-                       "required" => ["w", "t", "f"],
-                       "properties" => { "w" => { "type"       => "integer",
-                                                  "minimum"    => 0,
-                                                  "maximum"    => 3           },
-                                         "t" => { "pg_enum"    => "MammalEnum"},
-                                         "f" => { "type"       => ["number"],
-                                                  "minimum"    => 0,
-                                                  "maximum"    => 100,
-                                                  "multipleOf"=> 5.0           }}
+        'root1' => {
+          'type' => 'array',
+          'minItems' => 3,
+          'items' => {
+            'required' => ['x', 'y'],
+            'properties' => {
+              'x' => { 'type' => 'object',
+                       'required' => ['w', 't', 'f'],
+                       'properties' => { 'w' => { 'type'       => 'integer',
+                                                  'minimum'    => 0,
+                                                  'maximum'    => 3           },
+                                         't' => { 'pg_enum'    => 'MammalEnum' },
+                                         'f' => { 'type'       => ['number'],
+                                                  'minimum'    => 0,
+                                                  'maximum'    => 100,
+                                                  'multipleOf' => 5.0           } }
                      },
-              "y" => { "pg_enum" => "ElectronicsEnum" }
+              'y' => { 'pg_enum' => 'ElectronicsEnum' }
             }
           }
         },
-        "root2" => {
-          "type" => "array",
-          "minItems" => 2,
-          "items" => {
-            "required" => ["m1", "e", "m2"],
-            "properties" => {
-              "m1" => { "pg_enum" => "MammalEnum"      },
-              "e" =>  { "pg_enum" => "ElectronicsEnum" },
-              "m2" => { "pg_enum" => "MammalEnum"      },
+        'root2' => {
+          'type' => 'array',
+          'minItems' => 2,
+          'items' => {
+            'required' => ['m1', 'e', 'm2'],
+            'properties' => {
+              'm1' => { 'pg_enum' => 'MammalEnum'      },
+              'e' =>  { 'pg_enum' => 'ElectronicsEnum' },
+              'm2' => { 'pg_enum' => 'MammalEnum'      },
             }
           },
         },
       }
     }
 
-    it "validates a complex nested schema when correct" do
-      data = { "a" => 'Dog',
-               "b" => '2017-05-22T14:51:44Z',
-               "root1" => [ { "x" => {"w" => 0, "t" => 'Bear',  "f" => 0.0},
-                              "y" => 'Phone' },
-                            { "x" => {"w" => 1, "t" => 'Human', "f" => 5.0},
-                              "y" => 'Terminator' },
-                            { "x" => {"w" => 2, "t" => 'Dog',   "f" => 65.0},
-                              "y" => 'Phone' } ],
-               "root2" => [ {"m1" => 'Cat', "e" => 'Keyboard', "m2" => 'Dog' },
-                            {"m1" => 'Dog', "e" => 'Phone',    "m2" => 'Cow' }],
-               "c" => 'Terminator',
-               "d" => 5
+    it 'validates a complex nested schema when correct' do
+      data = { 'a' => 'Dog',
+               'b' => '2017-05-22T14:51:44Z',
+               'root1' => [{ 'x' => { 'w' => 0, 't' => 'Bear',  'f' => 0.0 },
+                              'y' => 'Phone' },
+                           { 'x' => { 'w' => 1, 't' => 'Human', 'f' => 5.0 },
+                             'y' => 'Terminator' },
+                           { 'x' => { 'w' => 2, 't' => 'Dog',   'f' => 65.0 },
+                             'y' => 'Phone' }],
+               'root2' => [{ 'm1' => 'Cat', 'e' => 'Keyboard', 'm2' => 'Dog' },
+                           { 'm1' => 'Dog', 'e' => 'Phone',    'm2' => 'Cow' }],
+               'c' => 'Terminator',
+               'd' => 5
              }
       expect(JSON::Validator.validate(nested_schema, data)).to be true
     end
 
-    it "validates a complex nested schema when incorrect -- 1" do
-      data = { "a" => 'Dog',
-               "b" => '2017-05-32T14:51:44Z', # note DD
-               "root1" => [ { "x" => {"w" => 0, "t" => 'Bear',  "f" => 0.0},
-                              "y" => 'Phone' },
-                            { "x" => {"w" => 1, "t" => 'Human', "f" => 5.0},
-                              "y" => 'Terminator' },
-                            { "x" => {"w" => 2, "t" => 'Dog',   "f" => 65.0},
-                              "y" => 'Phone' } ],
-               "root2" => [ {"m1" => 'Cat', "e" => 'Keyboard', "m2" => 'Dog' },
-                            {"m1" => 'Dog', "e" => 'Phone',    "m2" => 'Cow' }],
-               "c" => 'Terminator',
-               "d" => 5
+    it 'validates a complex nested schema when incorrect -- 1' do
+      data = { 'a' => 'Dog',
+               'b' => '2017-05-32T14:51:44Z', # note DD
+               'root1' => [{ 'x' => { 'w' => 0, 't' => 'Bear',  'f' => 0.0 },
+                              'y' => 'Phone' },
+                           { 'x' => { 'w' => 1, 't' => 'Human', 'f' => 5.0 },
+                             'y' => 'Terminator' },
+                           { 'x' => { 'w' => 2, 't' => 'Dog',   'f' => 65.0 },
+                             'y' => 'Phone' }],
+               'root2' => [{ 'm1' => 'Cat', 'e' => 'Keyboard', 'm2' => 'Dog' },
+                           { 'm1' => 'Dog', 'e' => 'Phone',    'm2' => 'Cow' }],
+               'c' => 'Terminator',
+               'd' => 5
              }
       expect(JSON::Validator.validate(nested_schema, data)).to be false
     end
 
-    it "validates a complex nested schema when incorrect -- 2" do
-      data = { "a" => 'Dog',
-               "b" => '2017-05-22T14:51:44Z',
-               "root1" => [ { "x" => {"w" => 0, "t" => 'Bar',   "f" => 0.0}, #
-                              "y" => 'Phone' },
-                            { "x" => {"w" => 1, "t" => 'Human', "f" => 5},
-                              "y" => 'Terminator' },
-                            { "x" => {"w" => 2, "t" => 'Dog',   "f" => 65.0},
-                              "y" => 'Phone' } ],
-               "root2" => [ {"m1" => 'Cat', "e" => 'Keyboard', "m2" => 'Dog' },
-                            {"m1" => 'Dog', "e" => 'Phone',    "m2" => 'Cow' }],
-               "c" => 'Terminator',
-               "d" => 5
+    it 'validates a complex nested schema when incorrect -- 2' do
+      data = { 'a' => 'Dog',
+               'b' => '2017-05-22T14:51:44Z',
+               'root1' => [{ 'x' => { 'w' => 0, 't' => 'Bar',   'f' => 0.0 },
+                              'y' => 'Phone' },
+                           { 'x' => { 'w' => 1, 't' => 'Human', 'f' => 5 },
+                             'y' => 'Terminator' },
+                           { 'x' => { 'w' => 2, 't' => 'Dog',   'f' => 65.0 },
+                             'y' => 'Phone' }],
+               'root2' => [{ 'm1' => 'Cat', 'e' => 'Keyboard', 'm2' => 'Dog' },
+                           { 'm1' => 'Dog', 'e' => 'Phone',    'm2' => 'Cow' }],
+               'c' => 'Terminator',
+               'd' => 5
              }
       expect(JSON::Validator.
               fully_validate(nested_schema, data, opt)[0]).to include(
-         "property '#/root1/0/x/t' value 'Bar' not contained in MammalEnum")
-    end
-
-    it "validates a complex nested schema when incorrect -- 3" do
-      data = { "a" => 'Dog',
-               "b" => '2017-05-22T14:51:44Z',
-               "root1" => [ { "x" => {"w" => 0, "t" => 'Bear',  "f" => 0.0},
-                              "y" => 'Phone' },
-                            { "x" => {"w" => 1, "t" => 'Human', "f" => 6.0}, #
-                              "y" => 'Terminator' },
-                            { "x" => {"w" => 2, "t" => 'Dog',   "f" => 65.0},
-                              "y" => 'Phone' } ],
-               "root2" => [ {"m1" => 'Cat', "e" => 'Keyboard', "m2" => 'Dog' },
-                            {"m1" => 'Dog', "e" => 'Phone',    "m2" => 'Cow' }],
-               "c" => 'Terminator',
-               "d" => 5
+                "property '#/root1/0/x/t' value 'Bar' not contained in MammalEnum")
+    end
+
+    it 'validates a complex nested schema when incorrect -- 3' do
+      data = { 'a' => 'Dog',
+               'b' => '2017-05-22T14:51:44Z',
+               'root1' => [{ 'x' => { 'w' => 0, 't' => 'Bear',  'f' => 0.0 },
+                              'y' => 'Phone' },
+                           { 'x' => { 'w' => 1, 't' => 'Human', 'f' => 6.0 },
+                             'y' => 'Terminator' },
+                           { 'x' => { 'w' => 2, 't' => 'Dog',   'f' => 65.0 },
+                             'y' => 'Phone' }],
+               'root2' => [{ 'm1' => 'Cat', 'e' => 'Keyboard', 'm2' => 'Dog' },
+                           { 'm1' => 'Dog', 'e' => 'Phone',    'm2' => 'Cow' }],
+               'c' => 'Terminator',
+               'd' => 5
              }
       expect(JSON::Validator.
               fully_validate(nested_schema, data, opt)[0]).to include(
-            "property '#/root1/1/x/f' was not divisible by 5.0")
-    end
-
-    it "validates a complex nested schema when incorrect -- 4" do
-      data = { "a" => 'Dog',
-               "b" => '2017-05-22T14:51:44Z',
-               "root1" => [ { "x" => {"w" => 0, "t" => 'Bear',  "f" => 0.0},
-                              "y" => 'Phone' },
-                            { "x" => {"w" => 1, "t" => 'Human', "f" => 5.0},
-                              "y" => 'Trminator' }, #
-                            { "x" => {"w" => 2, "t" => 'Dog',   "f" => 65.0},
-                              "y" => 'Phone' } ],
-               "root2" => [ {"m1" => 'Cat', "e" => 'Keyboard', "m2" => 'Dog' },
-                            {"m1" => 'Dog', "e" => 'Phone',    "m2" => 'Cow' }],
-               "c" => 'Terminator',
-               "d" => 5
+                "property '#/root1/1/x/f' was not divisible by 5.0")
+    end
+
+    it 'validates a complex nested schema when incorrect -- 4' do
+      data = { 'a' => 'Dog',
+               'b' => '2017-05-22T14:51:44Z',
+               'root1' => [{ 'x' => { 'w' => 0, 't' => 'Bear',  'f' => 0.0 },
+                              'y' => 'Phone' },
+                           { 'x' => { 'w' => 1, 't' => 'Human', 'f' => 5.0 },
+                             'y' => 'Trminator' },
+                           { 'x' => { 'w' => 2, 't' => 'Dog',   'f' => 65.0 },
+                             'y' => 'Phone' }],
+               'root2' => [{ 'm1' => 'Cat', 'e' => 'Keyboard', 'm2' => 'Dog' },
+                           { 'm1' => 'Dog', 'e' => 'Phone',    'm2' => 'Cow' }],
+               'c' => 'Terminator',
+               'd' => 5
              }
       expect(JSON::Validator.
               fully_validate(nested_schema, data, opt)[0]).to include(
-                      "property '#/root1/1/y' value 'Trminator' not contained "\
-                      "in ElectronicsEnum")
-    end
-
-    it "validates a complex nested schema when incorrect -- 5" do
-      data = { "a" => 'Dog',
-               "b" => '2017-05-22T14:51:44Z',
-               "root1" => [ { "x" => {"w" => 0, "t" => 'Bear',  "f" => 0.0},
-                              "y" => 'Phone' },
-                            { "x" => {"w" => 1, "t" => 'Human', "f" => 5.0},
-                              "y" => 'Terminator' },
-                            { "x" => {"w" => 5, "t" => 'Dog',   "f" => 65.0}, #
-                              "y" => 'Phone' } ],
-               "root2" => [ {"m1" => 'Cat', "e" => 'Keyboard', "m2" => 'Dog' },
-                            {"m1" => 'Dog', "e" => 'Phone',    "m2" => 'Cow' }],
-               "c" => 'Terminator',
-               "d" => 5
+                "property '#/root1/1/y' value 'Trminator' not contained "\
+                'in ElectronicsEnum')
+    end
+
+    it 'validates a complex nested schema when incorrect -- 5' do
+      data = { 'a' => 'Dog',
+               'b' => '2017-05-22T14:51:44Z',
+               'root1' => [{ 'x' => { 'w' => 0, 't' => 'Bear',  'f' => 0.0 },
+                              'y' => 'Phone' },
+                           { 'x' => { 'w' => 1, 't' => 'Human', 'f' => 5.0 },
+                             'y' => 'Terminator' },
+                           { 'x' => { 'w' => 5, 't' => 'Dog',   'f' => 65.0 },
+                             'y' => 'Phone' }],
+               'root2' => [{ 'm1' => 'Cat', 'e' => 'Keyboard', 'm2' => 'Dog' },
+                           { 'm1' => 'Dog', 'e' => 'Phone',    'm2' => 'Cow' }],
+               'c' => 'Terminator',
+               'd' => 5
              }
       expect(JSON::Validator.
               fully_validate(nested_schema, data, opt)[0]).to include(
-       "property '#/root1/2/x/w' did not have a maximum value of 3, inclusively")
-    end
-
-    it "validates a complex nested schema when incorrect -- 6" do
-      data = { "a" => 'Dog',
-               "b" => '2017-05-22T14:51:44Z',
-               "root1" => [ { "x" => {"w" => 0, "t" => 'Bear',  "f" => 0.0},
-                              "y" => 'Phone' },
-                            { "x" => {"w" => 1, "t" => 'Human', "f" => 5.0},
-                              "y" => 'Terminator' },
-                            { "x" => {"w" => -5, "t" => 'Dog',   "f" => 65.0}, #
-                              "y" => 'Phone' } ],
-               "root2" => [ {"m1" => 'Cat', "e" => 'Keyboard', "m2" => 'Dog' },
-                            {"m1" => 'Dog', "e" => 'Phone',    "m2" => 'Cow' }],
-               "c" => 'Terminator',
-               "d" => 5
+                "property '#/root1/2/x/w' did not have a maximum value of 3, inclusively")
+    end
+
+    it 'validates a complex nested schema when incorrect -- 6' do
+      data = { 'a' => 'Dog',
+               'b' => '2017-05-22T14:51:44Z',
+               'root1' => [{ 'x' => { 'w' => 0, 't' => 'Bear',  'f' => 0.0 },
+                              'y' => 'Phone' },
+                           { 'x' => { 'w' => 1, 't' => 'Human', 'f' => 5.0 },
+                             'y' => 'Terminator' },
+                           { 'x' => { 'w' => -5, 't' => 'Dog',   'f' => 65.0 },
+                             'y' => 'Phone' }],
+               'root2' => [{ 'm1' => 'Cat', 'e' => 'Keyboard', 'm2' => 'Dog' },
+                           { 'm1' => 'Dog', 'e' => 'Phone',    'm2' => 'Cow' }],
+               'c' => 'Terminator',
+               'd' => 5
              }
       expect(JSON::Validator.
               fully_validate(nested_schema, data, opt)[0]).to include(
-       "property '#/root1/2/x/w' did not have a minimum value of 0, inclusively")
-    end
-
-    it "validates a complex nested schema when incorrect -- 7" do
-      data = { "a" => 'Dog',
-               "b" => '2017-05-22T14:51:44Z',
-               "root1" => [ { "x" => {"w" => 0, "t" => 'Bear',  "f" => 0.0},
-                              "y" => 'Phone' },
-                            { "x" => {"w" => 1, "t" => 'Human', "f" => 5.0},
-                              "y" => 'Terminator' },
-                            { "x" => {"w" => 2, "t" => 'Dog',   "f" => 65.0},
-                              "y" => 'Phone' } ],
-               "root2" => [ {"m1" => 'Cat', "e" => 'Keyboard', "m2" => 'Dog' },
-                            {"m1" => 'Dog', "e" => 'Dog',    "m2" => 'Cow' }], #
-               "c" => 'Terminator',
-               "d" => 5
+                "property '#/root1/2/x/w' did not have a minimum value of 0, inclusively")
+    end
+
+    it 'validates a complex nested schema when incorrect -- 7' do
+      data = { 'a' => 'Dog',
+               'b' => '2017-05-22T14:51:44Z',
+               'root1' => [{ 'x' => { 'w' => 0, 't' => 'Bear',  'f' => 0.0 },
+                              'y' => 'Phone' },
+                           { 'x' => { 'w' => 1, 't' => 'Human', 'f' => 5.0 },
+                             'y' => 'Terminator' },
+                           { 'x' => { 'w' => 2, 't' => 'Dog',   'f' => 65.0 },
+                             'y' => 'Phone' }],
+               'root2' => [{ 'm1' => 'Cat', 'e' => 'Keyboard', 'm2' => 'Dog' },
+                           { 'm1' => 'Dog', 'e' => 'Dog',    'm2' => 'Cow' }],
+               'c' => 'Terminator',
+               'd' => 5
              }
       expect(JSON::Validator.
               fully_validate(nested_schema, data, opt)[0]).to include(
-          "property '#/root2/1/e' value 'Dog' not contained in ElectronicsEnum")
+                "property '#/root2/1/e' value 'Dog' not contained in ElectronicsEnum")
     end
-
   end
 
   ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ###
@@ -631,7 +627,7 @@ module Marty
   class FloorOf8 < JSON::Schema::Attribute
     def self.validate(curr_schema, data, frag, processor, validator, opt)
       if data < 8
-        msg = "Error at FloorOf8: Value is below 8"
+        msg = 'Error at FloorOf8: Value is below 8'
         validation_error(processor,
                          msg,
                          frag,
@@ -645,7 +641,7 @@ module Marty
   class CeilingOf20 < JSON::Schema::Attribute
     def self.validate(curr_schema, data, frag, processor, validator, opt)
       if data > 20
-        msg = "Error at CeilingOf20: Value exceeds 20"
+        msg = 'Error at CeilingOf20: Value exceeds 20'
         validation_error(processor,
                          msg,
                          frag,
@@ -656,121 +652,115 @@ module Marty
     end
   end
 
-
-  describe "how @uri behaves as a key to a set of attributes" do
-
+  describe 'how @uri behaves as a key to a set of attributes' do
     class BoundSchema < JSON::Schema::Draft4
       def initialize
         super
-        @attributes["bound"] = CeilingOf20
-        uri = "http://json-schema.org/bound-draft/schema#"
+        @attributes['bound'] = CeilingOf20
+        uri = 'http://json-schema.org/bound-draft/schema#'
         @uri = JSON::Util::URI.parse(uri)
       end
 
-      JSON::Validator.register_validator(self.new)
+      JSON::Validator.register_validator(new)
     end
 
     marty_uri = {
-     "$schema" => "http://json-schema.org/marty-draft/schema#",
-      "required"    => ["a"],
-      "properties"  => {
-        "a" => {
-          "pg_enum"    => "MammalEnum",
+     '$schema' => 'http://json-schema.org/marty-draft/schema#',
+      'required'    => ['a'],
+      'properties'  => {
+        'a' => {
+          'pg_enum'    => 'MammalEnum',
         },
       }
     }
 
     bound_uri = {
-      "$schema" => "http://json-schema.org/bound-draft/schema#",
-      "required"    => ["a"],
-      "properties"  => {
-        "a" => {
-          "pg_enum"    => "MammalEnum",
+      '$schema' => 'http://json-schema.org/bound-draft/schema#',
+      'required'    => ['a'],
+      'properties'  => {
+        'a' => {
+          'pg_enum'    => 'MammalEnum',
         },
       }
     }
 
-    it "validates an attribute dictated by its uri (Positive)" do
-      data = {"a" => 'Dog'}
+    it 'validates an attribute dictated by its uri (Positive)' do
+      data = { 'a' => 'Dog' }
       expect(JSON::Validator.validate(marty_uri, data)).to be true
     end
 
-    it "validates an attribute dictated by its uri (Negative)" do
-      data = {"a" => 'Table'}
+    it 'validates an attribute dictated by its uri (Negative)' do
+      data = { 'a' => 'Table' }
       expect(JSON::Validator.validate(marty_uri, data)).to be false
     end
 
-    it "incorrectly validates an attribute not part of its uri" do
-      data = {"a" => 'Table'}
+    it 'incorrectly validates an attribute not part of its uri' do
+      data = { 'a' => 'Table' }
       expect(JSON::Validator.validate(bound_uri, data)).to be true
     end
-
   end
 
-  describe "how @uri also behaves as namespace" do
-
+  describe 'how @uri also behaves as namespace' do
     class BoundFloorSchema < JSON::Schema::Draft4
       def initialize
         super
-        @attributes["bound"] = FloorOf8
-        uri = "http://json-schema.org/bound-floor-draft/schema#"
+        @attributes['bound'] = FloorOf8
+        uri = 'http://json-schema.org/bound-floor-draft/schema#'
         @uri = JSON::Util::URI.parse(uri)
       end
 
-      JSON::Validator.register_validator(self.new)
+      JSON::Validator.register_validator(new)
     end
 
     class BoundCeilingSchema < JSON::Schema::Draft4
       def initialize
         super
-        @attributes["bound"] = CeilingOf20
-        uri = "http://json-schema.org/bound-ceiling-draft/schema#"
+        @attributes['bound'] = CeilingOf20
+        uri = 'http://json-schema.org/bound-ceiling-draft/schema#'
         @uri = JSON::Util::URI.parse(uri)
       end
 
-      JSON::Validator.register_validator(self.new)
+      JSON::Validator.register_validator(new)
     end
 
     bound_floor_schema = {
-     "$schema" => "http://json-schema.org/bound-floor-draft/schema#",
-      "required"    => ["a"],
-      "properties"  => {
-        "a" => {
-          "bound"    => "",
+     '$schema' => 'http://json-schema.org/bound-floor-draft/schema#',
+      'required'    => ['a'],
+      'properties'  => {
+        'a' => {
+          'bound'    => '',
         },
       }
     }
 
     bound_ceiling_schema = {
-     "$schema" => "http://json-schema.org/bound-ceiling-draft/schema#",
-      "required"    => ["a"],
-      "properties"  => {
-        "a" => {
-          "bound"    => "",
+     '$schema' => 'http://json-schema.org/bound-ceiling-draft/schema#',
+      'required'    => ['a'],
+      'properties'  => {
+        'a' => {
+          'bound'    => '',
         },
       }
     }
 
-    it "validates BoundFloorSchema when called with its uri (Positive)" do
-      data = {"a" => 9}
+    it 'validates BoundFloorSchema when called with its uri (Positive)' do
+      data = { 'a' => 9 }
       expect(JSON::Validator.validate(bound_floor_schema, data)).to be true
     end
 
-    it "validates BoundFloorSchema when called with its uri (Negative)" do
-      data = {"a" => 7}
+    it 'validates BoundFloorSchema when called with its uri (Negative)' do
+      data = { 'a' => 7 }
       expect(JSON::Validator.validate(bound_floor_schema, data)).to be false
     end
 
-    it "validates BoundCeilingSchema when called with its uri (Positive)" do
-      data = {"a" => 19}
+    it 'validates BoundCeilingSchema when called with its uri (Positive)' do
+      data = { 'a' => 19 }
       expect(JSON::Validator.validate(bound_ceiling_schema, data)).to be true
     end
 
-    it "validates BoundCielingSchema when called with its uri (Negative)" do
-      data = {"a" => 21}
+    it 'validates BoundCielingSchema when called with its uri (Negative)' do
+      data = { 'a' => 21 }
       expect(JSON::Validator.validate(bound_ceiling_schema, data)).to be false
     end
-
   end
-
 end