heckler 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 605da338e5d75dfc3615fd7255390559228de9223cea8c4696a7781f64b7d33f
+  data.tar.gz: 067dfae307730437b0d5bae6a90e06f9033ab0f479469234d11da2dde64bff92
+SHA512:
+  metadata.gz: 0e84e49df096985d552c49bd91d9bae548904174d743c5ca6288884e9494ce4be5e5a4601f900b967334500b376e113c719888fbaa91ace5a02ef405b955d8bc
+  data.tar.gz: 3b1f705402cb5e522ee4f47d8652947ac1cb56b6e1d2ff539e2fd9d616b15e55a497f173295acbc917d58464fa79e9ab37e35fb03426b8871fad9cb4facfa12e

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/standardrb/standard
+ruby_version: 3.1

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-01-16
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Stanislav (Stas) Katkov
+
+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,44 @@
+# Heckler
+
+**Heckler** is a tool to identify wording or spelling mistakes in ruby codebase: filenames, class names, method names, property names and more. Spelling correction is powered by [GNU Aspell](https://en.wikipedia.org/wiki/GNU_Aspell) and originally started as a ruby port of [Peck](https://github.com/peckphp/peck).
+
+## Installation
+
+```bash
+bundle add heckler
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install heckler
+```
+
+## Dependencies
+Heckler requires Aspell to be present on a system to function.
+
+### MacOS
+`brew install aspell`
+
+### Linux
+- Debian/Ubuntu: `sudo apt-get install aspell aspell-en`
+- Fedora: `sudo dnf install aspell aspell-en`
+- Arch Linux: `sudo pacman -S aspell aspell-en`
+- openSUSE: `sudo zypper install aspell aspell-en`
+- Alpine: `sudo apk add aspell aspell-en`
+
+## Usage
+
+Start off by creating a configuration file, by running:
+`heckler init`
+
+Run spelling check with `heckler`
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/skatkov/heckler.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "standard/rake"
+
+task default: %i[test standard]
+
+desc "Build and install gem locally"
+task :local_install do
+  system "gem build heckler.gemspec"
+  system "gem install ./heckler-#{Heckler::VERSION}.gem"
+end

data/exe/heckler

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require "heckler"
+
+puts "test"
+Heckler::CLI.start(ARGV)

data/heckler.json

@@ -0,0 +1,10 @@
+{
+  "preset": "base",
+  "ignore": {
+    "words": [],
+    "paths": [
+      "tmp/",
+      "log/"
+    ]
+  }
+}

data/lib/heckler/aspell.rb

@@ -0,0 +1,47 @@
+require "open3"
+require_relative "config"
+
+Misspelling = Data.define(:word, :suggestions)
+
+module Heckler
+  class Aspell
+    @process = nil
+
+    def initialize(config)
+      @config = config
+    end
+
+    def check(text)
+      misspellings = get_misspellings(text)
+      misspellings.reject { |misspelling| @config.word_ignored?(misspelling.word) }
+    end
+
+    private
+
+    def get_misspellings(text)
+      misspellings = run(text)
+      misspellings
+    end
+
+    def take_suggestions(suggestions)
+      suggestions = suggestions.select { |suggestion| suggestion.match(/[^a-zA-Z]/).nil? }
+      suggestions.uniq
+    end
+
+    def run(text)
+      stdin, stdout, stderr, wait_thr = Open3.popen3("aspell", "--encoding", "utf-8", "-a", "--ignore-case", "--lang=en_US", "--sug-mode=ultra")
+      stdin.puts text
+      stdin.close
+      output = stdout.read
+      stdout.close
+      stderr.close
+
+      output.lines.select { |line| line.start_with?("&") }.map do |line|
+        word_metadata, suggestions = line.strip.split(":")
+        word = word_metadata.split(" ")[1]
+        suggestions = suggestions.strip.split(", ")
+        Misspelling.new(word, take_suggestions(suggestions))
+      end
+    end
+  end
+end

data/lib/heckler/checker/file_system.rb

@@ -0,0 +1,91 @@
+require_relative "../aspell"
+
+require "find"
+
+# The Checker::FileSystem class provides functionality to check spelling in file and directory names within a given directory structure.
+#
+# Usage:
+#   checker = Checker::FileSystem.new
+#   issues = checker.check("/path/to/directory")
+#
+# The check method:
+# - Recursively traverses the given directory
+# - Skips hidden files/directories (starting with .)
+# - Skips .git directories
+# - Checks spelling of each file/directory name
+# - Returns an array of Issue objects containing any misspellings found
+#
+# Each Issue object contains:
+# - The misspelling that was found
+# - The full path to the file/directory
+# - The line number (always 0 for filenames)
+module Heckler
+  class Checker
+    class FileSystem
+      def initialize(config, spellchecker)
+        @config = config
+        @spellchecker = spellchecker
+      end
+
+      def check(directory)
+        files_or_directories = []
+        Find.find(directory) do |path|
+          next if File.basename(path).start_with?(".")
+          next if File.fnmatch("*/.git/*", path)
+
+          files_or_directories << path
+        end
+
+
+        files_or_directories.sort_by! { |path| File.realpath(path) }
+
+        puts files_or_directories
+
+        issues = []
+
+        files_or_directories.each do |file_or_directory|
+          name = SpellcheckFormatter.format(File.basename(file_or_directory, ".*"))
+          new_issues = @spellchecker.check(name).map do |misspelling|
+            Issue.new(misspelling, File.realpath(file_or_directory), 0)
+          end
+
+          issues.concat(new_issues)
+        end
+
+        issues
+      end
+    end
+  end
+
+  class SpellcheckFormatter
+    def self.format(input)
+      # Remove leading underscores
+      input = input.gsub(/^_+/, "")
+
+      # Replace underscores and dashes with spaces
+      input = input.tr("_-", " ")
+
+      # Insert spaces between lowercase and uppercase letters (camelCase or PascalCase)
+      input = input.gsub(/([a-z])([A-Z])/, '\1 \2')
+
+      # Split sequences of uppercase letters, ensuring the last uppercase letter starts a new word
+      input = input.gsub(/([A-Z]+)([A-Z][a-z])/, '\1 \2')
+
+      # Replace multiple spaces with a single space
+      input = input.gsub(/\s+/, " ")
+
+      # Convert the final result to lowercase
+      input.downcase
+    end
+  end
+
+  class Issue
+    attr_reader :misspelling, :file, :line
+
+    def initialize(misspelling, file, line)
+      @misspelling = misspelling
+      @file = file
+      @line = line
+    end
+  end
+end

data/lib/heckler/cli.rb

@@ -0,0 +1,50 @@
+require 'optparse'
+
+require_relative "config"
+require_relative "aspell"
+require_relative "preset"
+require_relative "checker/file_system"
+
+
+module Heckler
+  class Runner
+    attr_reader :checkers
+
+    def initialize(checkers)
+      @checkers = checkers
+    end
+
+    def run(directory)
+      issues = []
+
+      puts directory
+
+      @checkers.each do |checker|
+        issues.concat(checker.check(directory))
+      end
+
+      issues
+    end
+  end
+
+  class CLI
+    def self.start(args)
+      command = args.shift
+
+      case command
+      when 'init'
+        Config.init
+      when nil
+        config = Config.instance
+        aspell = Aspell.new(config)
+
+        Runner.new([
+          Heckler::Checker::FileSystem.new(config, aspell)
+        ]).run(Dir.pwd)
+      else
+        puts "Unknown command: #{command}"
+        puts "Available commands: init, or no command for default behavior"
+      end
+    end
+  end
+end

data/lib/heckler/config.rb

@@ -0,0 +1,86 @@
+require "json"
+require "singleton"
+require_relative "preset"
+
+module Heckler
+  class Config
+    include Singleton
+
+    JSON_CONFIGURATION_NAME = "heckler.json".freeze
+
+    attr_accessor :whitelisted_words, :whitelisted_paths, :preset
+
+    def initialize
+      @whitelisted_words = []
+      @whitelisted_paths = []
+      @preset = nil
+      load_config
+    end
+
+    def self.flush
+      instance.whitelisted_words = []
+      instance.whitelisted_paths = []
+      instance.preset = nil
+      @resolve_config_file_path_using = nil
+    end
+
+    def self.exists?
+      File.exist?(Dir.pwd + "/" + JSON_CONFIGURATION_NAME)
+    end
+
+    def self.init
+      file_path = Dir.pwd + "/" + JSON_CONFIGURATION_NAME
+
+      return false if File.exist?(file_path)
+
+      configuration = {
+        preset: "base",
+        ignore: {
+          words: [],
+          paths: ["tmp/", "log/"]
+        }
+      }
+
+      File.write(file_path, JSON.pretty_generate(configuration))
+      true
+    end
+
+    def ignore_words(words)
+      @whitelisted_words.concat(words.map(&:downcase)).uniq!
+      persist
+    end
+
+    def word_ignored?(word)
+      @whitelisted_words.include?(word.downcase) ||
+        Preset.whitelisted_words(@preset).include?(word.downcase)
+    end
+
+    private
+
+    def load_config
+      base_path = Dir.pwd
+      file_path = base_path + "/" + (self.class.instance_variable_get(:@resolve_config_file_path_using)&.call || JSON_CONFIGURATION_NAME)
+
+      contents = File.exist?(file_path) ? File.read(file_path) : "{}"
+      json_as_array = JSON.parse(contents, symbolize_names: true) rescue {}
+
+      @whitelisted_words = (json_as_array.dig(:ignore, :words) || []).map(&:downcase)
+      @whitelisted_paths = json_as_array.dig(:ignore, :paths) || []
+      @preset = json_as_array[:preset]
+    end
+
+    def persist
+      file_path = Dir.pwd + "/" + JSON_CONFIGURATION_NAME
+
+      configuration = {
+        preset: @preset,
+        ignore: {
+          words: @whitelisted_words,
+          paths: @whitelisted_paths
+        }
+      }.compact
+
+      File.write(file_path, JSON.pretty_generate(configuration))
+    end
+  end
+end

data/lib/heckler/preset.rb

@@ -0,0 +1,20 @@
+module Heckler
+  class Preset
+    PRESET_STUBS_DIRECTORY = File.join(__dir__, "/presets")
+
+    def self.whitelisted_words(preset)
+      return [] if preset.nil? || !stub_exists?(preset)
+
+      get_words_from_stub("base") + get_words_from_stub(preset)
+    end
+
+    def self.get_words_from_stub(preset)
+      path = File.join(PRESET_STUBS_DIRECTORY, "#{preset}.stub")
+      File.read(path).lines.map(&:strip).reject(&:empty?)
+    end
+
+    def self.stub_exists?(preset)
+      File.exist?(File.join(PRESET_STUBS_DIRECTORY, "#{preset}.stub"))
+    end
+  end
+end

data/lib/heckler/presets/base.stub

@@ -0,0 +1,98 @@
+backfill
+cancelled
+propable
+dns
+verifier
+enum
+backend
+formatter
+init
+enums
+env
+misconfigured
+webhook
+auth
+webhooks
+middleware
+json
+fakeable
+fillable
+verifiers
+slugifier
+txt
+namespace
+truncatable
+unformatted
+finishable
+gitlab
+gitfake
+uri
+authenticatable
+hmac
+callables
+validator
+hostname
+ssl
+backoff
+bool
+schemas
+pre
+accessors
+unsuspend
+frontend
+repo
+src
+jwt
+nano
+slugify
+config
+ecr
+cloudflare
+bitbucket
+serverless
+postgres
+dev
+ui
+vite
+tls
+acl
+http
+parsable
+confirmable
+changelog
+livewire
+autocomplete
+followable
+recaptcha
+stringable
+viewables
+resizer
+params
+unfollow
+unfollows
+datetime
+otp
+lifecycle
+unbookmark
+pinnable
+mailables
+sharable
+blocklist
+conf
+timezones
+autocompletion
+arrayable
+pinkary
+sponsorship
+sponsorships
+iframe
+tokenize
+pwa
+stylesheets
+rubygems
+gemfile
+rakefile
+cli
+exe
+readme
+sig

data/lib/heckler/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Heckler
+  VERSION = "0.0.1"
+end

data/lib/heckler.rb

@@ -0,0 +1,11 @@
+##
+# Heckler is a ruby port of Peck tool
+# @see https://github.com/peckphp/peck
+##
+
+require_relative "heckler/version"
+require_relative "heckler/cli"
+
+module Heckler
+
+end

data/sig/heckler.rbs

@@ -0,0 +1,4 @@
+module Heckler
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: heckler
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Stanislav (Stas) Katkov
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-01-16 00:00:00.000000000 Z
+dependencies: []
+description: "**Heckler** is a tool to identify wording or spelling mistakes in ruby
+  codebase: filenames, class names, method names, property names and more. Spelling
+  correction is powered by **GNU Aspell**."
+email:
+- github@skatkov.com
+executables:
+- heckler
+extensions: []
+extra_rdoc_files: []
+files:
+- ".standard.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- exe/heckler
+- heckler.json
+- lib/heckler.rb
+- lib/heckler/aspell.rb
+- lib/heckler/checker/file_system.rb
+- lib/heckler/cli.rb
+- lib/heckler/config.rb
+- lib/heckler/personn.rb
+- lib/heckler/preset.rb
+- lib/heckler/presets/base.stub
+- lib/heckler/version.rb
+- sig/heckler.rbs
+homepage: https://github.com/skatkov/heckler
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/skatkov/heckler
+  source_code_uri: https://github.com/skatkov/heckler
+  changelog_uri: https://github.com/skatkov/heckler/CHANGELOG.md
+post_install_message:
+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.5.22
+signing_key:
+specification_version: 4
+summary: tool to identify wording or spelling mistakes in ruby codebase
+test_files: []