fix formatting

Author: kathap

lib/membrane/schema_parser.rb

@@ -1,10 +1,10 @@
-require "membrane/schemas"
+require 'membrane/schemas'
 
 module Membrane
 end
 
 class Membrane::SchemaParser
-  DEPARSE_INDENT = "  ".freeze
+  DEPARSE_INDENT = '  '.freeze
 
   class Dsl
     OptionalKeyMarker = Struct.new(:key)
@@ -37,47 +37,46 @@ def tuple(*elem_schemas)
     end
   end
 
-  def self.parse(&blk)
-    new.parse(&blk)
+  def self.parse(&)
+    new.parse(&)
   end
 
   def self.deparse(schema)
     new.deparse(schema)
   end
 
-  def parse(&blk)
-    intermediate_schema = Dsl.new.instance_eval(&blk)
+  def parse(&)
+    intermediate_schema = Dsl.new.instance_eval(&)
 
     do_parse(intermediate_schema)
   end
 
   def deparse(schema)
     case schema
     when Membrane::Schemas::Any
-      "any"
+      'any'
     when Membrane::Schemas::Bool
-      "bool"
+      'bool'
     when Membrane::Schemas::Class
       schema.klass.name
     when Membrane::Schemas::Dictionary
-      "dict(%s, %s)" % [deparse(schema.key_schema),
-                        deparse(schema.value_schema)]
+      sprintf('dict(%s, %s)', deparse(schema.key_schema), deparse(schema.value_schema))
     when Membrane::Schemas::Enum
-      "enum(%s)" % [schema.elem_schemas.map { |es| deparse(es) }.join(", ")]
+      sprintf('enum(%s)', schema.elem_schemas.map { |es| deparse(es) }.join(', '))
     when Membrane::Schemas::List
-      "[%s]" % [deparse(schema.elem_schema)]
+      sprintf('[%s]', deparse(schema.elem_schema))
     when Membrane::Schemas::Record
       deparse_record(schema)
     when Membrane::Schemas::Regexp
       schema.regexp.inspect
     when Membrane::Schemas::Tuple
-      "tuple(%s)" % [schema.elem_schemas.map { |es| deparse(es) }.join(", ")]
+      sprintf('tuple(%s)', schema.elem_schemas.map { |es| deparse(es) }.join(', '))
     when Membrane::Schemas::Value
       schema.value.inspect
     when Membrane::Schemas::Base
       schema.inspect
     else
-      emsg = "Expected instance of Membrane::Schemas::Base, given instance of" \
+      emsg = 'Expected instance of Membrane::Schemas::Base, given instance of' \
              + " #{schema.class}"
       raise ArgumentError.new(emsg)
     end
@@ -97,7 +96,7 @@ def do_parse(object)
       Membrane::Schemas::Regexp.new(object)
     when Dsl::DictionaryMarker
       Membrane::Schemas::Dictionary.new(do_parse(object.key_schema),
-                                       do_parse(object.value_schema))
+                                        do_parse(object.value_schema))
     when Dsl::EnumMarker
       elem_schemas = object.elem_schemas.map { |s| do_parse(s) }
       Membrane::Schemas::Enum.new(*elem_schemas)
@@ -113,25 +112,23 @@ def do_parse(object)
 
   def parse_list(schema)
     if schema.empty?
-      raise ArgumentError.new("You must supply a schema for elements.")
+      raise ArgumentError.new('You must supply a schema for elements.')
     elsif schema.length > 1
-      raise ArgumentError.new("Lists can only match a single schema.")
+      raise ArgumentError.new('Lists can only match a single schema.')
     end
 
     Membrane::Schemas::List.new(do_parse(schema[0]))
   end
 
   def parse_record(schema)
-    if schema.empty?
-      raise ArgumentError.new("You must supply at least one key-value pair.")
-    end
+    raise ArgumentError.new('You must supply at least one key-value pair.') if schema.empty?
 
     optional_keys = []
 
     parsed = {}
 
     schema.each do |key, value_schema|
-      if key.kind_of?(Dsl::OptionalKeyMarker)
+      if key.is_a?(Dsl::OptionalKeyMarker)
         key = key.key
         optional_keys << key
       end
@@ -143,40 +140,38 @@ def parse_record(schema)
   end
 
   def deparse_record(schema)
-    lines = ["{"]
+    lines = ['{']
 
     schema.schemas.each do |key, val_schema|
-      dep_key = nil
-      if schema.optional_keys.include?(key)
-        dep_key = "optional(%s)" % [key.inspect]
-      else
-        dep_key = key.inspect
-      end
+      nil
+      dep_key = if schema.optional_keys.include?(key)
+                  sprintf('optional(%s)', key.inspect)
+                else
+                  key.inspect
+                end
 
       dep_key = DEPARSE_INDENT + dep_key
       dep_val_schema_lines = deparse(val_schema).split("\n")
 
       dep_val_schema_lines.each_with_index do |line, line_idx|
-        to_append = nil
+        nil
 
-        if 0 == line_idx
-          to_append = "%s => %s" % [dep_key, line]
-        else
-          # Indent continuation lines
-          to_append = DEPARSE_INDENT + line
-        end
+        to_append = if 0 == line_idx
+                      sprintf('%s => %s', dep_key, line)
+                    else
+                      # Indent continuation lines
+                      DEPARSE_INDENT + line
+                    end
 
         # This concludes the deparsed schema, append a comma in preparation
         # for the next k-v pair.
-        if dep_val_schema_lines.size - 1 == line_idx
-          to_append += ","
-        end
+        to_append += ',' if dep_val_schema_lines.size - 1 == line_idx
 
         lines << to_append
       end
     end
 
-    lines << "}"
+    lines << '}'
 
     lines.join("\n")
   end

lib/membrane/schemas/any.rb

@@ -1,8 +1,8 @@
-require "membrane/errors"
-require "membrane/schemas/base"
+require 'membrane/errors'
+require 'membrane/schemas/base'
 
 class Membrane::Schemas::Any < Membrane::Schemas::Base
-  def validate(object)
+  def validate(_object)
     nil
   end
 end

lib/membrane/schemas/bool.rb

@@ -1,7 +1,5 @@
-require "set"
-
-require "membrane/errors"
-require "membrane/schemas/base"
+require 'membrane/errors'
+require 'membrane/schemas/base'
 
 class Membrane::Schemas::Bool < Membrane::Schemas::Base
   def validate(object)
@@ -16,7 +14,7 @@ def initialize(object)
     end
 
     def validate
-      fail!(@object) if !TRUTH_VALUES.include?(@object)
+      fail!(@object) unless TRUTH_VALUES.include?(@object)
     end
 
     private

lib/membrane/schemas/class.rb

@@ -1,5 +1,5 @@
-require "membrane/errors"
-require "membrane/schemas/base"
+require 'membrane/errors'
+require 'membrane/schemas/base'
 
 class Membrane::Schemas::Class < Membrane::Schemas::Base
   attr_reader :klass
@@ -14,14 +14,13 @@ def validate(object)
   end
 
   class ClassValidator
-
     def initialize(klass, object)
       @klass = klass
       @object = object
     end
 
     def validate
-      fail!(@klass, @object) if !@object.kind_of?(@klass)
+      fail!(@klass, @object) unless @object.is_a?(@klass)
     end
 
     private

lib/membrane/schemas/dictionary.rb

@@ -1,14 +1,13 @@
-require "membrane/errors"
-require "membrane/schemas/base"
+require 'membrane/errors'
+require 'membrane/schemas/base'
 
 module Membrane
   module Schema
   end
 end
 
 class Membrane::Schemas::Dictionary < Membrane::Schemas::Base
-  attr_reader :key_schema
-  attr_reader :value_schema
+  attr_reader :key_schema, :value_schema
 
   def initialize(key_schema, value_schema)
     @key_schema = key_schema
@@ -26,7 +25,7 @@ def initialize(object)
     end
 
     def validate
-      fail!(@object.class) if !@object.kind_of?(Hash)
+      fail!(@object.class) unless @object.is_a?(Hash)
     end
 
     private
@@ -48,12 +47,10 @@ def validate
       errors = {}
 
       @object.each do |k, v|
-        begin
-          @key_schema.validate(k)
-          @value_schema.validate(v)
-        rescue Membrane::SchemaValidationError => e
-          errors[k] = e.to_s
-        end
+        @key_schema.validate(k)
+        @value_schema.validate(v)
+      rescue Membrane::SchemaValidationError => e
+        errors[k] = e.to_s
       end
 
       fail!(errors) if errors.size > 0
@@ -62,7 +59,7 @@ def validate
     private
 
     def fail!(errors)
-      emsg = "{ " + errors.map { |k, e| "#{k} => #{e}" }.join(", ") + " }"
+      emsg = '{ ' + errors.map { |k, e| "#{k} => #{e}" }.join(', ') + ' }'
       raise Membrane::SchemaValidationError.new(emsg)
     end
   end

lib/membrane/schemas/enum.rb

@@ -1,5 +1,5 @@
-require "membrane/errors"
-require "membrane/schemas/base"
+require 'membrane/errors'
+require 'membrane/schemas/base'
 
 module Membrane
   module Schema
@@ -25,11 +25,9 @@ def initialize(elem_schemas, object)
 
     def validate
       @elem_schemas.each do |schema|
-        begin
-          schema.validate(@object)
-          return nil
-        rescue Membrane::SchemaValidationError
-        end
+        schema.validate(@object)
+        return nil
+      rescue Membrane::SchemaValidationError
       end
 
       fail!(@elem_schemas, @object)
@@ -38,12 +36,11 @@ def validate
     private
 
     def fail!(elem_schemas, object)
-      elem_schema_str = elem_schemas.map { |s| s.to_s }.join(", ")
+      elem_schema_str = elem_schemas.map { |s| s.to_s }.join(', ')
 
       emsg = "Object #{object} doesn't validate" \
            + " against any of #{elem_schema_str}"
       raise Membrane::SchemaValidationError.new(emsg)
     end
   end
-
 end

lib/membrane/schemas/list.rb

@@ -1,5 +1,5 @@
-require "membrane/errors"
-require "membrane/schemas/base"
+require 'membrane/errors'
+require 'membrane/schemas/base'
 
 module Membrane
   module Schema
@@ -24,7 +24,7 @@ def initialize(object)
     end
 
     def validate
-      fail!(@object) if !@object.kind_of?(Array)
+      fail!(@object) unless @object.is_a?(Array)
     end
 
     private
@@ -45,18 +45,16 @@ def validate
       errors = {}
 
       @object.each_with_index do |elem, ii|
-        begin
-          @elem_schema.validate(elem)
-        rescue Membrane::SchemaValidationError => e
-          errors[ii] = e.to_s
-        end
+        @elem_schema.validate(elem)
+      rescue Membrane::SchemaValidationError => e
+        errors[ii] = e.to_s
       end
 
       fail!(errors) if errors.size > 0
     end
 
     def fail!(errors)
-      emsg = errors.map { |ii, e| "At index #{ii}: #{e}" }.join(", ")
+      emsg = errors.map { |ii, e| "At index #{ii}: #{e}" }.join(', ')
       raise Membrane::SchemaValidationError.new(emsg)
     end
   end