blog-tools 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7653d790bc62101631922de1c8288efe77d7ec2563c1ed1a0822aca09010f3b0
-  data.tar.gz: dabe65fa231806eae07ed1e3a20b69a0dfa1c51074a033561c492848c366b024
+  metadata.gz: ccf964ed143ccaada2224313faf39eeefd1b06278f4643b83eb91d1200538e7f
+  data.tar.gz: 435b1cd63fcc143d02c720ffbeb251291e1a51dd86c8fd7c817171502d156b7c
 SHA512:
-  metadata.gz: a8bca7ed225b601cf99e6a46f6169a1b747f30a3487e908524c4bbe98d01c7743f34e99e3433e5fbc55fdaa7e5461e656f6355351ad208c0cd19d1502d7c22a9
-  data.tar.gz: b4bf5beb81654f40805b3d68ef412abebf8befa235aa55a533e8f834b301ec4e9859abe82efcfaf47c7511617ca34564397d8f0c0a43b8020aa535d3642f4f9c
+  metadata.gz: 2b66ac6f4d2ff10d3dac0b49f050b55ef6ee6ad8dfc8f6b7e86d5c82977fce189b0c239e371ea6bd56b6f31172a2a0886f1fbee2f1854b9745570cce31f79641
+  data.tar.gz: 22737f73babe47bdbd69c80e6e3d856ab88f455574813d6f5535a01f11b1ed86257fe2cc44b639954c297bc2e1b9d4d450a2b9f2ff6a68e9b2289eeb0a64d061

data/lib/blog-tools/cli.rb

@@ -8,24 +8,65 @@ require_relative 'commands/config'
 
 require_relative 'storage'
 
-# BlogTools is the main namespace for the blog-tools CLI application
-# It contains submodules for command logic, file storage, and CLI Interfaces
+# BlogTools is the main namespace for the blog-tools CLI application.
+#
+# It contains submodules for command logic, file storage, and CLI interfaces.
+#
+# @see BlogTools::CLI
 module BlogTools
-  # CLI handles all top-level commands for the blog-tools application
-  # It delegates to subcommands
+  # CLI is the entry point for the blog-tools command-line interface.
+  #
+  # It defines high-level commands like `generate`, `lists`, and `config`,
+  # and delegates their functionality to the appropriate subcommands.
+  #
+  # This class inherits from Thor, a Ruby gem for building command-line interfaces.
+  #
+  # @example Running the CLI
+  #   blog-tools generate my-post
+  #   blog-tools lists show my-list
+  #   blog-tools config
+  #
+  # @see Commands::Generate
+  # @see Commands::Lists
+  # @see Commands::Config
   class CLI < Thor
+    # Creates a new CLI instance and initializes the storage backend.
+    #
+    # This is called automatically when the CLI is run.
+    #
+    # @param [Array] args arguments passed to Thor
+    # @return [void]
     def initialize(*args)
       super
       Storage.setup!
     end
 
+    # @!group Commands
+
+    # Registers the `generate` subcommand.
+    #
+    # This command allows users to generate a new blog post interactively.
+    #
+    # @see Commands::Generate
     desc 'generate', 'Create a new post'
     subcommand 'generate', Commands::Generate
 
-    desc 'lists', 'Lists tools'
+    # Registers the `lists` subcommand.
+    #
+    # This command allows users to manage post lists.
+    #
+    # @see Commands::Lists
+    desc 'lists', 'Manage post lists'
     subcommand 'lists', Commands::Lists
 
+    # Registers the `config` subcommand.
+    #
+    # This command allows users to configure blog-tools settings.
+    #
+    # @see Commands::Config
     desc 'config', 'Configure blog-tools'
     subcommand 'config', Commands::Config
+
+    # @!endgroup
   end
 end

data/lib/blog-tools/commands/config.rb

@@ -2,13 +2,8 @@
 
 module BlogTools
   module Commands
-    # Config deals with all commands that configure how blog-tools works
+    # This command is a work in progress
     class Config < Thor
-      desc 'TITLE', 'Configure blog-tools'
-
-      def default(test)
-        puts test
-      end
     end
   end
 end

data/lib/blog-tools/commands/generate.rb

@@ -1,26 +1,61 @@
 # frozen_string_literal: true
 
+require 'colorize'
 require 'erb'
 require 'date'
 require_relative '../storage'
 
 module BlogTools
   module Commands
-    # Generate handles all of the subcommands related to generating posts
+    # BlogTools::Commands::Generate handles post generation
+    #
+    # It is a Thor-based CLI command set for generating blog posts
+    # It supports options like specifying a custom template, defining the author,
+    # setting tags, and defining the post content.
+    #
+    # @example Generate a basic post
+    #   blog-tools generate post "My post Title"
+    #
+    # @example Generate a post with tags and author
+    #   blog-tools generate post "My post Title" --tags ruby blog --author username
+    #
+    # @see BlogTools::CLI
+    # @see Storage::CONFIG_FILE
+    # @see Storage::TEMPLATES_DIR
     class Generate < Thor
       desc 'post TITLE', 'Generate a new blog post'
       method_option :template, type: :string, desc: 'Specify a template file'
       method_option :tags, type: :array, desc: 'Specify tags (space separated)'
       method_option :author, type: :string, desc: 'Specify author'
-      method_option :output, type: :string, desc: 'Output path or filename (default: title.md)'
+      method_option :output, type: :string, desc: 'Output directory'
       method_option :content, type: :string, desc: 'Path to content of post'
+
+      # Generates a new blog post from a template
+      #
+      # This command uses ERB templates to render a new post from a template
+      # You can customize the template, author, tags, and content, as well as
+      # where to save the file to.
+      #
+      # @param [String] title The title of the post
+      # @option options [String] :template Path to the ERB template
+      # @option options [Array<String>] :tags Tags to associate with the post
+      # @option options [String] :author Name of the author (overrides default in config file)
+      # @option options [String] :output Output directory (default: current)
+      # @option options [String] :content Path to file containing the post content
+      # @example
+      #  ❯ blog-tools generate post example
+      #  [✓] Post generated at example.md
+      # @return [Nil]
+      # @see ::ERB
+      # @see ::Date
+      # @see String#Colorize
       def post(title)
         config = File.exist?(Storage::CONFIG_FILE) ? YAML.load_file(Storage::CONFIG_FILE) : {}
 
         template_file = options[:template] || config['default_template'] || 'post.md'
         template_path = File.expand_path(File.join(Storage::TEMPLATES_DIR + template_file))
 
-        return puts("[!] Template file not found: #{template_path}") unless File.exist?(template_path)
+        return puts "[!] Template file not found: #{template_path}".colorize(:red) unless File.exist?(template_path)
 
         template = File.read(template_path)
         renderer = ERB.new(template)
@@ -34,10 +69,15 @@ module BlogTools
         )
 
         dir_path = "#{options[:output]}/"
-        output_filename = options[:output] ? "#{dir_path}#{title}.md" : "#{title.downcase.strip.gsub(/\s+/, '_')}.md"
+        output_filename = if options[:output]
+                            "#{dir_path}#{title}.md"
+                          else
+                            "#{title.downcase.strip.gsub(/\s+/,
+                                                         '_')}.md"
+                          end
         File.write(output_filename, result)
 
-        puts "[✓] Post generated at #{output_filename}"
+        puts "[✓] Post generated at #{output_filename}".colorize(:green)
       end
     end
   end

data/lib/blog-tools/commands/lists.rb

@@ -1,26 +1,83 @@
 # frozen_string_literal: true
 
+require 'colorize'
+
 require_relative '../storage'
 
 module BlogTools
   module Commands
-    # List handles all of the subcommands dealing with makes, editing, and
+    # BlogTools::Commands::Lists handles post lists
+    #
+    # List handles all of the subcommands dealing with making, editing, and
     # creating lists of blog post ideas
     #
-    # TODO option to add file path to the post
+    # @example Show all posts in a list
+    #   blog-tools lists show list
+    #
+    # @example Remove a post from a list
+    #   blog-tools lists remove list post
+    #
+    # @see BlogTools::CLI
+    # @see BlogTools::Storage
     class Lists < Thor
+      # Initializes the `lists` command with stored list data.
+      #
+      # This constructor is automatically called by Thor when the `lists` subcommand is invoked.
+      # It loads existing lists from storage into the `@lists` instance variable.
+      #
+      # @param [Array<String>] args Command-line arguments passed to the subcommand from Thor
+      # @see BlogTools::Storage::LISTS_FILE
       def initialize(*args)
         super
         @lists = Storage.read_lists || {}
       end
 
-      desc 'list LIST', 'View all posts in a list'
+      desc 'show LIST', 'View all posts in a list'
       method_option :completed, type: :boolean, default: false, desc: 'Show only completed posts'
-      method_option :in_progress, type: :boolean, default: false, desc: 'show only in-progress posts'
+      method_option :in_progress, type: :boolean, default: false, desc: 'Show only in-progress posts'
       method_option :status, type: :boolean, default: false, desc: 'Show post status as well'
-      # TODO: all option for all information about the post
-      def list(list)
-        return puts('[!] List not found') unless @lists[list]
+      # Shows all posts that are in a list
+      #
+      # This command reads the list from the `@lists` variable, and then shows it
+      # You can customize what it shows (completed/uncompleted), and if it shows
+      # the status of the post.
+      #
+      # @param [String] list The name of the list
+      # @option options [Boolean] :completed Show only posts that are completed.
+      # @option options [Boolean] :in_progress Show only posts that are in progress.
+      # @option options [Boolean] :status Show the status of the posts in the list.
+      # @example Basic usage
+      #   ❯ blog-tools lists show example
+      #   EXAMPLE
+      #   - example-post-1
+      #   - example-post-2
+      #   - example-post-3
+      #   - example-post-4
+      #   - example-post-5
+      #
+      # @example using the `--status` flag
+      #   ❯ blog-tools lists show example --status
+      #   EXAMPLE
+      #   - [✓] example-post-1
+      #   - [~] example-post-2
+      #   - [✓] example-post-3
+      #   - [ ] example-post-4
+      #   - [ ] example-post-5
+      #
+      # @example using the `--completed` flag
+      #   ❯ blog-tools lists show example --completed
+      #   EXAMPLE
+      #   - example-post-1
+      #   - example-post-3
+      #
+      # @example using the `--in-progress` flag
+      #   ❯ blog-tools lists show example --in-progress
+      #   EXAMPLE
+      #   - example-post-2
+      #
+      # @return [Nil]
+      def show(list)
+        return puts '[!] List not found'.colorize(:red) unless @lists[list]
 
         puts list.upcase
         @lists[list][:posts].each do |item, data|
@@ -44,58 +101,112 @@ module BlogTools
       end
 
       desc 'create NAME', 'Create a list'
+      # Creates a new list
+      #
+      # This command takes in a name for a list, and then creates a new list in
+      # the lists configuration file.
+      #
+      # @param [String] list The name of the list
+      # @example creating a new list
+      #   ❯ blog-tools lists create test
+      #   [✓] Created list: test
+      #
+      # @return [Nil]
       def create(name)
         @lists[name] = { posts: {} }
         Storage.write_lists(@lists)
-        puts "[✓] Created list: #{name}"
+        puts "[✓] Created list: #{name}".colorize(:green)
       end
 
       desc 'add LIST POST', 'Add a post to a list'
+      # Adds a post to a list
+      #
+      # This command takes the name of a list and the name of a post to be added.
+      # Assuming that the list exists, it will add the post to the list, and
+      # write the result to the list configuration file
+      #
+      # @param [String] list The name of the list
+      # @param [String] post_name The name of the post
+      # @example Adding a post to a list
+      #   ❯ blog-tools lists add test example
+      #   [✓] Added example to test list
+      # @return [Nil]
       def add(list, post_name)
-        return puts('[!] List not found') unless @lists[list]
+        return puts '[!] List not found'.colorize(:red) unless @lists[list]
 
         @lists[list][:posts][post_name] = { completed: false, in_progress: false }
-        puts "[✓] Added #{post_name} to #{list} list"
         Storage.write_lists(@lists)
+        puts "[✓] Added #{post_name} to #{list} list".colorize(:green)
       end
 
       desc 'delete LIST', 'Delete a list'
+      # Deletes a list
+      #
+      # This command takes in the name of a list and deletes it from the lists
+      # configuration file. It requires user input to confirm the deletion of
+      # the list. Once the user gives confirmation, it edits the `@lists`
+      # variable and writes it back to the lists configuration file.
+      #
+      # @param [String] list The name of the list
+      # @example Deleting a list
+      #   ❯ blog-tools lists delete test
+      #   [?] Are you sure you want to delete the 'test' list?
+      #   [?] This action cannot be undone. Proceed? (y/N)
+      #   > y
+      #   [✓] Deleted 'test' list
+      # @return [Nil]
       def delete(list)
-        return puts('[!] List not found') unless @lists[list]
+        return puts '[!] List not found'.colorize(:red) unless @lists[list]
 
-        puts "[?] Are you sure you want to delete the '#{list}' list?"
-        print "[?] This action cannot be undone. Proceed? (y/N)\n> "
+        puts "[?] Are you sure you want to delete the '#{list}' list?".colorize(:yellow)
+        print "[?] This action cannot be undone. Proceed? (y/N)\n> ".colorize(:yellow)
         input = $stdin.gets.chomp.strip
 
         case input.downcase
         when 'y'
           @lists.delete(list)
           Storage.write_lists(@lists)
-          puts "[✓] Deleted '#{list}' list"
+          puts "[✓] Deleted '#{list}' list".colorize(:green)
         when 'n', ''
-          puts '[i] Cancelled deletion.'
+          puts '[i] Cancelled deletion.'.colorize(:blue)
         else
-          puts '[!] Invalid input. Not deleting.'
+          puts '[!] Invalid input. Not deleting.'.colorize(:red)
         end
       end
 
       desc 'remove LIST POST', 'Remove a post from a list'
+      # Removes a post from a list
+      #
+      # This command take in both a list name and a post name, and then removes
+      # the post from the list. It requires user confirmation in order to make
+      # the deletion. Once the user confirms, it edits the `@lists` variable,
+      # and writes it to the lists configuration file.
+      #
+      # @param [String] list The name of the list
+      # @param [String] post_name The name of the post
+      # @example
+      #   ❯ blog-tools lists remove example example-post-1
+      #   [?] Are you sure you want to delete the post 'example-post-1'?
+      #   [?] This action cannot be undone. Proceed? (y/N)
+      #   > y
+      #   [✓] Deleted 'example-post-1' post
+      # @return [Nil]
       def remove(list, post_name)
-        return puts('[!] List not found') unless @lists[list]
+        return puts '[!] List not found'.colorize(:red) unless @lists[list]
 
-        puts "[?] Are you sure you want to delete the post '#{post_name}'?"
-        print "[?] This action cannot be undone. Proceed? (y/N)\n> "
+        puts "[?] Are you sure you want to delete the post '#{post_name}'?".colorize(:yellow)
+        print "[?] This action cannot be undone. Proceed? (y/N)\n> ".colorize(:yellow)
         input = $stdin.gets.chomp.strip
 
         case input.downcase
         when 'y'
           @lists[list][:posts].delete(post_name)
           Storage.write_lists(@lists)
-          puts "[✓] Deleted '#{post_name}' post"
+          puts "[✓] Deleted '#{post_name}' post".colorize(:green)
         when 'n', ''
-          puts '[i] Cancelled deletion.'
+          puts '[i] Cancelled deletion.'.colorize(:blue)
         else
-          puts '[!] Invalid input. Not deleting.'
+          puts '[!] Invalid input. Not deleting.'.colorize(:red)
         end
       end
 
@@ -104,30 +215,56 @@ module BlogTools
       method_option :in_progress, type: :boolean, default: false, desc: 'Mark as in progress'
       method_option :path, type: :string, desc: 'Path to the post contents'
       method_option :tags, type: :array
+      # Updates aspects of a post in a list
+      #
+      # This command takes a list and post, and requires a flag to be set to
+      # run. If no flag is set it will return. The set flag and the parameter
+      # with the flag are added into the lists configuration file under the
+      # post.
+      #
+      # @param [String] list The name of the list
+      # @param [String] post_name The name of the post
+      # @option options [Boolean] :completed This marks a post as completed
+      # @option options [Boolean] :in_progress This marks a post as in progress
+      # @option options [String] :path This specifies the path to the post's contents
+      # @option options [Array] :tags This adds tags to the post in the list
+      # @example Using the `--completed` flag.
+      #   ❯ blog-tools lists update example example-post-1 --completed
+      #   [✓] Marked 'example-post-1' as complete
+      # @example Using the `--in-progress` flag.
+      #   ❯ blog-tools lists update example example-post-2 --in-progress
+      #   [✓] Marked 'example-post-2' as in progress
+      # @example Using the `--path` flag.
+      #   ❯ blog-tools lists update example example-post-1 --path ~/documents/writeup.md
+      #   The post content is located at: /home/slavetomints/documents/writeup.md
+      # @example Using the `--tags` flag.
+      #   ❯ blog-tools lists update example example-post-3 --tags 1 2 3
+      #   Added the following tags to the post: ["1", "2", "3"]
+      # @return [Nil]
       def update(list, post_name)
         unless options[:completed] || options[:in_progress] || options[:tags] || options[:path]
-          return puts('[!] Please specify a status. Type "blog-tools lists help update" for more info.')
+          return puts '[!] Please specify a status. Type "blog-tools lists help update" for more info.'.colorize(:red)
         end
-        return puts('[!] List not found') unless @lists[list]
-        return puts('[!] Post not found') unless @lists[list][:posts].key?(post_name)
+        return puts '[!] List not found'.colorize(:red) unless @lists[list]
+        return puts '[!] Post not found'.colorize(:red) unless @lists[list][:posts].key?(post_name)
 
         post = @lists[list][:posts][post_name]
 
         if options[:completed]
           if post[:completed]
-            puts('[!] Post already marked as complete')
+            puts '[!] Post already marked as complete'.colorize(:redd)
           else
             post[:completed] = true
-            puts("[✓] Marked '#{post_name}' as complete")
+            puts "[✓] Marked '#{post_name}' as complete".colorize(:green)
           end
         end
 
         if options[:in_progress]
           if post[:in_progress]
-            puts('[!] Post already marked as in progress')
+            puts '[!] Post already marked as in progress'.colorize(:red)
           else
             post[:in_progress] = true
-            puts("[✓] Marked '#{post_name}' as in progress")
+            puts "[✓] Marked '#{post_name}' as in progress".colorize(:green)
           end
         end
         post[:tags] = options[:tags] if options[:tags]
@@ -136,24 +273,7 @@ module BlogTools
         puts "The post content is located at: #{options[:path]}" if options[:path]
 
         Storage.write_lists(@lists)
-      end
-
-      private
-
-      def show_statuses
-        if options[:status]
-          status =
-            if data[:completed]
-              '[✓]'
-            elsif data[:in_progress]
-              '[~]'
-            else
-              '[ ]'
-            end
-          puts "- #{status} #{item}"
-        else
-          puts "- #{item}"
-        end
+        nil
       end
     end
   end

data/lib/blog-tools/commands.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'commands/config'
+require_relative 'commands/generate'
+require_relative 'commands/lists'
+
+module BlogTools
+  # The Commands module groups all the CLI subcommands for blog-tools together.
+  #
+  # Each subcommand implements a feature of the CLI, such as generating posts,
+  # managing lists of future posts, and editing configurations for the tool.
+  #
+  # These subcommands are registered by the main BlogTools:CLI class.
+  #
+  # @see BlogTools::Commands::Generate
+  # @see BlogTools::Commands::Lists
+  # @see BlogTools::Commands::Config
+  module Commands
+    # This intentionally contains no logic. It exists to namespace the CLI commands
+  end
+end

data/lib/blog-tools/storage.rb

@@ -1,17 +1,42 @@
 # frozen_string_literal: true
 
+require 'colorize'
 require 'fileutils'
 require 'yaml'
 
 module BlogTools
-  # Handles paths and file initialization for blog-tools
+  # BlogTools::Storage handles paths and file initialization for blog-tools
   # configuration and templates.
+  #
+  # It is the namespace for all of the locations of files and directories the CLI
+  # accesses and writes to, as well as setting up the environment upon first run
+  # or if the configuration directory was deleted.
+  #
+  # @see BlogTools::CLI
   module Storage
+    # The location of the configuration directory. You can set your own with the
+    # `BLOG_TOOLS_DIR` environment variable, otherwise it will be located at
+    # `~/.config/blog-tools/`
     CONFIG_DIR            = ENV['BLOG_TOOLS_DIR'] || File.join(Dir.home, '.config', 'blog-tools')
+
+    # The location of the file used for storing lists. It is named `lists.yml`
+    # and put inside the configuration directory.
     LISTS_FILE            = File.join(CONFIG_DIR, 'lists.yml')
+
+    # The locaion of the default configurations file. It is inside the
+    # configuration directory
     CONFIG_FILE           = File.join(CONFIG_DIR, 'config.yml')
+
+    # The directory where `blog-tools` looks to find templates for generating
+    # posts. It is in the configuration directory.
     TEMPLATES_DIR         = File.join(CONFIG_DIR, 'templates/')
+
+    # This is the location of the default template file used.
     DEFAULT_TEMPLATE_FILE = File.join(TEMPLATES_DIR, 'post.md')
+
+    # This is the markdown for the default configuration file. It is put into
+    # the file when `BlogTools::Storage.create_default_template` is run
+    # @see BlogTools::Storage.create_default_template
     DEFAULT_TEMPLATE = <<~'MARKDOWN'
       ---
       title: "<%= title %>"
@@ -26,6 +51,12 @@ module BlogTools
     MARKDOWN
 
     # Ensure required directories and files exist.
+    #
+    # This method is used to completely setup the configuration environment
+    # It creates the `~/.config/blog-tools` directory, and the files
+    # and templates that are needed for the tool to run.
+    #
+    # @return [Nil]
     def self.setup!
       create_directories
       create_lists_file
@@ -33,40 +64,61 @@ module BlogTools
       create_default_template
     end
 
-    # Path to the config file
-    def self.config_path
-      CONFIG_FILE
-    end
-
+    # This method creates the configuration and templates directories.
+    #
+    # The directories are located at `~/.config/blog-tools`, and at
+    # `~/.config/blog-tools/templates`
+    #
+    # @return [Array] An array of the directories created
     def self.create_directories
       FileUtils.mkdir_p(CONFIG_DIR)
       FileUtils.mkdir_p(TEMPLATES_DIR)
     end
 
+    # Creates an empty lists file if it doesn't exist.
+    #
+    # @return [Array<String>, nil] The path to the file if created, otherwise nil.
     def self.create_lists_file
       FileUtils.touch(LISTS_FILE) unless File.exist?(LISTS_FILE)
     end
 
+    # Writes the given data to the lists file in YAML format.
+    #
+    # @param data [Hash] The data to write.
+    # @return [Integer] The number of bytes written to the file.
     def self.write_lists(data)
       File.write(LISTS_FILE, data.to_yaml)
     end
 
+    # Reads and parses the lists file, returning its contents as a hash.
+    #
+    # If the file doesn't exist or contains invalid YAML, returns an empty hash.
+    #
+    # @return [Hash] Parsed YAML data from the lists file.
     def self.read_lists
       return {} unless File.exist?(LISTS_FILE)
 
       data = YAML.safe_load_file(LISTS_FILE, permitted_classes: [Symbol, Date, Time], aliases: true)
       data.is_a?(Hash) ? data : {}
     rescue Psych::SyntaxError => e
-      warn "[!] Failed to parse lists.yml: #{e.message}"
+      warn "[!] Failed to parse lists.yml: #{e.message}".colorize(:red)
       {}
     end
 
+    # Creates a default configuration file if one does not already exist.
+    #
+    # If the config file is missing, this method will:
+    # - Print a warning message.
+    # - Create the config directory if needed.
+    # - Write a default config YAML file.
+    #
+    # @return [nil] Always returns nil.
     def self.create_config_file
       return if File.exist?(CONFIG_FILE)
 
       FileUtils.mkdir_p(File.dirname(CONFIG_FILE))
 
-      puts '[!] No configuration file found, generating now...'
+      puts '[!] No configuration file found, generating now...'.colorize(:red)
 
       default_config = {
         'author' => ENV['USER'] || 'changeme',
@@ -77,6 +129,11 @@ module BlogTools
       File.write(CONFIG_FILE, default_config.to_yaml)
     end
 
+    # Creates the default template file if the templates directory is empty.
+    #
+    # Writes the default post template to `post.md` and prints a success message.
+    #
+    # @return [nil] Always returns nil.
     def self.create_default_template
       return unless Dir.empty?(TEMPLATES_DIR)
 

data/lib/blog-tools/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 module BlogTools
-  VERSION = '0.2.0'
+  # Current tool version
+  VERSION = '0.2.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: blog-tools
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Slavetomints
@@ -60,6 +60,7 @@ extra_rdoc_files: []
 files:
 - bin/blog-tools
 - lib/blog-tools/cli.rb
+- lib/blog-tools/commands.rb
 - lib/blog-tools/commands/config.rb
 - lib/blog-tools/commands/generate.rb
 - lib/blog-tools/commands/lists.rb