delorean_lang 0.5.4 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afc7142d7683c1fe4d606a86dd7c46eff3ae672b1eb58db13cb587c18b9ea741
-  data.tar.gz: a522e77939cbcaa4b8592980ced9281179a07e171fe3e34b69adba13661a8215
+  metadata.gz: 2c6e040929f0803bd19bee9c0cd459a1a1bdcbdc20e99da3998a2e8c7f0ef1d3
+  data.tar.gz: 175ad860916a349b6a7bfe493e17a4e6c18a7eaaf3ce5625e7a71117f49581fa
 SHA512:
-  metadata.gz: 03b53dcf912b0311f12151e6fa189e797f767205cd36d6aac6547d58ab6fad6cfbe6905766caae199c15d4898360829a2249379d61634fec98062fc33753b8ae
-  data.tar.gz: d21c189ed7f03b98cc5c21525a1c031b4a6d43477291744a7016e75f411ca9aad5cafe4c2b87451059036438d5c60d6c14fc9a94fd703be7f902b802dfbe2fe2
+  metadata.gz: 51d8f5e885171313517eab09ea2536bfb807aae2fde1e450ccce5ffabf4b3250dfebd84384f32a67856d6eaa00fc8b8c56cd15ec2c9d7b07f7a48e84495e994d
+  data.tar.gz: 9896fef50b9852c7347048e5db5d4bb4412a78beb218d46117b0c805e8a9eccc3cb63aada6b9a04abf042d0357ea2e05977b9ab25e8f46acd662ef283c24b44e

data/.rubocop.yml

@@ -17,8 +17,7 @@ Style/StringLiterals:
 Metrics/LineLength:
   Max: 80
   Exclude:
-    - 'spec/func_spec.rb'
-    - 'spec/parse_spec.rb'
+    - 'spec/**/*'
 
 Metrics/ModuleLength:
   Max: 100
@@ -78,3 +77,7 @@ Naming/HeredocDelimiterCase:
 
 Naming/RescuedExceptionsVariableName:
   Enabled: false
+
+Metrics/ParameterLists:
+  Exclude:
+    - 'spec/spec_helper.rb'

data/Gemfile

@@ -4,8 +4,3 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in delorean.gemspec
 gemspec
-
-group :development, :test do
-  gem 'pry'
-  gem 'rspec-instafail', require: false
-end

data/README.md

@@ -172,6 +172,10 @@ There are two ways of calling ruby code from delorean. First one is to whitelist
     method.called_on Enumerable, with: [Integer]
   end
 
+  ::Delorean::Ruby.whitelist.add_class_method :last do |method|
+    method.called_on ActiveRecord::Base, with: [Integer]
+  end
+
 ```
 
 By default Delorean has some methods whitelisted, such as `length`, `min`, `max`, etc. Those can be found in `/lib/delorean/ruby/whitelists/default`. If you don't want to use defaults, you can override whitelist with and empty one.

data/delorean.gemspec

@@ -21,6 +21,7 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'treetop', '~> 1.5'
   gem.add_development_dependency 'pry'
   gem.add_development_dependency 'rspec', '~> 2.1'
+  gem.add_development_dependency 'rspec-instafail'
   gem.add_development_dependency 'rubocop'
   gem.add_development_dependency 'rubocop-performance'
   gem.add_development_dependency 'sqlite3', '~> 1.3.10'

data/lib/delorean/base.rb

@@ -160,15 +160,16 @@ module Delorean
           raise "bad method #{method}"
         end
 
-        # FIXME: this is pretty hacky -- should probably merge
-        # whitelist and SIG mechanisms.
         if obj.is_a?(Class) || obj.is_a?(Module)
-          _e[:_engine].parse_check_call_fn(method, args.count, obj)
-          return obj.send(msg, *args)
+          matcher = ::Delorean::Ruby.whitelist.class_method_matcher(
+            method_name: msg
+          )
+          klass = obj
+        else
+          matcher = ::Delorean::Ruby.whitelist.matcher(method_name: msg)
+          klass = obj.class
         end
 
-        matcher = ::Delorean::Ruby.whitelist.matcher(method_name: msg)
-
         raise "no such method #{method}" unless matcher
 
         if matcher.match_to?
@@ -177,7 +178,7 @@ module Delorean
           )
         end
 
-        matcher.match!(klass: obj.class, args: args)
+        matcher.match!(klass: klass, args: args)
 
         obj.send(msg, *args)
       end

data/lib/delorean/const.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 module Delorean
-  SIG = '_SIG'.freeze
-  MOD = 'DELOREAN__'.freeze
-  POST = '__D'.freeze
+  MOD = 'DELOREAN__'
+  POST = '__D'
 end

data/lib/delorean/engine.rb

@@ -202,7 +202,7 @@ module Delorean
       raise exc.new(msg, @module_name, curr_line)
     end
 
-    def parse_check_call_fn(fn, argcount, class_name = nil)
+    def parse_check_call_fn(fn, _argcount, class_name = nil)
       klass = case class_name
               when nil
                 @m::BaseClass
@@ -214,20 +214,6 @@ module Delorean
 
       err(UndefinedFunctionError, "Function #{fn} not found") unless
         klass.methods.member? fn.to_sym
-
-      # signature methods must be named FUNCTION_NAME_SIG
-      sig = "#{fn}#{SIG}".upcase.to_sym
-
-      err(UndefinedFunctionError, "Signature #{sig} not found") unless
-        klass.constants.member? sig
-
-      min, max = klass.const_get(sig)
-
-      err(BadCallError, "Too many args to #{fn} (#{argcount} > #{max})") if
-        argcount > max
-
-      err(BadCallError, "Too few args to #{fn} (#{argcount} < #{min})") if
-        argcount < min
     end
 
     def parser

data/lib/delorean/functions.rb

@@ -2,19 +2,14 @@
 
 module Delorean
   module Functions
-    def delorean_fn(name, options = {})
-      define_singleton_method(name) do |*args|
-        yield(*args)
-      end
-
-      sig = options[:sig]
+    def delorean_fn(name, _options = {}, &block)
+      any_args = Delorean::Ruby::Whitelists::Matchers::Arguments::ANYTHING
 
-      raise 'no signature' unless sig
+      define_singleton_method(name, block)
 
-      sig = [sig, sig] if sig.is_a? Integer
-      raise 'Bad signature' unless sig.is_a?(Array) && (sig.length == 2)
-
-      const_set(name.to_s.upcase + Delorean::SIG, sig)
+      ::Delorean::Ruby.whitelist.add_class_method name do |method|
+        method.called_on self, with: any_args
+      end
     end
 
     # FIXME: IDEA: we just make :cache an argument to delorean_fn.

data/lib/delorean/nodes.rb

@@ -400,13 +400,13 @@ eos
       end
 
       if vcode.is_a?(ClassText)
+        # FIXME: Do we really need this check here?
         # ruby class call
         class_name = vcode.text
         context.parse_check_call_fn(i.text_value, arg_count, class_name)
-        "#{class_name}.#{i.text_value}(#{args_str})"
-      else
-        "_instance_call(#{vcode}, '#{i.text_value}', [#{args_str}], _e)"
       end
+
+      "_instance_call(#{vcode}, '#{i.text_value}', [#{args_str}], _e)"
     end
   end
 

data/lib/delorean/ruby/whitelists/base.rb

@@ -8,6 +8,7 @@ module Delorean
     module Whitelists
       class Base
         attr_reader :matchers
+        attr_reader :class_method_matchers
 
         def add_method(method_name, match_to: nil, &block)
           return method_name_error unless method_name.is_a?(Symbol)
@@ -19,19 +20,48 @@ module Delorean
             )
           end
 
+          matcher = matchers[method_name.to_sym]
+
+          return matcher.extend_matcher(&block) if matcher
+
           matchers[method_name.to_sym] = method_matcher_class.new(
             method_name: method_name, &block
           )
         end
 
+        def add_class_method(method_name, match_to: nil, &block)
+          return method_name_error unless method_name.is_a?(Symbol)
+          return block_and_match_error if !match_to.nil? && block_given?
+
+          unless match_to.nil?
+            return add_class_matched_method(
+              method_name: method_name, match_to: match_to
+            )
+          end
+
+          matcher = class_method_matchers[method_name.to_sym]
+
+          return matcher.extend_matcher(&block) if matcher
+
+          class_method_matchers[method_name.to_sym] = method_matcher_class.new(
+            method_name: method_name, &block
+          )
+        end
+
         def matcher(method_name:)
           matchers[method_name.to_sym]
         end
 
+        def class_method_matcher(method_name:)
+          class_method_matchers[method_name.to_sym]
+        end
+
         private
 
         def initialize
           @matchers = {}
+          @class_method_matchers = {}
+
           initialize_hook
         end
 
@@ -39,13 +69,24 @@ module Delorean
           correct_match_to = match_to.is_a?(String) || match_to.is_a?(Symbol)
           return wrong_match_to_error unless correct_match_to
 
-          matcher = ::Delorean::Ruby::Whitelists::Matchers::Method.new(
+          matcher = method_matcher_class.new(
             method_name: method_name, match_to: match_to.to_sym
           )
 
           matchers[method_name.to_sym] = matcher
         end
 
+        def add_class_matched_method(method_name:, match_to:)
+          correct_match_to = match_to.is_a?(String) || match_to.is_a?(Symbol)
+          return wrong_match_to_error unless correct_match_to
+
+          matcher = method_matcher_class.new(
+            method_name: method_name, match_to: match_to.to_sym
+          )
+
+          class_method_matchers[method_name.to_sym] = matcher
+        end
+
         def block_and_match_error
           raise(
             ::Delorean::Ruby::Whitelists::WhitelistError,

data/lib/delorean/ruby/whitelists/matchers/arguments.rb

@@ -5,6 +5,8 @@ module Delorean
     module Whitelists
       module Matchers
         class Arguments
+          ANYTHING = :_delorean_anything
+
           attr_reader :called_on, :method_name, :with
 
           def initialize(called_on:, method_name:, with: [])
@@ -14,6 +16,8 @@ module Delorean
           end
 
           def match!(args:)
+            return if with == ANYTHING
+
             raise "too many args to #{method_name}" if args.size > with.size
 
             with.each_with_index do |s, i|

data/lib/delorean/ruby/whitelists/matchers/method.rb

@@ -23,6 +23,12 @@ module Delorean
             )
 
             arguments_matchers << matcher
+
+            # Sort matchers by reversed ancestors chain length, so
+            # matcher method would find the closest ancestor in hierarchy
+            arguments_matchers.sort_by! do |obj|
+              -obj.called_on.ancestors.size
+            end
           end
 
           def matcher(klass:)
@@ -42,6 +48,10 @@ module Delorean
           def match_to?
             !match_to.nil?
           end
+
+          def extend_matcher
+            yield self if block_given?
+          end
         end
       end
     end

data/lib/delorean/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Delorean
-  VERSION = '0.5.4'.freeze
+  VERSION = '0.6.0'
 end

data/spec/eval_spec.rb

@@ -371,6 +371,83 @@ eoc
     r.should == 867 + 5309
   end
 
+  it 'should be able call method defined in a parent or matched to' do
+    engine.parse defn(
+      'A:',
+      '    b = DeloreanFunctionsChildClass.test_fn',
+      '    c = DeloreanFunctionsChildClass.test_fn2',
+      '    d = DifferentClassSameMethod.test_fn2',
+      '    e = DifferentClassSameMethod.match_to_test_fn2',
+    )
+
+    r = engine.evaluate('A', 'b')
+    r.should == :test_fn_result
+
+    r = engine.evaluate('A', 'c')
+    r.should == :test_fn2_result
+
+    r = engine.evaluate('A', 'd')
+    r.should == :test_fn2_result_different
+
+    r = engine.evaluate('A', 'e')
+    r.should == :test_fn2_result_different
+  end
+
+  it 'should raise exception if method is not whitelisted' do
+    engine.parse defn(
+      'A:',
+      '    a = DeloreanFunctionsChildClass.test_fn4',
+      '    b = DeloreanFunctionsChildClass.test_fn4()',
+      '    c = Dummy.this_is_crazy()',
+    )
+
+    lambda {
+      engine.evaluate('A', 'a')
+    }.should raise_error(
+      Delorean::InvalidGetAttribute,
+      "attr lookup failed: 'test_fn4' on <Class> DeloreanFunctionsChildClass - no such method test_fn4"
+    )
+
+    lambda {
+      engine.evaluate('A', 'b')
+    }.should raise_error(RuntimeError, 'no such method test_fn4')
+
+    lambda {
+      engine.evaluate('A', 'c')
+    }.should raise_error(RuntimeError, 'no such method this_is_crazy')
+  end
+
+  it 'should raise exception if required arguments are missing' do
+    engine.parse defn(
+      'A:',
+      '    a = DifferentClassSameMethod.test_fn3(1, 2, 3, 4, 5,
+                                                 6, 7, 8, 9, 10)',
+      '    b = DifferentClassSameMethod.test_fn3(1, 2, 3, 4) ',
+      '    c = DifferentClassSameMethod.test_fn3(1, 2) ',
+      '    d = DifferentClassSameMethod.test_fn3() ',
+    )
+
+    r = engine.evaluate('A', 'a')
+    r.should == { a: 1, b: 2, c: 3, d: 4, e: 5, rest: [6, 7, 8, 9, 10] }
+
+    r = engine.evaluate('A', 'b')
+    r.should == { a: 1, b: 2, c: 3, d: 4, e: nil, rest: [] }
+
+    lambda {
+      r = engine.evaluate('A', 'c')
+    }.should raise_error(
+      ArgumentError,
+      'wrong number of arguments (given 2, expected 3+)'
+    )
+
+    lambda {
+      r = engine.evaluate('A', 'd')
+    }.should raise_error(
+      ArgumentError,
+      'wrong number of arguments (given 0, expected 3+)'
+    )
+  end
+
   it 'should ignore undeclared params sent to eval which match attr names' do
     engine.parse defn('A:',
                       '    d = 12',

data/spec/parse_spec.rb

@@ -393,21 +393,21 @@ describe 'Delorean' do
                      )
   end
 
-  it 'should get exception on arg count to class method call' do
-    lambda {
-      engine.parse defn('A:',
-                        '    b = Dummy.i_just_met_you(1, 2, 3)',
-                       )
-    }.should raise_error(Delorean::BadCallError)
-  end
-
-  it "shouldn't be able to call ActiveRecord methods without signature" do
-    lambda {
-      engine.parse defn('A:',
-                        '    b = Dummy.this_is_crazy()',
-                       )
-    }.should raise_error(Delorean::UndefinedFunctionError)
-  end
+  # it 'should get exception on arg count to class method call' do
+  # lambda {
+  # engine.parse defn('A:',
+  # '    b = Dummy.i_just_met_you(1, 2, 3)',
+  # )
+  # }.should raise_error(Delorean::BadCallError)
+  # end
+  #
+  # it "shouldn't be able to call ActiveRecord methods without signature" do
+  # lambda {
+  # engine.parse defn('A:',
+  # '    b = Dummy.this_is_crazy()',
+  # )
+  # }.should raise_error(Delorean::UndefinedFunctionError)
+  # end
 
   it 'should be able to call class methods on ActiveRecord classes in modules' do
     engine.parse defn('A:',

data/spec/ruby/whitelist_spec.rb

@@ -5,11 +5,14 @@ require 'delorean/ruby/whitelists/empty'
 
 describe 'Delorean Ruby whitelisting' do
   it 'allows to override whitelist with an empty one' do
+    old_whitelist = ::Delorean::Ruby.whitelist
     ::Delorean::Ruby.whitelist = whitelist
     expect(whitelist.matchers).to be_empty
 
     ::Delorean::Ruby.whitelist = ::Delorean::Ruby::Whitelists::Default.new
     expect(::Delorean::Ruby.whitelist.matchers).to_not be_empty
+
+    ::Delorean::Ruby.whitelist = old_whitelist
   end
 
   let(:whitelist) { ::Delorean::Ruby::Whitelists::Empty.new }
@@ -76,4 +79,108 @@ describe 'Delorean Ruby whitelisting' do
       expect(matcher.match_to?).to be true
     end
   end
+
+  describe 'class_methods' do
+    let(:method_matcher) do
+      Delorean::Ruby.whitelist.class_method_matcher(method_name: :test_method)
+    end
+
+    let(:engine) do
+      engine = Delorean::Engine.new 'XXX'
+
+      engine.parse defn(
+        'A:',
+        '    a = RootClass.test_method(1)',
+        '    b = RootClass.test_method(true)',
+        '    c = RootClassChild.test_method("test")',
+        '    d = RootClassChild.test_method(1)',
+        '    e = RootClassChildsChild.test_method(true)',
+        '    f = RootClassChildsChild.test_method(1)',
+        '    g = RootClassChildsChildsChild.test_method(true)',
+        '    h = RootClassChildsChildsChild.test_method(1)',
+        '    i = RootClassChildsChildsChild.test_method()',
+        '    j = RootClassChildsChildsChild.test_method',
+        '    k = RootClassChildsChildsChild.test_method(true, true)',
+        '    l = RootClassChildsChildsChild.test_method2(true)'
+      )
+
+      engine
+    end
+
+    it 'fetches the closest method matcher in class hierarchy' do
+      arg_matcher = method_matcher.matcher(klass: RootClass)
+      expect(arg_matcher.with).to eq [Integer]
+
+      arg_matcher = method_matcher.matcher(klass: RootClassChild)
+      expect(arg_matcher.with).to eq [String]
+
+      arg_matcher = method_matcher.matcher(klass: RootClassChildsChild)
+      expect(arg_matcher.with).to eq [TrueClass]
+
+      arg_matcher = method_matcher.matcher(klass: RootClassChildsChildsChild)
+      expect(arg_matcher.with).to eq [TrueClass]
+    end
+
+    it 'allows to call methods correctly' do
+      r = engine.evaluate('A', 'a')
+      expect(r).to eq :test_method_with_int_arg
+
+      r = engine.evaluate('A', 'c')
+      expect(r).to eq :test_method_with_str_arg
+
+      r = engine.evaluate('A', 'e')
+      expect(r).to eq :test_method_with_true_arg
+
+      r = engine.evaluate('A', 'g')
+      expect(r).to eq :test_method_with_true_arg
+    end
+
+    it 'raises exception if argument type mismatched' do
+      expect { engine.evaluate('A', 'b') }.to raise_error(
+        RuntimeError,
+        'bad arg 0, method test_method: true/TrueClass [Integer]'
+      )
+
+      expect { engine.evaluate('A', 'd') }.to raise_error(
+        RuntimeError,
+        'bad arg 0, method test_method: 1/Integer [String]'
+      )
+
+      expect { engine.evaluate('A', 'f') }.to raise_error(
+        RuntimeError,
+        'bad arg 0, method test_method: 1/Integer [TrueClass]'
+      )
+
+      expect { engine.evaluate('A', 'h') }.to raise_error(
+        RuntimeError,
+        'bad arg 0, method test_method: 1/Integer [TrueClass]'
+      )
+    end
+
+    it 'raises exception if argument is not present' do
+      expect { engine.evaluate('A', 'i') }.to raise_error(
+        RuntimeError,
+        'bad arg 0, method test_method: /NilClass [TrueClass]'
+      )
+
+      expect { engine.evaluate('A', 'j') }.to raise_error(
+        Delorean::InvalidGetAttribute,
+        "attr lookup failed: 'test_method' on <Class> RootClassChildsChildsChild - bad arg 0, method test_method: /NilClass [TrueClass]"
+      )
+    end
+
+    it 'raises exception if too many arguments' do
+      expect { engine.evaluate('A', 'k') }.to raise_error(
+        RuntimeError,
+        'too many args to test_method'
+      )
+    end
+
+    it 'raises exception method is not whitelisted' do
+      expect { engine.evaluate('A', 'l') }.to raise_error(
+        RuntimeError,
+        'no such method test_method2'
+      )
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -3,10 +3,10 @@
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
+require 'pry'
 require 'rspec'
 require 'delorean_lang'
 require 'active_record'
-require 'pry'
 
 # Requires supporting files with custom matchers and macros, etc,
 # in ./support/ and its subdirectories.
@@ -36,18 +36,14 @@ class Dummy < ActiveRecord::Base
 
   belongs_to :dummy
 
-  def self.i_just_met_you(name, number)
+  delorean_fn :i_just_met_you do |name, number|
     Dummy.new(name: name, number: number)
   end
 
-  I_JUST_MET_YOU_SIG = [1, 2].freeze
-
-  def self.call_me_maybe(*a)
+  delorean_fn :call_me_maybe do |*a|
     a.inject(0, :+)
   end
 
-  CALL_ME_MAYBE_SIG = [0, Float::INFINITY].freeze
-
   def self.this_is_crazy; end
 
   def self.miss_you_so_bad
@@ -55,18 +51,14 @@ class Dummy < ActiveRecord::Base
     Dummy.new(name: 'jello', number: 456, dummy: d)
   end
 
-  MISS_YOU_SO_BAD_SIG = [0, 0].freeze
-
   delorean_fn :all_of_me, sig: 0 do
     [{ 'name' => 'hello', 'foo' => 'bar' }]
   end
 
-  def self.i_threw_a_hash_in_the_well
+  delorean_fn :i_threw_a_hash_in_the_well do
     { a: 123, 'a' => 456, b: 789 }
   end
 
-  I_THREW_A_HASH_IN_THE_WELL_SIG = [0, 0].freeze
-
   def name2
     "#{name}-#{number.round(4)}"
   end
@@ -96,7 +88,6 @@ class DummyChild < Dummy
   def self.hello
     DummyChild.new(name: 'child', number: 99_999)
   end
-  HELLO_SIG = [0, 0].freeze
 end
 
 module M
@@ -106,10 +97,10 @@ module M
     delorean_fn(:heres_my_number, sig: [0, Float::INFINITY]) do |*a|
       a.inject(0, :+)
     end
+
     def self.sup
       LittleDummy.new
     end
-    SUP_SIG = [0, 0].freeze
   end
 
   module N
@@ -134,6 +125,80 @@ module M
   DummyModule = ::DummyModule
 end
 
+class DeloreanFunctionsClass
+  extend Delorean::Functions
+
+  delorean_fn :test_fn, sig: 0 do
+    :test_fn_result
+  end
+end
+
+class DeloreanFunctionsChildClass < DeloreanFunctionsClass
+  delorean_fn :test_fn2, sig: 0 do
+    :test_fn2_result
+  end
+
+  def self.test_fn4; end
+end
+
+class DifferentClassSameMethod
+  extend Delorean::Functions
+
+  delorean_fn :test_fn2, sig: 0 do
+    :test_fn2_result_different
+  end
+
+  delorean_fn :test_fn3, sig: 0 do |a, b, c, d = :default, e = nil, *args|
+    {
+      a: a,
+      b: b,
+      c: c,
+      d: d,
+      e: e,
+      rest: args
+    }
+  end
+end
+
+class RootClass
+  def self.test_method(_int_arg)
+    :test_method_with_int_arg
+  end
+end
+
+Delorean::Ruby.whitelist.add_class_method :test_method do |method|
+  method.called_on RootClass, with: [Integer]
+end
+
+class RootClassChild < RootClass
+  def self.test_method(_str_arg)
+    :test_method_with_str_arg
+  end
+end
+
+Delorean::Ruby.whitelist.add_class_method :test_method do |method|
+  method.called_on RootClassChild, with: [String]
+end
+
+class RootClassChildsChild < RootClassChild
+  def self.test_method(_true_arg)
+    :test_method_with_true_arg
+  end
+end
+
+Delorean::Ruby.whitelist.add_class_method :test_method do |method|
+  method.called_on RootClassChildsChild, with: [TrueClass]
+end
+
+class RootClassChildsChildsChild < RootClassChildsChild
+  def self.test_method2(bool_arg); end
+end
+
+Delorean::Ruby.whitelist.add_class_method(
+  :match_to_test_fn2,
+  match_to: :test_fn2
+)
+
 ######################################################################
 
 class TestContainer < Delorean::AbstractContainer

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delorean_lang
 version: !ruby/object:Gem::Version
-  version: 0.5.4
+  version: 0.6.0
 platform: ruby
 authors:
 - Arman Bostani
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-08 00:00:00.000000000 Z
+date: 2019-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: rspec-instafail
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement