zapata 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c4947c74075c16975810dfe03d6b0708dbae7214
+  data.tar.gz: fd9187d034ba8b411bd8d9d47bd676aa0d4d08ed
+SHA512:
+  metadata.gz: 5ce92767f6e47248793cddd5a5cc21ec911c5f247c5a809a0747e65a94707e7521648af0bccac6774fc77a9c641368c1bea8d0221b66f8cbe09d494e538f8b56
+  data.tar.gz: c9840ed16514a3bd7eaf0aceaddea7fa5154c818a4e7099a57249674ba3d5dac5bd7a3543b21709038567a76298dd5087287863401c371462b34f20534cf050a

data/.gitignore

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

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--warnings
+--require spec_helper

data/CONTRIBUTING.md

@@ -0,0 +1,5 @@
+1. [Fork it](https://github.com/Nedomas/zapata/fork)
+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/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Domas
+
+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,152 @@
+# Zapata
+
+Who has time to write tests? This is a revolutional tool to make them write
+themselves.
+
+![Emiliano Zapata](https://cloud.githubusercontent.com/assets/1877286/3753719/af3bfec2-1814-11e4-8790-242c2b26a8e9.jpg)
+
+# What is your problem?
+
+There comes a day where you have this bullshit class ``RobotToTest``. We need
+tests. :shipit:
+
+```ruby
+class RobotToTest
+  def initialize(human_name, cv)
+    @name = robot_name(human_name)
+  end
+
+  def robot_name(human_name)
+    "#{self.class.prefix}_#{human_name}"
+  end
+
+  def cv
+    { planets: planets }
+  end
+
+  def nested_fun_objects(fun_objects)
+    'It was fun'
+  end
+
+  def self.prefix
+    'Robot'
+  end
+
+  private
+
+  def planets
+    ['Mars', Human.home]
+  end
+
+  def fun_objects
+    [%i(array in array), { hash: nested_hash }]
+  end
+
+  def nested_hash
+    { in_hash: { in: array } }
+  end
+
+  def array
+    %w(array)
+  end
+end
+
+# just another class to analyze
+class Human
+  def initialize
+    human_name = 'Emiliano'
+  end
+
+  def self.home
+    'Earth'
+  end
+end
+```
+
+## Solving it
+
+You run ``zapata generate app/models/robot_to_test.rb`` and pop the champagne.
+Zapata generated ``spec/models/robot_to_test_spec.rb`` for you.
+
+```ruby
+describe RobotToTest do
+  let(:robot_to_test) do
+    RobotToTest.new('Emiliano', { planets: ['Mars', Human.home] })
+  end
+
+  it '#robot_name' do
+    expect(robot_to_test.robot_name('Emiliano')).to eq('Robot_Emiliano')
+  end
+
+  it '#cv' do
+    expect(robot_to_test.cv).to eq({ planets: ['Mars', 'Earth'] })
+  end
+
+  it '#nested_fun_objects' do
+    expect(robot_to_test.nested_fun_objects([
+      [:array, :in, :array],
+      {
+        hash: {
+          in_hash: {
+            in: ['array']
+          }
+        }
+      }
+    ])).to eq('It was fun')
+  end
+
+  it '#prefix' do
+    expect(RobotToTest.prefix).to eq('Robot')
+  end
+end
+```
+
+## What does it do?
+
+It tries to write a passing RSpec spec off the bat. It does fancy analysis
+to predict the values it could feed to the API of a class.
+
+__To be more specific:__
+- Analyzes all vars and methods definitions in ``app/models``
+- Checks what arguments does a testable method in ``app/models/robot_to_test.rb`` need
+- Searches for such variable or method name in methods in analyzed
+- Selects the most probable value by how many times it was repeated in code
+- Runs the RSpec and fills in the expected values of the test with those returned by RSpec
+
+For more things it can currently do check
+https://github.com/Nedomas/zapata/tree/master/spec
+
+## Installation
+
+It should be as easy as
+```sh
+gem install zapata
+```
+
+or
+
+```ruby
+gem 'zapata', groups: %w(development test)
+```
+
+## Collaboration :heart:
+
+I know that code analyzing is a sexy sphere to work on for many developers.
+So here it is - a sexy project where you can realize your wet dreams about magic
+in Ruby.
+
+To install, run:
+```sh
+git clone https://github.com/Nedomas/zapata
+cd zapata
+bundle exec rake install
+```
+
+For specs, run:
+```sh
+bundle exec rspec --patern "spec/*_spec.rb"
+```
+
+## Copyright
+Copyright (c) 2014 Domas.
+See [LICENSE](LICENSE) for details.

data/Rakefile

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

data/bin/zapata

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require_relative '../lib/zapata'
+
+Slop.parse do
+  banner 'Usage: zapata [options]'
+
+  on '--help', '-h' do
+    puts help
+  end
+
+  command 'generate' do
+    run do |opts, args|
+      spec_filename = Zapata::Revolutionist.generate(args.shift)
+      puts "Its done, comrades. File #{spec_filename} was generated."
+    end
+  end
+end

data/lib/zapata.rb

@@ -0,0 +1,91 @@
+require 'parser/current'
+require 'unparser'
+require 'pry'
+require 'pry-stack_explorer'
+require 'rails'
+require 'require_all'
+require 'file/temp'
+require 'open3'
+
+require_rel 'zapata/core'
+require_rel 'zapata/predictor'
+require_rel 'zapata/primitive'
+require_rel 'zapata/rzpec'
+require_relative 'zapata/analyst'
+require_relative 'zapata/diver'
+require_relative 'zapata/db'
+require_relative 'zapata/printer'
+require_relative 'zapata/version'
+
+module Zapata
+  class Revolutionist
+    class << self
+      attr_accessor :analysis, :analysis_as_array
+
+      def generate(filename)
+        dirs = %w(app/models)
+        file_list = Core::Collector.expand_dirs_to_files(dirs)
+
+        # files = %w(app/models/actual_fragment.rb app/models/ical.rb app/models/calendar/balance_transfer.rb)
+
+        new(file_list).generate_rspec_for(filename, spec_filename(filename))
+      end
+
+      def init_analysis_as_array
+        @analysis_as_array = analysis.values.flatten
+      end
+
+      def spec_filename(filename)
+        filename.gsub('app/', 'spec/').gsub('.rb', '_spec.rb')
+      end
+    end
+
+    def initialize(file_list)
+      Core::Loader.load_spec_helper
+      self.class.analysis = analyze_multiple(file_list)
+    end
+
+    def analyze_multiple(files)
+      total = files.size.to_s
+
+      files.each_with_object({}).with_index do |(filename, obj), i|
+        puts "[#{adjusted_current(i, total)}/#{total}] Analyzing: #{filename}"
+        obj[filename] = Analyst.analyze(filename)
+      end
+    end
+
+    def adjusted_current(i, total)
+      "#{i}".rjust(total.size)
+    end
+
+    def generate_rspec_for(filename, spec_filename)
+      unless self.class.analysis[filename]
+        self.class.analysis[filename] = Analyst.analyze(filename)
+      end
+
+      self.class.init_analysis_as_array
+
+      code = Core::Reader.parse(filename)
+
+      global_analysis = Revolutionist.analysis_as_array
+      # first run
+      tmp_spec_filename = File::Temp.new(false).path
+      RZpec::Writer.new(tmp_spec_filename, code, self.class.analysis[filename], global_analysis)
+
+      save_spec_file(tmp_spec_filename, spec_filename)
+      spec_analysis = RZpec::Runner.new(spec_filename)
+
+      # second run with RSpec results
+      RZpec::Writer.new(tmp_spec_filename, code, self.class.analysis[filename], global_analysis, spec_analysis)
+      save_spec_file(tmp_spec_filename, spec_filename)
+    end
+
+    def save_spec_file(tmp_spec_filename, spec_filename)
+      spec_path = "#{Dir.pwd}/#{spec_filename}"
+      spec_dir = spec_path.split('/')[0...-1].join('/')
+      FileUtils.mkdir_p(spec_dir)
+      FileUtils.cp(tmp_spec_filename, spec_path)
+      spec_filename
+    end
+  end
+end

data/lib/zapata/analyst.rb

@@ -0,0 +1,34 @@
+module Zapata
+  class Analyst
+    attr_reader :result
+
+    def self.analyze(filename)
+      code = Core::Reader.parse(filename)
+      analyst = Analyst.new(code)
+      result = analyst.result.dup
+      analyst.clean
+      result
+    end
+
+    def initialize(code)
+      # class dive
+      Diver.search_for(:klass)
+      Diver.dive(code)
+      # var dive
+      Diver.search_for(:var)
+      Diver.dive(code)
+      # def dive
+      Diver.search_for(:def)
+      Diver.dive(code)
+      # send dive
+      Diver.search_for(:send)
+      Diver.dive(code)
+
+      @result = DB.all
+    end
+
+    def clean
+      DB.destroy_all
+    end
+  end
+end

data/lib/zapata/core/collector.rb

@@ -0,0 +1,9 @@
+module Zapata
+  module Core
+    class Collector
+      def self.expand_dirs_to_files(dirs)
+        dirs.map { |dir| Dir["#{dir}/*.rb"] }.flatten
+      end
+    end
+  end
+end

data/lib/zapata/core/loader.rb

@@ -0,0 +1,38 @@
+module Zapata
+  module Core
+    class Loader
+      class << self
+        def rails_helper_path
+          File.expand_path("#{Dir.pwd}/spec/rails_helper",  __FILE__)
+        end
+
+        def spec_helper_path
+          File.expand_path("#{Dir.pwd}/spec/spec_helper",  __FILE__)
+        end
+
+        def helper_name
+          if File.exist?("#{rails_helper_path}.rb")
+            'rails_helper'
+          elsif File.exist?("#{spec_helper_path}.rb")
+            'spec_helper'
+          else
+            raise 'Was not able to load nor rails_helper, nor spec_helper'
+          end
+        end
+
+        def full_helper_path
+          paths = {
+            rails_helper: rails_helper_path,
+            spec_helper: spec_helper_path,
+          }.freeze
+
+          paths[helper_name.to_sym]
+        end
+
+        def load_spec_helper
+          require "#{full_helper_path}.rb"
+        end
+      end
+    end
+  end
+end

data/lib/zapata/core/reader.rb

@@ -0,0 +1,10 @@
+module Zapata
+  module Core
+    class Reader
+      def self.parse(filename)
+        plain_text_code = File.open(filename).read
+        Parser::CurrentRuby.parse(plain_text_code)
+      end
+    end
+  end
+end

data/lib/zapata/core/writer.rb

@@ -0,0 +1,33 @@
+module Zapata
+  module Core
+    class Writer
+      def initialize(filename)
+        @filename = filename
+        @padding = 0
+        clean
+      end
+
+      def clean
+        file = File.open(@filename, 'w')
+        file.write('')
+        file.close
+      end
+
+      def append_line(line = '')
+        @padding -= 1 if word_exists?(line, 'end')
+
+        padding_to_use = @padding
+        padding_to_use = 0 if line.empty?
+        file = File.open(@filename, 'ab+')
+        file.puts("#{'  ' * padding_to_use}#{line}")
+        file.close
+
+        @padding += 1 if word_exists?(line, 'do')
+      end
+
+      def word_exists?(string, word)
+        !!/\b(?:#{word})\b/.match(string)
+      end
+    end
+  end
+end