tagm 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5e77dba199d42762e97c564b9c38ef12da589bcb736bef951facad1649ea212e
+  data.tar.gz: d8bc453571324083c037ec58ade5d676d2ecd9e046c93b27a9e4d3e4a7e985b7
+SHA512:
+  metadata.gz: 3284fba542988028f64475b2bbc9b12dee0c679ab8a0069d2a4c1e3ae737a5c21ddef28b0a2165d8897c9b0bf75fc75695a3a418dce14d3db18f24be989eb344
+  data.tar.gz: f75b6664a6495620cb38cfa490e7035bc267c29129e8a12799735cd267392c2fd7fa20f37d4d81e2311104f6e4b58bf8af2a28ac769cc49d8038cecd79db88c3

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,30 @@
+plugins:
+  - rubocop-performance
+  - rubocop-rake
+  - rubocop-rspec
+
+AllCops:
+  TargetRubyVersion: 3.1
+  NewCops: enable
+
+Layout/HashAlignment:
+  EnforcedColonStyle: table
+  EnforcedHashRocketStyle: table
+
+Layout/LineLength:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/HashSyntax:
+  EnforcedShorthandSyntax: never
+
+Style/SymbolArray:
+  EnforcedStyle: brackets
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: comma

data/.ruby-version

@@ -0,0 +1 @@
+3.1.2

data/CHANGELOG.md

@@ -0,0 +1,43 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+<!--
+Quick remainder of the possible sections:
+-----------------------------------------
+### Added
+  for new features.
+### Changed
+  for changes in existing functionality.
+### Deprecated
+  for soon-to-be removed features.
+### Removed
+  for now removed features.
+### Fixed
+  for any bug fixes.
+### Security
+  in case of vulnerabilities.
+### Maintenance
+  in case of rework, dependencies change
+
+Please, keep them in this order when updating.
+
+Breaking changes should be prefixed by `[**BREAKING**]` (without the quotes), to stand out.
+-->
+
+## [Unreleased]
+
+## [0.1.0] 2022/03/07
+
+### Added
+
+Base features; be able to:
+
+- add tags on nodes
+- remove tags
+- show tags for a node
+- show nodes for one or more tags
+- merge tags

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,134 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, caste, color, religion, or sexual
+identity and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the overall
+  community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or advances of
+  any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email address,
+  without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official email address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+
+    contact-project+experimentslabs-tagm-67777926-issue-@incoming.gitlab.com
+
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series of
+actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or permanent
+ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within the
+community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.1, available at
+[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
+
+Community Impact Guidelines were inspired by
+[Mozilla's code of conduct enforcement ladder][Mozilla CoC].
+
+For answers to common questions about this code of conduct, see the FAQ at
+[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
+[https://www.contributor-covenant.org/translations][translations].
+
+[homepage]: https://www.contributor-covenant.org
+[v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
+[Mozilla CoC]: https://github.com/mozilla/diversity
+[FAQ]: https://www.contributor-covenant.org/faq
+[translations]: https://www.contributor-covenant.org/translations

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 manu
+
+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,75 @@
+# Tagm
+
+Small tool to associate tags to files.
+
+This gem was not tested on Windows; use at your own risks.
+
+## Community
+
+- [Matrix chatroom](https://matrix.to/#/#experimentslabs-general:matrix.org)
+- [Issues](https://gitlab.com/experimentslabs/tagm/-/issues)
+
+## Installation
+
+```sh
+gem install tagm
+```
+
+Tagm relies on the `TAGM_DB_PATH` environment variable, so you should export it from your .bashrc or similar file:
+
+```sh
+export TAGM_DB_PATH=$HOME/.config/tagm_database.sqlite3
+```
+
+Create the database:
+
+```sh
+tagm create_database
+```
+
+## Usage
+
+See all options and help on commands with:
+
+```sh
+# Commands list
+tagm
+
+# Help on a specific command
+tagm help tag
+```
+
+## 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).
+
+## Contributing
+
+Bug reports and pull requests are welcome on Gitlab at https://gitlab.com/experimentslabs/tagm. This project is intended
+to be a safe, welcoming space for collaboration, and contributors are expected to adhere to
+the [code of conduct](https://gitlab.com/experimentslabs/tagm/-/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Tagm project's codebases, issue trackers, chat rooms and mailing lists is expected to follow
+the [code of conduct](https://gitlab.com/experimentslabs/tagm/-/main/CODE_OF_CONDUCT.md).
+
+## Gem story
+
+I was searching for a tool to manage files with tags instead of directories; and I then found [TMSU](https://tmsu.org/),
+which provides taggings _and_ the ability to mount tags as directories with Fuse. Sadly, the project did not move since
+11/2022.
+
+So why not?
+
+If you dig a bit in the code, you'll see we don't use any ORM for accessing SQLite database. This was primarily intended
+as an exercice, as I have not written any SQL statement in ages. I'm OK to change this :) 

data/Rakefile

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

data/exe/tagm

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'tagm'
+
+require_relative '../lib/tagm/cli'
+
+Tagm::Cli.start ARGV

data/lib/tagm/cli.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'skittlize'
+require 'thor'
+
+require_relative 'config'
+require_relative 'db'
+
+module Tagm
+  class Cli < Thor
+    desc 'tag NODE', 'Adds tag to specified node, or to current directory when nothing specified'
+    option 'tags', aliases: ['t'], type: :array, desc: 'List of space-separated tags', required: true, default: []
+    def tag(node)
+      path = resolve_path node
+      Db.tag node: path, tags: options[:tags]
+
+      put_path_tags path, node
+    end
+
+    desc 'untag NODE', 'Removes one or many tags to specified node, or to current directory when nothing specified'
+    option 'tags', aliases: ['t'], type: :array, desc: 'List of space-separated tags', required: true, default: []
+    def untag(node)
+      path = resolve_path node
+      Db.untag node: path, tags: options[:tags]
+
+      put_path_tags path, node
+    end
+
+    desc 'on [NODE]', 'Displays tags associated to specified node. Displays all nodes if no node is provided'
+    def on(node = nil)
+      path = resolve_path(node)
+
+      put_path_tags path, node
+    end
+
+    desc 'tagged [TAGS]', 'Displays all registered paths matching the tags. Displays all nodes if no tag is provided'
+    def tagged(tags = [])
+      paths = Db.list(*tags)
+      paths.each_pair do |path, list|
+        puts "#{path}: #{colorize(list).join(', ')}"
+      end
+    end
+
+    desc 'merge', 'Merges one or many tags into another'
+    option 'from', aliases: ['-f'], type: :array, desc: 'List of space-separated tags', required: true, default: []
+    option 'into', aliases: ['-i'], type: :string, desc: 'Target tag', required: true
+    def merge
+      Db.merge(from: options[:from], into: options[:into])
+      puts "Merged \"#{options[:from].sort.join('", "')}\" into \"#{options[:into]}\""
+    end
+
+    desc 'create_db', "Creates database at \"$#{Config::DB_PATH_VAR}\""
+    def create_db
+      puts "Creating database at #{Config::DB_PATH_VAR}"
+      Tagm::Db.create_database!
+    end
+
+    private
+
+    def resolve_path(path)
+      path = File.absolute_path(path || Dir.pwd)
+
+      raise 'File does not exist' unless File.exist? path
+
+      path
+    end
+
+    def put_path_tags(full_path, option_node)
+      tags = colorize(Db.show(full_path)).join(', ')
+      puts "#{option_node}: #{tags}"
+    end
+
+    def colorize(strings)
+      strings.map(&:skittlize)
+    end
+  end
+end

data/lib/tagm/config.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Tagm
+  class Config
+    class MissingDbPathError < StandardError; end
+
+    DB_PATH_VAR = 'TAGM_DB_PATH'
+
+    class << self
+      def db_path
+        @db_path ||= ENV.fetch(DB_PATH_VAR, nil)
+
+        raise MissingDbPathError, "Missing #{DB_PATH_VAR} environment variable" unless @db_path
+
+        @db_path
+      end
+    end
+  end
+end

data/lib/tagm/db.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require 'sqlite3'
+
+require_relative 'config'
+
+require 'debug'
+
+module Tagm
+  class Db # rubocop:disable Metrics/ClassLength
+    class << self
+      def db
+        @db ||= SQLite3::Database.new Config.db_path
+      end
+
+      # Tags a node
+      #
+      # @param node [String] Node to tag
+      # @param tags [Array<String>] Tags to apply
+      #
+      # @return [nil]
+      def tag(node:, tags:)
+        tags = sanitize_tags(tags).uniq
+
+        path = find_path node
+        existing = show(node) || []
+
+        tags_to_create = tags - existing
+        return if tags_to_create.empty?
+
+        sql_inserts = tags_to_create.map do |t|
+          tag = find_tag t
+          "(#{path[:id]}, #{tag[:id]})"
+        end.join(', ')
+
+        db.execute "INSERT INTO paths_tags (path_id, tag_id) VALUES #{sql_inserts};"
+      end
+
+      # Remove tags from a node
+      #
+      # @param node [String] Node to tag
+      # @param tags [Array<String>] Tags to remove
+      #
+      # @return [nil]
+      def untag(node:, tags:)
+        tags = sanitize_tags(tags)
+        node = find_path node
+
+        tags = find_tags(tags).map { |t| t[:id] }
+
+        placeholders = Array.new(tags.length) { '?' }.join(', ')
+        db.execute "DELETE from paths_tags WHERE path_id=? AND tag_id IN (#{placeholders})", [node[:id]] + tags
+      end
+
+      # Merge tags
+      #
+      # @param from [Array<String>] List of tags to be merged
+      # @param into [String] Target tag
+      #
+      # @return [nil]
+      def merge(from:, into:) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        into = sanitize_tag(into)
+        # Don't sanitize "from" to allow work on previously malformed tags
+        from = [from] unless from.is_a? Array
+
+        raise 'Cannot merge into itself' if from.include? into
+
+        into = find_tag(into) # Will create target if missing
+
+        # Merge tags
+        from_ids = db.execute("SELECT id FROM tags WHERE name IN (#{query_placeholders(from)})", from).flatten
+        db.execute "UPDATE paths_tags SET tag_id= ? WHERE tag_id IN (#{query_placeholders(from_ids)})",
+                   [into[:id]] + from_ids
+
+        # Remove duplicate entries
+        dupes = db.execute <<~SQL
+          SELECT path_id, tag_id, count(*)
+          FROM paths_tags
+          GROUP BY path_id, tag_id
+          HAVING count(*) > 1
+        SQL
+
+        sql = dupes.map do |(path_id, tag_id)|
+          <<~SQL
+            DELETE FROM paths_tags WHERE path_id=#{path_id} AND tag_id=#{tag_id};
+            INSERT INTO paths_tags (path_id, tag_id) VALUES (#{path_id}, #{tag_id});
+          SQL
+        end
+
+        db.execute_batch sql.join
+      end
+
+      # Show tags on a node
+      #
+      # @param node [String] Node to check
+      # @return [Array<String>] Tags associated to the node
+      def show(node)
+        path = find_path node, create: false
+
+        return nil unless path
+
+        pt = db.execute <<~SQL, path[:id]
+          SELECT tags.name FROM tags INNER JOIN paths_tags pt on tags.id = pt.tag_id AND pt.path_id = ? ORDER BY tags.name
+        SQL
+
+        pt.flatten
+      end
+
+      # List nodes with tags
+      #
+      # @param tags [Array<String>] List of tags for the filter
+      # @return [Hash] Hash with path as keys and tags list as value
+      def list(*tags) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        tags = sanitize_tags(tags)
+
+        sql = <<~SQL
+          SELECT paths.path, tags.name
+          FROM paths, tags
+          INNER JOIN paths_tags pt on paths.id = pt.path_id AND tags.id = pt.tag_id
+        SQL
+        sql += "WHERE tags.name IN (#{query_placeholders(tags)})" unless tags.empty?
+        sql += 'ORDER BY tags.name'
+
+        results = if tags.empty?
+                    db.execute sql
+                  else
+                    db.execute sql, [tags]
+                  end
+
+        # { <path>: [<tags>] }
+        paths = {}
+        results.each do |l|
+          paths[l[0]] ||= []
+          paths[l[0]] << l[1]
+        end
+
+        paths
+      end
+
+      def create_database! # rubocop:disable Metrics/MethodLength
+        db.execute_batch <<~SQL
+          CREATE TABLE IF NOT EXISTS tags (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            name VARCHAR(30)
+          );
+          CREATE TABLE IF NOT EXISTS paths (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            path TEXT
+          );
+          CREATE TABLE IF NOT EXISTS paths_tags (
+            path_id INTEGER,
+            tag_id INTEGER,
+            FOREIGN KEY(path_id) REFERENCES paths(id),
+            FOREIGN KEY(tag_id) REFERENCES tags(id)
+          );
+        SQL
+      end
+
+      private
+
+      def find_tag(tag, create: true)
+        record = db.get_first_row 'SELECT id, name FROM tags WHERE name = ? LIMIT 1', tag
+        return [:id, :name].zip(record).to_h unless record.nil?
+        return unless create
+
+        db.execute 'INSERT INTO tags (name) VALUES (?)', tag
+        { id: db.last_insert_row_id, name: tag }
+      end
+
+      def find_tags(tags)
+        results = db.execute "SELECT id, name FROM tags WHERE name IN (#{query_placeholders(tags)})", tags
+
+        fields = [:id, :name]
+        results.map do |r|
+          fields.zip(r).to_h
+        end
+      end
+
+      def find_path(node, create: true)
+        record = db.get_first_row 'SELECT id, path FROM paths WHERE path = ? LIMIT 1', node
+        return [:id, :path].zip(record).to_h unless record.nil?
+        return unless create
+
+        db.execute 'INSERT INTO paths (path) VALUES (?)', node
+        { id: db.last_insert_row_id, path: node }
+      end
+
+      def sanitize_tags(tags)
+        tags.map { |t| sanitize_tag t }
+      end
+
+      def sanitize_tag(tag)
+        tag.downcase.strip.sub(/,$/, '')
+      end
+
+      def query_placeholders(array)
+        Array.new(array.length) { '?' }.join(', ')
+      end
+    end
+  end
+end

data/lib/tagm/version.rb

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

data/lib/tagm.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative 'tagm/version'
+require_relative 'tagm/config'
+require_relative 'tagm/db'
+
+module Tagm
+  class Error < StandardError; end
+  # Your code goes here...
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: tagm
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- manu
+bindir: exe
+cert_chain: []
+date: 2025-03-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: skittlize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: tty-config
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+description: Allows to add tags on files, then find the files by tags. A SQLite database
+  stores the references.
+email:
+- manu@experimentslabs.com
+executables:
+- tagm
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/tagm
+- lib/tagm.rb
+- lib/tagm/cli.rb
+- lib/tagm/config.rb
+- lib/tagm/db.rb
+- lib/tagm/version.rb
+homepage: https://experimentslabs.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://experimentslabs.com
+  source_code_uri: https://gitlab.com/experimentslabs/tagm
+  changelog_uri: https://gitlab.com/experimentslabs/tagm/-/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.5
+specification_version: 4
+summary: Tool to manage tags on files
+test_files: []