deprecate 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 28e14e1af502d891c520d0cd16d812a324fedc4e
-  data.tar.gz: 46f96120e8c8704c30f38680a44733193010fa85
+SHA256:
+  metadata.gz: 894e5fdc4e539804fd5e5701bfa28b79fc331142c845d904a51a5c3bdf1b617d
+  data.tar.gz: 05265c29e32f28474649d170ec6f7f60e5065976b6d327f5534f0368820fed1e
 SHA512:
-  metadata.gz: c7d9fdbdca96f918867b46c65eedd3e2722166ec9431c7433bec2b6c741578f26dd9bb8a9313cb23aa7bc7ade5d83111af3eda6c5a44417abf0bfb4aad7bfe65
-  data.tar.gz: 6870972e92cf07139f59e4d5f97b170f90ba32acc96ff7bc7139a3bda61ce32eeabbd229436a1468536501f55de2ba66c62610d75f54b1bcac8dc3914aa09c84
+  metadata.gz: 9234f5c056adf3299bf9b9ba0bd45e61c9f5ff3b902e8620c3f4a90f0ad81187971abeff790f729a14016932130c815f67466d06877ec9ece518fe72193a04b7
+  data.tar.gz: 33b9bf8fe007d0775e501a160127a86f93f242ce9290b6d8753d5ed12e81d3306901d5831c7dc05d96b238bc5af71a476b0924e2a2a2b06127c9efd1c1f1b583

data/.github/workflows/ci.yml

@@ -0,0 +1,71 @@
+name: CI
+
+on:
+  push:
+    branches: [ main, master ]
+  pull_request:
+    branches: [ main, master ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby-version: ['2.7', '3.0', '3.1', '3.2', '3.3']
+
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true
+    
+    - name: Run tests
+      run: |
+        bundle exec rspec
+    
+    - name: Run manual verification
+      run: |
+        bundle exec ruby -I lib test_manual.rb
+
+  quality:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+    
+    - name: Set up Ruby  
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: '3.3'
+        bundler-cache: true
+    
+    - name: Install Qlty
+      run: |
+        curl -s https://download.qlty.sh/qlty/install.sh | sh
+        echo "$HOME/.qlty/bin" >> $GITHUB_PATH
+    
+    - name: Run Qlty
+      run: qlty check --reporter github-actions
+
+  gem:
+    runs-on: ubuntu-latest
+    needs: [test, quality]
+    steps:
+    - uses: actions/checkout@v4
+    
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1  
+      with:
+        ruby-version: '3.3'
+        bundler-cache: true
+    
+    - name: Build gem
+      run: gem build deprecate.gemspec
+    
+    - name: Install gem locally
+      run: gem install ./deprecate-*.gem

data/.gitignore

@@ -11,4 +11,5 @@
 *.so
 *.o
 *.a
+*.gem
 mkmf.log

data/.qlty.toml

@@ -0,0 +1,50 @@
+[qlty]
+version = "0.1"
+
+# Ruby-specific tools
+[[tools]]
+name = "rubocop"
+enabled = true
+
+[[tools]]  
+name = "reek"
+enabled = true
+
+[[tools]]
+name = "flog" 
+enabled = true
+
+[[tools]]
+name = "flay"
+enabled = true
+
+# Security scanning
+[[tools]]
+name = "brakeman"
+enabled = false  # Not needed for library gems
+
+# General tools
+[[tools]]
+name = "git-diff-check"
+enabled = true
+
+[[tools]]
+name = "markdownlint"
+enabled = true
+
+# Configure specific tools
+[tools.rubocop]
+config_file = ".rubocop.yml"
+
+[tools.reek]
+config_file = ".reek.yml"
+
+# Exclude certain paths
+[[exclude]]
+path = "test_manual.rb"  # Temporary test file
+
+[[exclude]] 
+path = "*.gemspec"  # Generated files can have long lines
+
+[[exclude]]
+path = "Gemfile.lock"

data/.reek.yml

@@ -0,0 +1,24 @@
+---
+detectors:
+  # Don't complain about instance variable usage in module
+  InstanceVariableAssumption:
+    enabled: false
+    
+  # Allow long parameter lists for method wrapping  
+  LongParameterList:
+    max_params: 4
+    
+  # Allow utility modules to be a bit more complex
+  TooManyStatements:
+    max_statements: 15
+    
+  # Allow some complexity for method interception
+  NestedIterators:
+    max_allowed_nesting: 2
+    
+  # Don't complain about simple feature envy for configuration access
+  FeatureEnvy:
+    enabled: false
+    
+exclude_paths:
+  - test_manual.rb

data/.rspec

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

data/.rubocop.yml

@@ -0,0 +1,39 @@
+AllCops:
+  TargetRubyVersion: 2.7
+  NewCops: enable
+  Exclude:
+    - 'test_manual.rb'
+    - 'vendor/**/*'
+
+# Allow longer lines for documentation  
+Layout/LineLength:
+  Max: 100
+  AllowedPatterns: 
+    - '\A\s*#'  # Allow long comment lines
+
+# Allow class variables for module-level config
+Style/ClassVars:
+  Exclude:
+    - 'lib/deprecate.rb'
+
+# Allow module variables (@config, @warned_methods)
+Style/ModuleFunction:
+  Enabled: false
+
+# Don't require class documentation for simple classes
+Style/Documentation:
+  Exclude:
+    - 'test/**/*'
+    - 'lib/deprecate/version.rb'
+
+# Allow multiple assignments for configuration hash
+Style/HashSyntax:
+  EnforcedStyle: ruby19_no_mixed_keys
+
+# Don't require frozen string literals for a simple gem
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+# Allow method definitions after private
+Layout/EmptyLinesAroundMethodBody:
+  Enabled: false

data/README.md

@@ -1,5 +1,9 @@
 # Deprecate
 
+[![CI](https://github.com/twilightcoders/deprecate/actions/workflows/ci.yml/badge.svg)](https://github.com/twilightcoders/deprecate/actions/workflows/ci.yml)
+[![Gem Version](https://badge.fury.io/rb/deprecate.svg)](https://badge.fury.io/rb/deprecate)
+[![Code Quality](https://img.shields.io/badge/code%20quality-qlty-blue)](https://qlty.sh)
+
 Easily maintain your codebase by exposing an easy and concise way to mark methods as deprecated.
 
 ## Installation
@@ -20,7 +24,98 @@ Or install it yourself as:
 
 ## Usage
 
-Coming soon
+### Basic Usage
+
+Simply call `deprecate` with the method name you want to deprecate:
+
+```ruby
+class MyClass
+  def old_method
+    "This method still works but is deprecated"
+  end
+  
+  def new_method
+    "This is the new way"
+  end
+  
+  # Mark old_method as deprecated and suggest new_method
+  deprecate :old_method, :new_method
+end
+
+obj = MyClass.new
+obj.old_method  # Works but prints deprecation warning
+# => DEPRECATION WARNING: old_method is deprecated (use new_method instead). Called from example.rb:15
+```
+
+### Without Replacement Suggestion
+
+```ruby
+class MyClass
+  def legacy_method
+    "Going away soon"
+  end
+  
+  # Mark as deprecated without suggesting replacement
+  deprecate :legacy_method
+end
+
+obj = MyClass.new
+obj.legacy_method  # Prints: DEPRECATION WARNING: legacy_method is deprecated. Called from example.rb:10
+```
+
+### Configuration
+
+Configure deprecation behavior globally:
+
+```ruby
+Deprecate.configure do |config|
+  config[:output_stream] = File.open('deprecations.log', 'a')  # Log to file instead of stderr
+  config[:message_format] = "WARNING: %{method} is deprecated%{replacement}"  # Custom message format
+  config[:show_caller] = false  # Don't show caller location
+  config[:warn_once] = false    # Warn every time, not just once per method
+end
+```
+
+### Configuration Options
+
+- **`:output_stream`** - Where to send warnings (default: `$stderr`)
+- **`:message_format`** - Message template with `%{method}`, `%{replacement}`, `%{caller}` placeholders
+- **`:show_caller`** - Include caller location in warnings (default: `true`)
+- **`:warn_once`** - Only warn once per deprecated method (default: `true`)
+
+### Resetting Warnings
+
+Clear the "warned once" tracking to see warnings again:
+
+```ruby
+Deprecate.reset_warnings!
+```
+
+### Method Visibility
+
+The gem preserves the original method's visibility (public, protected, private):
+
+```ruby
+class MyClass
+  private
+  
+  def secret_method
+    "private stuff"
+  end
+  
+  deprecate :secret_method
+  
+  public
+  
+  def call_secret
+    secret_method  # This works and shows deprecation warning
+  end
+end
+
+obj = MyClass.new
+obj.call_secret      # Works
+obj.secret_method    # Still raises NoMethodError (method remains private)
+```
 
 ## Contributing
 

data/Rakefile

@@ -1,2 +1,12 @@
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+desc "Run manual verification"
+task :manual do
+  sh "ruby -I lib test_manual.rb"  
+end
+
+task :default => :spec
 

data/deprecate.gemspec

@@ -4,20 +4,22 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'deprecate/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "deprecate"
+  spec.name          = 'deprecate'
   spec.version       = Deprecate::VERSION
-  spec.authors       = ["Dale Stevens"]
-  spec.email         = ["dale@twilightcoder.net"]
-  spec.summary       = %q{Easily maintain your codebase by exposing an easy and concise way to mark methods as deprecated.}
-  # spec.description   = %q{Write a longer description. Optional.}
-  spec.homepage      = ""
-  spec.license       = "MIT"
+  spec.authors       = ['Dale Stevens']
+  spec.email         = ['dale@twilightcoder.net']
+  spec.summary       = 'Easily maintain your codebase by exposing an easy and concise way to mark methods as deprecated.'
+  spec.homepage      = 'https://github.com/twilightcoders/deprecate'
+  spec.license       = 'MIT'
+
+  spec.required_ruby_version = '>= 2.7.0'
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
 end

data/lib/deprecate/version.rb

@@ -1,3 +1,3 @@
 module Deprecate
-  VERSION = "0.0.0"
+  VERSION = '0.0.1'
 end

data/lib/deprecate.rb

@@ -1,5 +1,83 @@
-require "deprecate/version"
+require 'deprecate/version'
+
+class DeprecationError < StandardError; end
 
 module Deprecate
-  # Your code goes here...
+  @config = {
+    output_stream: $stderr,
+    message_format: "DEPRECATION WARNING: %{method} is deprecated%{replacement}. Called from %{caller}",
+    show_caller: true,
+    warn_once: true
+  }
+
+  @warned_methods = {}
+
+  class << self
+    attr_reader :config, :warned_methods
+
+    def configure
+      yield @config if block_given?
+      @config
+    end
+
+    def reset_warnings!
+      @warned_methods.clear
+    end
+  end
+
+  module Deprecatable
+    def __deprecated_run_action__(method_name, replacement = nil)
+      method_key = "#{self.class.name}##{method_name}"
+      
+      return if Deprecate.config[:warn_once] && Deprecate.warned_methods[method_key]
+
+      replacement_text = replacement ? " (use #{replacement} instead)" : ""
+      caller_info = if Deprecate.config[:show_caller]
+        caller_location = caller_locations(3, 1)
+        caller_location && caller_location.first ? caller_location.first.to_s : "unknown"
+      else
+        "unknown"
+      end
+      
+      message = Deprecate.config[:message_format] % {
+        method: method_name,
+        replacement: replacement_text,
+        caller: caller_info
+      }
+
+      Deprecate.config[:output_stream].puts(message)
+      Deprecate.warned_methods[method_key] = true if Deprecate.config[:warn_once]
+    end
+    def deprecate(sym, replacement=nil, scope=nil)
+      unless sym.is_a?(Symbol)
+        raise ArgumentError, 'deprecate() requires symbols for its first argument.'
+      end
+
+      meth = instance_method(sym)
+      unless scope
+        pub = public_instance_methods
+        pro = protected_instance_methods
+        pri = private_instance_methods
+        if pub.include?(sym) || pub.include?(sym.to_s)
+          scope = :public
+        elsif pro.include?(sym) || pro.include?(sym.to_s)
+          scope = :protected
+        elsif pri.include?(sym) || pri.include?(sym.to_s)
+          scope = :private
+        end
+      end
+
+      define_method(sym) do |*args|
+        __deprecated_run_action__(sym, replacement)
+        meth.bind(self).call(*args)
+      end
+
+      method(scope).call(sym) if scope
+      return scope
+    end
+  end
+end
+
+class Object
+  include Deprecate::Deprecatable
 end

data/spec/deprecate_spec.rb

@@ -0,0 +1,211 @@
+require 'spec_helper'
+
+RSpec.describe Deprecate do
+  let(:output) { StringIO.new }
+  
+  before do
+    Deprecate.reset_warnings!
+    Deprecate.configure do |config|
+      config[:output_stream] = output
+      config[:warn_once] = false
+    end
+  end
+  
+  after do
+    Deprecate.configure do |config|
+      config[:output_stream] = $stderr
+      config[:warn_once] = true
+    end
+  end
+
+  describe '#deprecate' do
+    context 'with replacement method' do
+      let(:test_class) do
+        Class.new do
+          def old_method
+            "old result"
+          end
+          
+          def new_method
+            "new result"
+          end
+          
+          deprecate :old_method, :new_method
+        end
+      end
+
+      it 'returns the original method result' do
+        obj = test_class.new
+        expect(obj.old_method).to eq("old result")
+      end
+
+      it 'prints deprecation warning with replacement' do
+        obj = test_class.new
+        obj.old_method
+        expect(output.string).to match(/DEPRECATION WARNING: old_method is deprecated \(use new_method instead\)/)
+      end
+    end
+
+    context 'without replacement method' do
+      let(:test_class) do
+        Class.new do
+          def legacy_method
+            "legacy result"
+          end
+          
+          deprecate :legacy_method
+        end
+      end
+
+      it 'returns the original method result' do
+        obj = test_class.new
+        expect(obj.legacy_method).to eq("legacy result")
+      end
+
+      it 'prints deprecation warning without replacement' do
+        obj = test_class.new
+        obj.legacy_method
+        expect(output.string).to match(/DEPRECATION WARNING: legacy_method is deprecated\./)
+        expect(output.string).not_to match(/use .* instead/)
+      end
+    end
+
+    context 'with method arguments' do
+      let(:test_class) do
+        Class.new do
+          def old_method(arg1, arg2)
+            "#{arg1}-#{arg2}"
+          end
+          
+          deprecate :old_method, :new_method
+        end
+      end
+
+      it 'passes arguments correctly' do
+        obj = test_class.new
+        expect(obj.old_method("hello", "world")).to eq("hello-world")
+      end
+
+      it 'prints deprecation warning' do
+        obj = test_class.new
+        obj.old_method("hello", "world")
+        expect(output.string).to match(/DEPRECATION WARNING/)
+      end
+    end
+
+    context 'with private methods' do
+      let(:test_class) do
+        Class.new do
+          private
+
+          def private_method
+            "private result"
+          end
+
+          deprecate :private_method
+
+          public
+
+          def call_private
+            private_method
+          end
+        end
+      end
+
+      it 'preserves method visibility' do
+        obj = test_class.new
+        expect(obj.call_private).to eq("private result")
+        expect { obj.private_method }.to raise_error(NoMethodError)
+      end
+
+      it 'prints deprecation warning when called' do
+        obj = test_class.new
+        obj.call_private
+        expect(output.string).to match(/DEPRECATION WARNING: private_method is deprecated/)
+      end
+    end
+
+    context 'with invalid arguments' do
+      it 'raises ArgumentError for non-symbol arguments' do
+        expect {
+          Class.new do
+            deprecate "string_method"
+          end
+        }.to raise_error(ArgumentError, /deprecate\(\) requires symbols/)
+      end
+    end
+  end
+
+  describe 'configuration' do
+    context 'warn_once setting' do
+      before { Deprecate.configure { |config| config[:warn_once] = true } }
+
+      let(:test_class) do
+        Class.new do
+          def old_method
+            "result"
+          end
+          
+          deprecate :old_method
+        end
+      end
+
+      it 'warns only once per method' do
+        obj = test_class.new
+        obj.old_method
+        obj.old_method
+        
+        warnings = output.string.scan(/DEPRECATION WARNING/)
+        expect(warnings.length).to eq(1)
+      end
+    end
+
+    context 'custom message format' do
+      before do
+        Deprecate.configure do |config|
+          config[:message_format] = "CUSTOM: %{method} is old%{replacement}"
+          config[:show_caller] = false
+        end
+      end
+
+      let(:test_class) do
+        Class.new do
+          def old_method
+            "result"
+          end
+          
+          deprecate :old_method, :new_method
+        end
+      end
+
+      it 'uses custom message format' do
+        obj = test_class.new
+        obj.old_method
+        expect(output.string).to match(/CUSTOM: old_method is old \(use new_method instead\)/)
+      end
+    end
+  end
+
+  describe '.reset_warnings!' do
+    it 'clears the warned methods hash' do
+      # Just test that the hash gets cleared
+      Deprecate.configure { |config| config[:warn_once] = true }
+      
+      # Add a warning to the hash
+      test_class = Class.new do
+        def old_method
+          "result"
+        end
+        deprecate :old_method
+      end
+      
+      obj = test_class.new
+      obj.old_method  # This should add to warned_methods hash
+      
+      expect(Deprecate.warned_methods).not_to be_empty
+      
+      Deprecate.reset_warnings!
+      expect(Deprecate.warned_methods).to be_empty
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'stringio'
+require_relative '../lib/deprecate'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+end

data/test/test_basic.rb

@@ -0,0 +1,126 @@
+#!/usr/bin/env ruby
+require 'stringio'
+require_relative '../lib/deprecate'
+
+def assert_equal(expected, actual, message = nil)
+  unless expected == actual
+    raise "Assertion failed#{message ? ": #{message}" : ""}\n  Expected: #{expected.inspect}\n  Actual: #{actual.inspect}"
+  end
+end
+
+def assert_match(pattern, string, message = nil)
+  unless pattern.match?(string)
+    raise "Assertion failed#{message ? ": #{message}" : ""}\n  Pattern: #{pattern.inspect}\n  String: #{string.inspect}"
+  end
+end
+
+def refute_match(pattern, string, message = nil)
+  if pattern.match?(string)
+    raise "Assertion failed#{message ? ": #{message}" : ""}\n  Pattern should NOT match: #{pattern.inspect}\n  String: #{string.inspect}"
+  end
+end
+
+# Setup
+def setup_test
+  Deprecate.reset_warnings!
+  output = StringIO.new
+  Deprecate.configure do |config|
+    config[:output_stream] = output
+    config[:warn_once] = false
+  end
+  output
+end
+
+def teardown_test
+  Deprecate.configure do |config|
+    config[:output_stream] = $stderr
+    config[:warn_once] = true
+  end
+end
+
+puts "Running basic deprecation tests..."
+
+# Test 1: Basic deprecation
+output = setup_test
+
+klass = Class.new do
+  def old_method
+    "old result"
+  end
+
+  deprecate :old_method, :new_method
+end
+
+obj = klass.new
+result = obj.old_method
+
+assert_equal "old result", result
+assert_match(/DEPRECATION WARNING: old_method is deprecated/, output.string)
+puts "✓ Basic deprecation test passed"
+
+teardown_test
+
+# Test 2: Without replacement
+output = setup_test
+
+klass2 = Class.new do
+  def legacy_method
+    "legacy"
+  end
+
+  deprecate :legacy_method
+end
+
+obj2 = klass2.new
+result2 = obj2.legacy_method
+
+assert_equal "legacy", result2
+assert_match(/DEPRECATION WARNING: legacy_method is deprecated/, output.string)
+refute_match(/use .* instead/, output.string)
+puts "✓ Deprecation without replacement test passed"
+
+teardown_test
+
+# Test 3: Method with arguments
+output = setup_test
+
+klass3 = Class.new do
+  def old_method(arg1, arg2)
+    "#{arg1}-#{arg2}"
+  end
+
+  deprecate :old_method
+end
+
+obj3 = klass3.new
+result3 = obj3.old_method("hello", "world")
+
+assert_equal "hello-world", result3
+assert_match(/DEPRECATION WARNING/, output.string)
+puts "✓ Method with arguments test passed"
+
+teardown_test
+
+# Test 4: Warn once functionality
+output = setup_test
+Deprecate.configure { |config| config[:warn_once] = true }
+
+klass4 = Class.new do
+  def old_method
+    "result"
+  end
+
+  deprecate :old_method
+end
+
+obj4 = klass4.new
+obj4.old_method
+obj4.old_method
+
+warnings_count = output.string.scan(/DEPRECATION WARNING/).length
+assert_equal 1, warnings_count
+puts "✓ Warn once functionality test passed"
+
+teardown_test
+
+puts "\nAll tests passed! ✅"

data/test/test_deprecate.rb

@@ -0,0 +1,167 @@
+require 'minitest/autorun'
+require_relative '../lib/deprecate'
+
+class TestDeprecate < Minitest::Test
+  def setup
+    Deprecate.reset_warnings!
+    @output = StringIO.new
+    Deprecate.configure do |config|
+      config[:output_stream] = @output
+      config[:warn_once] = false
+    end
+  end
+
+  def teardown
+    Deprecate.configure do |config|
+      config[:output_stream] = $stderr
+      config[:warn_once] = true
+    end
+  end
+
+  def test_deprecate_method_with_replacement
+    klass = Class.new do
+      def old_method
+        "old result"
+      end
+
+      def new_method
+        "new result"
+      end
+
+      deprecate :old_method, :new_method
+    end
+
+    obj = klass.new
+    result = obj.old_method
+
+    assert_equal "old result", result
+    assert_match(/DEPRECATION WARNING: old_method is deprecated \(use new_method instead\)/, @output.string)
+  end
+
+  def test_deprecate_method_without_replacement
+    klass = Class.new do
+      def old_method
+        "old result"
+      end
+
+      deprecate :old_method
+    end
+
+    obj = klass.new
+    result = obj.old_method
+
+    assert_equal "old result", result
+    assert_match(/DEPRECATION WARNING: old_method is deprecated\. Called from/, @output.string)
+    refute_match(/use .* instead/, @output.string)
+  end
+
+  def test_deprecate_with_arguments
+    klass = Class.new do
+      def old_method(arg1, arg2)
+        "#{arg1}-#{arg2}"
+      end
+
+      deprecate :old_method, :new_method
+    end
+
+    obj = klass.new
+    result = obj.old_method("hello", "world")
+
+    assert_equal "hello-world", result
+    assert_match(/DEPRECATION WARNING/, @output.string)
+  end
+
+  def test_deprecate_preserves_method_scope
+    klass = Class.new do
+      private
+
+      def private_method
+        "private result"
+      end
+
+      deprecate :private_method
+
+      public
+
+      def call_private
+        private_method
+      end
+    end
+
+    obj = klass.new
+    result = obj.call_private
+
+    assert_equal "private result", result
+    assert_raises(NoMethodError) { obj.private_method }
+  end
+
+  def test_warn_once_configuration
+    Deprecate.configure { |config| config[:warn_once] = true }
+
+    klass = Class.new do
+      def old_method
+        "result"
+      end
+
+      deprecate :old_method
+    end
+
+    obj = klass.new
+    obj.old_method
+    obj.old_method
+
+    assert_equal 1, @output.string.scan(/DEPRECATION WARNING/).length
+  end
+
+  def test_reset_warnings
+    Deprecate.configure { |config| config[:warn_once] = true }
+
+    klass = Class.new do
+      def old_method
+        "result"
+      end
+
+      deprecate :old_method
+    end
+
+    obj = klass.new
+    obj.old_method
+    Deprecate.reset_warnings!
+    obj.old_method
+
+    assert_equal 2, @output.string.scan(/DEPRECATION WARNING/).length
+  end
+
+  def test_invalid_symbol_argument
+    klass = Class.new
+
+    assert_raises(ArgumentError, "deprecate() requires symbols for its first argument.") do
+      klass.class_eval do
+        deprecate "string_method"
+      end
+    end
+  end
+
+  def test_custom_message_format
+    original_format = Deprecate.config[:message_format]
+    Deprecate.configure do |config|
+      config[:message_format] = "CUSTOM: %{method} is old%{replacement}"
+      config[:show_caller] = false
+    end
+
+    klass = Class.new do
+      def old_method
+        "result"
+      end
+
+      deprecate :old_method, :new_method
+    end
+
+    obj = klass.new
+    obj.old_method
+
+    assert_match(/CUSTOM: old_method is old \(use new_method instead\)/, @output.string)
+
+    Deprecate.configure { |config| config[:message_format] = original_format }
+  end
+end

data/test/test_deprecate_simple.rb

@@ -0,0 +1,107 @@
+require 'minitest/autorun'
+require 'stringio'
+require_relative '../lib/deprecate'
+
+class TestDeprecate < Minitest::Test
+  def setup
+    Deprecate.reset_warnings!
+    @output = StringIO.new
+    Deprecate.configure do |config|
+      config[:output_stream] = @output
+      config[:warn_once] = false
+    end
+  end
+
+  def teardown
+    Deprecate.configure do |config|
+      config[:output_stream] = $stderr
+      config[:warn_once] = true
+    end
+  end
+
+  def test_basic_deprecation
+    klass = Class.new do
+      def old_method
+        "old result"
+      end
+
+      deprecate :old_method, :new_method
+    end
+
+    obj = klass.new
+    result = obj.old_method
+
+    assert_equal "old result", result
+    assert_match(/DEPRECATION WARNING: old_method is deprecated/, @output.string)
+  end
+
+  def test_deprecation_without_replacement
+    klass = Class.new do
+      def legacy_method
+        "legacy"
+      end
+
+      deprecate :legacy_method
+    end
+
+    obj = klass.new
+    result = obj.legacy_method
+
+    assert_equal "legacy", result
+    assert_match(/DEPRECATION WARNING: legacy_method is deprecated/, @output.string)
+    refute_match(/use .* instead/, @output.string)
+  end
+
+  def test_method_with_arguments
+    klass = Class.new do
+      def old_method(arg1, arg2)
+        "#{arg1}-#{arg2}"
+      end
+
+      deprecate :old_method
+    end
+
+    obj = klass.new
+    result = obj.old_method("hello", "world")
+
+    assert_equal "hello-world", result
+    assert_match(/DEPRECATION WARNING/, @output.string)
+  end
+
+  def test_warn_once_functionality
+    Deprecate.configure { |config| config[:warn_once] = true }
+
+    klass = Class.new do
+      def old_method
+        "result"
+      end
+
+      deprecate :old_method
+    end
+
+    obj = klass.new
+    obj.old_method
+    obj.old_method
+
+    assert_equal 1, @output.string.scan(/DEPRECATION WARNING/).length
+  end
+
+  def test_reset_warnings
+    Deprecate.configure { |config| config[:warn_once] = true }
+
+    klass = Class.new do
+      def old_method
+        "result"
+      end
+
+      deprecate :old_method
+    end
+
+    obj = klass.new
+    obj.old_method
+    Deprecate.reset_warnings!
+    obj.old_method
+
+    assert_equal 2, @output.string.scan(/DEPRECATION WARNING/).length
+  end
+end

data/test_manual.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+require_relative 'lib/deprecate'
+
+# Simple test to verify the gem works
+class TestClass
+  def old_method(name = "world")
+    "Hello, #{name}!"
+  end
+  
+  def new_method(name = "world") 
+    "Hi there, #{name}!"
+  end
+  
+  deprecate :old_method, :new_method
+end
+
+puts "Testing basic functionality..."
+obj = TestClass.new
+
+puts "Calling deprecated method:"
+result = obj.old_method("Claude")
+puts "Result: #{result}"
+
+puts "\nCalling again (should warn only once by default):"
+result2 = obj.old_method("again")
+puts "Result: #{result2}"
+
+puts "\nResetting warnings and calling again:"
+Deprecate.reset_warnings!
+result3 = obj.old_method("reset")
+puts "Result: #{result3}"
+
+puts "\nTesting without replacement:"
+class TestClass2
+  def legacy_method
+    "legacy"
+  end
+  
+  deprecate :legacy_method
+end
+
+obj2 = TestClass2.new
+result4 = obj2.legacy_method
+puts "Legacy result: #{result4}"
+
+puts "\nAll tests completed successfully!"

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: deprecate
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - Dale Stevens
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-03 00:00:00.000000000 Z
+date: 2025-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,36 +15,54 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
-description: 
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 email:
 - dale@twilightcoder.net
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
+- ".qlty.toml"
+- ".reek.yml"
+- ".rspec"
+- ".rubocop.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -53,11 +70,16 @@ files:
 - deprecate.gemspec
 - lib/deprecate.rb
 - lib/deprecate/version.rb
-homepage: ''
+- spec/deprecate_spec.rb
+- spec/spec_helper.rb
+- test/test_basic.rb
+- test/test_deprecate.rb
+- test/test_deprecate_simple.rb
+- test_manual.rb
+homepage: https://github.com/twilightcoders/deprecate
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -65,17 +87,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
-signing_key: 
+rubygems_version: 3.6.3
 specification_version: 4
 summary: Easily maintain your codebase by exposing an easy and concise way to mark
   methods as deprecated.
-test_files: []
+test_files:
+- spec/deprecate_spec.rb
+- spec/spec_helper.rb
+- test/test_basic.rb
+- test/test_deprecate.rb
+- test/test_deprecate_simple.rb