devdisciples/mycroforge
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Renamed MicroForge to MycroForge

Browse Source
This commit is contained in:
Donné Napo
2024-04-22 09:56:39 +02:00
parent 8fed922cfe
commit 7e249e12c4
46 changed files with 265 additions and 266 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
MycroForge.CLI/Commands/Interfaces/ISubCommandOf.cs Normal file
View File

@@ -0,0 +1,7 @@
using System.CommandLine;
namespace MycroForge.CLI.Commands.Interfaces;
public interface ISubCommandOf<T> where T : Command
{
}

21
MycroForge.CLI/Commands/MycroForge.Add.Api.cs Normal file
View File

@@ -0,0 +1,21 @@
using System.CommandLine;
using MycroForge.CLI.Commands.Interfaces;
using MycroForge.CLI.Features;
namespace MycroForge.CLI.Commands;
public partial class MycroForge
{
public partial class Add
{
public class Api : Command, ISubCommandOf<Add>
{
public Api(ProjectContext context, IEnumerable<IFeature> features) :
base("api", "Add FastAPI to your project")
{
var feature = features.First(f => f.Name == Features.Api.FeatureName);
this.SetHandler(async () => await feature.ExecuteAsync(context));
}
}
}
}

26
MycroForge.CLI/Commands/MycroForge.Add.Orm.cs Normal file
View File

@@ -0,0 +1,26 @@
using System.CommandLine;
using MycroForge.CLI.Commands.Interfaces;
using MycroForge.CLI.Features;
namespace MycroForge.CLI.Commands;
public partial class MycroForge
{
public partial class Add
{
public class Orm : Command, ISubCommandOf<Add>
{
public Orm(ProjectContext context, IEnumerable<IFeature> features) :
base("orm", "Add SQLAlchemy to your project")
{
var feature = features.First(f => f.Name == Features.Orm.FeatureName);
this.SetHandler(async () => await feature.ExecuteAsync(context));
}
public class Generate
{
}
}
}
}

33
MycroForge.CLI/Commands/MycroForge.Add.cs Normal file
View File

@@ -0,0 +1,33 @@
using System.CommandLine;
using MycroForge.CLI.Commands.Interfaces;
namespace MycroForge.CLI.Commands;
public partial class MycroForge
{
public new partial class Add : Command, ISubCommandOf<MycroForge>
{
public Add(IEnumerable<ISubCommandOf<Add>> subCommands) :
base("add", "Add a predefined feature to your project")
{
foreach (var subCommandOf in subCommands)
AddCommand((subCommandOf as Command)!);
}
}
public class Run : Command, ISubCommandOf<MycroForge>
{
public Run() : base("run", "Run your app")
{
this.SetHandler(ExecuteAsync);
}
private async Task ExecuteAsync()
{
await Bash.RunAsync([
"source .venv/bin/activate",
"uvicorn main:app --reload"
]);
}
}
}

56
MycroForge.CLI/Commands/MycroForge.Generate.Entity.cs Normal file
View File

@@ -0,0 +1,56 @@
using System.CommandLine;
using Humanizer;
using MycroForge.CLI.CodeGen;
using MycroForge.CLI.Commands.Interfaces;
namespace MycroForge.CLI.Commands;
public partial class MycroForge
{
public partial class Generate
{
public class Entity : Command, ISubCommandOf<Generate>
{
private static readonly string[] Template =
[
"from sqlalchemy import INTEGER, Column, String",
"from orm.entities.entity_base import EntityBase",
"",
"class %class_name%(EntityBase):",
"\t__tablename__ = \"%table_name%\"",
"\tid = Column(INTEGER, primary_key=True)",
"",
"\tdef __repr__(self) -> str:",
"\t\treturn f\"%class_name%(id={self.id!r})\""
];
private static readonly Argument<string> NameArgument =
new(name: "name", description: "The name of the orm entity");
private readonly ProjectContext _context;
public Entity(ProjectContext context) : base("entity", "Generate and orm entity")
{
_context = context;
AddAlias("e");
AddArgument(NameArgument);
this.SetHandler(ExecuteAsync, NameArgument);
}
private async Task ExecuteAsync(string name)
{
var className = name.Underscore().Pascalize();
var moduleName = name.Underscore();
var code = string.Join('\n', Template);
code = code.Replace("%class_name%", className);
code = code.Replace("%table_name%", name.ToLower().Underscore());
await _context.CreateFile($"orm/entities/{moduleName}.py", code);
var env = await _context.ReadFile("orm/env.py");
env = new OrmEnvUpdater(env, moduleName, className).Rewrite();
await _context.WriteFile("orm/env.py", env);
}
}
}
}

32
MycroForge.CLI/Commands/MycroForge.Generate.Migration.cs Normal file
View File

@@ -0,0 +1,32 @@
using System.CommandLine;
using MycroForge.CLI.Commands.Interfaces;
namespace MycroForge.CLI.Commands;
public partial class MycroForge
{
public partial class Generate
{
public class Migration : Command, ISubCommandOf<Generate>
{
private static readonly Argument<string> NameArgument =
new(name: "name", description: "The name of the migration");
public Migration() : base("migration", "Generate a migration")
{
AddAlias("m");
AddArgument(NameArgument);
this.SetHandler(ExecuteAsync, NameArgument);
}
private async Task ExecuteAsync(string name)
{
await Bash.ExecuteAsync(
"source .venv/bin/activate",
$"alembic revision --autogenerate -m \"{name}\" --rev-id $(date -u +\"%Y%m%d%H%M%S\")"
);
}
}
}
}

53
MycroForge.CLI/Commands/MycroForge.Generate.Router.cs Normal file
View File

@@ -0,0 +1,53 @@
using System.CommandLine;
using Humanizer;
using MycroForge.CLI.Commands.Interfaces;
namespace MycroForge.CLI.Commands;
public partial class MycroForge
{
public partial class Generate
{
public class Router : Command, ISubCommandOf<Generate>
{
private static readonly string[] Template =
[
"from fastapi import APIRouter",
"from fastapi.responses import JSONResponse",
"from fastapi.encoders import jsonable_encoder",
"",
"router = APIRouter()",
"",
"@router.get(\"/{name}\")",
"async def index(name: str):",
"\treturn JSONResponse(status_code=200, content=jsonable_encoder({'greeting': f\"Hello, {name}!\"}))"
];
private static readonly Argument<string> NameArgument =
new(name: "name", description: "The name of the api router");
private readonly ProjectContext _context;
public Router(ProjectContext context) : base("router", "Generate an api router")
{
_context = context;
AddAlias("r");
AddArgument(NameArgument);
this.SetHandler(ExecuteAsync, NameArgument);
}
private async Task ExecuteAsync(string name)
{
var moduleName = name.Underscore();
await _context.CreateFile($"api/routers/{moduleName}.py", Template);
var main = await _context.ReadFile("main.py");
main += string.Join('\n',
$"\nfrom api.routers import {moduleName}",
$"app.include_router(prefix=\"/{name.Kebaberize()}\", router={moduleName}.router)\n"
);
await _context.WriteFile("main.py", main);
}
}
}
}

18
MycroForge.CLI/Commands/MycroForge.Generate.cs Normal file
View File

@@ -0,0 +1,18 @@
using System.CommandLine;
using MycroForge.CLI.Commands.Interfaces;
namespace MycroForge.CLI.Commands;
public partial class MycroForge
{
public partial class Generate : Command, ISubCommandOf<MycroForge>
{
public Generate(IEnumerable<ISubCommandOf<Generate>> subCommands) :
base("generate", "Generate a project item")
{
AddAlias("g");
foreach (var subCommandOf in subCommands)
AddCommand((subCommandOf as Command)!);
}
}
}

159
MycroForge.CLI/Commands/MycroForge.Init.cs Normal file
View File

@@ -0,0 +1,159 @@
using System.CommandLine;
using Microsoft.Extensions.DependencyInjection;
using MycroForge.CLI.Commands.Interfaces;
using MycroForge.CLI.Features;
namespace MycroForge.CLI.Commands;
public partial class MycroForge
{
public class Init : Command, ISubCommandOf<MycroForge>
{
#region GitIgnore
private static readonly string[] GitIgnore =
[
"# Byte-compiled / optimized / DLL files", "__pycache__/", "*.py[cod]", "*$py.class", "# C extensions",
"*.so", "# Distribution / packaging", ".Python", "build/", "develop-eggs/", "dist/", "downloads/", "eggs/",
".eggs/", "lib/", "lib64/", "parts/", "sdist/", "var/", "wheels/", "share/python-wheels/", "*.egg-info/",
".installed.cfg", "*.egg", "MANIFEST", "# PyInstaller",
"# Usually these files are written by a python script from a template",
"# before PyInstaller builds the exe, so as to inject date/other infos into it.", "*.manifest", "*.spec",
"# Installer logs", "pip-log.txt", "pip-delete-this-directory.txt", "# Unit test / coverage reports",
"htmlcov/", ".tox/", ".nox/", ".coverage", ".coverage.*", ".cache", "nosetests.xml", "coverage.xml",
"*.cover", "*.py,cover", ".hypothesis/", ".pytest_cache/", "cover/", "# Translations", "*.mo", "*.pot",
"# Django stuff:", "*.log", "local_settings.py", "db.sqlite3", "db.sqlite3-journal", "# Flask stuff:",
"instance/", ".webassets-cache", "# Scrapy stuff:", ".scrapy", "# Sphinx documentation", "docs/_build/",
"# PyBuilder", ".pybuilder/", "target/", "# Jupyter Notebook", ".ipynb_checkpoints", "# IPython",
"profile_default/", "ipython_config.py", "# pyenv",
"# For a library or package, you might want to ignore these files since the code is",
"# intended to run in multiple environments; otherwise, check them in:", "# .python-version", "# pipenv",
"# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.",
"# However, in case of collaboration, if having platform-specific dependencies or dependencies",
"# having no cross-platform support, pipenv may install dependencies that don't work, or not",
"# install all needed dependencies.", "#Pipfile.lock", "# poetry",
"# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.",
"# This is especially recommended for binary packages to ensure reproducibility, and is more",
"# commonly ignored for libraries.",
"# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control",
"#poetry.lock", "# pdm",
"# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.",
"#pdm.lock",
"# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it",
"# in version control.", "# https://pdm.fming.dev/#use-with-ide", ".pdm.toml",
"# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm", "__pypackages__/",
"# Celery stuff", "celerybeat-schedule", "celerybeat.pid", "# SageMath parsed files", "*.sage.py",
"# Environments", ".env", ".venv", "env/", "venv/", "ENV/", "env.bak/", "venv.bak/",
"# Spyder project settings", ".spyderproject", ".spyproject", "# Rope project settings", ".ropeproject",
"# mkdocs documentation", "/site", "# mypy", ".mypy_cache/", ".dmypy.json", "dmypy.json",
"# Pyre type checker", ".pyre/", "# pytype static type analyzer", ".pytype/", "# Cython debug symbols",
"cython_debug/", "# PyCharm",
"# JetBrains specific template is maintained in a separate JetBrains.gitignore that can",
"# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore",
"# and can be added to the global gitignore or merged into this file. For a more nuclear",
"# option (not recommended) you can uncomment the following to ignore the entire idea folder.", "#.idea/"
];
#endregion
private static readonly Argument<string> NameArgument =
new(name: "name", description: "The name of your project");
private static readonly Option<string> EntryPoint =
new(name: "--entrypoint", description: "The name of the entrypoint file");
private static readonly Option<string> BranchOption =
new(name: "--branch", description: "The name of the initial git branch");
private static readonly Option<IEnumerable<string>> FeaturesOption =
new(name: "--features", description: "The features to include")
{
AllowMultipleArgumentsPerToken = true
};
private readonly IServiceProvider _services;
private readonly List<IFeature> _features;
public Init(IServiceProvider services) : base("init", "Initialize a new project")
{
AddArgument(NameArgument);
AddOption(EntryPoint);
AddOption(BranchOption);
AddOption(FeaturesOption);
this.SetHandler(ExecuteAsync, NameArgument, EntryPoint, BranchOption, FeaturesOption);
_services = services;
_features = _services.GetServices<IFeature>().ToList();
}
private async Task ExecuteAsync(string name, string entrypoint, string branch, IEnumerable<string> features)
{
var featuresList = features.ToList();
Validate(featuresList);
await Initialize(name, entrypoint, branch, featuresList);
}
private void Validate(List<string> features)
{
foreach (var feature in features)
if (_features.All(f => f.Name != feature))
throw new Exception($"Feature {feature} was not found.");
}
private async Task Initialize(string name, string entrypoint, string branch, List<string> features)
{
// Create the project directory and change the directory for the ProjectContext
var projectRoot = await CreateDirectory(name);
var ctx = _services.GetRequiredService<ProjectContext>();
ctx.ChangeDirectory(projectRoot);
// Create the config file and initialize the config
await ctx.CreateFile("m4g.json", "{}");
await ctx.LoadConfig(force: true);
// Create the entrypoint file
entrypoint = string.IsNullOrEmpty(entrypoint) ? "main.py" : entrypoint;
await ctx.CreateFile(entrypoint, string.Empty);
ctx.Config.Entrypoint = entrypoint;
// Create the default .gitignore
await ctx.CreateFile(".gitignore", GitIgnore);
// Create the venv
await Bash.ExecuteAsync($"python3 -m venv {Path.Combine(projectRoot, ".venv")}");
// Initialize git
var _branch = string.IsNullOrEmpty(branch) ? "main" : branch;
await Bash.ExecuteAsync($"git -c init.defaultBranch={_branch} init {projectRoot}");
// Initialize features
if (features.Count > 0)
await InitializeFeatures(ctx, features);
Console.WriteLine($"Directory {projectRoot} was successfully initialized");
}
private async Task<string> CreateDirectory(string name)
{
var directory = Path.Combine(Directory.GetCurrentDirectory(), name);
if (Directory.Exists(directory))
throw new Exception($"Directory {directory} already exists.");
Console.WriteLine($"Creating directory {directory}");
Directory.CreateDirectory(directory);
await Bash.ExecuteAsync($"chmod -R 777 {directory}");
return directory;
}
private async Task InitializeFeatures(ProjectContext projectCtx, List<string> features)
{
foreach (var feature in features)
await _features.First(p => p.Name == feature).ExecuteAsync(projectCtx);
}
}
}

29
MycroForge.CLI/Commands/MycroForge.Install.cs Normal file
View File

@@ -0,0 +1,29 @@
using System.CommandLine;
using MycroForge.CLI.Commands.Interfaces;
namespace MycroForge.CLI.Commands;
public partial class MycroForge
{
public class Install : Command, ISubCommandOf<MycroForge>
{
private static readonly Argument<IEnumerable<string>> PackagesArgument =
new(name: "packages", description: "The names of the packages to install");
public Install() : base("install", "Install packages and update the requirements.txt")
{
AddAlias("i");
AddArgument(PackagesArgument);
this.SetHandler(ExecuteAsync, PackagesArgument);
}
private async Task ExecuteAsync(IEnumerable<string> packages)
{
await Bash.ExecuteAsync(
"source .venv/bin/activate",
$"pip install {string.Join(' ', packages)}",
"pip freeze > requirements.txt"
);
}
}
}

27
MycroForge.CLI/Commands/MycroForge.Migrations.Apply.cs Normal file
View File

@@ -0,0 +1,27 @@
using System.CommandLine;
using MycroForge.CLI.Commands.Interfaces;
namespace MycroForge.CLI.Commands;
public partial class MycroForge
{
public partial class Migrations
{
public class Apply : Command, ISubCommandOf<Migrations>
{
public Apply() : base("apply", "Apply migrations to the database")
{
AddAlias("a");
this.SetHandler(ExecuteAsync);
}
private async Task ExecuteAsync()
{
await Bash.ExecuteAsync([
"source .venv/bin/activate",
"alembic upgrade head"
]);
}
}
}
}

27
MycroForge.CLI/Commands/MycroForge.Migrations.Rollback.cs Normal file
View File

@@ -0,0 +1,27 @@
using System.CommandLine;
using MycroForge.CLI.Commands.Interfaces;
namespace MycroForge.CLI.Commands;
public partial class MycroForge
{
public partial class Migrations
{
public class Rollback : Command, ISubCommandOf<Migrations>
{
public Rollback() : base("rollback", "Rollback the last migration")
{
AddAlias("r");
this.SetHandler(ExecuteAsync);
}
private async Task ExecuteAsync()
{
await Bash.ExecuteAsync([
"source .venv/bin/activate",
"alembic downgrade -1"
]);
}
}
}
}

18
MycroForge.CLI/Commands/MycroForge.Migrations.cs Normal file
View File

@@ -0,0 +1,18 @@
using System.CommandLine;
using MycroForge.CLI.Commands.Interfaces;
namespace MycroForge.CLI.Commands;
public partial class MycroForge
{
public partial class Migrations : Command, ISubCommandOf<MycroForge>
{
public Migrations(IEnumerable<ISubCommandOf<Migrations>> subCommands) :
base("migrations", "Manage your migrations")
{
AddAlias("m");
foreach (var subCommandOf in subCommands)
AddCommand((subCommandOf as Command)!);
}
}
}

24
MycroForge.CLI/Commands/MycroForge.Rewrite.cs Normal file
View File

@@ -0,0 +1,24 @@
using System.CommandLine;
using MycroForge.CLI.Commands.Interfaces;
namespace MycroForge.CLI.Commands;
public partial class MycroForge
{
public class Rewrite : Command, ISubCommandOf<MycroForge>
{
public Rewrite() : base("rewrite", "Test a python source rewriter.")
{
this.SetHandler(ExecuteAsync);
}
private async Task ExecuteAsync()
{
// var path = Path.Combine(Directory.GetCurrentDirectory(), "main.py");
// var source = await File.ReadAllTextAsync(path);
// var rewriter = new TestRewriter(source);
// var rewrite = rewriter.Rewrite();
// await File.WriteAllTextAsync(path, rewrite);
}
}
}

29
MycroForge.CLI/Commands/MycroForge.Uninstall.cs Normal file
View File

@@ -0,0 +1,29 @@
using System.CommandLine;
using MycroForge.CLI.Commands.Interfaces;
namespace MycroForge.CLI.Commands;
public partial class MycroForge
{
public class Uninstall : Command, ISubCommandOf<MycroForge>
{
private static readonly Argument<IEnumerable<string>> PackagesArgument =
new(name: "packages", description: "The names of the packages to uninstall");
public Uninstall() : base("uninstall", "Uninstall packages and update the requirements.txt")
{
AddAlias("u");
AddArgument(PackagesArgument);
this.SetHandler(ExecuteAsync, PackagesArgument);
}
private async Task ExecuteAsync(IEnumerable<string> packages)
{
await Bash.ExecuteAsync(
"source .venv/bin/activate",
$"pip uninstall {string.Join(' ', packages)}",
"pip freeze > requirements.txt"
);
}
}
}

17
MycroForge.CLI/Commands/MycroForge.cs Normal file
View File

@@ -0,0 +1,17 @@
using System.CommandLine;
using MycroForge.CLI.Commands.Interfaces;
namespace MycroForge.CLI.Commands;
public partial class MycroForge : RootCommand
{
public override string Name => "m4g";
public MycroForge(IEnumerable<ISubCommandOf<MycroForge>> commands) : base("The MycroForge CLI tool.")
{
commands
.Cast<Command>()
.ToList()
.ForEach(AddCommand);
}
}