minitestify 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b8d0d4202c4c1c1aba785fcea7db1810ee21e58a1f6f904b0d95f2f8199490a
-  data.tar.gz: 0a9a0126d2f41ec3b688fd87562850a301bd12515eed86c0589530f41feded07
+  metadata.gz: b169c65b41f33533e17a58e0cd66140a64d08039f6e20df0679d5746ac4ff99b
+  data.tar.gz: 6207f274d48bf806f3dcf2f490ffe1cc44d4aa0a4a36b521b47b8caaa8af01f8
 SHA512:
-  metadata.gz: '080b030988c144384db8b694691acf0ece4dfbf013897753850fd8a1eea006016653b0726577e302f6b3796ca968c704c8a293258462b4a39a55d27060cd0d22'
-  data.tar.gz: 040341ca4fb0a102b8545d66bc5254054e16341c7c71e77933b50c957a916b12fca8fb0fec49ec002ade98bcbe5586ef05736b623ce8c7d2d095345d0d5bf052
+  metadata.gz: 0af88789ce5f56b3170cbb5fdb4fad7a68f890e09bc1f6f2748466e5c25734d5a0b8d6a02b344fbc492fc229be6392677c37ffd1e77a9d41093d5cd990fe38e2
+  data.tar.gz: ad16675adb29636e70805c58cde16a43871588f5e1171dbe585a2cec43caf6bf9a54ae8c6ff9944630906091b5be5dce8cbd23fe23f014f146b2460ab0898ab9

data/README.md

@@ -1,8 +1,13 @@
 # Minitestify
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/minitestify`. To experiment with that code, run `bin/console` for an interactive prompt.
+minitestify is a tool to convert Rspec specs to equivalent minitest tests by parsing and transforming the code using the [syntax_tree](https://github.com/ruby-syntax-tree/syntax_tree) gem.
 
-TODO: Delete this and the text above, and describe your gem
+It's early days and this work is still experimental.  Here's what it can do now
+
+### Capabilities
+- describe -> class
+- it -> def test_*
+- expect(actual).to eq(expected) -> assert_equal(expected, actual)
 
 ## Installation
 
@@ -16,7 +21,9 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 ## Usage
 
-TODO: Write usage instructions here
+```
+minitestify print FILES             # Convert one or more specs to minitest and print to standard out
+```
 
 ## Development
 

data/exe/minitestify

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "dry/cli"
+require "minitestify/cli"
+
+Dry::CLI.new(Minitestify::CLI::Commands).call

data/lib/minitestify/cli.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "dry/cli"
+require "minitestify"
+require "minitestify/version"
+require "minitestify/spec"
+
+module Minitestify::CLI
+  module Commands
+    extend Dry::CLI::Registry
+
+    class Version < Dry::CLI::Command
+      desc "Print version"
+
+      def call(*)
+        puts Minitestify::VERSION
+      end
+    end
+
+    class Print < Dry::CLI::Command
+      desc "Convert one or more specs to minitest and print to standard out"
+
+      argument :files, type: :array, required: true, desc: "Spec files to convert"
+
+      example [
+        "spec/dog_spec.rb # Generates dog_test.rb and prints to standard out"
+      ]
+
+      def call(files:, **)
+        files.each do |file|
+          spec = Minitestify::Spec.new(file: file)
+          puts "# #{spec.to_test_filepath}"
+          puts spec.to_test_code
+          puts
+        end
+      end
+    end
+
+    register "version", Version, aliases: ["v", "-v", "--version"]
+    register "print", Print, aliases: ["p", "-p", "--print"]
+  end
+end

data/lib/minitestify/spec.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "minitestify"
+
+module Minitestify
+  class Spec
+    def initialize(file:)
+      @file = file
+    end
+
+    def to_test_filepath
+      @file.gsub "spec", "test"
+      # TODO be smarter here and dissect the file path
+      # replacing only the spec dir (if present)
+      # and the _spec.rb suffix
+    end
+
+    def to_test_code
+      source = SyntaxTree.read(@file)
+      program = SyntaxTree.parse(source)
+
+      visitor = SyntaxTree::Visitor::MutationVisitor.new
+      inflector = Dry::Inflector.new
+
+      # describe -> class
+      visitor.mutate("Command[ message: Ident[value: \"describe\"] ]") do |node|
+        node => SyntaxTree::Command[
+
+          message: SyntaxTree::Ident[value: "describe"],
+          arguments: SyntaxTree::Args[
+            parts: [SyntaxTree::VarRef[value: SyntaxTree::Const[value: value]]]
+          ]
+        ]
+
+        SyntaxTree::ClassDeclaration.new(
+          constant:
+            SyntaxTree::ConstRef.new(
+              constant:
+                SyntaxTree::Const.new(
+                  value: "#{inflector.camelize_upper(value)}Test",
+                  location: node.location
+                ),
+              location: node.location
+            ),
+          superclass:
+            SyntaxTree::ConstPathRef.new(
+              parent:
+                SyntaxTree::VarRef.new(
+                  value:
+                    SyntaxTree::Const.new(
+                      value: "Minitest",
+                      location: node.location
+                    ),
+                  location: node.location
+                ),
+              constant:
+                SyntaxTree::Const.new(value: "Test", location: node.location),
+              location: node.location
+            ),
+          bodystmt: node.child_nodes.last.bodystmt,
+          location: node.location
+        )
+      end
+
+      # it -> def
+      visitor.mutate("Command[message: Ident[value: \"it\"]]") do |node|
+        node => SyntaxTree::Command[
+          message: SyntaxTree::Ident[value: "it"],
+          arguments: SyntaxTree::Args[
+            parts: [
+              SyntaxTree::StringLiteral[
+                parts: [SyntaxTree::TStringContent[value: value]]
+              ]
+            ]
+          ]
+        ]
+
+        SyntaxTree::DefNode.new(
+          target: nil,
+          operator: nil,
+          name:
+            SyntaxTree::Ident.new(
+              value: "test_#{value.gsub(" ", "_")}",
+              location: node.location
+            ),
+          params: SyntaxTree::Params,
+          bodystmt: node.child_nodes.last.bodystmt,
+          location: node.location
+        )
+      end
+
+      expect_eq_search =
+        'CommandCall[
+          receiver: CallNode[
+            message: Ident[value: "expect"]
+          ],
+          operator: Period[value: "."],
+          message: Ident[value: "to"],
+          arguments: Args[
+            parts: [ CallNode[
+              message: Ident[value: "eq"]
+              ]
+            ]
+          ]
+        ]'
+      visitor.mutate(expect_eq_search) do |node|
+        node => SyntaxTree::CommandCall[
+          receiver: SyntaxTree::CallNode[
+            receiver: nil,
+            operator: nil,
+            message: SyntaxTree::Ident[value: "expect"],
+            arguments: SyntaxTree::ArgParen[
+              arguments: SyntaxTree::Args[parts: [actual_expr]]
+            ]
+          ],
+          operator: SyntaxTree::Period[value: "."],
+          message: SyntaxTree::Ident[value: "to"],
+          arguments: SyntaxTree::Args[
+            parts: [
+              SyntaxTree::CallNode[
+                receiver: nil,
+                operator: nil,
+                message: SyntaxTree::Ident[value: "eq"],
+                arguments: SyntaxTree::ArgParen[
+                  arguments: SyntaxTree::Args[parts: [expected_expr]]
+                ]
+              ]
+            ]
+          ]
+        ]
+
+        SyntaxTree::CallNode.new(
+          message:
+            SyntaxTree::Ident.new(
+              value: "assert_equal",
+              location: node.location
+            ),
+          arguments:
+            SyntaxTree::ArgParen.new(
+              arguments:
+                SyntaxTree::Args.new(
+                  parts: [expected_expr, actual_expr],
+                  location: node.location
+                ),
+              location: node.location
+            ),
+          location: node.location,
+          receiver: nil,
+          operator: nil
+        )
+      end
+
+      SyntaxTree::Formatter.format(source, program.accept(visitor))
+    end
+  end
+end

data/lib/minitestify/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Minitestify
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/minitestify.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
 require_relative "minitestify/version"
+require "syntax_tree"
+require "dry/inflector"
 
 module Minitestify
-  class Error < StandardError; end
-  # Your code goes here...
+  class Error < StandardError
+  end
 end

data/minitestify.gemspec

@@ -30,6 +30,8 @@ Gem::Specification.new do |spec|
 
   # Uncomment to register a new dependency of your gem
   spec.add_dependency "syntax_tree", "~> 5.0"
+  spec.add_dependency "dry-inflector", "~> 1.0"
+  spec.add_dependency "dry-cli", "~> 1.0"
 
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html

data/scripts/transform.md

@@ -0,0 +1,237 @@
+# How to add a transformation
+
+Run the following in an irb session to determine the search pattern
+
+```ruby
+require "syntax_tree"
+
+code = <<~RUBY
+  expect(calculator.add(1, 1)).to eq(2)
+RUBY
+
+program = SyntaxTree.parse code
+puts program.construct_keys
+```
+
+You'll get a bunch of output like this
+```ruby
+SyntaxTree::Program[
+  statements: SyntaxTree::Statements[
+    body: [
+      SyntaxTree::CommandCall[
+        receiver: SyntaxTree::CallNode[
+          receiver: nil,
+          operator: nil,
+          message: SyntaxTree::Ident[value: "expect"],
+          arguments: SyntaxTree::ArgParen[
+            arguments: SyntaxTree::Args[
+              parts: [
+                SyntaxTree::CallNode[
+                  receiver: SyntaxTree::VCall[
+                    value: SyntaxTree::Ident[value: "calculator"]
+                  ],
+                  operator: SyntaxTree::Period[value: "."],
+                  message: SyntaxTree::Ident[value: "add"],
+                  arguments: SyntaxTree::ArgParen[
+                    arguments: SyntaxTree::Args[
+                      parts: [
+                        SyntaxTree::Int[value: "1"],
+                        SyntaxTree::Int[value: "1"]
+                      ]
+                    ]
+                  ]
+                ]
+              ]
+            ]
+          ]
+        ],
+        operator: SyntaxTree::Period[value: "."],
+        message: SyntaxTree::Ident[value: "to"],
+        arguments: SyntaxTree::Args[
+          parts: [
+            SyntaxTree::CallNode[
+              receiver: nil,
+              operator: nil,
+              message: SyntaxTree::Ident[value: "eq"],
+              arguments: SyntaxTree::ArgParen[
+                arguments: SyntaxTree::Args[
+                  parts: [SyntaxTree::Int[value: "2"]]
+                ]
+              ]
+            ]
+          ]
+        ]
+      ]
+    ]
+  ]
+]
+```
+
+We want the top level node of the body.  Remove the SyntaxTree namespaces and take just enough to identify the top node
+```ruby
+expect_eq_search =
+    'CommandCall[
+      receiver: CallNode[
+        message: Ident[value: "expect"]
+      ],
+      operator: Period[value: "."],
+      message: Ident[value: "to"],
+      arguments: Args[
+        parts: [ CallNode[
+          message: Ident[value: "eq"]
+          ]
+        ]
+      ]
+    ]'
+```
+
+And use that as our argument to `visitor.mutate`
+```ruby
+visitor.mutate(expect_eq_search) do
+  # ...
+end
+```
+
+For the block body, start by pulling out relevant information with a pattern matching statement from construct_keys
+TODO pare down the pattern match and extract variables
+```ruby
+node => SyntaxTree::CommandCall[
+  receiver: SyntaxTree::CallNode[
+    receiver: nil,
+    operator: nil,
+    message: SyntaxTree::Ident[value: "expect"],
+    arguments: SyntaxTree::ArgParen[
+      arguments: SyntaxTree::Args[parts: [actual_expr]]
+    ]
+  ],
+  operator: SyntaxTree::Period[value: "."],
+  message: SyntaxTree::Ident[value: "to"],
+  arguments: SyntaxTree::Args[
+    parts: [
+      SyntaxTree::CallNode[
+        receiver: nil,
+        operator: nil,
+        message: SyntaxTree::Ident[value: "eq"],
+        arguments: SyntaxTree::ArgParen[
+          arguments: SyntaxTree::Args[parts: [expected_expr]]
+        ]
+      ]
+    ]
+  ]
+]
+```
+
+Now write the code you want to transform it to and construct the nodes
+
+```ruby
+require "syntax_tree"
+
+code = <<~RUBY
+  assert_equal(2, calculator.add(1, 1))
+RUBY
+
+program = SyntaxTree.parse code
+puts program.construct_keys
+```
+
+Again you get a bunch of output
+```ruby
+SyntaxTree::Program[
+  statements: SyntaxTree::Statements[
+    body: [
+      SyntaxTree::CallNode[
+        receiver: nil,
+        operator: nil,
+        message: SyntaxTree::Ident[value: "assert_equal"],
+        arguments: SyntaxTree::ArgParen[
+          arguments: SyntaxTree::Args[
+            parts: [
+              SyntaxTree::Int[value: "2"],
+              SyntaxTree::CallNode[
+                receiver: SyntaxTree::VCall[
+                  value: SyntaxTree::Ident[value: "calculator"]
+                ],
+                operator: SyntaxTree::Period[value: "."],
+                message: SyntaxTree::Ident[value: "add"],
+                arguments: SyntaxTree::ArgParen[
+                  arguments: SyntaxTree::Args[
+                    parts: [
+                      SyntaxTree::Int[value: "1"],
+                      SyntaxTree::Int[value: "1"]
+                    ]
+                  ]
+                ]
+              ]
+            ]
+          ]
+        ]
+      ]
+    ]
+  ]
+]
+```
+
+Add `.new` and convert parentheses.  You'll have to add `location: node.location` where required (trial and error).  Make this node tree the return value of the mutate block.
+
+```ruby
+expect_eq_search =
+  'CommandCall[
+    receiver: CallNode[
+      message: Ident[value: "expect"]
+    ],
+    operator: Period[value: "."],
+    message: Ident[value: "to"],
+    arguments: Args[
+      parts: [ CallNode[
+        message: Ident[value: "eq"]
+        ]
+      ]
+    ]
+  ]'
+visitor.mutate(expect_eq_search) do |node|
+  node => SyntaxTree::CommandCall[
+    receiver: SyntaxTree::CallNode[
+      receiver: nil,
+      operator: nil,
+      message: SyntaxTree::Ident[value: "expect"],
+      arguments: SyntaxTree::ArgParen[
+        arguments: SyntaxTree::Args[parts: [actual_expr]]
+      ]
+    ],
+    operator: SyntaxTree::Period[value: "."],
+    message: SyntaxTree::Ident[value: "to"],
+    arguments: SyntaxTree::Args[
+      parts: [
+        SyntaxTree::CallNode[
+          receiver: nil,
+          operator: nil,
+          message: SyntaxTree::Ident[value: "eq"],
+          arguments: SyntaxTree::ArgParen[
+            arguments: SyntaxTree::Args[parts: [expected_expr]]
+          ]
+        ]
+      ]
+    ]
+  ]
+
+  SyntaxTree::CallNode.new(
+    message:
+      SyntaxTree::Ident.new(
+        value: "assert_equal",
+        location: node.location
+      ),
+    arguments:
+      SyntaxTree::ArgParen.new(
+        arguments:
+          SyntaxTree::Args.new(
+            parts: [expected_expr, actual_expr],
+            location: node.location
+          ),
+        location: node.location
+      ),
+    location: node.location,
+    receiver: nil,
+    operator: nil
+  )
+end
+```

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitestify
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Rafe Rosen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-11-23 00:00:00.000000000 Z
+date: 2022-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: syntax_tree
@@ -24,10 +24,39 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: dry-inflector
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: dry-cli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: 
 email:
 - rafe@existentialmutt.com
-executables: []
+executables:
+- minitestify
 extensions: []
 extra_rdoc_files: []
 files:
@@ -38,9 +67,13 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- exe/minitestify
 - lib/minitestify.rb
+- lib/minitestify/cli.rb
+- lib/minitestify/spec.rb
 - lib/minitestify/version.rb
 - minitestify.gemspec
+- scripts/transform.md
 - sig/minitestify.rbs
 homepage: https://github.com/existentialmutt/minitestify
 licenses: