dotcodegen 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3df431650d3b7c3736d9f9c8c47b7eb70fae00c78368d21954d5ef139170f4bc
+  data.tar.gz: 2ba426662ea615dfdce8f7eebee074deb5165072808d08f0c0cc13c54bcdba82
+SHA512:
+  metadata.gz: 37ad7696e16dbfbdda40ce3b75796bbf1d7b0caa02cc7419283c66d89bf61ba05b0025fc622e6921e1a141dedb2602246602e56c49a6f8479b7d0371d1b883d8
+  data.tar.gz: 1cdbc250648762a3f688749f944622e83263686eb95b755ba334aacfabed1b3ebb172a74976db87461566577e97482e55a11309b80ec3158a6a9c2dfc179c3ac

data/.codegen/instructions/ruby.md

@@ -0,0 +1,145 @@
+---
+regex: 'lib/.*\.rb'
+root_path: 'lib'
+test_root_path: 'spec'
+test_file_suffix: '_spec.rb'
+---
+
+When writing a test, you should follow these steps:
+
+1. Avoid typos.
+2. Avoid things that could be infinite loops.
+3. This codebase is a Ruby gem, try to follow the conventions of the Ruby community.
+4. Avoid things that could be security vulnerabilities.
+5. Keep the codebase clean and easy to understand.
+6. Use Rspec for tests, don't use any other testing framework.
+7. Don't include ANY dependencies that are not already in the files you are provided.
+8. Don't start your tests with ``` or other strings, as your reply will be run as a Ruby file.
+
+Here's an example of a good test you should reply with:
+
+```ruby
+# frozen_string_literal: true
+
+require 'dotcodegen/test_file_generator'
+
+RSpec.describe Dotcodegen::TestFileGenerator do
+  let(:file_path) { 'client/app/components/feature.tsx' }
+  let(:api_matcher) do
+    {
+      'regex' => 'api/.*\.rb',
+      'root_path' => 'api/app/',
+      'test_root_path' => 'api/spec/',
+      'test_file_suffix' => '_spec.rb'
+    }
+  end
+  let(:client_matcher) do
+    {
+      'regex' => 'client/app/.*\.tsx',
+      'test_file_suffix' => '.test.tsx'
+    }
+  end
+  let(:matchers) { [api_matcher, client_matcher] }
+  let(:openai_key) { 'test_openai_key' }
+  let(:codegen_instance) { instance_double(Dotcodegen::TestFileGenerator) }
+
+  subject { described_class.new(file_path:, matchers:, openai_key:) }
+
+  describe '#run' do
+    after(:each) { FileUtils.remove_dir('client/', force: true) }
+    let(:file_path) { 'spec/fixtures/feature.tsx' }
+    let(:client_matcher) do
+      {
+        'regex' => 'spec/fixtures/.*\.tsx',
+        'test_file_suffix' => '.test.tsx',
+        'root_path' => 'spec/fixtures/',
+        'test_root_path' => 'tmp/codegen_spec/',
+        'instructions' => 'instructions/react.md'
+      }
+    end
+
+    context 'when test file does not exist' do
+      it 'creates a test file and writes generated code once' do
+        allow(File).to receive(:exist?).with('tmp/codegen_spec/feature.test.tsx').and_return(false)
+        expect(FileUtils).to receive(:mkdir_p).with('tmp/codegen_spec')
+        allow(Dotcodegen::TestCodeGenerator).to receive_message_chain(:new, :generate_test_code).and_return('Mocked generated code')
+        expect(File).to receive(:write).with('tmp/codegen_spec/feature.test.tsx', '').once
+        expect(File).to receive(:write).with('tmp/codegen_spec/feature.test.tsx', 'Mocked generated code').once
+        subject.run
+      end
+    end
+
+    context 'when test file already exists' do
+      it 'does not create a test file but writes generated code' do
+        allow(File).to receive(:exist?).with('tmp/codegen_spec/feature.test.tsx').and_return(true)
+        expect(FileUtils).not_to receive(:mkdir_p)
+        allow(Dotcodegen::TestCodeGenerator).to receive_message_chain(:new, :generate_test_code).and_return('Mocked generated code')
+        expect(File).to receive(:write).with('tmp/codegen_spec/feature.test.tsx', 'Mocked generated code').once
+        subject.run
+      end
+    end
+  end
+
+  describe '#matcher' do
+    it 'returns the matching regex for the frontend' do
+      expect(subject.matcher).to eq(client_matcher)
+    end
+
+    context 'when file path is a ruby file' do
+      let(:file_path) { 'api/app/models/app.rb' }
+      it 'returns the matching regex for the backend' do
+        expect(subject.matcher).to eq(api_matcher)
+      end
+    end
+
+    context 'when there are no matches' do
+      let(:file_path) { 'terraform/models/app.rb' }
+      it 'returns nil' do
+        expect(subject.matcher).to be_nil
+      end
+    end
+
+    context 'when file path does not match any regex' do
+      let(:file_path) { 'api/models/app.go' }
+      it 'returns nil' do
+        expect(subject.matcher).to be_nil
+      end
+    end
+  end
+
+  describe '#test_file_path' do
+    it 'returns the test file path for the frontend' do
+      expect(subject.test_file_path).to eq('client/app/components/feature.test.tsx')
+    end
+
+    context 'when file path is a ruby file' do
+      let(:file_path) { 'api/app/models/app.rb' }
+      it 'returns the test file path for the backend' do
+        expect(subject.test_file_path).to eq('api/spec/models/app_spec.rb')
+      end
+    end
+  end
+end
+```
+
+Here's the skeleton of a test you can start from:
+
+```ruby
+# frozen_string_literal: true
+
+require 'dotcodegen/__file_path__'
+
+RSpec.describe Dotcodegen::__CLASS_NAME__ do
+  let(:params) do
+    {
+      # Add params here
+    }
+  end
+  subject { described_class.new(params) }
+
+
+  it 'runs' do
+    # Add assertions here
+  end
+end
+```

data/.env.example

@@ -0,0 +1 @@
+OPENAI_KEY=your-api-key

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  TargetRubyVersion: 3.3.0
+  Exclude:
+    - "spec/**/*"
+
+Documentation:
+  Enabled: false
+
+Style/GlobalVars:
+  Enabled: false
+
+Layout/LineLength:
+  Enabled: false

data/.simplecov

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+SimpleCov.start do
+  add_filter '/spec/'
+  add_filter '/vendor/bundle/'
+end

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-03-10
+
+- Initial release
+- Support for Ruby 3.3.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Ferruccio Balestreri
+
+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,91 @@
+# Automatic test generation for monoliths
+
+Never write a test from scratch again. Automatically generate tests for any file you open in your codebase.
+
+Keep your team up to date with the latest best practices and conventions you adopt. Customize the templates to fit your team's needs.
+
+We're using this tool to speed up writing tests for our monolith at [June](https://june.so). We open sourced it so you can use it too.
+
+## Get started
+
+
+1. Install our CLI by running:
+
+```bash
+brew tap ferrucc-io/dotcodegen
+brew install dotcodegen
+```
+
+2. Initialise the `.codegen` directory in your codebase:
+
+```bash
+codegen init
+```
+
+3. Configure the templates to fit your team's needs. See the [configuration](./docs/configuration.md) section for more details.
+
+4. Run the codegen command in your terminal:
+
+```bash
+codegen path/to/the/file/you/want/to/test --openai_key <your_openai_key>
+```
+
+
+5. That's it! You're ready to start generating tests for your codebase.
+
+
+**Extra**:
+
+This code becomes very powerful when you integrate it with your editor, so you can open a file and generate tests with a single command.
+
+In order to do that you can add a task to your `tasks.json` file in the `.vscode` directory of your project:
+
+```json
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "Generate test for the current file",
+      "type": "shell",
+      // Alternatively you can specify the OPENAI_KEY environment variable in your .env file
+      "command": "codegen ${relativeFile} --openai_key your_openai_key",
+      "group": "test",
+      "problemMatcher": [],
+      "options": {
+          "cwd": "${workspaceFolder}"
+      },
+    }
+  ]
+}
+```
+
+We're currently building a VSCode extension to be able to generate tests directly from your editor. Stay tuned!
+
+## How it works
+
+The extension uses AI to generate tests for any file you open in your codebase. It uses a set of customizable templates to generate the tests. You can customize the templates to fit your team's needs.
+
+## Features
+
+- **Easy to learn**: Get started in minutes.
+- **AI powered scaffolding**: Generate smart tests for any file you open in your codebase.
+- **Fully customisable**: Customize the templates to fit your team's needs.
+- **Bring your own API key**: Use your own OpenAI API key to generate the tests.
+- **🚧 Integrates with VSCode**: Use the extension to generate tests directly from your editor.
+
+## Contributing
+
+If you want to add some default templates for your language, feel free to open a PR. See the [config/default](./config/default) directory for the ones we have already.
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ferrucc-io/dotcodegen.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/config/default/.codegen/instructions/react-vitest.md

@@ -0,0 +1,86 @@
+---
+regex: 'src/.*\.tsx'
+test_file_suffix: '.test.tsx'
+---
+
+
+When writing a test, you should follow these steps:
+
+1. Avoid typos.
+2. Avoid things that could be infinite loops.
+3. This codebase is React and Typescript, try to follow the conventions and patterns of React and Typescript.
+4. Avoid dangerous stuff, like things that would show up as a CVE somewhere.
+5. Use vitest for tests. It's a testing library that is used in this codebase.
+6. Always import tests from test-utils/
+
+Here's the skeleton of a test:
+
+```Typescript
+
+import "@testing-library/jest-dom";
+import userEvent from "@testing-library/user-event";
+import { Pagination } from "./Pagination";
+import { render, screen } from "../../../../tests/testUtils";
+
+describe("core/components/List/Pagination", () => {
+  const mockNextPage = vi.fn();
+  const mockPreviousPage = vi.fn();
+  const setup = (currentPage = 1, lastPage = 5) => {
+    const pagy = {
+      page: currentPage,
+      items: 10,
+      count: 50,
+      last: lastPage,
+    };
+    const pagination = {
+      currentPage: currentPage,
+      nextPage: mockNextPage,
+      previousPage: mockPreviousPage,
+    };
+    render(
+      <Pagination pagination={pagination} pagy={pagy} resourceName="items" />,
+    );
+  };
+
+  test("renders pagination component correctly", () => {
+    setup();
+    expect(screen.getByText(/previous page/i)).toBeInTheDocument();
+    expect(screen.getByText(/next page/i)).toBeInTheDocument();
+    expect(screen.getByText(/1-10/i)).toBeInTheDocument();
+    expect(screen.getByText(/out of 50/i)).toBeInTheDocument();
+  });
+
+  test("disables 'Previous page' button on first page", () => {
+    setup(1);
+    expect(screen.getByText(/previous page/i)).toBeDisabled();
+  });
+
+  test("enables 'Previous page' button on page greater than 1", () => {
+    setup(2);
+    expect(screen.getByText(/previous page/i)).toBeEnabled();
+  });
+
+  test("disables 'Next page' button on last page", () => {
+    setup(5, 5);
+    expect(screen.getByText(/next page/i)).toBeDisabled();
+  });
+
+  test("enables 'Next page' button before last page", () => {
+    setup(4, 5);
+    expect(screen.getByText(/next page/i)).toBeEnabled();
+  });
+
+  test("calls nextPage function when 'Next page' button is clicked", async () => {
+    setup(1, 5);
+    await userEvent.click(screen.getByText(/next page/i));
+    expect(mockNextPage).toHaveBeenCalled();
+  });
+
+  test("calls previousPage function when 'Previous page' button is clicked", async () => {
+    setup(2);
+    await userEvent.click(screen.getByText(/previous page/i));
+    expect(mockPreviousPage).toHaveBeenCalled();
+  });
+});
+
+```

data/config/default/.codegen/instructions/rspec-rails.md

@@ -0,0 +1,31 @@
+---
+regex: 'app/.*\.rb'
+root_path: 'app'
+test_root_path: 'spec'
+test_file_suffix: '_spec.rb'
+---
+
+When writing a test, you should follow these steps:
+
+1. Avoid typos.
+2. Avoid things that could be infinite loops.
+3. This codebase is Rails, try to follow the conventions of Rails.
+4. Write tests using RSpec like in the example I included
+5. If you're in doubt, just write the parts you're sure of
+6. No comments in the test file, just the test code
+
+Use FactoryBot factories for tests, so you should always create a factory for the model you are testing. This will help you create test data quickly and easily.
+
+Here's the skeleton of a test:
+
+```ruby
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe __FULL_TEST_NAME__ do
+  let(:app) { create(:app) }
+
+	# Tests go here
+end
+```

data/docs/configuration.md

@@ -0,0 +1,82 @@
+# Configuration
+
+## Introduction
+
+To make sure the tests generated by `dotcodegen` fit your team's needs, you can customize the instructions used to generate the tests. This section will guide you through the process of customizing the instructions.
+
+The instructions are markdown files in plain English. They are used to generate the tests for your codebase. You can customize the instructions to fit your team's needs.
+
+## Writing your first instruction
+
+To write your first instruction make sure you have `codegen` installed. If you don't have it installed, follow the [installation](../README.md#installation) instructions.
+
+Create a new file in the `.codegen/instructions` directory called `react.md`. This file will contain the instructions used to generate the tests.
+
+```bash
+mkdir -p .codegen/instructions
+touch .codegen/instructions/react.md
+```
+
+Then for the content of the file, you'll want to specify:
+
+- The regex to match the files you want to generate the test for. (e.g. `.*\.tsx` or `api/.*\.rb`)
+- The suffix of the test file. (e.g. `.test.tsx` or `_spec.rb`)
+- The instructions to generate the tests.
+
+Here's an example of a `react.md` file:
+
+```markdown
+---
+regex: '.*\.tsx'
+test_file_suffix: '.test.tsx'
+---
+
+When writing a test, you should follow these steps:
+
+1. Avoid typos.
+2. Avoid things that could be infinite loops.
+3. This codebase is a React codebase, try to follow the conventions of the React community.
+
+Here's an example of a good test you should reply with:
+
+<!-- Copy paste one of your existing tests here -->
+
+```
+
+## Customizing the file paths
+
+In some programming languages, tests live in specific directories. For example, in Ruby, tests live in a `spec` directory. You can specify the directory where the tests should be generated by adding a `test_file_directory` key to the instruction file.
+
+Here's an example of a `rails-controller.md` file, that specifies `spec/controllers` the directory where the tests should be generated and removes the `app/controllers` prefix from the starting file path:
+
+```markdown
+---
+regex: 'app/controllers/.*\.rb'
+root_path: 'app/controllers'
+test_root_path: 'spec/controllers'
+test_file_suffix: '_spec.rb'
+---
+
+Follow these steps when writing a test for a Rails controller:
+
+1. Avoid typos.
+2. Avoid things that could be infinite loops.
+3. This codebase is a Rails codebase, try to follow the conventions of the Rails community.
+```
+
+
+## Instructions reference
+
+The instructions need to be .md files in the `.codegen/instructions` directory. For each instruction file, you can specify the following keys:
+
+- `regex`: The regex to match the files you want to generate the test for. (e.g. `.*\.tsx` or `api/.*\.rb`)
+- `test_root_path`: The root path that codegen will pre-pend to all test files. (e.g. `spec/controllers` or `api`)
+- `root_path`: The root path of your which you want to remove when adding the test files `test_root_path`. (e.g. `app/controllers` or `api`)
+- `test_file_suffix`: The suffix of the test file. (e.g. `.test.tsx` or `_spec.rb`) We will automatically add this suffix to the file name and remove the .extension from your original file name.
+
+## The .codegen directory
+
+The `.codegen` directory is where you can customize the instructions used to generate the tests. The directory should be placed at the root of your project.
+
+
+

data/dotcodegen.gemspec

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'lib/dotcodegen/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'dotcodegen'
+  spec.version = Dotcodegen::VERSION
+  spec.authors = ['Ferruccio Balestreri']
+  spec.email = ['ferruccio.balestreri@gmail.com']
+
+  spec.summary = 'Generate tests for your code using LLMs.'
+  spec.description = 'Generate tests for your code using LLMs. This gem is a CLI tool that uses OpenAI to generate test code for your code. It uses a configuration file to match files with the right test code generation instructions. It is designed to be used with Ruby on Rails, but it can be used with any codebase. It is a work in progress.'
+  spec.homepage = 'https://github.com/ferrucc-io/dotcodegen'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '= 3.3.0'
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/ferrucc-io/dotcodegen'
+  spec.metadata['changelog_uri'] = 'https://github.com/ferrucc-io/dotcodegen/blob/main/CHANGELOG.md'
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ /lib test/ spec/ features/ .git .github appveyor Gemfile])
+    end
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'dotenv'
+  spec.add_dependency 'front_matter_parser'
+  spec.add_dependency 'optparse'
+  spec.add_dependency 'ostruct'
+  spec.add_dependency 'ruby-openai'
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/dotcodegen/cli.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'ostruct'
+require 'front_matter_parser'
+require 'fileutils'
+require_relative 'test_file_generator'
+require_relative 'version'
+require_relative 'init'
+require 'dotenv' unless defined?($running_tests) && $running_tests
+
+module Dotcodegen
+  class CLI
+    def self.parse(args)
+      options = OpenStruct.new
+      opt_parser = build_option_parser(options)
+      handle_arguments(args, opt_parser, options)
+      options
+    end
+
+    def self.run(args)
+      Dotenv.load unless defined?($running_tests) && $running_tests
+      options = parse(args)
+      return version if options.version
+
+      return Init.run if options.init
+
+      matchers = load_matchers('.codegen/instructions')
+      TestFileGenerator.new(file_path: options.file_path, matchers:, openai_key: options.openai_key).run
+    end
+
+    def self.version
+      puts "Dotcodegen version #{Dotcodegen::VERSION}"
+      exit
+    end
+
+    def self.load_matchers(instructions_path)
+      Dir.glob("#{instructions_path}/*.md").map do |file|
+        parsed = FrontMatterParser::Parser.parse_file(file)
+        parsed.front_matter.merge({ content: parsed.content })
+      end
+    end
+
+    def self.build_option_parser(options)
+      OptionParser.new do |opts|
+        opts.banner = 'Usage: dotcodegen [options] file_path'
+
+        opts.on('--openai_key KEY', 'OpenAI API Key') { |key| options.openai_key = key }
+        opts.on('--init', 'Initialize a .codegen configuration in the current directory') { options.init = true }
+        opts.on('--version', 'Show version') { options.version = true }
+        opts.on_tail('-h', '--help', 'Show this message') do
+          puts opts
+          exit
+        end
+      end
+    end
+
+    def self.handle_arguments(args, opt_parser, options)
+      opt_parser.parse!(args)
+      return if options.version || options.init
+
+      validate_file_path(args, opt_parser)
+      options.file_path = args.shift
+
+      options.openai_key ||= ENV['OPENAI_KEY']
+
+      return unless options.openai_key.to_s.strip.empty?
+
+      puts 'Error: Missing --openai_key flag or OPENAI_KEY environment variable.'
+      puts opt_parser
+      exit 1
+    end
+
+    def self.validate_file_path(args, opt_parser)
+      return unless args.empty?
+
+      puts 'Error: Missing file path.'
+      puts opt_parser
+      exit 1
+    end
+  end
+end

data/lib/dotcodegen/init.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Dotcodegen
+  class Init
+    # rubocop:disable Metrics/MethodLength
+    def self.run
+      source_dir = File.expand_path('../../config/default/.codegen', __dir__)
+      destination_dir = File.expand_path('.codegen', Dir.pwd)
+
+      FileUtils.mkdir_p(destination_dir) unless Dir.exist?(destination_dir)
+      FileUtils.cp_r("#{source_dir}/.", destination_dir)
+
+      instructions_dir = File.expand_path('instructions', destination_dir)
+      FileUtils.mkdir_p(instructions_dir) unless Dir.exist?(instructions_dir)
+
+      Dir.glob("#{source_dir}/instructions/*.md").each do |md_file|
+        FileUtils.cp(md_file, instructions_dir)
+      end
+
+      puts 'Codegen initialized.'
+      exit
+    end
+    # rubocop:enable Metrics/MethodLength
+  end
+end

data/lib/dotcodegen/test_code_generator.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'openai'
+module Dotcodegen
+  class TestCodeGenerator
+    attr_reader :config, :file_to_test_path, :openai_key
+
+    def initialize(config:, file_to_test_path:, openai_key:)
+      @config = config
+      @file_to_test_path = file_to_test_path
+      @openai_key = openai_key
+    end
+
+    def generate_test_code
+      response = openai_client.chat(
+        parameters: {
+          model: 'gpt-4-turbo-preview',
+          messages: [{ role: 'user', content: test_prompt_text }], # Required.
+          temperature: 0.7
+        }
+      )
+      response.dig('choices', 0, 'message', 'content')
+    end
+
+    def test_prompt_text
+      [{ "type": 'text', "text": test_prompt }]
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    def test_prompt
+      [
+        'You are an expert programmer. You have been given a task to write a test file for a given file following some instructions.',
+        'This is the file you want to test:',
+        '--start--',
+        test_file_content,
+        '--end--',
+        'Here are the instructions on how to write the test file:',
+        '--start--',
+        test_instructions,
+        '--end--',
+        "Your answer will be directly written in the file you want to test. Don't include any explanation or comments in your answer that isn't code.",
+        'You can use the comment syntax to write comments in your answer.'
+      ].join("\n")
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def test_file_content
+      File.open(file_to_test_path).read
+    end
+
+    def test_instructions
+      config['content']
+    end
+
+    def openai_client
+      @openai_client ||= OpenAI::Client.new(
+        access_token: openai_key,
+        organization_id: 'org-4nA9FJ8NajsLJ2fbHRAw7MLI'
+      )
+    end
+  end
+end

data/lib/dotcodegen/test_file_generator.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require_relative 'test_code_generator'
+
+module Dotcodegen
+  class TestFileGenerator
+    attr_reader :file_path, :matchers, :openai_key
+
+    def initialize(file_path:, matchers:, openai_key:)
+      @file_path = file_path
+      @matchers = matchers
+      @openai_key = openai_key
+    end
+
+    def run
+      puts "Finding matcher for #{file_path}..."
+      return puts "No matcher found for #{file_path}" unless matcher
+
+      puts "Test file path: #{test_file_path}"
+      ensure_test_file_presence
+
+      write_generated_code_to_test_file
+      open_test_file_in_editor unless $running_tests
+
+      puts 'Running codegen...'
+    end
+
+    def ensure_test_file_presence
+      puts "Creating test file if it doesn't exist..."
+      return if File.exist?(test_file_path)
+
+      FileUtils.mkdir_p(File.dirname(test_file_path))
+      File.write(test_file_path, '')
+    end
+
+    def write_generated_code_to_test_file
+      generated_code = Dotcodegen::TestCodeGenerator.new(config: matcher, file_to_test_path: file_path,
+                                                         openai_key:).generate_test_code
+      File.write(test_file_path, generated_code)
+    end
+
+    def open_test_file_in_editor
+      system("code #{test_file_path}")
+    end
+
+    def matcher
+      @matcher ||= matchers.find { |m| file_path.match?(m['regex']) }
+    end
+
+    def test_file_path
+      @test_file_path ||= "#{test_root_path}#{relative_file_name}#{test_file_suffix}"
+    end
+
+    def relative_file_name
+      file_path.sub(root_path, '').sub(/\.\w+$/, '')
+    end
+
+    def test_root_path
+      matcher['test_root_path'] || ''
+    end
+
+    def root_path
+      matcher['root_path'] || ''
+    end
+
+    def test_file_suffix
+      matcher['test_file_suffix'] || ''
+    end
+  end
+end

data/lib/dotcodegen/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Dotcodegen
+  VERSION = '0.1.0'
+end

data/lib/dotcodegen.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'dotcodegen/version'
+require_relative 'dotcodegen/test_file_generator'
+
+module Dotcodegen
+  class Error < StandardError; end
+end

data/sig/dotcodegen.rbs

@@ -0,0 +1,4 @@
+module Dotcodegen
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,141 @@
+--- !ruby/object:Gem::Specification
+name: dotcodegen
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ferruccio Balestreri
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-03-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: front_matter_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: optparse
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-openai
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Generate tests for your code using LLMs. This gem is a CLI tool that
+  uses OpenAI to generate test code for your code. It uses a configuration file to
+  match files with the right test code generation instructions. It is designed to
+  be used with Ruby on Rails, but it can be used with any codebase. It is a work in
+  progress.
+email:
+- ferruccio.balestreri@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".codegen/instructions/ruby.md"
+- ".env.example"
+- ".rspec"
+- ".rubocop.yml"
+- ".simplecov"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- config/default/.codegen/instructions/react-vitest.md
+- config/default/.codegen/instructions/rspec-rails.md
+- docs/configuration.md
+- dotcodegen.gemspec
+- lib/dotcodegen.rb
+- lib/dotcodegen/cli.rb
+- lib/dotcodegen/init.rb
+- lib/dotcodegen/test_code_generator.rb
+- lib/dotcodegen/test_file_generator.rb
+- lib/dotcodegen/version.rb
+- sig/dotcodegen.rbs
+homepage: https://github.com/ferrucc-io/dotcodegen
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/ferrucc-io/dotcodegen
+  source_code_uri: https://github.com/ferrucc-io/dotcodegen
+  changelog_uri: https://github.com/ferrucc-io/dotcodegen/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '='
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.6
+signing_key:
+specification_version: 4
+summary: Generate tests for your code using LLMs.
+test_files: []