liveunit 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b96000301a521657a5e4b992d250c36cddc730ef
+  data.tar.gz: 8d6f9e073f1df38e909c5d3ffddd762e11487439
+SHA512:
+  metadata.gz: 5420ce45c866f5dad307fc99cee4570b50fab5c94eab181998dd4d7bf54cb4dcf87d10c0b744871504ec81fa5a6f4b0efc1c637ec47f32f13a7559242be787cf
+  data.tar.gz: e025028fb0070a44b7656cc23013707fec02d3e544c0f5e05ff527b13aedbfa112e4e3df25271b6f5e6c4c51c9dc84faec0e25c86b9a6ce2e65c59e445ecc515

data/.editorconfig

@@ -0,0 +1,18 @@
+# EditorConfig helps developers define and maintain consistent
+# coding styles between different editors and IDEs
+# editorconfig.org
+
+root = true
+
+[*]
+
+indent_style = space
+indent_size = 2
+
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+gem 'after_do'
+gem 'minitest'

data/Gemfile.lock

@@ -0,0 +1,14 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    after_do (0.3.1)
+    minitest (5.6.0)
+    rake (10.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  after_do
+  minitest
+  rake

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) <2015> <Zisis Maras - contact@zisismaras.me>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,93 @@
+# LiveUnit
+
+Example implementation to test my experiment on live unit testing.  
+Check the blog post here.  
+
+##Installing
+```ruby
+gem install liveunit
+```
+##Using
+Include the module and place the evaluate_me method call in the entry point of your object(eg. the `initialize` method)  
+
+```ruby
+require 'liveunit'
+
+class Example
+  include LiveUnit
+  def initialize
+    evaluate_me #!
+    @myvar = 15
+  end
+  def calculate(num)
+    num + 10
+  end
+end
+
+ex = Example.new
+puts ex.calculate(40)
+```
+
+Then let's create a test for our calculate method in a `livetest/test_example.rb` file:  
+```ruby
+require 'liveunit/testcase'
+
+class TestExample < LiveUnit::TestCase
+  #doomed to fail
+  def test_calculate
+    msg "Result should be greater than 400 when @myvar==15"
+    assert_equal(15, state[:@myvar])
+    assert_operator myreturn, :>=, 400
+  end
+end
+``` 
+
+Run the program and you should see this :
+```
+Failure : TestExample#test_calculate
+Message : Result should be greater than 400 when @myvar==15
+Expected 50 to be >= 400.
+``` 
+
+## Features/Problems
+The minitest's assertion system is used so most assert operations should work.  
+Autoloading and discovering is quite dumb so certain conventions must be followed:  
+
+1. Test files should be placed in a /livetest folder in the program's root directory.
+2. Test file name should be in a format of `test_objectname.rb`.
+3. Unit test suite has to be in a format of `class TestObjectName < LiveUnit::TestCase`
+4. Unit test method should be named `def test_method_name`  
+
+It has not been tested with more complex things like rack applications or anything that actually matters, only simple plain ruby programs.  
+Runtime overhead is significant.  
+
+## Creating custom reporters
+By default a reporter that writes to stdout will be used but it can be easily changed.  
+Let's create a reporter that writes to a log file, just subclass `LiveUnit::Reporter` and overwrite the `report` method.
+The `report` method gets executed after each test and the results are available in the `results` method.   
+```ruby
+require 'logger'
+require 'liveunit/reporter'
+
+class MyReporter < LiveUnit::Reporter
+  def initialize
+    @logger = Logger.new('logs')
+    super
+  end
+
+  def report
+    results.each do |re|
+      @logger.error("Case : #{re[:case]} Failed.")
+      @logger.error("Message : #{re[:msg]}")
+      @logger.error("Enviroment : #{re[:env]}")
+      @logger.error("Expectation : #{re[:expectation]}")
+    end
+  end
+end
+``` 
+then just pass it to the evaluate_me method : `evaluate_me(MyReporter)`  
+
+## Final Notice
+Make sure you also read the blog post if you are interested.  
+This is not meant to be used in anything serious(it can't anyway)  
+It is just an experimental testing tool and will be probably die soon.

data/lib/liveunit.rb

@@ -0,0 +1,91 @@
+require "after_do"
+require_relative "liveunit/evaluator.rb"
+require_relative "liveunit/loader.rb"
+require_relative "liveunit/print_reporter.rb"
+
+##
+#Core parent module, everything lives inside it
+module LiveUnit
+  extend self
+  ##
+  #inject the required liveunit's methods when the module is included
+  def self.included(klass)
+    unless klass.instance_methods.include?(:evaluator)
+      body = Proc.new { |reporter=LiveUnit::PrintReporter|
+        @_liveunit_evaluator = LiveUnit::Evaluator.new(self)
+        if self.methods.select{|m| m.match(/^liveunit/)}.empty?
+          LiveUnit.track_methods(self, first_pass=true)
+        else
+          LiveUnit.track_methods(self, first_pass=false)
+        end
+        @_liveunit_reporter = @_liveunit_evaluator.create_reporter(klass, reporter)
+        LiveUnit::Loader.new.require_directory("./livetest")
+      }
+      klass.send(:define_method, :evaluate_me, body)
+      body = Proc.new { @_liveunit_evaluator }
+      klass.send(:define_method, :evaluator, body)
+      body = Proc.new { @_liveunit_reporter }
+      klass.send(:define_method, :reporter, body)
+    end
+  end
+
+  ##
+  #tracks all the object's methods
+  #if we have already modified the class, don't redefine again and just create the callbacks
+  def track_methods(obj, first_pass)
+    my_methods =  obj.class.instance_methods(false)
+    my_methods.delete(:evaluate_me)
+    my_methods.delete(:evaluator)
+    my_methods.delete(:reporter)
+    my_methods.delete(:loader)
+    if first_pass
+      my_methods.each do |m|
+        redefine(obj, m)
+        create_callbacks_for(obj, m)
+      end
+    else
+      my_methods.each do |m|
+        create_callbacks_for(obj, m)
+      end
+    end
+  end
+
+  private
+  ##
+  #we alias the method and then wrap it as proc we can keep track of the returned value
+  def redefine(obj, meth)
+    obj.class.class_eval { alias_method "liveunit_#{meth}".to_sym, meth }
+    obj.class.class_eval <<-END_EVAL, __FILE__, __LINE__ + 1
+      def #{meth}(*args)
+        method_proc = self.method("liveunit_#{meth}".to_sym).to_proc
+        @liveunit_#{meth} = method_proc.call(*args)
+        #@liveunit_#{meth}_binding = method_proc.binding
+        @_liveunit_snapshot =  @_liveunit_evaluator.liveunit_snapshot("#{meth}")
+        @liveunit_#{meth}
+      end
+    END_EVAL
+  end
+
+  ##
+  #creates <evaluate> and <report> callbacks to be run after the method has finished
+  def create_callbacks_for(obj, meth)
+    obj.class.extend AfterDo
+    obj.class.after "#{meth.to_sym}" do
+      snapshot = obj.instance_variable_get("@_liveunit_snapshot")
+      obj.instance_variable_get("@_liveunit_evaluator").evaluate(snapshot)
+      obj.instance_variable_get("@_liveunit_reporter").report
+    end
+  end
+
+end
+
+#replace the eval
+
+#body_proc = Proc.new { |*args|
+  #method_proc = obj.class.method("liveunit_#{meth}".to_sym).to_proc
+  #instance_variable_set("@liveunit_#{meth}".to_sym, method_proc.call(*args))
+  #instance_variable_set("@liveunit_#{meth}_snapshot".to_sym, @_liveunit_evaluator.liveunit_snapshot)
+  ##instance_variable_set("@liveunit_#{meth}_binding".to_sym, method_proc.binding)
+ # instance_variable_get("@liveunit_#{meth}".to_sym)
+#}
+#obj.class.send(:define_method, "#{meth}".to_sym, body_proc)

data/lib/liveunit/evaluator.rb

@@ -0,0 +1,81 @@
+module LiveUnit
+  ##
+  #core evaluator class, gets instantiated when the module is included
+  class Evaluator
+
+    def initialize(obj)
+      @obj = obj
+    end
+    ##
+    #this will be run as a callback after every method we want to evaluate has finished,
+    #uses the snapshot taken, runs the corresponding test file and stores the results
+    def evaluate(snapshot)
+      unit, suite, obj_env, myreturn = snapshot
+      test = "test_#{unit}"
+      if Module.const_defined?("Test#{suite}")
+        test_class = Module.const_get("Test#{suite}").new(obj_env, @obj.clone, myreturn)
+        test_class.send(test)
+        unless test_class.passed?
+          @obj.reporter.liveunit_results.push(
+          :case => "#{test_class.class}##{test}",
+          :msg => test_class.msg,
+          :expectation => test_class.result_msg,
+          :env => obj_env
+          )
+          @obj.reporter.liveunit_fails += 1
+        else
+          @obj.reporter.liveunit_passes += 1
+        end
+        @obj.reporter.liveunit_assertions += 1
+        test_class.passed?
+      else
+        true
+      end
+    end
+
+    ##
+    #captures the state that will be passed later to <evaluate>
+    def liveunit_snapshot(unit)
+      suite = @obj.class
+      instanced = @obj.instance_variables
+      consts = @obj.class.constants
+      globals = global_variables
+      classed = @obj.class.class_variables
+      obj_env = set_env(@obj, unit, instanced, consts, globals, classed)
+      myreturn =@obj.instance_variable_get("@liveunit_#{unit}".to_sym)
+      [unit, suite, obj_env, myreturn]
+    end
+
+    ##
+    #creates the reporter for each object that will be getting evaluated
+    def create_reporter(me, rep)
+      if LiveUnit.const_defined?("#{me}Reporter")
+        LiveUnit.const_get("#{me}Reporter").new
+      else
+        LiveUnit.const_set("#{me}Reporter", Class.new(rep)).new
+      end
+    end
+
+    private
+    ##
+    #returnes the current object's state env, exluding liveunit specific variables
+    def set_env(obj, unit, instanced, consts, globals, classed)
+      my_env = {}
+      instanced.delete(:@_liveunit_evaluator)
+      instanced.delete(:@_liveunit_snapshot)
+      instanced.delete(:@_liveunit_reporter)
+      instanced.delete("@liveunit_#{unit}".to_sym)
+      instanced.each do |varname|
+        my_env.merge!({varname => obj.instance_variable_get(varname)})
+      end
+      consts.each do |con|
+        my_env.merge!({con => obj.class.const_get(con)})
+      end
+      classed.each do |varname|
+        my_env.merge!({varname => obj.class.class_variable_get(varname)})
+      end
+      my_env
+    end
+
+  end
+end

data/lib/liveunit/loader.rb

@@ -0,0 +1,21 @@
+module LiveUnit
+  ##
+  #loads all the required test files when the <evaluate_me> method is called
+  class Loader
+    ##
+    #extracted from require_directory gem
+    def require_directory(dir, add_to_load_path = false, skip_invalid_syntax = false)
+      raise "Not a directory: #{dir}" unless File.directory?(dir)
+      if add_to_load_path
+        $LOAD_PATH << dir
+      end
+      Dir.glob(File.join(dir + '/**/*.rb')).each do |file|
+        if (skip_invalid_syntax && !(`/usr/bin/env ruby -c #{file}` =~ /Syntax OK/m))
+          warn "Invalid syntax in: #{file}"
+          next
+        end
+        require file
+      end
+    end
+  end
+end

data/lib/liveunit/print_reporter.rb

@@ -0,0 +1,18 @@
+require_relative "reporter.rb"
+
+module LiveUnit
+  ##
+  #default reporter that writes results to stdout
+  class PrintReporter < LiveUnit::Reporter
+      def report
+        results.each do |re|
+          puts "Failure : " + re[:case]
+          puts "Message : " + re[:msg]
+          puts re[:expectation]
+          #skip printing the env, too much noise
+          #puts "Environment : " + re[:env].to_s
+          puts
+        end
+      end
+  end
+end

data/lib/liveunit/reporter.rb

@@ -0,0 +1,28 @@
+module LiveUnit
+  ##
+  #subclass this to create custom reporters
+  class Reporter
+    attr_accessor :liveunit_assertions, :liveunit_passes, :liveunit_fails, :liveunit_results
+
+    def initialize
+      @liveunit_assertions = 0
+      @liveunit_passes = 0
+      @liveunit_fails = 0
+      @liveunit_results = []
+    end
+    ##
+    #gets called after each evaluation to store the result
+    def report
+      #overwrite me
+    end
+
+    private
+    ##
+    #returns the results and also clears them for the next run
+    def results
+      re = @liveunit_results
+      @liveunit_results = []
+      re
+    end
+  end
+end

data/lib/liveunit/testcase.rb

@@ -0,0 +1,88 @@
+require "minitest/assertions"
+
+module LiveUnit
+  ##
+  #all liveunit tests will be a child of LiveUnit::TestCase
+  #uses the assertion system from Minitest
+  class TestCase
+    include Minitest::Assertions
+    attr_accessor :assertions
+
+    def initialize(obj_env, obj, myreturn)
+      @obj_env = obj_env
+      @obj = obj
+      @myreturn = myreturn
+      #for minitest
+      @assertions = 0
+      @results ||= []
+      @last_result ||={}
+      @untested = 0
+    end
+    ##
+    #the unit's returned value
+    def myreturn
+      @myreturn
+    end
+    ##
+    #returns a cloned version of the object where the methods are defined
+    def me
+      @obj
+    end
+    ##
+    #extra msg string for tests
+    def msg(m="")
+      @m ||= m
+    end
+    ##
+    #returns true if all our tests has passed
+    def passed?
+      results.each { |re| return false unless re[:passed] }
+      true
+    end
+    ##
+    #expectation messages if our tests have failed
+    def result_msg
+      msgs = []
+      results.each { |re| msgs.push(re[:msg]) unless re[:passed]}
+      msgs
+    end
+    ##
+    #the object's enviroment, includes constants, instance and class variables
+    def state
+      @obj_env
+    end
+    ##
+    #ignore error for not implemented unit tests
+    def method_missing(m)
+      if m.to_s =~ /test_/
+        @untested += 1
+      else
+        super
+      end
+    end
+
+  end
+end
+
+module Minitest
+  module Assertions
+    ##
+    #overwrite minitest's assert method to store our results instead of raising errors
+    def assert test, msg = nil
+      self.assertions += 1
+      unless test then
+        msg ||= "Failed assertion, no message given."
+        msg = msg.call if Proc === msg
+      end
+      @last_result = {:passed => test, :msg => msg}
+      @results.push(@last_result)
+      @last_result
+    end
+    def results
+      @results
+    end
+    def last_result
+      @last_result
+    end
+  end
+end

data/liveunit.gemspec

@@ -0,0 +1,23 @@
+Gem::Specification.new do |s|
+  s.name        = 'liveunit'
+  s.version     = '0.0.1'
+  s.date        = '2015-06-05'
+  s.required_ruby_version = '>= 2.0.0'
+  s.summary     = "Example implementation to test my experiment on live unit testing. "
+  s.description = <<EOF
+Example implementation to test my experiment on live unit testing.
+Make sure to check the blog post here : http://zisismaras.me/general/2015/05/01/exploring-live-unit-tests.html
+and the github repo.
+EOF
+
+  s.files       = `git ls-files`.split("\n")
+  s.add_development_dependency 'rspec', '~> 3.2', '>= 3.2.0'
+  s.add_runtime_dependency 'after_do', '~> 0.3.1'
+  s.add_runtime_dependency 'minitest', '~> 5.7', '>= 5.7.0'
+
+
+  s.authors = ["Zisis Maras"]
+  s.email = 'contact@zisismaras.me'
+  s.homepage = 'https://github.com/zisismaras/liveunit'
+  s.license = 'MIT'
+end

data/spec/README.md

@@ -0,0 +1,8 @@
+# Testing
+Rspec has been used to test the tests(!) to avoid mix ups with the included patched minitest.
+
+The autoloader is bad so each example should be run individually from the root directory or it will fail :  
+```
+rspec spec/liveunit/evaluator_spec.rb 
+rspec spec/liveunit/liveunit_spec.rb 
+```

data/spec/fixture.rb

@@ -0,0 +1,32 @@
+require_relative "../lib/liveunit.rb"
+class Fixture
+  include LiveUnit
+
+  def initialize
+    evaluate_me(NilReporter)
+    @myvar, @anothervar = 15, 3.14
+  end
+
+  def calculate(num)
+    num + 10
+  end
+
+  def hello
+    "hi"
+  end
+
+  def myarray
+    ["dog", "cat", "thing"]
+  end
+
+end
+
+
+require_relative "../lib/liveunit/reporter.rb"
+class NilReporter < LiveUnit::Reporter
+  def report
+    #report nothing
+  end
+end
+
+

data/spec/livetest/test_fixture.rb

@@ -0,0 +1,16 @@
+require_relative "../lib/liveunit/testcase.rb"
+
+class TestFixture < LiveUnit::TestCase
+
+  #this fails
+  def test_calculate
+    msg "Result should be greater than 400 when @myvar=35"
+    assert_equal(35, state[:@myvar])
+    assert_operator myreturn, :>=, 400
+  end
+  #this passes
+  def test_hello
+    msg "Result should be hi"
+    assert_equal("hi", myreturn)
+  end
+end

data/spec/liveunit/evaluator_spec.rb

@@ -0,0 +1,59 @@
+require_relative '../spec_helper.rb'
+
+RSpec.configure do |c|
+  c.order = "random"
+  c.before(:all) do
+      FileUtils.mkdir_p(File.expand_path('./livetest'))
+      FileUtils.copy(File.expand_path("./spec/livetest/test_fixture.rb"), File.expand_path("./livetest/test_fixture.rb"))
+  end
+  c.after(:all) { FileUtils.rm_r(File.expand_path('./livetest')) }
+end
+
+describe "Evaluator" do
+  let(:fix) { Fixture.new }
+
+  describe "#evaluate" do
+    it "returnes true for passed example" do
+      fix.hello
+      snapshot = fix.evaluator.liveunit_snapshot("hello")
+      expect(fix.evaluator.evaluate(snapshot)).to eq(true)
+    end
+    it "returnes false for failed example" do
+      #call it first to get a snapshot
+      fix.calculate(40)
+      snapshot = fix.evaluator.liveunit_snapshot("calculate")
+      expect(fix.evaluator.evaluate(snapshot)).to eq(false)
+    end
+    it "returnes true for untested example" do
+      fix.myarray
+      snapshot = fix.evaluator.liveunit_snapshot("myarray")
+      expect(fix.evaluator.evaluate(snapshot)).to eq(true)
+    end
+  end
+
+  describe "#liveunit_snapshot" do
+    let(:fix) { Fixture.new }
+    it "makes correct object snapshots" do
+      #call it first to get a snapshot
+      fix.hello
+      snapshot = fix.evaluator.liveunit_snapshot("hello")
+      #unit name
+      expect(snapshot[0]).to eq("hello")
+      #suite
+      expect(snapshot[1]).to eq(Fixture)
+      #env
+      expect(snapshot[2].length).to eq(8)
+      #value returned
+      expect(snapshot[3]).to eq("hi")
+    end
+  end
+
+  describe "#create_reporter" do
+    let(:fix) { Fixture.new }
+    it "creates reporters successfully" do
+      expect(fix.evaluator.create_reporter(Fixture, NilReporter)).to be_an_instance_of(LiveUnit::FixtureReporter)
+    end
+  end
+
+
+end

data/spec/liveunit/liveunit_spec.rb

@@ -0,0 +1,32 @@
+require_relative '../spec_helper.rb'
+
+RSpec.configure do |c|
+  c.order = "random"
+  c.before(:all) do
+      FileUtils.mkdir_p(File.expand_path('./livetest'))
+      FileUtils.copy(File.expand_path("./spec/livetest/test_fixture.rb"), File.expand_path("./livetest/test_fixture.rb"))
+  end
+  c.after(:all) { FileUtils.rm_r(File.expand_path('./livetest')) }
+end
+
+describe "LiveUnit" do
+  let(:fix) { Fixture.new }
+
+  it "properly prepares the object" do
+    expect(fix).to respond_to(:evaluate_me, :evaluator, :reporter)
+  end
+  it "properly redefines all methods" do
+    expect(fix).to respond_to(:calculate, :hello, :myarray)
+    expect(fix).to respond_to(:liveunit_calculate, :liveunit_hello, :liveunit_myarray)
+  end
+  it "has redefined methods that work" do
+    expect(fix.hello).to eq("hi")
+    expect(fix.liveunit_hello).to eq("hi")
+    expect(fix.liveunit_hello).to eq(fix.hello)
+  end
+  it "has a reporter up and running" do
+    expect(NilReporter).to eq(LiveUnit::FixtureReporter.superclass)
+    expect(LiveUnit::Reporter).to eq(NilReporter.superclass)
+    expect(fix.reporter).to be_an_instance_of(LiveUnit::FixtureReporter)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'rspec'
+require 'fileutils'
+
+require_relative "fixture.rb"

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: liveunit
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Zisis Maras
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: after_do
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.7.0
+description: |
+  Example implementation to test my experiment on live unit testing.
+  Make sure to check the blog post here : http://zisismaras.me/general/2015/05/01/exploring-live-unit-tests.html
+  and the github repo.
+email: contact@zisismaras.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".editorconfig"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- lib/liveunit.rb
+- lib/liveunit/evaluator.rb
+- lib/liveunit/loader.rb
+- lib/liveunit/print_reporter.rb
+- lib/liveunit/reporter.rb
+- lib/liveunit/testcase.rb
+- liveunit.gemspec
+- spec/README.md
+- spec/fixture.rb
+- spec/livetest/test_fixture.rb
+- spec/liveunit/evaluator_spec.rb
+- spec/liveunit/liveunit_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/zisismaras/liveunit
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Example implementation to test my experiment on live unit testing.
+test_files: []