DEV Community: Omar Rodriguez

Increasing my command line efficiency

Omar Rodriguez — Fri, 30 Apr 2021 00:00:00 +0000

My command line environment is where I spend a big chunk of my time as a developer. I have noticed a big boost in efficiency by taking some time to customize some small and simple pieces of my command line environment and powershell profile.

Skip to the meat and potatoes of this post, the 'My powershell profile' section, here.

Skip to the setup section here.

Tools used

ConEmu

ConEmu is the terminal I use. I would prefer to use Windows Terminal but my work computer is not on a new enough build of Windows 10 to use it :(. Main reason I picked ConEmu is because it seemed to be the base that a lot of popular terminals are built on top of and it allows tabbing of shells. ConEmu is highly customizable and tons of features but I don’t take advantage of much of it.

Powershell

For my shell I use Powershell 5.1, the default version on Windows 10. I have become very comftorable with powershell and find automating things a breeze and fun with powershell.

Posh-git

Posh-git is a must have powershell module for git. It provides a bunch of really important info at a glance in the command line when in a git repo.

Side note related to must have git add-ons is the one and only git GUI I like. It is a nice lightweight VsCode extension called GitGraph.

Setup

ConEmu

Download and install ConEmu here. First thing I did was to modify one of the Predefined tasks. Speifically the {Shells::Powershell (Admin)} task and set it as the startup task. The modification and setting of startup task is all done in the settings. This is what my startup task looks like.


powershell.exe -new_console:a
powershell.exe -new_console:s50V
powershell.exe -new_console:as50H

What I have here is a base command powershell.exe -new_console:* which creates a new powershell shell with some addtional arguments. The first line uses the a argument to create the shell as admin. The second line uses s50V which translates to split the current panel (s) by 50% (50) vertically (V). The third line uses as50H which translates to run as admin (a) split the current panel (s) by 50% (50) horizontally (H).

The end result can be seen in the main image above.

Posh-git

The github readme has really good installation instruction as well as alternatives installation/setup options to what I will provide below.

Run the following 3 commands. The following installs via powershell gallery, imports the module, and then adds the module to your powershell profile. Install it via powershell gallery.

PowerShellGet\Install-Module posh-git -Scope CurrentUser -Force
Import-Module posh-git
Add-PoshGitToProfile -AllHosts

NOTE: If you’re asked to trust packages from the PowerShell Gallery, answer yes to continue installation of posh-git

My powershell profile

Customizing my powershell profile is really where I have increased my dev workflow efficiency. The powershell profile is essentially just a powershell script that runs when you open a new powershell shell. What I have done is created a bunch of little cmdlets, basically global functions, I can run at anytime in any powershell shell.

To get started what I do is run $PROFILE.CurrentUserAllHosts this will tell you the file path for your profile. Go ahead and open it in your favorite text editor and if it doesn’t exists create it.

Switching directories like a ninja

Something I do a lot is switch between code repositories. A lot of the code repos I work with have long names which means a lot more keystores than I would like just to switch between repo directories. So I created some aliases. Here is an example of what I put in my profile.ps1:


function Set-ShuttleCodeLocation {
    Set-Location D:\code\space-shuttle-controller
}

# Use New-Alias over Set-Alias https://stackoverflow.com/a/48093733
New-Alias -Name ShuttleCode -Value Set-ShuttleCodeLocation

Now any powershell session I start I can just type ShuttleCode and it will change my directory to my shuttle code repo’s directory. To save even more keystrokes you can take advantage of powershell auto complete and just type shu followed by TAB and powershell should auto complete to ShuttleCode.

Clean a project folder

Every now and then we want to clean up all bin and obj folders because something isn’t working correctly.


<#
   This will recursively remove all bin and obj folders in the current directory.
#>
function rmBinAndObjs {
    # Commented out is the shorthand version
    # ls -include bin,obj -r | %{rm -r -Force }
    Get-ChildItem -Include bin,obj -Recurse | ForEach-Object { Remove-Item -Recurse -Force $_.FullName }
}

Some git cmdlets

Yes, I know I could probably do this with git aliases but for non trivial git commands I feel less constrained with powershell.

This first set of cmdlets is useful for working with those files that are checked into git, and get modified locally but we don’t want them showing up in our local set of modified files in git. Usually this is useful with config files.


function Hide-FileFromGit {
    [CmdletBinding()]
    param(
        [string]$FileName
    )

    # Don't show file in changes
    git update-index --skip-worktree $FileName
}

function Show-FilesHiddenFromGit {
    [CmdletBinding()]
    param(
        [string]$FileName
    )
    # List files you are skipping
    git ls-files -v . | sls ^S
}

function Undo-HideFileFromGit {
    [CmdletBinding()]
    param(
        [string]$FileName
    )
    # Undo skip file
    git update-index --no-skip-worktree $FileName
}

This cmdlet is a convenient way to create a new branch from latest version of master and publish it to the remote repo. You may notice the [Parameter(Mandatory)] attribute on the $NewBranchName parameter. This is a really cool feature that makes it so that if you run this cmdlet without providing that parameter powershell will auto prompt you for the paramter value before proceeding.


function Publish-GitBranch {
   [CmdletBinding()]
   param(
      [Parameter(Mandatory)]
      [string]$NewBranchName,
      [string]$BaseBranch = 'master'
   ) 
   try {
      $currentBranch = git rev-parse --abbrev-ref HEAD
      if ($LASTEXITCODE -ne 0) { throw "You must be in a Git repository" }

      Write-Output "git checkout $BaseBranch"
      git checkout $BaseBranch
      Write-Output "git pull"
      git pull
      Write-Output "git checkout -b $NewBranchName"
      git checkout -b $NewBranchName
      Write-Output "git push --set-upstream origin $NewBranchName"
      git push --set-upstream origin $NewBranchName
   } finally {
   }
}

I have a lot more stuff in my powershell profile but is essentially just variations on what I’ve already shown above but more tailored to my specific work environment.

Conclusion

I found the majority of my increase in efficency came in customizing my powershell profile to automate a bunch of repititve tasks that saved me keystrokes and little google searches for commands throughout the day. Using something like conemu over powershell I think makes the screen more pleasing to look at, also the multiple shells at a glance using split panels is very useful in many scenarios. Using posh-git is just a must have for anyone using git on windows I would take that and powershell any day over the windows git bash terminal.

If you have any comments or questions reach out on Twitter @Omarr2d2.

How to create a zip in Xamarin Android

Omar Rodriguez — Mon, 10 Jun 2019 00:00:00 +0000

This solution is specifically for Android using Xamarin because I am using the Java.Util.Zip Class. This solution can just as easily be ported to Java.

Skip to the solution section below if you just want to see code.

Why I needed this functionality?

I am working on building an Android tool to help troubleshoot problems on a device that isn’t easily accessible. I was implementing a feature to gather important local files and folders then package them up and email them to interested parties. The compressing of the files is important since many of the devices where the app will be used will likely have poor internet connection.

Different approaches to the problem

The pure C# approach

Originally I tried looking for a generic C# solution that I could potentially make cross platform. However the System.IO.Compression API was a bit limited. For example I can easily compresses a directory but I have no control over what gets compressed in the folder i.e. if I want to skip over specific folders the api does not allow this.

The NuGet package approach

I attempted to look for a NuGet package that would simply zip a folder for me. That lead me to the possibility of using the 7z nuget but decided to hold off on going down that path because of lack of easy to find/read documentation.

The Android specific approach

Then I attempted to find an Android specific solution, in Java, which lead me to the Java.Util.Zip class. I found a nice example of it’s usage to compress and decompress zips. The port to C# was pretty straight forward.

I made some modifications like being able to skip folders as well as some refactoring for readability. Fixed some file contingency issues since I am not guaranteed that the files I am compressing will not be written to as I am reading them to compress them.

Example usage of solution

Here is an example of a simple usage of the solution. Notice the destination of the zip can be anywhere. The last parameter can be an empty set if you don’t want to exclude any folders.

ZippingAround.Compress("/sdcard/foo/", "/sdcard/destination/foo.zip", new HashSet<string>{ "large-files-folder" });

Solution

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

using Java.Util.Zip;

namespace foo
{
   public class ZippingAround
   {
      public static void Compress(string from, string to, HashSet<string> excludeFolders)
      {
         if (File.Exists(to)) File.Delete(to);

         using (var filestream = new FileStream(to, FileMode.OpenOrCreate, FileAccess.Write))
         {
            using (var zipStream = new ZipOutputStream(filestream))
            {
               CompressDirectory(from, zipStream, excludeFolders);
               zipStream.Finish();
            }
         }
      }

      private static void CompressDirectory(string dir2zip, ZipOutputStream zipStream, HashSet<string> foldersToExclude, string parent = "")
      {
         if (!Directory.Exists(dir2zip)) throw new ArgumentException($"Directory given does not exists. [{dir2zip}]");

         var zipDir = new DirectoryInfo(dir2zip);

         foreach (var file in zipDir.GetFiles())
         {
            var relativePath = string.IsNullOrEmpty(parent) ? file.Name : $"{parent}/{file.Name}";
            AddFileToArchive(zipStream, relativePath, file.FullName);
         }

         var directories = from directory in zipDir.GetDirectories()
                           where !foldersToExclude.Contains(directory.Name)
                           select directory;

         foreach (var directory in directories)
         {
            var relativeParentPath = string.IsNullOrEmpty(parent) ? directory.Name : $"{parent}/{directory.Name}";
            CompressDirectory(directory.FullName, zipStream, foldersToExclude, relativeParentPath);
         }
      }

      private static void AddFileToArchive(ZipOutputStream zipStream, string relativePath, string fullPath)
      {
         var tempFileName = $"{fullPath}.{DateTime.UtcNow.Ticks}.temp";

         try
         {
            File.Copy(fullPath, tempFileName);

            zipStream.PutNextEntry(new ZipEntry(relativePath));
            byte[] bytes = File.ReadAllBytes(tempFileName);
            zipStream.Write(bytes, 0, bytes.Length);
            zipStream.CloseEntry();
         }
         catch (Exception ex)
         {
            Console.WriteLine($"Problem compressing {ex.Message}");
         }

         if (File.Exists(tempFileName)) File.Delete(tempFileName);
      }
   }
}

Room for improvement

This class could be improved by adding an ability to skip files and file extensions.

Git the most edited files in a project

Omar Rodriguez — Mon, 10 Jun 2019 00:00:00 +0000

This post was inspired from seeing multiple bugs coming from the same file in a project in a short period of time. I could easily see all types of code smells in this particular file. So I had a hypothesis, if I could find the most edited files in the repo I would likely find the files with the most technical debt i.e. most code smells. So I created a very simple powershell script to test my hypothesis.

Skip to the solution section below if you just want to see code.

Why do the most edited files matter ?

Why do files change? In most cases files change for two reasons, there is a bug or there are changes that are needed to support a new feature. Lots of changes in a file due to bugs is obviously a good reason to take a closer look at a file.

Lots of changes to a file in order to support new features is also a good reason to take a closer look at a file since it could mean that the rest of your project may be too tightly coupled to things in this file or maybe the file has too many responsibilities.

Different approaches to the problem

The solution below can easily be converted into some other scripting language if needed but since powershell is cross-platform you should be able to run this on any some what modern computer. Tested both on windows and OSX

Solution

This is the pretty script version you can just copy paste this into a .ps1 file and run it.

Notice that the last command argument -First 10 can be changed to control the top results you want displayed.
Add a -# to the git command to control how many commits you want to run the script on. For example git log --pretty=format: --name-only -50 will only run the analysis on the last 50 commits.

git log --pretty=format: --name-only | 
Where-Object { ![string]::IsNullOrEmpty($_) } | 
Group-Object | 
Sort-Object -Property Count -Descending | 
Select-Object -Property Count, Name -First 10

Here is a shortened dirty one-liner version

git log --pretty=format: --name-only | ? { ![string]::IsNullOrEmpty($_) } | group | Sort-Object -Property Count -Descending | select -Property Count, Name -First 10

Code breakdown

Using some built-in powershell cmdlets and pipelining we transform some git text output into some useful statistics about a repository.

git log --pretty=format: --name-only gives you the list of files changed per commit.
Where-Object { ![string]::IsNullOrEmpty($_) } filters out all empty lines that are used by the git output from the first command to separate commits.
Group-Object groups all the lines that are the same together and gives you the number of objects in each group.
Sort-Object -Property Count -Descending sorts the groups by the count which is number of same files from highest to lowest.
Select-Object -Property Count, Name -First 10 selects the first 10 objects and displays the Count and Name properties. (The properties are from the objects that Group-Object has passed down the pipeline)

Some notes on the “Dirty one-liner”

This one-liner is essentially the same thing as the pretty version except that it is all on one-line and uses the aliases for Where-Object, Group-Object, and Select-Object.

Example output

Output after running the code should be something like this :

Count Name                            
----- ----                            
   33 _config.yml                     
   16 _layouts/post.html              
   15 README.md                       
   13 _includes/sidebar.html

Room for improvement

Instead of just sorting by the number of times a file has changed sort by the number of lines in aggregate that has changed in a file.
Maybe as a part 2 complementary type script, have a way to determine the most changed section of code maybe even narrow it down to functions or class names.
Filter out certain projects in a repository to target analysis to a specific project.
Filter out non bug-fix changes.
Filter out bug-fix changes.