lazy_names 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d0507f34b2f1f59a72734ddeb41c5b867f5114fd117ba73baa33293b46773d05
-  data.tar.gz: 3d9e34b1beeba0a4ef3ac8b87e3faf295614efcee1da770d40ee5f5619c9752e
+  metadata.gz: 4d4b509d7cf80a3a06d081c317071cd6fbe5108f86f4e5e3c73b6ad04919be47
+  data.tar.gz: c975ba3dba6e0c88ed1277e757284a1f98599b2387264285765451150efeb1b2
 SHA512:
-  metadata.gz: 26231616eaa3a461ff281553300503d678952a3e4957593473b7db00fa00454848a6fa1cf4071de52d2e04b4afd4030ccd27c5988e69b17606ef3a027973481c
-  data.tar.gz: 81f910b280c65f62d9316a34b67d932950d991ba13a4dea3df18dcf78b8459d5745581d9422b1078eed624336e3a88985a4741710785530ee50aa9e79934f067
+  metadata.gz: 92841fbe989e3f7556d9dd1269f35bff70fc78b8f9b75762011f37d7510bda072f9d63e21fa23c427d968ae657acfb2241aeeef7cb29c8f0b7cc271447cb0ca6
+  data.tar.gz: d8d5b5031d35521f754bc9c27dd9db7af016a6a347bac8c0b777039094a33e6a9e76005879fb1806ae7e25c4c3a2cacccd2bdcfcd9b93c058ee523be31ca7dee

data/.github/workflows/codecov.yml

@@ -9,7 +9,7 @@ jobs:
     timeout-minutes: 15
     runs-on: ubuntu-24.04
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: 3.1

data/.github/workflows/codeql.yml

@@ -55,7 +55,7 @@ jobs:
         # your codebase is analyzed, see https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/codeql-code-scanning-for-compiled-languages
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v4
+      uses: actions/checkout@v6
 
     # Add any setup steps before running the `github/codeql-action/init` action.
     # This includes steps like installing compilers or runtimes (`actions/setup-node`
@@ -65,7 +65,7 @@ jobs:
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3
+      uses: github/codeql-action/init@v4
       with:
         languages: ${{ matrix.language }}
         build-mode: ${{ matrix.build-mode }}
@@ -93,6 +93,6 @@ jobs:
         exit 1
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v3
+      uses: github/codeql-action/analyze@v4
       with:
         category: "/language:${{matrix.language}}"

data/.github/workflows/rake.yml

@@ -14,7 +14,7 @@ jobs:
         os: [ ubuntu-latest, macos-latest, windows-latest ]
     runs-on: ${{ matrix.os }}
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: '3.1'

data/.lazy_names.tt.rb

@@ -0,0 +1,5 @@
+# project specific
+MUCC = Models::Users::CreditCard
+
+# global
+ARBase = ActiveRecord::Base

data/.rubocop.yml

@@ -37,5 +37,43 @@ Metrics/BlockLength:
   Exclude:
     - spec/**/*.rb
 
+Metrics/MethodLength:
+  Max: 15
+
+Metrics/AbcSize:
+  Max: 20
+
 RSpec/NestedGroups:
   Enabled: false
+
+RSpec/MultipleExpectations:
+  Max: 5
+
+RSpec/ExampleLength:
+  Max: 20
+
+RSpec/MessageSpies:
+  Enabled: false
+
+RSpec/RemoveConst:
+  Enabled: false
+
+RSpec/InstanceVariable:
+  Enabled: false
+
+RSpec/DescribeClass:
+  Enabled: false
+
+RSpec/ContextWording:
+  Enabled: false
+
+RSpec/AnyInstance:
+  Enabled: false
+
+Security/Eval:
+  Exclude:
+    - spec/**/*.rb
+
+Style/FrozenStringLiteralComment:
+  Exclude:
+    - .lazy_names.tt.rb

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    lazy_names (1.0.0)
+    lazy_names (2.0.0)
 
 GEM
   remote: https://rubygems.org/
@@ -10,7 +10,7 @@ GEM
     coderay (1.1.3)
     diff-lcs (1.5.1)
     docile (1.4.1)
-    json (2.10.1)
+    json (2.10.2)
     language_server-protocol (3.17.0.4)
     lint_roller (1.1.0)
     method_source (1.1.0)

data/MIGRATION_FROM_V1.md

@@ -0,0 +1,276 @@
+# Migration Guide: v1.x to v2.0
+
+This guide will help you migrate from LazyNames v1.x (YAML configuration) to v2.0 (Ruby configuration).
+
+## Overview
+
+LazyNames v2.0 removes YAML support in favor of plain Ruby configuration files. This change makes the gem more intuitive and Ruby-native.
+
+## Why the Change?
+
+As discussed in the original issue, `.irbrc` and `.pryrc` already support plain Ruby. The YAML abstraction was unnecessary when you can simply write:
+
+```ruby
+MUCC = Models::Users::CreditCard
+```
+
+Instead of:
+
+```yaml
+---
+definitions:
+  'Models::Users::CreditCard': 'MUCC'
+```
+
+## Breaking Changes
+
+- ❌ `.lazy_names.yml` is no longer supported
+- ✅ You must use `.lazy_names.rb` instead
+- ✅ Constants are validated at load time (mandatory)
+
+## Quick Conversion
+
+### Before (v1.x)
+
+**.lazy_names.yml**:
+```yaml
+---
+definitions:
+  'Models::User': 'MU'
+  'Services::EmailSender': 'SES'
+  'Controllers::API::V1::UsersController': 'CAVUC'
+```
+
+### After (v2.0)
+
+**.lazy_names.rb**:
+```ruby
+MU = Models::User
+SES = Services::EmailSender
+CAVUC = Controllers::API::V1::UsersController
+```
+
+## Automated Conversion Script
+
+Save this as `convert_to_v2.rb` and run it in your project directory:
+
+```ruby
+#!/usr/bin/env ruby
+require 'yaml'
+
+yaml = YAML.load_file('.lazy_names.yml')
+definitions = yaml['definitions'] || yaml.values.first['definitions']
+
+File.open('.lazy_names.rb', 'w') do |f|
+  f.puts "# Converted from .lazy_names.yml"
+  definitions.each do |full, short|
+    f.puts "#{short} = #{full}"
+  end
+end
+
+puts "✓ Converted to .lazy_names.rb"
+```
+
+### Using the Conversion Script
+
+1. Run the script in your project directory:
+   ```bash
+   ruby convert_to_v2.rb
+   ```
+
+2. Review the generated `.lazy_names.rb`:
+   ```bash
+   cat .lazy_names.rb
+   ```
+
+3. Test it in your console:
+   ```bash
+   bundle exec rails c
+   # or
+   bin/console
+   ```
+
+4. Once verified, delete the old YAML file:
+   ```bash
+   rm .lazy_names.yml
+   ```
+
+## Global Configuration Migration
+
+If you have a global configuration in `~/.lazy_names.yml` with namespace/project scoping:
+
+### Before
+
+**~/.lazy_names.yml**:
+```yaml
+---
+my_project:
+  definitions:
+    'Models::User': 'MU'
+another_project:
+  definitions:
+    'API::Client': 'AC'
+```
+
+### Namespace Scoping Is Intentionally Removed
+
+v2.0 **does not support** namespace/project scoping in global config files. This was a deliberate decision:
+
+- **It was YAML-induced complexity.** YAML encourages nested structures, but Ruby doesn't need this abstraction.
+- **Project detection is fragile.** Matching project names to directories adds magic that can break.
+- **Project-specific files are better.** Each project having its own `.lazy_names.rb` is more explicit and maintainable.
+
+### After: Use Project-Specific Files (Recommended)
+
+**This is the preferred migration path.** Create `.lazy_names.rb` in each project directory:
+
+```ruby
+# my_project/.lazy_names.rb
+MU = Models::User
+```
+
+```ruby
+# another_project/.lazy_names.rb
+AC = API::Client
+```
+
+Benefits:
+- Version controlled with each project
+- Explicit about what's loaded
+- No surprises or magic detection
+- Easy to understand and maintain
+
+### Alternative: Global File with Guards
+
+If you prefer a single global file, use `if defined?()` guards:
+
+**~/.lazy_names.rb**:
+```ruby
+# Only defined if the constant exists in the current project
+MU = Models::User if defined?(Models::User)
+AC = API::Client if defined?(API::Client)
+```
+
+This achieves the same result as namespace scoping but is simpler and more transparent.
+
+## New Features in v2.0
+
+### Validation
+
+All constants are now validated before being defined:
+
+```ruby
+# Valid - will be defined
+MU = Models::User
+
+# Invalid - will show warning and skip
+INVALID = NonExistent::Class
+# Warning: Line 4: Constant NonExistent::Class not found - INVALID = NonExistent::Class
+```
+
+### Comments and Formatting
+
+```ruby
+# You can add comments to document your shortcuts
+MU = Models::User
+
+# Blank lines are allowed for organization
+
+SES = Services::EmailSender
+
+# Underscores and numbers work too
+API_V1 = API::V1
+CACHE2 = Cache::RedisCache
+```
+
+### Better Error Messages
+
+v2.0 provides detailed error messages with line numbers:
+
+```
+Loading definitions from /path/to/.lazy_names.rb
+Line 5: Constant Foo::Bar not found - FB = Foo::Bar
+Loaded 10 definitions
+Skipped 1 invalid lines
+```
+
+## Troubleshooting
+
+### "Constant not found" warnings
+
+If you see warnings about constants not being found:
+
+1. **Make sure the constant exists** in your application
+2. **Check the spelling** - constant names are case-sensitive
+3. **Ensure the constant is loaded** before LazyNames runs
+
+Example:
+```ruby
+# This will fail if Models isn't loaded yet
+MU = Models::User
+
+# This is safer - only define if it exists
+MU = Models::User if defined?(Models::User)
+```
+
+### Constants not defined in console
+
+If constants aren't showing up in your console:
+
+1. Check that `.lazy_names.rb` is in the right location:
+   - Project root: `./.lazy_names.rb`
+   - Home directory: `~/.lazy_names.rb`
+
+2. Verify your IRB/Pry configuration is correct:
+
+   **For Pry** (`~/.pryrc` or `.pryrc`):
+   ```ruby
+   if defined?(LazyNames)
+     Pry.config.hooks.add_hook(:when_started, :lazy_names) do
+       LazyNames.load_definitions!
+     end
+   end
+   ```
+
+   **For IRB** (`~/.irbrc` or `.irbrc`):
+   ```ruby
+   if defined?(LazyNames)
+     LazyNames.load_definitions!
+   end
+   ```
+
+3. Make sure you've updated to v2.0:
+   ```bash
+   bundle update lazy_names
+   ```
+
+### Migration script errors
+
+If the conversion script fails:
+
+**Error: No .lazy_names.yml found**
+- Make sure you're in the correct directory
+- Check if the file is named exactly `.lazy_names.yml`
+
+**Error: .lazy_names.rb already exists**
+- Review the existing file
+- Delete it if you want to regenerate: `rm .lazy_names.rb`
+- Or merge manually
+
+## Need Help?
+
+If you encounter issues during migration:
+
+1. Check the [README](README.md) for configuration examples
+2. Review the [implementation plan](MIGRATION_PLAN_V2.md) for technical details
+3. Open an issue on [GitHub](https://github.com/zhisme/lazy_names/issues)
+
+## Benefits of v2.0
+
+After migrating, you'll enjoy:
+
+- ✅ **More intuitive** - Same syntax as `.irbrc`/`.pryrc`
+- ✅ **Better IDE support** - Syntax highlighting and autocomplete
+- ✅ **Mandatory validation** - Know immediately if a constant doesn't exist
+- ✅ **Simpler** - No YAML parsing overhead
+- ✅ **Ruby-native** - Write Ruby to configure Ruby

data/README.md

@@ -17,6 +17,16 @@ Consider this example from pry terminal session.
 
 The idea is to reduce typing of long namespaced constants to shorter versions. It's very useful when you have a lot of nested namespaces and you need to access them frequently. This gem will take your responsibility to redefine constants to shorter versions and making constant/classes validations.
 
+## Why Plain Ruby? (v2.0+)
+
+LazyNames v2.0 uses plain Ruby instead of YAML because:
+
+- ✅ **Intuitive**: Same syntax you'd write in `.irbrc`/`.pryrc`
+- ✅ **IDE Support**: Syntax highlighting and autocomplete work out of the box
+- ✅ **Validation**: Constants are validated at load time
+- ✅ **Simpler**: No YAML parsing, no extra abstraction
+- ✅ **Ruby-native**: Write Ruby to configure Ruby
+
 ## Installation
 
 1. Add this line to your application's Gemfile:
@@ -53,7 +63,9 @@ bundle
 
 4. Create your own lazy_names config where you define constants
 ```bash
-cp .lazy_names.tt.yml ~/.lazy_names.yml
+touch ~/.lazy_names.rb
+# or for project-specific config
+touch .lazy_names.rb
 ```
 
 5. Login into your rails or non-rails console
@@ -64,57 +76,93 @@ $ bundle exec rails c # or bin/console
 
 ## Configuration
 
-### Global definition
+Create a `.lazy_names.rb` file in your project root or home directory:
+
+```ruby
+# .lazy_names.rb
+MUCC = Models::Users::CreditCard
+SPP = Services::PaymentProcessor
+CAVUC = Controllers::API::V1::UsersController
+```
+
+### File Lookup Priority
+
+LazyNames looks for configuration in this order:
 
-Take a look onto `lazy_names.tt.yml` it has very basic template for you to start.
+1. `./.lazy_names.rb` (project-specific) — **recommended**
+2. `~/.lazy_names.rb` (global fallback)
 
-```yml
----
-my_awesome_project:
-  definitions:
-    'Models::Users::CreditCard': 'MUCC'
+### Project-Specific Configuration (Recommended)
+
+**This is the preferred approach.** Create `.lazy_names.rb` in your project root:
+
+```ruby
+# myproject/.lazy_names.rb
+MUCC = Models::Users::CreditCard
+SPP = Services::PaymentProcessor
 ```
-`my_awesome_project` should be you project/folder name
 
-So consider this example:
+Why project-specific files are better:
+- Version controlled with your project (or gitignored for personal shortcuts)
+- Explicit about what's loaded — no surprises
+- Each project has exactly the shortcuts it needs
+- No conflicts between projects
+
+Don't forget to add it to `.gitignore` if you don't want to share:
 ```sh
-$ pwd
-/Users/name/my_awesome_project
-```
-The last folder name of you ruby project must match the same one in your configuration.
-After **definitions** sections you can actually redefine your long constants.
-So in this example `Models::Users::CreditCard` is your real project constant and
-`MUCC` will be your short variant of it, so you can access `Models::Users::CreditCard`
-from `MUCC`. `MUCC` and any other right hand side can be any value, you define the best-suitable names.
-
-You can define as many constants as you want. The same rule applies for projects.
-Your config can have multiple constant definitions per namespace.
-```yml
----
-my_awesome_project:
-  definitions:
-    'Models::Users::CreditCard': 'MUCC'
-my_another_project:
-  definitions:
-    'OtherLongConst': 'Short'
+echo '.lazy_names.rb' >> .gitignore
 ```
 
-### Project definitions
+### Global Configuration
 
-In the meantime you can put your `.lazy_names.yml` config directly to project folder, it will be looked up firstly from project.
-Just do not forget to put in your `.gitignore`. I believe every developer defines shorter versions of constants by his own opinion.
-```sh
-echo '.lazy_names.yml' >> .gitignore
+For shortcuts that work across multiple projects, create `~/.lazy_names.rb` in your home directory.
+
+**Important:** Use `if defined?()` guards since constants vary between projects:
+
+```ruby
+# ~/.lazy_names.rb
+# Generic Rails shortcuts (usually available)
+AR = ActiveRecord if defined?(ActiveRecord)
+AM = ActionMailer if defined?(ActionMailer)
+
+# Only defined if these exist in the current project
+MU = Models::User if defined?(Models::User)
 ```
-If project folder doesn't contain any `.lazy_names.yml`, it will fallback to home directory.
 
-Configuration per project a bit different: you don't need to specify global scope `my_awesome_project`, you can skip forward to definitions
-```yml
----
-definitions:
-  'Models::Users::CreditCard: 'MUCC'
+**Note:** v2.0 intentionally removed namespace/project scoping that existed in v1.x YAML configs. The `if defined?()` pattern is simpler and achieves the same result without magic.
+
+### Validation
+
+LazyNames validates each line:
+
+- ✅ Must be a constant assignment: `SHORT = Full::Constant::Path`
+- ✅ Constant must exist in your application
+- ⚠️ Invalid lines are skipped with a warning
+
+### Examples
+
+```ruby
+# Comments are allowed
+MUCC = Models::Users::CreditCard
+
+# Blank lines are fine
+
+SPP = Services::PaymentProcessor
+
+# Underscores and numbers in short names
+API_V1 = API::V1
+CACHE2 = Cache::RedisCache
 ```
-Example config can be found in `.lazy_names.tt.project.yml`
+
+## Migrating from v1.x to v2.0
+
+LazyNames v2.0 removes YAML support in favor of plain Ruby configuration.
+
+**Upgrading from v1.x?** See the complete [Migration Guide](MIGRATION_FROM_V1.md) for:
+- Automated conversion script
+- Step-by-step instructions
+- Troubleshooting tips
+- New features in v2.0
 
 ## Development
 

data/bin/convert_to_v2

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'yaml'
+
+# rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+def convert_yaml_to_ruby
+  yaml_file = '.lazy_names.yml'
+  ruby_file = '.lazy_names.rb'
+
+  unless File.exist?(yaml_file)
+    puts "No #{yaml_file} found in current directory"
+    exit 1
+  end
+
+  if File.exist?(ruby_file)
+    puts "#{ruby_file} already exists. Remove it first or merge manually."
+    exit 1
+  end
+
+  begin
+    yaml = YAML.load_file(yaml_file)
+    definitions = extract_definitions(yaml)
+
+    if definitions.empty?
+      puts "No definitions found in #{yaml_file}"
+      exit 1
+    end
+
+    File.open(ruby_file, 'w') do |f|
+      f.puts '# Converted from .lazy_names.yml'
+      f.puts ''
+      definitions.each do |full, short|
+        f.puts "#{short} = #{full}"
+      end
+    end
+
+    puts "✓ Converted #{definitions.size} definitions to #{ruby_file}"
+    puts ''
+    puts 'Next steps:'
+    puts "  1. Review #{ruby_file}"
+    puts "  2. Delete #{yaml_file}"
+    puts '  3. Update lazy_names gem to v2.0'
+  rescue StandardError => e
+    puts "Error: #{e.message}"
+    exit 1
+  end
+end
+# rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+def extract_definitions(yaml)
+  if yaml['definitions']
+    yaml['definitions']
+  elsif yaml.is_a?(Hash) && yaml.values.first.is_a?(Hash)
+    yaml.values.first['definitions'] || {}
+  else
+    {}
+  end
+end
+
+convert_yaml_to_ruby

data/lazy_names.gemspec

@@ -11,10 +11,10 @@ Gem::Specification.new do |spec|
   spec.email = ['evdev34@gmail.com']
 
   spec.description = <<~DESC
-    lazy_names is ruby programmer friend. You can save your time not typing long
-    error-phone constants/classes but defining short and nice versions of them.
+    lazy_names is ruby programmer friend. Define short aliases for long constant names using plain Ruby.
+    Save your time not typing long constants/classes by defining short and intuitive versions of them.
   DESC
-  spec.summary = 'Define short constants to frequently used classes/constants'
+  spec.summary = 'Define short aliases for long constant names using plain Ruby'
   spec.homepage = 'https://github.com/zhisme/lazy_names'
   spec.license = 'MIT'
 

data/lib/lazy_names/line_validator.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module LazyNames
+  class LineValidator
+    ASSIGNMENT_PATTERN = /\A\s*([A-Z][A-Z0-9_]*)\s*=\s*([A-Z][A-Za-z0-9_:]*)\s*\z/.freeze
+
+    class ValidationResult
+      attr_reader :valid, :short_name, :full_constant, :error
+
+      def initialize(valid:, short_name: nil, full_constant: nil, error: nil)
+        @valid = valid
+        @short_name = short_name
+        @full_constant = full_constant
+        @error = error
+      end
+
+      def valid?
+        @valid
+      end
+    end
+
+    def self.validate(line)
+      return skip_result if skip_line?(line)
+
+      match = line.match(ASSIGNMENT_PATTERN)
+      return invalid_result('Invalid syntax') unless match
+
+      short_name = match[1]
+      full_constant = match[2]
+
+      return invalid_result("Constant #{full_constant} not found") unless constant_exists?(full_constant)
+
+      ValidationResult.new(
+        valid: true,
+        short_name: short_name,
+        full_constant: full_constant
+      )
+    end
+
+    def self.skip_line?(line)
+      line.strip.empty? || line.strip.start_with?('#')
+    end
+
+    def self.constant_exists?(constant_path)
+      Object.const_get(constant_path)
+      true
+    rescue NameError
+      false
+    end
+
+    def self.skip_result
+      ValidationResult.new(valid: false)
+    end
+
+    def self.invalid_result(error)
+      ValidationResult.new(valid: false, error: error)
+    end
+
+    private_class_method :skip_line?, :constant_exists?, :skip_result, :invalid_result
+  end
+end

data/lib/lazy_names/ruby_loader.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module LazyNames
+  class RubyLoader
+    CONFIG_FILE = '.lazy_names.rb'
+
+    def self.load!(binding)
+      new.load!(binding)
+    end
+
+    def initialize
+      @loaded_count = 0
+      @skipped_count = 0
+      @error_count = 0
+    end
+
+    def load!(binding)
+      path = find_config_file
+      unless path
+        Kernel.warn("No #{CONFIG_FILE} found")
+        return
+      end
+
+      puts "Loading definitions from #{path}"
+
+      File.readlines(path).each_with_index do |line, index|
+        line_number = index + 1
+        process_line(line, line_number, binding)
+      end
+
+      log_summary
+    end
+
+    private
+
+    def find_config_file
+      project_config = File.join(Dir.pwd, CONFIG_FILE)
+      return project_config if File.exist?(project_config)
+
+      home_config = File.join(Dir.home, CONFIG_FILE)
+      return home_config if File.exist?(home_config)
+
+      nil
+    end
+
+    def process_line(line, line_number, binding)
+      result = LineValidator.validate(line)
+
+      if result.valid?
+        eval_line(line, binding)
+        @loaded_count += 1
+      elsif result.error
+        Kernel.warn("Line #{line_number}: #{result.error} - #{line.strip}")
+        @error_count += 1
+      else
+        # Blank line or comment - skip silently
+        @skipped_count += 1
+      end
+    rescue StandardError => e
+      Kernel.warn("Line #{line_number}: #{e.message}")
+      @error_count += 1
+    end
+
+    def eval_line(line, binding)
+      binding.eval(line)
+    end
+
+    def log_summary
+      puts "Loaded #{@loaded_count} definitions" if @loaded_count.positive?
+      Kernel.warn("Skipped #{@error_count} invalid lines") if @error_count.positive?
+    end
+  end
+end

data/lib/lazy_names/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LazyNames
-  VERSION = '1.0.0'
+  VERSION = '2.0.0'
 end

data/lib/lazy_names.rb

@@ -1,23 +1,11 @@
 # frozen_string_literal: true
 
-require 'lazy_names/version'
-require 'lazy_names/find_namespace'
-require 'lazy_names/config_loader'
-require 'lazy_names/config'
-require 'lazy_names/config_validator'
-require 'lazy_names/definer'
-require 'lazy_names/logger'
+require_relative 'lazy_names/version'
+require_relative 'lazy_names/line_validator'
+require_relative 'lazy_names/ruby_loader'
 
 module LazyNames
-  def self.load_definitions!(top_level_binding = TOPLEVEL_BINDING) # rubocop:disable Metrics/AbcSize
-    basic_config = LazyNames::ConfigLoader
-                   .(namespace: LazyNames::FindNamespace.())
-    config = LazyNames::Config.new(basic_config.definitions, basic_config.path)
-    config.validate!
-    LazyNames::Definer.(config, top_level_binding)
-
-    LazyNames::Logger.warn_undefined(config.errors.undefined, config.path)
-    LazyNames::Logger.warn_duplicate_definition(config.errors.already_defined, config.path)
-    LazyNames::Logger.warn_empty_definitions(config.constants.to_a.empty?, config.path)
+  def self.load_definitions!(top_level_binding = TOPLEVEL_BINDING)
+    RubyLoader.load!(top_level_binding)
   end
 end

metadata

@@ -1,18 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: lazy_names
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - zhisme
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-02-21 00:00:00.000000000 Z
+date: 2026-01-12 00:00:00.000000000 Z
 dependencies: []
 description: |
-  lazy_names is ruby programmer friend. You can save your time not typing long
-  error-phone constants/classes but defining short and nice versions of them.
+  lazy_names is ruby programmer friend. Define short aliases for long constant names using plain Ruby.
+  Save your time not typing long constants/classes by defining short and intuitive versions of them.
 email:
 - evdev34@gmail.com
 executables: []
@@ -24,27 +24,23 @@ files:
 - ".github/workflows/codeql.yml"
 - ".github/workflows/rake.yml"
 - ".gitignore"
-- ".lazy_names.tt.project.yml"
-- ".lazy_names.tt.yml"
+- ".lazy_names.tt.rb"
 - ".rspec"
 - ".rubocop.yml"
 - ".ruby-version"
-- ".travis.yml"
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
+- MIGRATION_FROM_V1.md
 - README.md
 - Rakefile
 - bin/console
+- bin/convert_to_v2
 - bin/setup
 - lazy_names.gemspec
 - lib/lazy_names.rb
-- lib/lazy_names/config.rb
-- lib/lazy_names/config_loader.rb
-- lib/lazy_names/config_validator.rb
-- lib/lazy_names/definer.rb
-- lib/lazy_names/find_namespace.rb
-- lib/lazy_names/logger.rb
+- lib/lazy_names/line_validator.rb
+- lib/lazy_names/ruby_loader.rb
 - lib/lazy_names/version.rb
 homepage: https://github.com/zhisme/lazy_names
 licenses:
@@ -69,5 +65,5 @@ requirements: []
 rubygems_version: 3.3.26
 signing_key:
 specification_version: 4
-summary: Define short constants to frequently used classes/constants
+summary: Define short aliases for long constant names using plain Ruby
 test_files: []

data/.lazy_names.tt.project.yml

@@ -1,3 +0,0 @@
----
-definitions:
-  'Models::Users::CreditCard': 'MUCC'

data/.lazy_names.tt.yml

@@ -1,4 +0,0 @@
----
-my_awesome_project:
-  definitions:
-    'Models::Users::CreditCard': 'MUCC'

data/.travis.yml

@@ -1,7 +0,0 @@
----
-sudo: false
-language: ruby
-cache: bundler
-rvm:
-  - 2.3.3
-before_install: gem install bundler -v 1.16.3

data/lib/lazy_names/config.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module LazyNames
-  class Config
-    extend Forwardable
-
-    attr_reader :path, :validator
-
-    def_delegator :@validator, :errors
-
-    def initialize(definitions, path)
-      @definitions = definitions
-      @path = path
-      @validator = ConfigValidator.new(definitions.values, definitions.keys)
-    end
-
-    def constants
-      definitions.keys
-    end
-
-    def lazy_names
-      definitions.values
-    end
-
-    def lazy_name(name)
-      definitions[name]
-    end
-
-    def validate!
-      validator.()
-      remove_invalid_definitions!
-    end
-
-    private
-
-    def remove_invalid_definitions!
-      errors.undefined.each { |name| definitions.delete(name) }
-    end
-
-    attr_reader :definitions
-  end
-end

data/lib/lazy_names/config_loader.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-require 'yaml'
-
-module LazyNames
-  class ConfigLoader
-    class NoConfig < StandardError; end
-    class YAMLConfigInvalid < StandardError; end
-    class ConfigNotResolved < StandardError; end
-    class NamespaceNotFound < StandardError; end
-    class NoDefinitions < StandardError; end
-
-    class << self
-      BasicConfig = Struct.new(:path, :definitions)
-      HOME_PATH = '~/.lazy_names.yml'
-
-      def call(namespace:, path: nil)
-        return read_from_path(namespace, path) if path
-
-        config = read_from_project if config_in_project_path?
-        config ||= read_from_home_dir(namespace)
-
-        config
-      end
-
-      private
-
-      def read_from_path(namespace, path)
-        definitions = find_definitions(path, namespace)
-
-        BasicConfig.new(path, definitions)
-      rescue Errno::ENOENT, Errno::ENOTDIR
-        raise NoConfig, "No config found by given path: #{path}"
-      end
-
-      def read_from_home_dir(namespace)
-        definitions = find_definitions(home_path, namespace)
-
-        BasicConfig.new(home_path, definitions)
-      rescue Errno::ENOENT
-        raise NoConfig, 'No config found in your home directory. ' \
-                        'Create ~/.lazy_names.yml'
-      end
-
-      def read_from_project
-        definitions = find_project_definitions
-
-        BasicConfig.new(project_path, definitions)
-      end
-
-      def find_project_definitions
-        read_config(project_path)['definitions'].to_hash
-      rescue NoMethodError
-        raise NoDefinitions, "No definitions found in #{project_path}. " \
-                             'See config example .lazy_names.tt.project.yml'
-      end
-
-      def find_definitions(path, namespace)
-        find_namespace_contents(path, namespace)['definitions'].to_hash
-      rescue NoMethodError
-        raise NoDefinitions, "No definitions found in #{path}. " \
-                             'See config example in .lazy_names.tt.yml'
-      end
-
-      def find_namespace_contents(path, namespace)
-        read_config(path)[namespace].to_hash
-      rescue NoMethodError
-        raise NamespaceNotFound, "No namespace found in #{path}. " \
-                                 'See config example in .lazy_names.tt.yml and check README'
-      end
-
-      def config_in_project_path?
-        File.exist?(project_path)
-      end
-
-      def read_config(path)
-        YAML.safe_load(File.read(path))
-      rescue Psych::SyntaxError => e
-        raise YAMLConfigInvalid, e
-      end
-
-      def project_path
-        File.expand_path(Pathname.new(Dir.pwd).join('.lazy_names.yml'))
-      end
-
-      def home_path
-        File.expand_path(HOME_PATH)
-      end
-    end
-  end
-end

data/lib/lazy_names/config_validator.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module LazyNames
-  class ConfigValidator
-    attr_reader :errors
-
-    Errors = Struct.new(:undefined, :already_defined)
-
-    def initialize(lazy_names, constants)
-      @errors = Errors.new([], [])
-      @constants = constants
-      @lazy_names = lazy_names
-    end
-
-    def call
-      validate_constants!
-      validate_lazy_names!
-
-      self
-    end
-
-    private
-
-    attr_reader :lazy_names, :constants
-
-    def validate_constants!
-      constants.each do |c|
-        resolve_const_in_project(c)
-      rescue NameError
-        self.errors.undefined << c
-      end
-    end
-
-    def validate_lazy_names!
-      a = lazy_names.uniq
-      b = lazy_names
-
-      diff = difference(b, a)
-
-      return unless diff
-
-      diff.each { |name| self.errors.already_defined << name }
-    end
-
-    def resolve_const_in_project(const)
-      Module.const_get(const)
-    end
-
-    def difference(arr, other)
-      copy = arr.dup
-      other.each do |e|
-        i = copy.rindex(e)
-        copy.delete_at(i) if i
-      end
-
-      copy
-    end
-  end
-end

data/lib/lazy_names/definer.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module LazyNames
-  class Definer
-    class << self
-      def call(config, top_level_binding)
-        config.constants.each do |origin|
-          eval <<-RUBY, top_level_binding, __FILE__, __LINE__ + 1 # rubocop:disable Security/Eval
-            #{config.lazy_name(origin)} = #{origin} # LN_MC = LazyNames::MyClass. See spec/lazy_names/definer_spec.rb
-          RUBY
-        end
-      end
-    end
-  end
-end

data/lib/lazy_names/find_namespace.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module LazyNames
-  class FindNamespace
-    class << self
-      ##
-      # Find project namespace by folder name
-      #
-      def call(path = Dir.pwd)
-        path.split('/').last
-      end
-    end
-  end
-end

data/lib/lazy_names/logger.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module LazyNames
-  class Logger
-    class << self
-      def warn_undefined(errors, config_path)
-        return if errors.empty?
-
-        message = <<~MSG
-          Error loading lazy_names gem.
-          Found #{errors.size} undefined constants.
-          Please check spelling for #{errors.join(', ')}
-          #{config_path}
-          \n
-        MSG
-
-        warn(message)
-      end
-
-      def warn_duplicate_definition(errors, config_path)
-        return if errors.empty?
-
-        message = <<~MSG
-          Error loading lazy_names gem.
-          Found #{errors.size} already defined constants.
-          Using same lazy names for different constants may lead to unexpected results
-          Avoid duplications in your config file.
-          #{config_path}
-          \n
-        MSG
-
-        warn(message)
-      end
-
-      def warn_empty_definitions(errors, config_path)
-        return unless errors
-
-        message = <<~MSG
-          Error loading lazy_names gem.
-          Seems like you misspelled namespace in config.
-          #{config_path}
-          Please ensure word definitions exists in config
-          or check .lazy_names.tt.yml for consistency.
-        MSG
-
-        warn(message)
-      end
-    end
-  end
-end