private_attr 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 3fe27ad01f2e233e9d5422b483cfeef78abe6ac5
-  data.tar.gz: 09790254ddce8d6828c3a73cff4446edb3de33c6
+SHA256:
+  metadata.gz: 88d9a3ef59b6c3f35666213427fe1bfcbf62bfa1d68880842c87aded09b88941
+  data.tar.gz: d8f0ef61f6bce1cc59d42ca4e6cedda297537d4b7183781801eb80d7e81052af
 SHA512:
-  metadata.gz: 6921dcd2d484d73587154668ea5e99ac1c3e5586d1600c487d02388b1e9348342a0794cc20305e5e307c9f2cb70c717123a7c767d8a3be531c1f4390a61d0d24
-  data.tar.gz: 5ccea01bdb065d1dda91d50568f1b2df5d088b20974774ab84c39a5f41e0903bb06baf0fb1de3dc2427e3f11e83524a086d1787b60e8a639b6a452f509801a23
+  metadata.gz: 6b86f6095fb35bb4273e528708380293f4a43f542d8ee790efb7d81b1c27444861139338bf5139de7a51ba0bcbc0d76228fb29625815f4690d5aa5e60e160ef7
+  data.tar.gz: 807ad97fa745e06a1a881c1d0318c57a6b94cf904c986da94376f546816b2125211e2a0a65ccb30e9848fedc1e58a102aa77f28f223f8d4db2f784f0a55665e8

data/.travis.yml

@@ -1,6 +1,10 @@
 language: ruby
 rvm:
-  - 1.9.3
-  - 2.0.0
+  - 2.0
   - 2.1
   - 2.2
+  - 2.3
+  - 2.4
+  - 2.5
+  - 2.6
+  - 2.7

data/README.md

@@ -17,8 +17,9 @@ class Foo
 end
 ```
 
-But, I really like to declare my attribute readers and writers near the
-top of my classes, which means I sometimes use something like:
+Unfortunately, this makes Ruby show a ‘private attribute?’ warning.
+Also, I really like to declare my attribute readers and writers near
+the top of my classes, which means I sometimes use something like:
 
 ```ruby
 class Bar
@@ -56,6 +57,7 @@ class Bar
   private_attr_accessor :foo
   private_attr_reader :baz
   private_attr_writer :bat
+  private_alias_method :bar, :foo
 
   def initialize foo
     self.foo = foo
@@ -79,6 +81,10 @@ class Bar
 end
 ```
 
+If you don’t want to extend all of your modules and classes
+separately you can also `require 'private_attr/everywhere'`
+and the methods will be available everywhere.
+
 ## Contributing
 
 1. Fork it

data/lib/private_attr/everywhere.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative "../private_attr"
+
+# Module.include is private in Ruby < 2.1
+Module.__send__(:include, PrivateAttr)

data/lib/private_attr/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module PrivateAttr
-  VERSION = "1.0.0"
+  VERSION = "2.0.0"
 end

data/lib/private_attr.rb

@@ -1,35 +1,47 @@
+# frozen_string_literal: true
+
 require "private_attr/version"
 
 module PrivateAttr
   module_function
 
-  def private_attr_accessor *attr
+  def private_attr_accessor(*attr)
     private_attr_reader(*attr)
     private_attr_writer(*attr)
   end
 
-  def private_attr_reader *attr
+  def private_attr_reader(*attr)
     attr_reader(*attr)
     private(*attr)
   end
 
-  def private_attr_writer *attr
+  def private_attr_writer(*attr)
     attr_writer(*attr)
     private(*attr.map { |a| "#{a}=" })
   end
 
-  def protected_attr_accessor *attr
+  def protected_attr_accessor(*attr)
     protected_attr_reader(*attr)
     protected_attr_writer(*attr)
   end
 
-  def protected_attr_reader *attr
+  def protected_attr_reader(*attr)
     attr_reader(*attr)
     protected(*attr)
   end
 
-  def protected_attr_writer *attr
+  def protected_attr_writer(*attr)
     attr_writer(*attr)
     protected(*attr.map { |a| "#{a}=" })
   end
+
+  def private_alias_method(new_name, old_name)
+    alias_method(new_name, old_name)
+    private(new_name)
+  end
+
+  def protected_alias_method(new_name, old_name)
+    alias_method(new_name, old_name)
+    protected(new_name)
+  end
 end

data/private_attr.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
+  gem.add_development_dependency 'bundler'
   gem.add_development_dependency 'minitest', '~> 5.0'
-  gem.add_development_dependency 'rake',     '~> 10.0'
+  gem.add_development_dependency 'rake',     '~> 12.3.3'
 end

data/spec/private_attr/everywhere_spec.rb

@@ -0,0 +1,20 @@
+require "minitest/autorun"
+
+describe "private_attr/everywhere" do
+  # these particular tests must be run in order
+  def self.test_order
+    :alpha
+  end
+
+  it "requiring only private_attr keeps Classes and Modules intact" do
+    require "private_attr"
+    _(Class.new.private_methods).wont_include :private_attr_reader
+    _(Module.new.private_methods).wont_include :private_attr_reader
+  end
+
+  it "requiring private_attr/everywhere adds it to all Classes and Modules" do
+    require "private_attr/everywhere"
+    _(Class.new.private_methods).must_include :private_attr_reader
+    _(Module.new.private_methods).must_include :private_attr_reader
+  end
+end

data/spec/private_attr_spec.rb

@@ -1,20 +1,20 @@
-require 'minitest/autorun'
-require 'private_attr'
+require "minitest/autorun"
+require "private_attr"
 
 class Dummy
   def read_accessor
     accessor
   end
 
-  def read_accessor_other other
+  def read_accessor_other(other)
     other.accessor
   end
 
-  def write_accessor value
+  def write_accessor(value)
     self.accessor = value
   end
 
-  def write_accessor_other other, value
+  def write_accessor_other(other, value)
     other.accessor = value
   end
 
@@ -22,17 +22,27 @@ class Dummy
     reader
   end
 
-  def read_reader_other other
+  def read_reader_other(other)
     other.reader
   end
 
-  def write_writer value
+  def write_writer(value)
     self.writer = value
   end
 
-  def write_writer_other other, value
+  def write_writer_other(other, value)
     other.writer = value
   end
+
+  attr_reader :original
+
+  def call_aliased
+    aliased
+  end
+
+  def call_aliased_other(other)
+    other.aliased
+  end
 end
 
 class PrivateDummy < Dummy
@@ -40,6 +50,7 @@ class PrivateDummy < Dummy
   private_attr_accessor :accessor
   private_attr_reader :reader
   private_attr_writer :writer
+  private_alias_method :aliased, :original
 end
 
 class ProtectedDummy < Dummy
@@ -47,205 +58,308 @@ class ProtectedDummy < Dummy
   protected_attr_accessor :accessor
   protected_attr_reader :reader
   protected_attr_writer :writer
+  protected_alias_method :aliased, :original
 end
 
 describe PrivateAttr do
   let(:dummy) { dummy_class.new }
   let(:other) { dummy_class.new }
-  let(:old_value) { 'old value' }
-  let(:value) { 'value' }
+  let(:old_value) { "old value" }
+  let(:new_value) { "new value" }
 
-  describe 'private_attr_accessor' do
+  describe "private_attr_accessor" do
     let(:dummy_class) { PrivateDummy }
 
-    before { dummy.instance_variable_set '@accessor', old_value }
+    before { dummy.instance_variable_set "@accessor", old_value }
 
-    it 'allows attribute to be read internally' do
-      dummy.read_accessor.must_equal old_value
+    it "allows attribute to be read internally" do
+      _(dummy.read_accessor).must_equal old_value
     end
 
-    it 'allows attribute to be written internally' do
-      dummy.write_accessor value
-      dummy.instance_variable_get('@accessor').must_equal value
+    it "allows attribute to be written internally" do
+      dummy.write_accessor new_value
+      _(dummy.instance_variable_get("@accessor")).must_equal new_value
     end
 
-    it 'raises Error when read externally' do
-      -> { dummy.accessor }.must_raise NoMethodError
+    it "raises Error when read externally" do
+      _{ dummy.accessor }.must_raise NoMethodError
     end
 
-    it 'raises Error when written externally' do
-      -> { dummy.accessor = value }.must_raise NoMethodError
+    it "raises Error when written externally" do
+      _{ dummy.accessor = new_value }.must_raise NoMethodError
     end
 
-    it 'raises Error when read by other' do
-      -> { dummy.read_accessor_other other }.must_raise NoMethodError
+    it "raises Error when read by other" do
+      _{ dummy.read_accessor_other other }.must_raise NoMethodError
     end
 
-    it 'raises Error when written by other' do
-      -> { dummy.write_accessor_other other, value }.must_raise NoMethodError
+    it "raises Error when written by other" do
+      _{ dummy.write_accessor_other other, new_value }.must_raise NoMethodError
     end
   end
 
-  describe 'private_attr_reader' do
+  describe "private_attr_reader" do
     let(:dummy_class) { PrivateDummy }
 
-    before { dummy.instance_variable_set '@reader', old_value }
+    before { dummy.instance_variable_set "@reader", old_value }
 
-    it 'allows attribute to be read internally' do
-      dummy.read_reader.must_equal old_value
+    it "allows attribute to be read internally" do
+      _(dummy.read_reader).must_equal old_value
     end
 
-    it 'raises Error when written internally' do
-      -> { dummy.write_reader value }.must_raise NoMethodError
+    it "raises Error when written internally" do
+      _{ dummy.write_reader new_value }.must_raise NoMethodError
     end
 
-    it 'raises Error when read externally' do
-      -> { dummy.reader }.must_raise NoMethodError
+    it "raises Error when read externally" do
+      _{ dummy.reader }.must_raise NoMethodError
     end
 
-    it 'raises Error when written externally' do
-      -> { dummy.reader = value }.must_raise NoMethodError
+    it "raises Error when written externally" do
+      _{ dummy.reader = new_value }.must_raise NoMethodError
     end
 
-    it 'raises Error when read by other' do
-      -> { dummy.read_reader_other other }.must_raise NoMethodError
+    it "raises Error when read by other" do
+      _{ dummy.read_reader_other other }.must_raise NoMethodError
     end
 
-    it 'raises Error when written by other' do
-      -> { dummy.write_reader_other other, value }.must_raise NoMethodError
+    it "raises Error when written by other" do
+      _{ dummy.write_reader_other other, new_value }.must_raise NoMethodError
     end
   end
 
-  describe 'private_attr_writer' do
+  describe "private_attr_writer" do
     let(:dummy_class) { PrivateDummy }
 
-    before { dummy.instance_variable_set '@writer', old_value }
+    before { dummy.instance_variable_set "@writer", old_value }
 
-    it 'raises Error when read internally' do
-      -> { dummy.read_writer }.must_raise NoMethodError
+    it "raises Error when read internally" do
+      _{ dummy.read_writer }.must_raise NoMethodError
     end
 
-    it 'allows attribute to be written internally' do
-      dummy.write_writer value
-      dummy.instance_variable_get('@writer').must_equal value
+    it "allows attribute to be written internally" do
+      dummy.write_writer new_value
+      _(dummy.instance_variable_get("@writer")).must_equal new_value
     end
 
-    it 'raises Error when read externally' do
-      -> { dummy.writer }.must_raise NoMethodError
+    it "raises Error when read externally" do
+      _{ dummy.writer }.must_raise NoMethodError
     end
 
-    it 'raises Error when written externally' do
-      -> { dummy.writer = value }.must_raise NoMethodError
+    it "raises Error when written externally" do
+      _{ dummy.writer = new_value }.must_raise NoMethodError
     end
 
-    it 'raises Error when read by other' do
-      -> { dummy.read_writer_other other }.must_raise NoMethodError
+    it "raises Error when read by other" do
+      _{ dummy.read_writer_other other }.must_raise NoMethodError
     end
 
-    it 'raises Error when written by other' do
-      -> { dummy.write_writer_other other, value }.must_raise NoMethodError
+    it "raises Error when written by other" do
+      _{ dummy.write_writer_other other, new_value }.must_raise NoMethodError
+    end
+  end
+
+  describe "private_alias_method" do
+    let(:dummy_class) { PrivateDummy }
+
+    before { dummy.instance_variable_set "@original", old_value }
+
+    it "allows alias to be called internally" do
+      _(dummy.call_aliased).must_equal old_value
+    end
+
+    it "raises Error when alias is called externally" do
+      _{ dummy.aliased other }.must_raise NoMethodError
+    end
+
+    it "raises Error when alias is called by other" do
+      _{ dummy.call_aliased_other other }.must_raise NoMethodError
+    end
+
+    it "allows the original method to be called externally" do
+      _(dummy.original).must_equal old_value
+    end
+
+    describe "when the original method is overridden" do
+      let(:dummy_class) do
+        mod = Module.new do
+          def original
+            super.upcase
+          end
+        end
+        Class.new(PrivateDummy).send(:include, mod)
+      end
+
+      it "allows alias to be called internally" do
+        _(dummy.call_aliased).must_equal old_value
+      end
+
+      it "raises Error when alias is called externally" do
+        _{ dummy.aliased }.must_raise NoMethodError
+      end
+
+      it "raises Error when alias is called by other" do
+        _{ dummy.call_aliased_other other }.must_raise NoMethodError
+      end
+
+      it "allows the overridden method to be called externally" do
+        _(dummy.original).must_equal old_value.upcase
+      end
     end
   end
 
-  describe 'protected_attr_accessor' do
+  describe "protected_attr_accessor" do
     let(:dummy_class) { ProtectedDummy }
 
-    before { dummy.instance_variable_set '@accessor', old_value }
+    before { dummy.instance_variable_set "@accessor", old_value }
 
-    it 'allows attribute to be read internally' do
-      dummy.read_accessor.must_equal old_value
+    it "allows attribute to be read internally" do
+      _(dummy.read_accessor).must_equal old_value
     end
 
-    it 'allows attribute to be written internally' do
-      dummy.write_accessor value
-      dummy.instance_variable_get('@accessor').must_equal value
+    it "allows attribute to be written internally" do
+      dummy.write_accessor new_value
+      _(dummy.instance_variable_get("@accessor")).must_equal new_value
     end
 
-    it 'raises Error when read externally' do
-      -> { dummy.accessor }.must_raise NoMethodError
+    it "raises Error when read externally" do
+      _{ dummy.accessor }.must_raise NoMethodError
     end
 
-    it 'raises Error when written externally' do
-      -> { dummy.accessor = value }.must_raise NoMethodError
+    it "raises Error when written externally" do
+      _{ dummy.accessor = new_value }.must_raise NoMethodError
     end
 
-    it 'allows attribute to be read by other' do
-      other.instance_variable_set '@accessor', value
-      dummy.read_accessor_other(other).must_equal value
+    it "allows attribute to be read by other" do
+      other.instance_variable_set "@accessor", new_value
+      _(dummy.read_accessor_other(other)).must_equal new_value
     end
 
-    it 'allows attribute to be written by other' do
-      dummy.write_accessor_other other, value
-      other.instance_variable_get('@accessor').must_equal value
+    it "allows attribute to be written by other" do
+      dummy.write_accessor_other other, new_value
+      _(other.instance_variable_get("@accessor")).must_equal new_value
     end
   end
 
-  describe 'protected_attr_reader' do
+  describe "protected_attr_reader" do
     let(:dummy_class) { ProtectedDummy }
 
-    before { dummy.instance_variable_set '@reader', old_value }
+    before { dummy.instance_variable_set "@reader", old_value }
 
-    it 'allows attribute to be read internally' do
-      dummy.read_reader.must_equal old_value
+    it "allows attribute to be read internally" do
+      _(dummy.read_reader).must_equal old_value
     end
 
-    it 'raises Error when written internally' do
-      -> { dummy.write_reader value }.must_raise NoMethodError
+    it "raises Error when written internally" do
+      _{ dummy.write_reader new_value }.must_raise NoMethodError
     end
 
-    it 'raises Error when read externally' do
-      -> { dummy.reader }.must_raise NoMethodError
+    it "raises Error when read externally" do
+      _{ dummy.reader }.must_raise NoMethodError
     end
 
-    it 'raises Error when written externally' do
-      -> { dummy.reader = value }.must_raise NoMethodError
+    it "raises Error when written externally" do
+      _{ dummy.reader = new_value }.must_raise NoMethodError
     end
 
-    it 'allows attribute to be read by other' do
-      other.instance_variable_set '@reader', value
-      dummy.read_reader_other(other).must_equal value
+    it "allows attribute to be read by other" do
+      other.instance_variable_set "@reader", new_value
+      _(dummy.read_reader_other(other)).must_equal new_value
     end
 
-    it 'raises Error when written by other' do
-      -> { dummy.write_reader_other other, value }.must_raise NoMethodError
+    it "raises Error when written by other" do
+      _{ dummy.write_reader_other other, new_value }.must_raise NoMethodError
     end
   end
 
-  describe 'protected_attr_writer' do
+  describe "protected_attr_writer" do
     let(:dummy_class) { ProtectedDummy }
 
-    before { dummy.instance_variable_set '@writer', old_value }
+    before { dummy.instance_variable_set "@writer", old_value }
+
+    it "raises Error when read internally" do
+      _{ dummy.read_writer }.must_raise NoMethodError
+    end
+
+    it "allows attribute to be written internally" do
+      dummy.write_writer new_value
+      _(dummy.instance_variable_get("@writer")).must_equal new_value
+    end
 
-    it 'raises Error when read internally' do
-      -> { dummy.read_writer }.must_raise NoMethodError
+    it "raises Error when read externally" do
+      _{ dummy.writer }.must_raise NoMethodError
     end
 
-    it 'allows attribute to be written internally' do
-      dummy.write_writer value
-      dummy.instance_variable_get('@writer').must_equal value
+    it "raises Error when written externally" do
+      _{ dummy.writer = new_value }.must_raise NoMethodError
     end
 
-    it 'raises Error when read externally' do
-      -> { dummy.writer }.must_raise NoMethodError
+    it "raises Error when read by other" do
+      _{ dummy.read_writer_other other }.must_raise NoMethodError
     end
 
-    it 'raises Error when written externally' do
-      -> { dummy.writer = value }.must_raise NoMethodError
+    it "allows attribute to be written by other" do
+      dummy.write_writer_other other, new_value
+      _(other.instance_variable_get("@writer")).must_equal new_value
+    end
+  end
+
+  describe "protected_alias_method" do
+    let(:dummy_class) { ProtectedDummy }
+    let(:other_value) { "other value" }
+
+    before do
+      dummy.instance_variable_set "@original", old_value
+      other.instance_variable_set "@original", other_value
     end
 
-    it 'raises Error when read by other' do
-      -> { dummy.read_writer_other other }.must_raise NoMethodError
+    it "allows alias to be called internally" do
+      _(dummy.call_aliased).must_equal old_value
     end
 
-    it 'allows attribute to be written by other' do
-      dummy.write_writer_other other, value
-      other.instance_variable_get('@writer').must_equal value
+    it "raises Error when alias is called externally" do
+      _{ dummy.aliased }.must_raise NoMethodError
+    end
+
+    it "allows alias to be called by other" do
+      _(dummy.call_aliased_other(other)).must_equal other_value
+    end
+
+    it "allows the original method to be called externally" do
+      _(dummy.original).must_equal old_value
+    end
+
+    describe "when the original method is overridden" do
+      let(:dummy_class) do
+        mod = Module.new do
+          def original
+            super.upcase
+          end
+        end
+        Class.new(ProtectedDummy).send(:include, mod)
+      end
+
+      it "allows alias to be called internally" do
+        _(dummy.call_aliased).must_equal old_value
+      end
+
+      it "raises Error when alias is called externally" do
+        _{ dummy.aliased }.must_raise NoMethodError
+      end
+
+      it "allows alias to be called by other" do
+        _(dummy.call_aliased_other(other)).must_equal other_value
+      end
+
+      it "allows the overridden method to be called externally" do
+        _(dummy.original).must_equal old_value.upcase
+      end
     end
   end
 
-  describe 'method visibility' do
-    it 'extending classes does not increase their public APIs' do
-      PrivateDummy.public_methods.wont_include :private_attr_accessor
+  describe "method visibility" do
+    it "extending classes does not increase their public APIs" do
+      _(PrivateDummy.public_methods).wont_include :private_attr_accessor
     end
   end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: private_attr
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Jacob Swanner
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-02-03 00:00:00.000000000 Z
+date: 2022-09-29 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -30,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
 description: Easily create private/protected attribute readers/writers
 email:
 - jacob@jacobswanner.com
@@ -52,14 +66,16 @@ files:
 - README.md
 - Rakefile
 - lib/private_attr.rb
+- lib/private_attr/everywhere.rb
 - lib/private_attr/version.rb
 - private_attr.gemspec
+- spec/private_attr/everywhere_spec.rb
 - spec/private_attr_spec.rb
 homepage: https://github.com/jswanner/private_attr
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -74,11 +90,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
-signing_key: 
+rubygems_version: 3.2.31
+signing_key:
 specification_version: 4
 summary: Easily create private/protected attribute readers/writers
 test_files:
+- spec/private_attr/everywhere_spec.rb
 - spec/private_attr_spec.rb
-has_rdoc: