skeem 0.2.11 → 0.2.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c08f4d71464aad98f53e99e6f66cd18e5961dbd1930353a560844b05d824e288
-  data.tar.gz: f38223cedadc6689670c1d4db901a25cf18caf5b2761519e866909575228b5d9
+  metadata.gz: d37e901cd3042b1b0b81e29aa885c78bcfd61494e015508687187380be313d5d
+  data.tar.gz: 99918e85f8dafcd9a53465d77dfad99961786bafed16458d3d58eb2a36e39867
 SHA512:
-  metadata.gz: 6618523bb5c1a4145b625ed5d264c1879f6980677df9c18e208f9a623652329cf952b4620a8c0c15c96cc38157e75f0590e9555535fa76b63a4361c866393bfb
-  data.tar.gz: 2b0ce438844db721e855dc9a805a66dcacac97240895d3be96e09e9634b8d80056e7dd4cdcb9e36c98896bb536f36ef0801ae830173a8b7ff0d1f032cfd3f18f
+  metadata.gz: e0834459d4d616c84b66ac0e261737388002ba972586a343767ca1f41e5c3d2c52ee31a2367a75362e6b9c9618baf2b69b4feff81fee7e71acd4948900ddb9e1
+  data.tar.gz: 9653c511dd58eabbd15340becadbb4bd23d6bab4cd8ed454e6d98d9e4d304f7837d60775fd40b0528cac252958012a4a7c1c9e3421e3f28074033d21917c7a60

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+## [0.2.12] - 2019-06-19
+- Skeem now supports character datatype
+- Added procedures: `boolean=?`, `char?`, `string`, `make-string`, `reverse`
+  
+### Added
+- Class `SkmChar`
+- Method `SkmPair#proper?` to check whether a pair/list is a proper one.
+
+### Changed
+- Class Tokenizer updated to recognize character literals (specified by name, by hexadecimal code, escaped).
+- File `grammar.rb` Added new terminal CHAR and one derivation rule
+- File `primitive_builder.rb` Implemented primitive procedures `boolean=?`, `char?`, `string`, `make-string`, `reverse`
+- File `README.md` Added mentions to new procedures.
+- File `tokenize_spec.rb`DRYing the spec file.`
+- File `primitive_builder_spec.rb`: Added tests for new procedures.
+
 ## [0.2.11] - 2019-06-16
 - Added procedures: `gcd`, `lcm`, `numerator`, `denominator`, `floor`, `ceiling`, `truncate`,
   `round`.
@@ -19,12 +35,12 @@
 
 ### Changed
 - `DatumDSL#to_datum(aLiteral): added conversion of literal rational into rational value.
+ - Class Tokenizer updated to recognize rational numbers.
 - File `grammar.rb` Added new terminal RATIONAL and rule deriving number from rational
 - File `primitive_builder.rb` Implemented primitive procedures floor/ and truncate/
 - Class `SkmInteger` now inherits from `SkmRational` class
 - File `base.skm` added implementation of  `floor-quotient`, `floor-remainder`, `truncate-quotient`, 
   `truncate-remainder`, `quotient`, `remainder`, `modulo`
- - Class Tokenizer updated to recognize rational numbers.
  - Test suite file `base_tests.scm` expanded.
  - File `README.md` Added mentions to new procedures.
 

data/README.md

@@ -6,7 +6,7 @@
 [![Gem Version](https://badge.fury.io/rb/skeem.svg)](https://badge.fury.io/rb/skeem)
 [![License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat)](https://github.com/famished-tiger/Skeem/blob/master/LICENSE.txt)
 
-__Skeem__ will be an interpreter of a subset of the Scheme programming language.
+__Skeem__ is a Scheme language interpreter written in Ruby.
 
 
 ## Installation
@@ -171,10 +171,11 @@ Here are a few pointers for the Scheme programming language:
 - Block `#| ... |#` comments
 
 ### Data type literals
-- Booleans: `#t`, `#true`, `#f`, `#false`
+- Booleans: `#t`, `#true`, `#f`, `#false`  
+- Characters: `#\a`, `#\newline`, `#\x3BB`
 - Of the number hierarchy:  
   `real` (e.g. 2.718, 6.671e-11),  
-  `rational` (e.g. 22/7, 1/137, -13/41)
+  `rational` (e.g. 22/7, 1/137, -13/41)  
   `integer` (42, -3)
 - Lists (quoted) : '(1 two "three")
 - Strings: `"Hello, world."`
@@ -250,6 +251,9 @@ This section lists the implemented standard procedures
 #### Boolean procedures
 * `boolean?`, `and`, `or`,  `not`
 
+#### Character procedures
+* `char?`
+
 #### Numerical operations
 * Number-level: `number?`, `complex?`, `real?`, `rational?`, `integer?`, `zero?`, `exact?`, `inexact?`, `exact-integer?` , `+`, `-`, `*`, `/`,
 `=`, `square`, `number->string`
@@ -258,11 +262,11 @@ This section lists the implemented standard procedures
 * Integer-level: `even?`, `odd?`
 
 #### List procedures
-* `list?`, `null?`, `pair?`, `append`, `car`, `cdr`, `caar`, `cadr`, `cdar`, `cddr`,  `cons`,  `length`, `list`, `list-copy`, `list->vector`, `set-car!`, `set-cdr!`
+* `list?`, `null?`, `pair?`, `append`, `car`, `cdr`, `caar`, `cadr`, `cdar`, `cddr`,  `cons`,  `length`, `list`, `list-copy`, `list->vector`, `reverse`,  `set-car!`, `set-cdr!`
  , `assq`, `assv`
 
 #### String procedures
-* `string?`, `string=?`,  `string-append`, `string-length`, `string->symbol`
+* `string?`, `string=?`, `string`, `make-string`, `string-append`, `string-length`, `string->symbol`
 
 #### Symbol procedures
 * `symbol?`, `symbol=?`, `symbol->string`

data/lib/skeem/grammar.rb

@@ -15,8 +15,8 @@ module Skeem
     add_terminals('VECTOR_BEGIN')
 
     # Literal values...
-    add_terminals('BOOLEAN', 'INTEGER', 'RATIONAL')
-    add_terminals('REAL', 'STRING_LIT', 'IDENTIFIER')
+    add_terminals('BOOLEAN', 'INTEGER', 'RATIONAL', 'REAL')
+    add_terminals('CHAR', 'STRING_LIT', 'IDENTIFIER')
 
     # Keywords...
     add_terminals('BEGIN', 'COND', 'DEFINE', 'ELSE')
@@ -47,6 +47,7 @@ module Skeem
     rule('quotation' => 'LPAREN QUOTE datum RPAREN').as 'quotation'
     rule 'self-evaluating' => 'BOOLEAN'
     rule 'self-evaluating' => 'number'
+    rule 'self-evaluating' => 'CHAR'
     rule 'self-evaluating' => 'STRING_LIT'
     rule 'self-evaluating' => 'vector'
     rule 'datum' => 'simple_datum'

data/lib/skeem/primitive/primitive_builder.rb

@@ -11,6 +11,7 @@ module Skeem
         add_comparison(aRuntime)
         add_number_procedures(aRuntime)
         add_boolean_procedures(aRuntime)
+        add_char_procedures(aRuntime)
         add_string_procedures(aRuntime)
         add_symbol_procedures(aRuntime)
         add_list_procedures(aRuntime)
@@ -89,10 +90,17 @@ module Skeem
         create_and(aRuntime)
         create_or(aRuntime)
         create_object_predicate(aRuntime, 'boolean?')
+        create_boolean_equal(aRuntime)
+      end
+
+      def add_char_procedures(aRuntime)
+        create_object_predicate(aRuntime, 'char?')
       end
 
       def add_string_procedures(aRuntime)
         create_object_predicate(aRuntime, 'string?')
+        create_make_string(aRuntime)
+        create_string_string(aRuntime)
         create_string_equal(aRuntime)
         create_string_append(aRuntime)
         create_string_length(aRuntime)
@@ -114,6 +122,7 @@ module Skeem
         create_length(aRuntime)
         create_list2vector(aRuntime)
         create_append(aRuntime)
+        create_reverse(aRuntime)
         create_setcar(aRuntime)
         create_setcdr(aRuntime)
         create_assq(aRuntime)
@@ -552,15 +561,61 @@ module Skeem
         define_primitive_proc(aRuntime, 'or', zero_or_more, primitive)
       end
 
-      def create_string_equal(aRuntime)
+      # Return true, if all arguments have the same values
+      def all_same?(first_operand, arglist)
+        if arglist.empty?
+          boolean(true)
+        else
+          first_value = first_operand.value
+          all_equal = arglist.all? { |elem| first_value == elem.value }
+          boolean(all_equal)
+        end
+      end
+
+      def create_boolean_equal(aRuntime)
         primitive = ->(_runtime, first_operand, arglist) do
+          all_same?(first_operand, arglist)
+        end
+
+        define_primitive_proc(aRuntime, 'boolean=?', one_or_more, primitive)
+      end
+
+      def create_make_string(aRuntime)
+        primitive = ->(runtime, count_arg, arglist) do
+          count = count_arg
+          check_argtype(count, SkmInteger, 'integer', 'make_string')
           if arglist.empty?
-            boolean(true)
+            filler = SkmChar.create(rand(0xff).chr)
           else
-            first_value = first_operand.value
-            all_equal = arglist.all? { |elem| first_value == elem.value }
-            boolean(all_equal)
+            filler = arglist.first
+            check_argtype(filler, SkmChar, 'char', 'make_string')
           end
+          string(filler.value.to_s * count.value)
+        end
+
+        define_primitive_proc(aRuntime, 'make-string', one_or_two, primitive)
+      end
+
+      def create_string_string(aRuntime)
+        primitive = ->(_runtime, arglist) do
+          if arglist.empty?
+            value = ''
+          else
+            value = arglist.reduce('') do |interim, some_char|
+              check_argtype(some_char, SkmChar, 'character', 'string')
+              interim << some_char.value
+            end
+          end
+
+          string(value)
+        end
+
+        define_primitive_proc(aRuntime, 'string', zero_or_more, primitive)
+      end
+
+      def create_string_equal(aRuntime)
+        primitive = ->(_runtime, first_operand, arglist) do
+          all_same?(first_operand, arglist)
         end
 
         define_primitive_proc(aRuntime, 'string=?', one_or_more, primitive)
@@ -703,6 +758,23 @@ module Skeem
         define_primitive_proc(aRuntime, 'append', zero_or_more, primitive)
       end
 
+      def create_reverse(aRuntime)
+        primitive = ->(_runtime, arg_evaluated) do
+          check_argtype(arg_evaluated, [SkmPair, SkmEmptyList], 'list', 'reverse')
+          if arg_evaluated == SkmEmptyList.instance
+            result = arg_evaluated
+          else
+            err_msg = 'reverse procedure requires a proper list as argument'
+            raise StandardError, err_msg  unless arg_evaluated.proper?
+            elems_reversed = arg_evaluated.to_a.reverse
+            result = SkmPair.create_from_a(elems_reversed)
+          end
+          result
+        end
+
+        define_primitive_proc(aRuntime, 'reverse', unary, primitive)
+      end
+
       def create_setcar(aRuntime)
         # Arguments aren't evaluated yet!...
         primitive = ->(runtime, pair_arg, obj_arg) do

data/lib/skeem/primitive/primitive_procedure.rb

@@ -122,7 +122,6 @@ module Skeem
               result = code.call(aRuntime, evaluated_args)
             end
           else
-            # require 'debug'
             args = operands.take(arity.low)
             args.map! { |arg| arg.evaluate(aRuntime) } unless args.empty?
             count_delta = operands.size - arity.low

data/lib/skeem/s_expr_builder.rb

@@ -14,6 +14,7 @@ module Skeem
   class SkmBuilder < Rley::ParseRep::ASTBaseBuilder
     Terminal2NodeClass = {
       'BOOLEAN' => SkmBoolean,
+      'CHAR' => SkmChar,
       'IDENTIFIER' => SkmIdentifier,
       'INTEGER' => SkmInteger,
       'RATIONAL' => SkmRational,

data/lib/skeem/skm_element.rb

@@ -32,6 +32,10 @@ module Skeem
     def boolean?
       false
     end
+    
+    def char?
+      false
+    end
 
     def string?
       false

data/lib/skeem/skm_pair.rb

@@ -98,6 +98,11 @@ module Skeem
         cdr.last_pair
       end
     end
+    
+    def proper?
+      last_node = self.last_pair
+      last_node.cdr.nil? || (last_node.cdr == SkmEmptyList.instance)
+    end
 
     def last
       self.to_a.last

data/lib/skeem/skm_simple_datum.rb

@@ -97,7 +97,7 @@ module Skeem
     def number?
       true
     end
-    
+
     def complex?
       false
     end
@@ -123,7 +123,7 @@ module Skeem
     def real?
       true
     end
-    
+
     def complex?
       true
     end
@@ -132,7 +132,7 @@ module Skeem
       false
     end
   end # class
-  
+
   class SkmRational < SkmReal
     def rational?
       true
@@ -141,7 +141,7 @@ module Skeem
     def exact?
       true
     end
-  end # class  
+  end # class
 
   class SkmInteger < SkmRational
     def integer?
@@ -149,6 +149,12 @@ module Skeem
     end
   end # class
 
+  class SkmChar < SkmSimpleDatum
+    def char?
+      true
+    end  
+  end # class
+
   class SkmString < SkmSimpleDatum
     # Override
     def init_value(aValue)

data/lib/skeem/tokenizer.rb

@@ -78,7 +78,7 @@ module Skeem
     private
 
     def _next_token
-      skip_whitespaces
+      skip_intertoken_spaces
       curr_ch = scanner.peek(1)
       return nil if curr_ch.nil? || curr_ch.empty?
 
@@ -91,10 +91,12 @@ module Skeem
         token = build_token('PERIOD', lexeme)
       elsif (lexeme = scanner.scan(/(?:,@?)|(?:=>)/))
         token = build_token(@@lexeme2name[lexeme], lexeme)
+      elsif (token = recognize_char_token)
+        # Do nothing
       elsif (lexeme = scanner.scan(/#(?:(?:true)|(?:false)|(?:u8)|[\\\(tfeiodx]|(?:\d+[=#]))/))
         token = cardinal_token(lexeme)
       elsif (lexeme = scanner.scan(/[+-]?[0-9]+\/[0-9]+(?=\s|[|()";]|$)/))
-        token = build_token('RATIONAL', lexeme) # Decimal radix        
+        token = build_token('RATIONAL', lexeme) # Decimal radix
       elsif (lexeme = scanner.scan(/[+-]?[0-9]+(?:.0+)?(?=\s|[|()";]|$)/))
         token = build_token('INTEGER', lexeme) # Decimal radix
       elsif (lexeme = scanner.scan(/[+-]?[0-9]+(?:\.[0-9]*)?(?:(?:e|E)[+-]?[0-9]+)?/))
@@ -128,11 +130,6 @@ module Skeem
     end
 
 =begin
-#t #f These are the boolean constants (section 6.3), along
-with the alternatives #true and #false.
-#\ This introduces a character constant (section 6.6).
-#( This introduces a vector constant (section 6.8). Vector
-constants are terminated by ) .
 #u8( This introduces a bytevector constant (section 6.9).
 Bytevector constants are terminated by ) .
 #e #i #b #o #d #x These are used in the notation for
@@ -152,6 +149,23 @@ other literal data (section 2.4).
       return token
     end
 
+    def recognize_char_token()
+      token = nil
+      if lexeme = scanner.scan(/#\\/)
+        if lexeme = scanner.scan(/(?:alarm|backspace|delete|escape|newline|null|return|space|tab)/)
+          token = build_token('CHAR', lexeme, :name)
+        elsif lexeme = scanner.scan(/[^x]/)
+          token = build_token('CHAR', lexeme, :escaped)
+        elsif lexeme = scanner.scan(/x[0-9a-fA-F]+/)
+          token = build_token('CHAR', lexeme, :hex_value)
+        elsif lexeme = scanner.scan(/x/)
+          token = build_token('CHAR', lexeme, :escaped)          
+        end
+      end
+
+      token
+    end
+
     def build_token(aSymbolName, aLexeme, aFormat = :default)
       begin
         (value, symb) = convert_to(aLexeme, aSymbolName, aFormat)
@@ -178,6 +192,8 @@ other literal data (section 2.4).
         symb = 'INTEGER' if value.kind_of?(Integer)
       when 'REAL'
         value = to_real(aLexeme, aFormat)
+      when 'CHAR'
+        value = to_char(aLexeme, aFormat)
       when 'STRING_LIT'
         value = to_string(aLexeme, aFormat)
       when 'IDENTIFIER'
@@ -199,7 +215,7 @@ other literal data (section 2.4).
         value = aLexeme.to_i
       end
 
-      return value
+      value
     end
 
     def to_rational(aLexeme, aFormat)
@@ -209,16 +225,29 @@ other literal data (section 2.4).
         value = value.numerator if value.denominator == 1
       end
 
-      return value
+      value
     end
-    
+
     def to_real(aLexeme, aFormat)
       case aFormat
       when :default
         value = aLexeme.to_f
       end
 
-      return value
+      value
+    end
+
+    def to_char(aLexeme, aFormat)
+      case aFormat
+        when :name
+          value = named_char(aLexeme)
+        when :escaped
+          value = escaped_char(aLexeme)
+        when :hex_value
+          value = hex_value_char(aLexeme)
+      end
+
+      value
     end
 
     def to_string(aLexeme, aFormat)
@@ -239,7 +268,38 @@ other literal data (section 2.4).
       return value
     end
 
-    def skip_whitespaces
+    def named_char(aLexeme)
+      name = aLexeme.sub(/^\#\\/, '')
+      name2char = {
+        'alarm' => ?\a,
+        'backspace' => ?\b,
+        'delete' => ?\x7f,
+        'escape' => ?\e,
+        'newline' => ?\n,
+        'null' => ?\x00,
+        'return' => ?\r,
+        'space' => ?\s,
+        'tab' => ?\t
+      }
+
+      name2char[name]
+    end
+    
+    def escaped_char(aLexeme)
+      aLexeme.chr
+    end
+    
+    def hex_value_char(aLexeme)
+      hex_literal = aLexeme.sub(/^x/, '')
+      hex_value = hex_literal.to_i(16)
+      if hex_value < 0xff
+        hex_value.chr
+      else
+        [hex_value].pack('U')
+      end
+    end
+
+    def skip_intertoken_spaces
       pre_pos = scanner.pos
 
       loop do

data/lib/skeem/version.rb

@@ -1,3 +1,3 @@
 module Skeem
-  VERSION = '0.2.11'.freeze
+  VERSION = '0.2.12'.freeze
 end

data/spec/skeem/interpreter_spec.rb

@@ -718,7 +718,7 @@ SKEEM
           ["(not 'nil)", false]
         ]
         compare_to_predicted(checks)
-      end
+      end      
 
       it 'should implement the list procedure' do
         checks = [

data/spec/skeem/primitive/primitive_builder_spec.rb

@@ -413,6 +413,16 @@ SKEEM
           ]
           compare_to_predicted(checks)
         end
+
+        it 'should implement the boolean=? procedure' do
+          checks = [
+            ['(boolean=? #t #t)', true],
+            ['(boolean=? #f #f)', true],
+            ['(boolean=? #t #f)', false],
+            ['(boolean=? #f #t)', false]
+          ]
+          compare_to_predicted(checks)
+        end
       end # context
 
       context 'String procedures:' do
@@ -444,6 +454,24 @@ SKEEM
           compare_to_predicted(checks)
         end
 
+        it 'should implement the string procedure' do
+          checks = [
+            ['(string)', ''],
+            ['(string #\a #\b #\c)', 'abc'],
+            ['(string #\H #\e #\l #\l #\o #\x021 #\newline)', "Hello!\n"]
+          ]
+          compare_to_predicted(checks)
+        end
+
+        it 'should implement the make-string procedure' do
+          checks = [
+            ['(make-string 0)', ''],
+            ['(make-string 0 #\x)', ''],
+            ['(make-string 5 #\x)', 'x' * 5]
+          ]
+          compare_to_predicted(checks)
+        end
+
         it 'should implement the string-append procedure' do
           checks = [
             ['(string-append)', ''],
@@ -637,6 +665,22 @@ SKEEM
           expect(result.cdr.cdr.cdr).to eq( SkmIdentifier.create('d'))
         end
 
+
+        it 'should implement the reverse procedure' do
+          checks = [
+            ["(reverse '())", SkmEmptyList.instance],
+            ["(reverse '(a b c))", array2list_ids(['c', 'b', 'a'])],
+            ["(reverse '((a) b c))", array2list_ids(['c', 'b']) << SkmPair.new(SkmIdentifier.create('a'), nil)]
+          ]
+          compare_to_predicted(checks) do |result, expectation|
+            if result.kind_of?(SkmPair)
+              expect(result.to_a).to eq(expectation)
+            else
+              expect(result).to eq(expectation)
+            end
+          end
+        end
+
         it 'should implement the list->vector procedure' do
           checks = [
             ["(list->vector '())", []],

data/spec/skeem/tokenizer_spec.rb

@@ -11,6 +11,16 @@ module Skeem
       end
     end
 
+    # Assumption: subject is a Skeem::Tokenizer
+		def check_tokens(tokenTests, tokType)
+		  tokenTests.each do |(input, prediction)|
+        subject.reinitialize(input)
+        token = subject.tokens.first
+        expect(token.terminal).to eq(tokType)
+        expect(token.lexeme).to eq(prediction)
+		  end
+		end
+
     def unquoted(aString)
       aString.gsub(/(^")|("$)/, '')
     end
@@ -52,12 +62,7 @@ module Skeem
           [' #false', false]
         ]
 
-        tests.each do |(input, prediction)|
-          subject.reinitialize(input)
-          token = subject.tokens.first
-          expect(token.terminal).to eq('BOOLEAN')
-          expect(token.lexeme).to eq(prediction)
-        end
+        check_tokens(tests, 'BOOLEAN')
       end
     end # context
 
@@ -73,12 +78,7 @@ module Skeem
           ['-1234', -1234]
         ]
 
-        tests.each do |(input, prediction)|
-          subject.reinitialize(input)
-          token = subject.tokens.first
-          expect(token.terminal).to eq('INTEGER')
-          expect(token.lexeme).to eq(prediction)
-        end
+        check_tokens(tests, 'INTEGER')
       end
     end # context
 
@@ -90,18 +90,13 @@ module Skeem
           ['-22/7', -Rational(22, 7)],
         ]
 
-        tests.each do |(input, prediction)|
-          subject.reinitialize(input)
-          token = subject.tokens.first
-          expect(token.terminal).to eq('RATIONAL')
-          expect(token.lexeme).to eq(prediction)
-        end
-        
+        check_tokens(tests, 'RATIONAL')
+
         # Special case: implicit promotion to integer
         subject.reinitialize('8/4')
         token = subject.tokens.first
         expect(token.terminal).to eq('INTEGER')
-        expect(token.lexeme).to eq(2)        
+        expect(token.lexeme).to eq(2)
       end
     end # context
 
@@ -115,12 +110,43 @@ module Skeem
           ['123e+45', 1.23e+47]
         ]
 
-        tests.each do |(input, prediction)|
-          subject.reinitialize(input)
-          token = subject.tokens.first
-          expect(token.terminal).to eq('REAL')
-          expect(token.lexeme).to eq(prediction)
-        end
+        check_tokens(tests, 'REAL')
+      end
+    end # context
+
+    context 'Character literal recognition:' do
+      it 'should tokenize named characters' do
+        tests = [
+          # couple [raw input, expected]
+          ["#\\alarm", ?\a],
+          ["#\\newline", ?\n],
+          ["#\\return", ?\r]
+        ]
+
+        check_tokens(tests, 'CHAR')
+      end
+
+      it 'should tokenize escaped characters' do
+        tests = [
+          # couple [raw input, expected]
+          ["#\\a", ?a],
+          ["#\\A", ?A],
+          ["#\\(", ?(],
+          ["#\\ ", ?\s]
+        ]
+
+        check_tokens(tests, 'CHAR')
+      end
+
+      it 'should tokenize hex-coded characters' do
+        tests = [
+          # couple [raw input, expected]
+          ["#\\x07", ?\a],
+          ["#\\x1B", ?\e],
+          ["#\\x3BB", ?\u03bb]
+        ]
+
+        check_tokens(tests, 'CHAR')
       end
     end # context
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: skeem
 version: !ruby/object:Gem::Version
-  version: 0.2.11
+  version: 0.2.12
 platform: ruby
 authors:
 - Dimitri Geshef
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-16 00:00:00.000000000 Z
+date: 2019-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rley