fix rubocop

Author: kathap

spec/unit/lib/membrane/complex_schema_spec.rb

@@ -1,38 +1,36 @@
 # frozen_string_literal: true
 
-require_relative "membrane_spec_helper"
-require "membrane"
+require_relative 'membrane_spec_helper'
+require 'membrane'
 
 RSpec.describe Membrane do
   let(:schema) do
     Membrane::SchemaParser.parse do
-      { "ints"       => [Integer],
-        "tf"         => bool,
-        "any"        => any,
-        "1_or_2"     => enum(1, 2),
-        "str_to_str_to_int" => dict(String, dict(String, Integer)),
-        optional("optional") => bool,
-      }
+      { 'ints' => [Integer],
+        'tf' => bool,
+        'any' => any,
+        '1_or_2' => enum(1, 2),
+        'str_to_str_to_int' => dict(String, dict(String, Integer)),
+        optional('optional') => bool }
     end
   end
 
   let(:valid) do
-    { "ints"       => [1, 2],
-      "tf"         => false,
-      "any"        => nil,
-      "1_or_2"     => 2,
-      "optional"   => true,
-      "str_to_str_to_int" => { "ten" => { "twenty" => 20 } },
-    }
+    { 'ints' => [1, 2],
+      'tf' => false,
+      'any' => nil,
+      '1_or_2' => 2,
+      'optional' => true,
+      'str_to_str_to_int' => { 'ten' => { 'twenty' => 20 } } }
   end
 
-  it "should work with complex nested schemas" do
+  it 'works with complex nested schemas' do
     expect(schema.validate(valid)).to be_nil
   end
 
-  it "should complain about missing keys" do
+  it 'complains about missing keys' do
     required_keys = schema.schemas.keys.dup
-    required_keys.delete("optional")
+    required_keys.delete('optional')
 
     required_keys.each do |k|
       invalid = valid.dup
@@ -43,10 +41,10 @@
     end
   end
 
-  it "should validate nested maps" do
+  it 'validates nested maps' do
     invalid = valid.dup
 
-    invalid["str_to_str_to_int"]["ten"]["twenty"] = "invalid"
+    invalid['str_to_str_to_int']['ten']['twenty'] = 'invalid'
 
     expect_validation_failure(schema, invalid, /twenty => Expected/)
   end

spec/unit/lib/membrane/schema_parser_spec.rb

@@ -1,158 +1,158 @@
 # frozen_string_literal: true
 
-require_relative "membrane_spec_helper"
-require "membrane"
+require_relative 'membrane_spec_helper'
+require 'membrane'
 
 RSpec.describe Membrane::SchemaParser do
   let(:parser) { Membrane::SchemaParser.new }
 
-  describe "#deparse" do
-    it "should call inspect on the value of a Value schema" do
-      val = "test"
+  describe '#deparse' do
+    it 'calls inspect on the value of a Value schema' do
+      val = 'test'
       schema = Membrane::Schemas::Value.new(val)
 
       # Just verify it returns the inspected value
       expect(parser.deparse(schema)).to eq val.inspect
     end
 
-    it "should return 'any' for instance of Membrane::Schemas::Any" do
+    it "returns 'any' for instance of Membrane::Schemas::Any" do
       schema = Membrane::Schemas::Any.new
 
-      expect(parser.deparse(schema)).to eq "any"
+      expect(parser.deparse(schema)).to eq 'any'
     end
 
-    it "should return 'bool' for instances of Membrane::Schemas::Bool" do
+    it "returns 'bool' for instances of Membrane::Schemas::Bool" do
       schema = Membrane::Schemas::Bool.new
 
-      expect(parser.deparse(schema)).to eq "bool"
+      expect(parser.deparse(schema)).to eq 'bool'
     end
 
-    it "should call name on the class of a Membrane::Schemas::Class schema" do
+    it 'calls name on the class of a Membrane::Schemas::Class schema' do
       klass = String
       schema = Membrane::Schemas::Class.new(klass)
 
       # Just verify it returns the class name
       expect(parser.deparse(schema)).to eq klass.name
     end
 
-    it "should deparse the k/v schemas of a Membrane::Schemas::Dictionary schema" do
+    it 'deparses the k/v schemas of a Membrane::Schemas::Dictionary schema' do
       key_schema = Membrane::Schemas::Class.new(String)
       val_schema = Membrane::Schemas::Class.new(Integer)
 
       dict_schema = Membrane::Schemas::Dictionary.new(key_schema, val_schema)
 
-      expect(parser.deparse(dict_schema)).to eq "dict(String, Integer)"
+      expect(parser.deparse(dict_schema)).to eq 'dict(String, Integer)'
     end
 
-    it "should deparse the element schemas of a Membrane::Schemas::Enum schema" do
+    it 'deparses the element schemas of a Membrane::Schemas::Enum schema' do
       schemas =
         [String, Integer, Float].map { |c| Membrane::Schemas::Class.new(c) }
 
       enum_schema = Membrane::Schemas::Enum.new(*schemas)
 
-      expect(parser.deparse(enum_schema)).to eq "enum(String, Integer, Float)"
+      expect(parser.deparse(enum_schema)).to eq 'enum(String, Integer, Float)'
     end
 
-    it "should deparse the element schema of a Membrane::Schemas::List schema" do
+    it 'deparses the element schema of a Membrane::Schemas::List schema' do
       key_schema = Membrane::Schemas::Class.new(String)
       val_schema = Membrane::Schemas::Class.new(Integer)
       item_schema = Membrane::Schemas::Dictionary.new(key_schema, val_schema)
 
       list_schema = Membrane::Schemas::List.new(item_schema)
 
-      expect(parser.deparse(list_schema)).to eq "[dict(String, Integer)]"
+      expect(parser.deparse(list_schema)).to eq '[dict(String, Integer)]'
     end
 
-    it "should deparse elem schemas of a Membrane::Schemas::Record schema" do
+    it 'deparses elem schemas of a Membrane::Schemas::Record schema' do
       str_schema = Membrane::Schemas::Class.new(String)
       int_schema = Membrane::Schemas::Class.new(Integer)
       dict_schema = Membrane::Schemas::Dictionary.new(str_schema, int_schema)
 
       int_rec_schema = Membrane::Schemas::Record.new({
-                                                     :str => str_schema,
-                                                     :dict => dict_schema
-                                                    })
+                                                       str: str_schema,
+                                                       dict: dict_schema
+                                                     })
       rec_schema = Membrane::Schemas::Record.new({
-                                                  "str" => str_schema,
-                                                  "rec" => int_rec_schema,
-                                                  "int" => int_schema
-                                                })
-
-      exp_deparse =<<EOT
-{
-  "str" => String,
-  "rec" => {
-    :str => String,
-    :dict => dict(String, Integer),
-  },
-  "int" => Integer,
-}
-EOT
+                                                   'str' => str_schema,
+                                                   'rec' => int_rec_schema,
+                                                   'int' => int_schema
+                                                 })
+
+      exp_deparse = <<~EXPECTED_DEPARSE
+        {
+          "str" => String,
+          "rec" => {
+            :str => String,
+            :dict => dict(String, Integer),
+          },
+          "int" => Integer,
+        }
+      EXPECTED_DEPARSE
       expect(parser.deparse(rec_schema)).to eq exp_deparse.strip
     end
 
-    it "should call inspect on regexps for Membrane::Schemas::Regexp" do
+    it 'calls inspect on regexps for Membrane::Schemas::Regexp' do
       regexp_val = /test/
       schema = Membrane::Schemas::Regexp.new(regexp_val)
 
       # Just verify it returns the regexp inspected
       expect(parser.deparse(schema)).to eq regexp_val.inspect
     end
 
-    it "should deparse the element schemas of a Membrane::Schemas::Tuple schema" do
+    it 'deparses the element schemas of a Membrane::Schemas::Tuple schema' do
       schemas = [String, Integer].map { |c| Membrane::Schemas::Class.new(c) }
-      schemas << Membrane::Schemas::Value.new("test")
+      schemas << Membrane::Schemas::Value.new('test')
 
       enum_schema = Membrane::Schemas::Tuple.new(*schemas)
 
       expect(parser.deparse(enum_schema)).to eq 'tuple(String, Integer, "test")'
     end
 
-    it "should call inspect on a Membrane::Schemas::Base schema" do
+    it 'calls inspect on a Membrane::Schemas::Base schema' do
       schema = Membrane::Schemas::Base.new
       expect(parser.deparse(schema)).to eq schema.inspect
     end
 
-    it "should raise an error if given a non-schema" do
+    it 'raises an error if given a non-schema' do
       expect do
         parser.deparse({})
       end.to raise_error(ArgumentError, /Expected instance/)
     end
   end
 
-  describe "#parse" do
-    it "should leave instances derived from Membrane::Schemas::Base unchanged" do
+  describe '#parse' do
+    it 'leaves instances derived from Membrane::Schemas::Base unchanged' do
       old_schema = Membrane::Schemas::Any.new
 
       expect(parser.parse { old_schema }).to eq old_schema
     end
 
-    it "should translate 'any' into Membrane::Schemas::Any" do
+    it "translates 'any' into Membrane::Schemas::Any" do
       schema = parser.parse { any }
 
       expect(schema.class).to eq Membrane::Schemas::Any
     end
 
-    it "should translate 'bool' into Membrane::Schemas::Bool" do
+    it "translates 'bool' into Membrane::Schemas::Bool" do
       schema = parser.parse { bool }
 
       expect(schema.class).to eq Membrane::Schemas::Bool
     end
 
-    it "should translate 'enum' into Membrane::Schemas::Enum" do
+    it "translates 'enum' into Membrane::Schemas::Enum" do
       schema = parser.parse { enum(bool, any) }
 
       expect(schema.class).to eq Membrane::Schemas::Enum
 
       expect(schema.elem_schemas.length).to eq 2
 
-      elem_schema_classes = schema.elem_schemas.map { |es| es.class }
+      elem_schema_classes = schema.elem_schemas.map(&:class)
 
       expected_classes = [Membrane::Schemas::Bool, Membrane::Schemas::Any]
       expect(elem_schema_classes).to eq expected_classes
     end
 
-    it "should translate 'dict' into Membrane::Schemas::Dictionary" do
+    it "translates 'dict' into Membrane::Schemas::Dictionary" do
       schema = parser.parse { dict(String, Integer) }
 
       expect(schema.class).to eq Membrane::Schemas::Dictionary
@@ -164,29 +164,29 @@
       expect(schema.value_schema.klass).to eq Integer
     end
 
-    it "should translate 'tuple' into Membrane::Schemas::Tuple" do
+    it "translates 'tuple' into Membrane::Schemas::Tuple" do
       schema = parser.parse { tuple(String, any, Integer) }
 
       expect(schema.class).to eq Membrane::Schemas::Tuple
 
       expect(schema.elem_schemas[0].class).to eq Membrane::Schemas::Class
       expect(schema.elem_schemas[0].klass).to eq String
 
-      schema.elem_schemas[1].class == Membrane::Schemas::Any
+      schema.elem_schemas[1].class
 
       expect(schema.elem_schemas[2].class).to eq Membrane::Schemas::Class
       expect(schema.elem_schemas[2].klass).to eq Integer
     end
 
-    it "should translate classes into Membrane::Schemas::Class" do
+    it 'translates classes into Membrane::Schemas::Class' do
       schema = parser.parse { String }
 
       expect(schema.class).to eq Membrane::Schemas::Class
 
       expect(schema.klass).to eq String
     end
 
-    it "should translate regexps into Membrane::Schemas::Regexp" do
+    it 'translates regexps into Membrane::Schemas::Regexp' do
       regexp = /foo/
 
       schema = parser.parse { regexp }
@@ -196,27 +196,27 @@
       expect(schema.regexp).to eq regexp
     end
 
-    it "should fall back to Membrane::Schemas::Value" do
+    it 'falls back to Membrane::Schemas::Value' do
       schema = parser.parse { 5 }
 
       expect(schema.class).to eq Membrane::Schemas::Value
       expect(schema.value).to eq 5
     end
 
-    describe "when parsing a list" do
-      it "should raise an error when no element schema is supplied" do
+    describe 'when parsing a list' do
+      it 'raises an error when no element schema is supplied' do
         expect do
           parser.parse { [] }
         end.to raise_error(ArgumentError, /must supply/)
       end
 
-      it "should raise an error when supplied > 1 element schema" do
+      it 'raises an error when supplied > 1 element schema' do
         expect do
           parser.parse { [String, String] }
         end.to raise_error(ArgumentError, /single schema/)
       end
 
-      it "should parse '[<expr>]' into Membrane::Schemas::List" do
+      it "parses '[<expr>]' into Membrane::Schemas::List" do
         schema = parser.parse { [String] }
 
         expect(schema.class).to eq Membrane::Schemas::List
@@ -226,37 +226,36 @@
       end
     end
 
-    describe "when parsing a record" do
-      it "should raise an error if the record is empty" do
+    describe 'when parsing a record' do
+      it 'raises an error if the record is empty' do
         expect do
           parser.parse { {} }
         end.to raise_error(ArgumentError, /must supply/)
       end
 
-      it "should parse '{ <key> => <schema> }' into Membrane::Schemas::Record" do
+      it "parses '{ <key> => <schema> }' into Membrane::Schemas::Record" do
         schema = parser.parse do
-          { "string" => String,
-            "ints"   => [Integer],
-          }
+          { 'string' => String,
+            'ints' => [Integer] }
         end
 
         expect(schema.class).to eq Membrane::Schemas::Record
 
-        str_schema = schema.schemas["string"]
+        str_schema = schema.schemas['string']
         expect(str_schema.class).to eq Membrane::Schemas::Class
         expect(str_schema.klass).to eq String
 
-        ints_schema = schema.schemas["ints"]
+        ints_schema = schema.schemas['ints']
         expect(ints_schema.class).to eq Membrane::Schemas::List
         expect(ints_schema.elem_schema.class).to eq Membrane::Schemas::Class
         expect(ints_schema.elem_schema.klass).to eq Integer
       end
 
-      it "should handle keys marked with 'optional()'" do
-        schema = parser.parse { { optional("test") => Integer } }
+      it "handles keys marked with 'optional()'" do
+        schema = parser.parse { { optional('test') => Integer } }
 
         expect(schema.class).to eq Membrane::Schemas::Record
-        expect(schema.optional_keys.to_a).to eq ["test"]
+        expect(schema.optional_keys.to_a).to eq ['test']
       end
     end
   end