DEV Community: Adetoba ✨

Using Dart to create custom directories and files for your new Flutter project.

Adetoba ✨ — Mon, 21 Aug 2023 09:53:09 +0000

After my recent post on how to generate directories and files for your new flutter project in Golang, i got a comment on my twitter post to replicate this same implementation in dart. I agree with the comment since any flutter developer would already have dart installed on their system and won't necessarily need to setup Golang on their machine.

In this tutorial, we will learn how to generate custom directories and files for your new flutter project using dart.

Getting Started 👍

We will assume you already have flutter installed on your system so we'd skip the installation process and jump right into the implementation. Every Flutter SDK comes with a dart SDK which is automatically setup on your system.

Writing our codes 👨🏾‍💻

To start off, we will create a new dart file generator.dart which will contain all necessary functions for our program.

First, we import all necessary packages for our program

import 'dart.io';

dart.io package allows us to manipulate files and directories in dart.

Map<String, List<String>> directories = {
  "features": [],
  "shared": [],
  "theme": [
    "colors.dart",
    "theme.dart",
    "styles.dart"
  ],
  "utils": [
    "utils.dart",
    "storage.dart",
    "dimensions.dart"
  ],
  "/features/auth": [],
  "/features/auth/view_models": []
};

Create a key-value variable named directories of type Map<String, List<String>>. The key represents the name of the directory and the value represents the list of files to be created in the directory.

Future<Directory?> createDirectory(String path) async {
  try {
    final newDir = Directory(path);
    newDir.createSync(recursive: true);

    return newDir;
  } catch (e) {
    return null;
  }
}

Create a function named createDirectory which takes in a string path as an argument. The path string represents the parent directory where we want to create all our custom directories.
Create a new Directory variable called newDir and specify the path.
newDir.createSync(recursive: true) function creates a new directory with the path you specified.
Use a try-catch block to handle exceptions. Return null if an exception occurs and return the newDir if the directory was successfully created.

Future<File?> createFile(String path, String fileName) async {
  try {
    final file = File("/$path/$fileName");
    final f = await file.create();
    return f;
  } catch (e) {
    return null;
  }
}

Create a new function named createFile which takes two arguments. The first argument is the path where the file should be created and the second argument represents the file name.
Create a new File variable and specify the path and fileName.
Use await file.create() from the dart.io package to create a new file.

Now, let's create our main function

void main() {
  print("Please provide a path to the lib folder of your flutter project (e.g /Users/hash/Documents/test_app/lib): ");
  String? parentPath = stdin.readLineSync();

  if(parentPath == null) {
    print("You must provide a path");
    exit(0);
  }

  directories.forEach((directory, fileNames) async {
    String? fullPath = "/$parentPath/$directory";

    final dir = await createDirectory(fullPath);

    if (dir == null) {
      print("Failed to create directory: $directory");
    } else {
      print("=> $directory created");
    }

    for (String fileName in fileNames) {
      final file = await createFile(fullPath, fileName);

      if (file == null) {
        print("Failed to create file: $fileName");
      }

    }
  });
}

The std.readLineSync() function is used to read an input from the command line. We store the input in a String variable called parentPath.
Check if the parentPath is not null and exit the app using exit(0) if the variable is null.
Use a forEach loop to iterate through the directories variable and create each directory using the createDirectory function you created earlier.
The createDirectory function takes an argument which represents the full path where the directory should be created. We combine the parentPath and the directory string to get the full path.
Create another for loop to iterate through each fileName in the directories map.
Use the createFile function we created earlier to create each file. Pass the full path and the filename as arguments to the function.

Next, create a new flutter project named test_app in your documents folder.

Now, we need to run our generator.dart file to generate our custom directories for our flutter project. Open up a terminal and make sure you're in the directory where your generator.dart file is stored then type dart run generator.dart

You should see this screen if everything works as expected.

Check the new flutter project you created to see if your files were generated successfully.

Conclusion 👏

We have learnt how to generate custom directories and files for our flutter project using dart. You can tweak this dart code and use it however necessary to create custom directories or files for your projects.

Creating custom directories and files for your Flutter project with Go

Adetoba ✨ — Sun, 20 Aug 2023 10:45:14 +0000

As a flutter developer, it can be really cumbersome having to create directories and files for your project all the time 😓. Every flutter project, depending on the architecture you prefer to use will normally have similar directories or files.

In this tutorial, we will learn how to generate custom directories and files for your new flutter project using Go. 👨🏾‍💻

What is Golang? 🤖

Golang, is a statically typed, compiled programming language designed for simplicity, efficiency, and ease of use. It was created by Google engineers and was first released in 2009. Golang is commonly used for various types of applications, including web development, system programming, cloud services, network services, and more.

We will be making use of Golang's system programming capabilities to create our desired directories and files. System programming is a specialized area of software development focused on creating programs that interact closely with the underlying hardware and operating system.

Setting up Golang

You can skip this step if you already have Go SDK setup on your system. If you're new to Golang, you need to download and install the sdk from their official website. Golang SDK is available for MacOS, Linux and Windows. After downloading and installing the SDK, run this command to verify that the sdk was installed successfully.

go version

This should print out the sdk version currently installed on your system.

Important packages

We will be making use of some in-built packages available in the Golang. One of the important package we will be using is the os package. This package allows us to manipulate files and directories as entities.

The fmt package allows us to print and format string extensively in go.

Writing our codes 👨🏾‍💻

To start off, we will create a new file called generator.go which will contain all the necessary functions for our program.

First, we import all the necessary packages:

package main

import(
   "fmt"
   "os"
)

var directories map[string][]string = map[string][string]{
   "features": {},
   "shared": {},
   "theme": {
     "colors.dart",
     "theme.dart",
     "styles.dart"
   },
  "utils": {
     "storage.dart",
     "utils.dart",
     "validator.dart"
  },
  "/features/auth": {},
  "features/auth/views": {},
}

The import statement is used to import all the necessary packages we need for our program to run.
We created a key-value variable named directories of type map[string][]string. The key represents the name of the directory and the value represents the list of files to be created in the directory.

func CreateDirectory(path string) error {
   _, err := os.Stat(path)

   if err == nil {
     return nil
   }

   if os.IsNotExist(err) {
     err := os.MkdirAll(path, os.ModePerm)
     if err != nil {
       return err
     }
   }

   return nil
}

We created a function named CreateDirectory which takes in a string path as an argument. The path string represents the parent directory where we want to create all our custom directories.
The os.Stat function is used to get the file information for our directory.
os.IsNotExist function is used to check if the directory already exists. If it doesn't exists, create a new directory using the os.MkdirAll(path, os.ModePerm) function.
os.MkdirAll takes two arguments. The first argument is the path where the directory should be created and the second argument is the permission needed to create the directory.

func CreateDartFile(path, filename string) error {
   _, err := os.Create(fmt.Sprintf("/%v/%v", path, filename))

   if err != nil {
     return err
   }

   return nil
}

We create a new function named CreateDartFile which takes two arguments. The first argument is the path where the file should be created and the second argument represents the file name.
os.Create function takes an argument which specifies the directory where the file should be created.
fmt.Sprintf is used to combine the path and filename which then returns a string.
The os.Create returns two values. The first value represents the file and the second value returns an error if the file was not created successfully.
We check if os.Create function throws an error and return it to the CreateDartFile function.
If os.Create does not throw an error, we return nil

Next, we will look at our main function.

func main() {
  if len(os.Args) != 2 {
    fmt.Println("Please provide a parent directory")
    os.Exit(1)
  }

  parentPath := os.Args[1]

  for directory, files := range directories {
    err := CreateDirectory(fmt.Sprintf("/%v/%v", parentPath, directory))
    if err != nil {
       fmt.Printf("Failed to create directory: %v\n", directory)
    }

    for _, fileName := range files {
       err := CreateDartFile(fmt.Sprintf("/%v/%v", parentPath, directory), fileName)
       if err != nil {
         fmt.Printf("Failed to create file: %v\n", fileName)
       }
    }
  }

  fmt.Println("All directories & files generated successfully 🚀")
}

The os.Args function is used to specify a directory when we run go run from the terminal. The argument represents the parent directory where all our custom directory will be created.
Create a new variable parentPath to hold the specified directory from the terminal.
Use a for loop to iterate through the directories variable and create each directory using the CreateDirectory function you created earlier.
The CreateDirectory takes an argument which represents the full path where the directory should be created. We combine the parentPath and the directory string to get the full path.
Create another for loop to iterate through each file in the directories map.
Use the CreateDartFile function we created earlier to create each file. Pass the full path and the filename as arguments to the function.

Next, create a new flutter project named test_app in your documents folder.

Now, we need to run our generator.go file to generate our custom directories for our flutter project. Open up a terminal and type go run generator.go ~/documents/test_app/lib

You should see the message "All directories & files generated successfully".

Yay! All our custom directories and files were successfully generated.

Conclusion 👏

We have learnt how to generate custom directories and files for our flutter project. You can tweak this go code and use it however necessary to create custom directories or files for your projects.