legacy_column 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e0f3e99c2f72f39807384c2224be01fe1edf691d130b841cf5164e6c03fea7d
-  data.tar.gz: f6cabee32966225461c81efb9b8eef15b4dc5d7dc0d37d946e8636f4b5eacac1
+  metadata.gz: a09851d6a69c5fffa341bbcb0fae4b937903c1b26e2a8d36bb9f4a8b2ca9201a
+  data.tar.gz: d458748a4dc483d16d11e8c6f02f4a794b5cc08bfad3f36f42bbba375816f91f
 SHA512:
-  metadata.gz: 011c616903e4d49021400d15f372c8ce9e080dc6d060337448f54e5c377768d61dc7d5f04fd64035f195432341b986b203fb88bcd303c916d8e75d56fe3073d8
-  data.tar.gz: c60ecb2598d4281fd947e800b65e0b3f4e6cfdfc006bf945123ef7d28ab49956565f2ad6ffcc724edef0bb3ba797cbfb81fd0a995b204a3d678078d703bba8ec
+  metadata.gz: cf307d3a3da65ed7441173135cce638179e810b12c72b791aea18eeb93248740aba8aaf9dcf8e16a7bf3d2af82390f2ef189d6e01b096710a5bb7176a0c65056
+  data.tar.gz: 4b0427368bbf8969f7eadbe243307d71a4306381af8f5027b1ab0b5ba4fd03969375f3d3e324722aabe81ab7cd2bfd88989571634f28f63abf0955f3fa77f008

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    legacy_column (0.2.0)
+    legacy_column (0.3.0)
       activerecord (>= 5.2.0, < 9.0)
       activesupport (>= 5.2.0, < 9.0)
 

data/README.md

@@ -26,6 +26,8 @@ This gem supports:
 
 ## Usage
 
+### Basic Usage
+
 Just list the column names:
 ```ruby
 legacy_column :old_email, :old_phone_number
@@ -36,20 +38,61 @@ A custom message can be added:
 legacy_column :old_email, :old_phone_number, message: 'Do not touch this!!!'
 ```
 
-It will output something like this in Rails logs:
+### Read Access Detection
+
+By default, the gem only detects write operations (when columns are modified). To also detect read access, use the `detect_reads` option:
+
+```ruby
+legacy_column :old_email, :old_phone_number, detect_reads: true
+```
+
+This will warn whenever the legacy columns are accessed:
+
+```ruby
+legacy_column :old_status, message: 'This field is deprecated!', detect_reads: true
+
+user.old_status  # Will log a warning about read access
+user.old_status = 'active'  # Will log a warning about write access
+```
+
+### Combined Usage
 
+You can combine read detection with custom messages:
+```ruby
+legacy_column :old_price, :old_name, 
+              message: 'These fields will be removed in v2.0!', 
+              detect_reads: true
+```
+
+## Output Examples
+
+### Write Detection (Default)
 ```
-Use of legacy column detected.
+USE of legacy column detected.
   User => old_email
   Do not touch this!!!
 ```
 
-## Output
+### Read Detection (When enabled)
+```
+READ of legacy column detected.
+  User => old_email
+  Do not touch this!!!
+```
+
+## Logging
 
 The gem will:
-- Log warnings to `Rails.logger` when Rails is available
+- Log warnings to `Rails.logger` when Rails is available  
 - Fall back to `puts` for non-Rails environments or when Rails.logger is not available
 
+## Options
+
+| Option | Default | Description |
+|--------|---------|-------------|
+| `message` | `"This column is set as legacy and should not be used anymore."` | Custom warning message |
+| `detect_reads` | `false` | Enable read access detection |
+
 ## Contributing
 Pull requests are welcome. For major changes, please open an issue first to discuss what you would like to change.
 

data/lib/legacy_column/version.rb

@@ -1,3 +1,3 @@
 module LegacyColumn
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/lib/legacy_column.rb

@@ -10,18 +10,43 @@ module LegacyColumn
   included do
     class_attribute :legacy_column_names, instance_writer: false, default: nil
     class_attribute :legacy_column_message, instance_writer: false, default: nil
+    class_attribute :legacy_column_detect_reads, instance_writer: false, default: false
   end
 
   module ClassMethods
     DEFAULT_MESSAGE = 'This column is set as legacy and should not be used anymore.'
 
-    def legacy_column(*columns, message: nil)
+    def legacy_column(*columns, message: nil, detect_reads: false)
       return unless columns
 
       self.legacy_column_names = columns
       self.legacy_column_message = message || DEFAULT_MESSAGE
+      self.legacy_column_detect_reads = detect_reads
 
       send('before_validation', :legacy_column)
+      
+      if detect_reads
+        setup_read_detection(columns)
+      end
+    end
+
+    private
+
+    def setup_read_detection(columns)
+      mod = Module.new do
+        columns.each do |column|
+          define_method(column) do
+            # Log read access
+            if defined?(Rails) && Rails.logger
+              Rails.logger.warn "\n\nREAD of legacy column detected.\n  #{self.class} => #{column}\n  #{legacy_column_message}\n\n"
+            else
+              puts "\n\nREAD of legacy column detected.\n  #{self.class} => #{column}\n  #{legacy_column_message}\n\n"
+            end
+            super()  # Call original getter
+          end
+        end
+      end
+      prepend(mod)
     end
   end
 

data/spec/db/schema.rb

@@ -6,4 +6,21 @@ ActiveRecord::Schema.define(:version => 0) do
     t.string :old_email
     t.string :old_phone_number
   end
+
+  create_table :products, :force => true do |t|
+    t.decimal :old_price
+    t.string :old_name
+  end
+
+  create_table :items, :force => true do |t|
+    t.string :old_status
+  end
+
+  create_table :orders, :force => true do |t|
+    t.decimal :old_total
+  end
+
+  create_table :accounts, :force => true do |t|
+    t.decimal :old_balance
+  end
 end

data/spec/legacy_column_spec.rb

@@ -50,4 +50,124 @@ RSpec.describe LegacyColumn do
       end
     end
   end
+
+  context 'read detection enabled' do
+    before do
+      class Product < ActiveRecord::Base
+        legacy_column :old_price, :old_name, detect_reads: true
+      end
+    end
+
+    it 'should recognize detect_reads setting' do
+      expect(Product.legacy_column_detect_reads).to eq(true)
+    end
+
+    describe 'read access detection' do
+      let(:product) do
+        # Create product without triggering write detection by using update_attribute
+        p = Product.create
+        p.update_attribute(:old_price, 100)
+        p.update_attribute(:old_name, 'Test Product')
+        p
+      end
+
+      it 'detects read access to legacy columns' do
+        expect {
+          product.old_price
+        }.to output(/READ of legacy column detected.*Product => old_price.*This column is set as legacy and should not be used anymore/m).to_stdout
+      end
+
+      it 'detects read access to multiple legacy columns' do
+        expect {
+          product.old_name
+        }.to output(/READ of legacy column detected.*Product => old_name.*This column is set as legacy and should not be used anymore/m).to_stdout
+      end
+
+      it 'still returns the actual attribute value' do
+        # Capture output but test return value
+        value = nil
+        expect {
+          value = product.old_price
+        }.to output(/READ of legacy column detected/).to_stdout
+        expect(value).to eq(100)
+      end
+    end
+  end
+
+  context 'read detection with custom message' do
+    before do
+      class Item < ActiveRecord::Base  
+        legacy_column :old_status, message: 'Stop reading this!', detect_reads: true
+      end
+    end
+
+    describe 'read access detection with custom message' do
+      let(:item) do
+        i = Item.create
+        i.update_attribute(:old_status, 'active')
+        i
+      end
+
+      it 'shows custom message for read access' do
+        expect {
+          item.old_status
+        }.to output(/READ of legacy column detected.*Item => old_status.*Stop reading this!/m).to_stdout
+      end
+    end
+  end
+
+  context 'read detection disabled (default)' do
+    before do
+      class Order < ActiveRecord::Base
+        legacy_column :old_total  # detect_reads defaults to false
+      end
+    end
+
+    it 'should not detect reads when disabled' do
+      expect(Order.legacy_column_detect_reads).to eq(false)
+    end
+
+    describe 'no read access detection' do
+      let(:order) do
+        o = Order.create
+        o.update_attribute(:old_total, 50)
+        o
+      end
+
+      it 'does not detect read access when disabled' do
+        expect {
+          order.old_total
+        }.to_not output.to_stdout
+      end
+
+      it 'still returns the actual attribute value' do
+        expect(order.old_total).to eq(50)
+      end
+    end
+  end
+
+  context 'combined read and write detection' do
+    before do
+      class Account < ActiveRecord::Base
+        legacy_column :old_balance, message: 'Legacy account field!', detect_reads: true
+      end
+    end
+
+    describe 'both read and write detection' do
+      let(:account) { Account.create }
+
+      it 'detects write access' do
+        expect {
+          account.update(old_balance: 1000)
+        }.to output("\n\nUSE of legacy column detected.\n  Account => old_balance\n  Legacy account field!\n\n").to_stdout
+      end
+
+      it 'detects read access' do
+        account.update_attribute(:old_balance, 1000)  # Set without triggering write detection
+        expect {
+          account.old_balance
+        }.to output(/READ of legacy column detected.*Account => old_balance.*Legacy account field!/m).to_stdout
+      end
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legacy_column
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Aleksander Lopez Yazikov