pretentious 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4eac89f08c915484d2749c73f703b6d8654f5e94
+  data.tar.gz: abf3901c3235fa2ee6d266cbb5cd019f22e83c2a
+SHA512:
+  metadata.gz: a0f020ba8a6903e3bd55682c58e42a63c3ffddb3db7e99bada136aae4ecc2252a6ddd5a45ebe02f82e23f287aa8062f6a18b32d85a88c59af4558e782ac08d50
+  data.tar.gz: 4c4c7d237a30ec08800be2d09fa363f6ced13a2cfaea11651c41508b1950e499f7077d759a194c76f2262bfb784825c2605b20254d146e7ed5e1792843330357

data/.gitignore

@@ -0,0 +1,17 @@
+.DS_Store
+.idea
+*.gem
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pretentious.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Joseph Emmanuel Dayo
+
+MIT License
+
+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,164 @@
+# Ruby::Pretentious
+
+Do you have a pretentious boss or dev lead that pushes you to embrace bdd/tdd but for reasons hate it or them?
+here is a gem to deal with that. Now you CAN write code first and then GENERATE tests later!! Yes you heard that
+right! This gem allows you to write your code first and then automatically generate tests using the code
+you've written!
+
+On a serious note, this gem allows you to generate tests template much better than those generated by default
+for various frameworks.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pretentious'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pretentious
+
+## Usage
+
+First Create an example file (etc. example.rb) and define the classes that you want to test, if the class is
+already defined elsewhere just require them. Below is an example:
+
+```ruby
+class Fibonacci
+
+  def fib(n)
+    return 0 if (n == 0)
+    return 1 if (n == 1)
+    return 1 if (n == 2)
+    return fib(n - 1) + fib(n - 2)
+  end
+
+  def self.say_hello
+    "hello"
+  end
+
+end
+```
+
+Inside a Pretentious.spec_for(...) block. Just write boring code that calls the methods of your class like
+how you'd normally use them. Finally Specify the classes that you want to test:
+
+```ruby
+class Fibonacci
+
+  def fib(n)
+    return 0 if (n == 0)
+    return 1 if (n == 1)
+    return 1 if (n == 2)
+    return fib(n - 1) + fib(n - 2)
+  end
+
+  def self.say_hello
+    "hello"
+  end
+
+end
+
+Pretentious.spec_for(Fibonacci) do
+
+
+  instance = Fibonacci.new
+
+  (1..10).each do |n|
+    instance.fib(n)
+  end
+
+  Fibonacci.say_hello
+
+end
+```
+
+Save your file and then switch to the terminal to invoke:
+
+    ddtgen example.rb
+
+This will automatically generate rspec tests for Fibonacci under spec of the current working directory.
+
+you can invoke spec at this point, but the tests will fail. Instead you should edit spec/spec_helper.rb and
+put the necessary requires and definitions there.
+
+For this example place the following into spec_helper.rb:
+
+```ruby
+#inside spec_helper.rb
+
+class Fibonacci
+
+  def fib(n)
+    return 0 if (n == 0)
+    return 1 if (n == 1)
+    return 1 if (n == 2)
+    return fib(n - 1) + fib(n - 2)
+  end
+
+  def self.say_hello
+    "hello"
+  end
+
+end
+```
+
+You can also try this out with build in libraries like MD5 for example
+
+```ruby
+#example.rb
+
+Pretentious.spec_for(Digest::MD5) do
+  sample = "This is the digest"
+  Digest::MD5.hexdigest(sample)
+end
+```
+
+You should get something like:
+
+```ruby
+require 'spec_helper'
+
+RSpec.describe Digest::MD5 do
+
+    it 'should pass current expectations' do
+
+      sample = "This is the digest"
+
+      # Digest::MD5::hexdigest when passed "This is the digest" should return 9f12248dcddeda976611d192efaaf72a
+      expect( Digest::MD5.hexdigest(sample) ).to eq("9f12248dcddeda976611d192efaaf72a")
+
+    end
+end
+```
+
+Only RSpec is support at this point. But other testing frameworks should be trivial to add support to.
+
+## Limitations
+
+Computers are bad at mind reading (for now) and they don't really know your expectation of "correctness", as such
+it assumes your code is correct and can only use equality based matchers. It can also only reliably match
+primitive data types and hashs and arrays to degree. More complex expectations are unfortunately left for the human to resolve.
+
+Also do note that it tries its best to determine how your fixtures are created, as well as the types
+of your parameters and does so by figuring out the components that your object needs. Failure can happen during this process.
+
+Finally, Limit this gem for test environments only.
+
+## Bugs
+
+This is the first iteration and a lot of broken things could happen
+
+## Contributing
+
+1. Fork it (https://github.com/jedld/pretentious.git)
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/ddtgen

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+
+require 'pretentious'
+require 'optparse'
+require 'ripper'
+require "readline"
+require 'json'
+require 'fileutils'
+
+$test_framework = :rspec
+$output_folder = 'spec'
+
+# ddtgen example.rb -t rspec -o rspec/
+options = OptionParser.new do |o|
+  o.banner =
+"Usage: ddtgen FILENAME [options] # Generates tests using the specified example file\n"
+  o.separator ""
+  o.separator "options:"
+  o.on('-t','--test-type','test framework to use (default :rspec)') { |b| $test_framework = b.to_sym}
+  o.on('-o','--output-dir','folder to place the files in') { |b| $output_folder = b}
+  o.parse!
+end
+
+
+filename = ARGV[0]
+
+if filename.nil?
+  puts "an example file is required."
+  puts options
+  exit(1)
+end
+
+example_body = ""
+
+index = 0
+File.open(filename, "r") do |f|
+  f.each_line do |line|
+     example_body << "#{line}\n"
+  end
+end
+
+eval(example_body)
+
+#collect results
+
+FileUtils.mkdir_p $output_folder
+
+module DdtUtils
+   def self.to_underscore(str)
+     str.gsub(/(.)([A-Z])/,'\1_\2').downcase
+   end
+end
+
+Pretentious.last_results.each { |klass, result|
+
+  klass_name_parts = klass.name.split('::')
+  last_part = klass_name_parts.pop
+
+  filename = File.join($output_folder,"#{DdtUtils.to_underscore(last_part)}_spec.rb")
+  File.open(filename, 'w') {
+    |f| f.write(result)
+  }
+  puts "#{filename}"
+}
+
+filename = File.join($output_folder,"spec_helper.rb")
+unless File.exists?(filename)
+    File.open(filename, 'w') {
+        |f| f.write("#Place your requires here")
+      }
+    puts "#{filename}"
+end

data/example.rb

@@ -0,0 +1,93 @@
+require 'digest/md5'
+
+class Fibonacci
+
+  def fib(n)
+    return 0 if (n == 0)
+    return 1 if (n == 1)
+    return 1 if (n == 2)
+    return fib(n - 1) + fib(n - 2)
+  end
+
+  def self.say_hello
+    "hello"
+  end
+
+end
+
+class TestClass1
+
+  def initialize(message)
+    @message = message
+  end
+
+  def print_message
+    puts @message
+  end
+
+  def something_is_wrong
+    raise StandardError.new
+  end
+end
+
+class TestClass2
+  def initialize(message)
+    @message = {message: message}
+  end
+
+  def print_message
+    puts @message[:message]
+  end
+end
+
+class TestClass3
+
+  def initialize(testclass1, testclass2)
+    @class1 = testclass1
+    @class2 = testclass2
+  end
+
+  def get_hash
+    {hello: "world", message: {another: :hash}}
+  end
+
+  def show_messages
+    @class1.print_message
+    @class2.print_message
+    "awesome!!!"
+  end
+
+end
+
+Pretentious.spec_for(Fibonacci) do
+
+
+  instance = Fibonacci.new
+
+  (1..10).each do |n|
+    instance.fib(n)
+  end
+
+  Fibonacci.say_hello
+
+end
+
+Pretentious.spec_for(TestClass1, TestClass2, TestClass3) do
+
+  another_object = TestClass1.new("test")
+  test_class_one = TestClass1.new({hello: "world", test: another_object, arr_1: [1,2,3,4,5, another_object],
+                                   sub_hash: {yes: true, obj: another_object}})
+  test_class_two = TestClass2.new("This is message 2")
+
+  class_to_test = TestClass3.new(test_class_one, test_class_two)
+  class_to_test.show_messages
+
+  class_to_test = TestClass3.new(test_class_one, test_class_two)
+  class_to_test.show_messages
+
+end
+
+Pretentious.spec_for(Digest::MD5) do
+  sample = "This is the digest"
+  Digest::MD5.hexdigest(sample)
+end

data/lib/pretentious.rb

@@ -0,0 +1,370 @@
+require "pretentious/version"
+require "pretentious/rspec_generator"
+require 'binding_of_caller'
+require 'pretentious/deconstructor'
+
+module Pretentious
+
+  def self.spec_for(*klasses, &block)
+    @results = @results || {}
+    @results.merge!(Pretentious::Generator.generate_for(*klasses, &block))
+  end
+
+  def self.clear_results
+    @results = {}
+  end
+
+  def self.last_results
+    @results
+  end
+
+  def self.value_ize(value, let_variables, declared_names)
+    if (value.kind_of? String)
+      "#{value.dump}"
+    elsif (value.is_a? Symbol)
+      ":#{value.to_s}"
+    elsif (value.is_a? Hash)
+      Pretentious::Deconstructor.pick_name(let_variables, value.object_id, declared_names)
+    else
+      "#{value.to_s}"
+    end
+  end
+
+  def self.watch(&block)
+    Pretentious::Generator.watch_new_instances
+    block.call
+    Pretentious::Generator.unwatch_new_instances
+  end
+
+  class Generator
+
+    def self.impostor_for(module_space, klass)
+      newStandInKlass = Class.new()
+      name = klass.name
+      module_space.const_set "#{name.split('::').last}Impostor", newStandInKlass
+
+      common_snippet = "
+              @_method_calls = @_method_calls || []
+              @_method_calls_by_method = @_method_calls_by_method || {}
+              @_methods_for_test = @_methods_for_test || []
+              @_let_variables = @_let_variables || {}
+
+              caller_context = binding.of_caller(1)
+              #puts \"local_variables\"
+              v_locals = caller_context.eval('local_variables')
+
+              v_locals.each { |v|
+                variable_value = caller_context.eval(\"\#{v.to_s}\")
+                @_let_variables[variable_value.object_id] = v
+              }
+
+              info_block = {}
+              info_block[:method] = method_sym
+              info_block[:params] = arguments
+              info_block[:names] = @_instance.method(method_sym).parameters
+
+              begin
+                if (@_instance.methods.include? method_sym)
+                  result = @_instance.send(method_sym, *arguments, &block)
+                else
+                  result = @_instance.send(:method_missing, method_sym, *arguments, &block)
+                end
+                info_block[:result] = result
+              rescue Exception=>e
+                info_block[:result] = e
+              rescue StandardError=>e
+                info_block[:result] = e
+              end
+
+              @_method_calls << info_block
+
+              if (@_method_calls_by_method[method_sym].nil?)
+                @_method_calls_by_method[method_sym] = []
+              end
+
+              @_method_calls_by_method[method_sym] << info_block
+              raise e if (e.kind_of? Exception)
+              result"
+
+      newStandInKlass.class_eval("
+        def setup_instance(*args, &block)
+          @_instance = #{klass.name}_ddt.new(*args, &block)
+        end
+      ")
+
+      newStandInKlass.class_exec do
+        def initialize(*args, &block)
+
+          @_instance_init = {params: [], block: nil}
+
+          @_instance_init[:params] = args
+          @_instance_init[:block] = block
+
+          setup_instance(*args, &block)
+
+
+          @_method_calls = []
+          @_method_calls_by_method = {}
+          @_methods_for_test = []
+          @_let_variables = {}
+
+
+          @_init_let_variables = {}
+
+          caller_context = binding.of_caller(2)
+          v_locals = caller_context.eval('local_variables')
+
+          v_locals.each { |v|
+            variable_value = caller_context.eval("#{v.to_s}")
+            @_init_let_variables[variable_value.object_id] = v
+          }
+
+          self.class._add_instances(self)
+        end
+
+        def _init_arguments
+          @_instance_init
+        end
+
+        def test_class
+          @_instance.class
+        end
+
+        def include_for_tests(method_list = [])
+          @_methods_for_test = @_methods_for_test + method_list
+        end
+
+        def let_variables
+          @_let_variables
+        end
+
+        def init_let_variables
+          @_init_let_variables
+        end
+
+        def method_calls_by_method
+          @_method_calls_by_method
+        end
+
+        def method_calls
+          @_method_calls
+        end
+
+        def to_s
+          @_instance.to_s
+        end
+
+        def ==(other)
+          @_instance==other
+        end
+
+        def kind_of?(klass)
+          @_instance.kind_of? klass
+        end
+
+        def methods
+          @_instance.methods + [:method_calls]
+        end
+
+        def freeze
+          @_instance.freeze
+        end
+
+        def hash
+          @instance.hash
+        end
+
+        def inspect
+          @_instance.inspect
+        end
+
+        def is_a?(something)
+          @_instance.is_a? something
+        end
+
+        class << self
+          def _add_instances(instance)
+            @_instances = @_instances || []
+            @_instances << instance unless @_instances.include? instance
+          end
+
+          def let_variables
+            @_let_variables
+          end
+
+          def method_calls_by_method
+            @_method_calls_by_method
+          end
+
+          def method_calls
+            @_method_calls
+          end
+
+          def _add_instances(instance)
+            @_instances = @_instances || []
+            @_instances << instance unless @_instances.include? instance
+          end
+
+          def _instances
+            @_instances
+          end
+
+        end
+
+      end
+
+      newStandInKlass.class_eval("
+        def method_missing(method_sym, *arguments, &block)
+          #puts \"\#{method_sym} \#{arguments}\"
+          #{common_snippet}
+        end
+
+        class << self
+
+            def test_class
+              #{klass.name}
+            end
+
+            def method_missing(method_sym, *arguments, &block)
+              #puts \"method \#{method_sym.to_s}\"
+              _add_instances(self)
+              @_instance = #{klass.name}_ddt
+              #{common_snippet}
+            end
+        end
+      ")
+
+      newStandInKlass
+    end
+
+    def self.generate_for(*klasses_or_instances, &block)
+      all_results = {}
+      klasses = []
+
+      klasses_or_instances.each { |klass_or_instance|
+        klass = klass_or_instance.class == Class ? klass_or_instance : klass_or_instance.class
+
+
+        klass_name_parts = klass.name.split('::')
+        last_part = klass_name_parts.pop
+
+        module_space = Object
+
+        if (klass_name_parts.size > 0)
+          klass_name_parts.each do |part|
+            module_space = module_space.const_get(part)
+          end
+        end
+
+        newStandInKlass = impostor_for module_space, klass
+
+        module_space.send(:remove_const,last_part.to_sym)
+        module_space.const_set("#{last_part}_ddt", klass)
+        module_space.const_set("#{last_part}", newStandInKlass)
+
+        klasses << [module_space, klass, last_part, newStandInKlass]
+      }
+
+      watch_new_instances
+
+      block.call
+
+      unwatch_new_instances
+
+      klasses.each { |module_space, klass, last_part, newStandInKlass|
+
+        module_space.send(:remove_const,"#{last_part}Impostor".to_sym)
+        module_space.send(:remove_const,"#{last_part}".to_sym)
+        module_space.const_set(last_part, klass)
+        module_space.send(:remove_const,"#{last_part}_ddt".to_sym)
+
+        test_generator = Pretentious::RspecGenerator.new
+        test_generator.begin_spec(klass)
+        num = 1
+
+        newStandInKlass._instances.each do |instance|
+          test_generator.generate(instance, num)
+          num+=1
+        end
+
+        test_generator.end_spec
+
+        result = all_results[klass]
+        if result.nil?
+          all_results[klass] = []
+        end
+
+        all_results[klass] = test_generator.output
+
+      }
+
+      all_results
+    end
+
+    def self.watch_new_instances
+      Object.class_eval do
+        def _get_init_arguments
+          @_init_arguments
+        end
+
+        def _set_init_arguments(*args, &block)
+          @_init_arguments = @_init_arguments || {}
+          @_init_arguments[:params]  = args
+          @_init_arguments[:block] = block
+          @_variable_names= {}
+
+          index = 0
+          params = method(:initialize).parameters
+
+          args.each do |arg|
+            p = params[index]
+            if p.size > 1
+              @_variable_names[arg.object_id] = p[1].to_s
+            end
+            index+=1
+          end
+
+        end
+
+        def _variable_map
+          @_variable_names
+        end
+
+        def _deconstruct
+          Pretentious::Deconstructor.new().deconstruct(self)
+        end
+
+        def _deconstruct_to_ruby(indentation = 0)
+          Pretentious::Deconstructor.new().deconstruct_to_ruby(indentation, _variable_map, self)
+        end
+
+      end
+
+      Class.class_eval do
+        alias_method :_ddt_old_new, :new
+
+        def new(*args, &block)
+          instance = _ddt_old_new(*args, &block)
+          instance._set_init_arguments(*args, &block)
+          instance
+        end
+      end
+    end
+
+    def self.clean_watches
+      Class.class_eval do
+        remove_method :new
+        alias_method :new, :_ddt_old_new
+      end
+    end
+
+    def self.unwatch_new_instances
+      Class.class_eval do
+        remove_method :new
+        alias_method :new, :_ddt_old_new
+      end
+    end
+
+  end
+
+end