rebase_attr 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1c989126e78f373d7608f11824429b65974311bc
-  data.tar.gz: 2859dd7b67c93645a72d0ad8f38ee128b9d72d29
+  metadata.gz: ea935085ce8abb358a0cf745bed76b3eafcd2d23
+  data.tar.gz: 70e69e3bb784845327ff3fa78223bcb9c7c3d0c1
 SHA512:
-  metadata.gz: e812eced8377afca51ce32ee032411782b1aba3395df1b7480603011a2c6a3e988406d0d12eb6d3fad162afdab3c0353ab7c67e5256e1add033e540b8991afc3
-  data.tar.gz: bc4df6f016698c5a4ec2c89c48eda5f243beb5c709a29f10d65331b80f344076c5e4bd7b523adf335bc44b40b39cb8a40a6d8834524a2adba2a4a537cbf383b4
+  metadata.gz: 8742d2a06433dfb567b4464d6025bff600502d1eafe487040e9ddb9faf4734d952a35b9bf10d926aaf0278bcd043542fb85c7086e7d3428a6fbd1012ad279639
+  data.tar.gz: 2805a5159796f79fea91660ae8886a0bd5378bd7123cd4585f946be19ef21f599f7e4044c1979b549a88ccfcbf03ac48c4d1da7ae80781e28c85a0c11485e660

data/README.md

@@ -36,7 +36,7 @@ Example for an active record table with long IDs:
 #
 
 class Bill < ActiveRecord::Base
-  rebase_attr :id, base: 32, readable: true # only digits and leters, without '0', '1', 'i' and 'l'
+  rebase_attr :id, to: 32, readable: true # digits and leters, without '0', 'o', '1' and 'l'
 end
 ```
 

data/lib/rebase_attr.rb

@@ -1,4 +1,5 @@
 require "rebase_attr/version"
+require "generate_method"
 
 module RebaseAttr
   READABLE_MAPPING = { '0' => 'x', '1' => 'y', 'l' => 'w', 'o' => 'z' }
@@ -9,66 +10,67 @@ module RebaseAttr
       raise ArgumentError, "#rebase_attr does not accept a block, did you mean to use :convert?" if block_given?
       raise ArgumentError, "#rebase_attr does not allow :readable option with bases higher than 32, #{to} given" if readable and to > 32
 
-      attributes.each do |attr|
-        # encoders & decoders
-        define_singleton_method :"encode_#{attr}" do |decoded|
-          break nil if decoded.nil?
+      generate_singleton_methods do
+        attributes.each do |attr|
+          # encoders & decoders
+          define_method :"encode_#{attr}" do |decoded|
+            break nil if decoded.nil?
 
-          result = decoded
-          raise TypeError, "decoded value must implement #to_i, #{result.inspect} given" unless result.respond_to?(:to_i)
-          result = result.to_i(from || 10) if result.is_a?(String)
-          result = result.to_s(to)
-          READABLE_MAPPING.each { |s, d| result.gsub!(/#{s}/i, d) } if readable # gsub! to conserve memory
-          result = convert.respond_to?(:call) ? convert.call(result) : result.public_send(convert) if convert
-          result
-        end
-        define_method :"encode_#{attr}" do |decoded|
-          self.class.send(:"encode_#{attr}", decoded)
-        end
+            result = decoded
+            raise TypeError, "decoded value must implement #to_i, #{result.inspect} given" unless result.respond_to?(:to_i)
+            result = result.to_i(from || 10) if result.is_a?(String)
+            result = result.to_s(to)
+            READABLE_MAPPING.each { |s, d| result.gsub!(/#{s}/i, d) } if readable # gsub! to conserve memory
+            result = convert.respond_to?(:call) ? convert.call(result) : result.public_send(convert) if convert
+            result
+          end
 
-        define_singleton_method :"decode_#{attr}" do |encoded|
-          break nil if encoded.nil?
+          define_method :"decode_#{attr}" do |encoded|
+            break nil if encoded.nil?
 
-          result = encoded
-          if deconvert
-            begin
-              result = result.clone # deconvert to not modify outside variable
-            rescue TypeError # can't clone, immutable
+            result = encoded
+            if deconvert
+              begin
+                result = result.clone # deconvert to not modify outside variable
+              rescue TypeError # can't clone, immutable
+              end
+              result = deconvert.respond_to?(:call) ? deconvert.call(result) : result.public_send(deconvert)
             end
-            result = deconvert.respond_to?(:call) ? deconvert.call(result) : result.public_send(deconvert)
-          end
-          raise TypeError, "encoded value must implement #to_i, #{result.inspect} given" unless result.respond_to?(:to_i)
-          if readable
-            begin
-              result = result.clone # not modifying outside variable
-            rescue TypeError # can't clone, immutable
+            raise TypeError, "encoded value must implement #to_i, #{result.inspect} given" unless result.respond_to?(:to_i)
+            if readable
+              begin
+                result = result.clone # not modifying outside variable
+              rescue TypeError # can't clone, immutable
+              end
+              READABLE_MAPPING.each { |s, d| result.gsub!(/#{d}/i, s) } # gsub! to conserve memory
             end
-            READABLE_MAPPING.each { |s, d| result.gsub!(/#{d}/i, s) } # gsub! to conserve memory
+            result = result.to_i(to)
+            result = result.to_s(from) if from
+            result
           end
-          result = result.to_i(to)
-          result = result.to_s(from) if from
-          result
-        end
-        define_method :"decode_#{attr}" do |encoded|
-          self.class.send(:"decode_#{attr}", encoded)
         end
+      end
 
-        # readers & writers
-        begin
-          alias_method :"#{attr}_without_rebase", attr
-        rescue NameError # reader does not exist
-        else
-          define_method attr do
-            send(:"encode_#{attr}", send(:"#{attr}_without_rebase"))
+      generate_methods do
+        attributes.each do |attr|
+          # encoders & decoders
+          define_method :"encode_#{attr}" do |decoded|
+            self.class.send(:"encode_#{attr}", decoded)
+          end
+          define_method :"decode_#{attr}" do |encoded|
+            self.class.send(:"decode_#{attr}", encoded)
           end
         end
+      end
 
-        begin
-          alias_method :"#{attr}_without_rebase=", :"#{attr}="
-        rescue NameError # writer does not exist
-        else
+      generate_methods(overrider: :rebase) do
+        attributes.each do |attr|
+          # readers & writers
+          define_method attr do
+            send(:"encode_#{attr}", respond_to?(:"#{attr}_without_rebase") ? send(:"#{attr}_without_rebase") : super())
+          end
           define_method :"#{attr}=" do |encoded|
-            send(:"#{attr}_without_rebase=", send(:"decode_#{attr}", encoded))
+            respond_to?(:"#{attr}_without_rebase=") ? send(:"#{attr}_without_rebase=", send(:"decode_#{attr}", encoded)) : super(send(:"decode_#{attr}", encoded))
           end
         end
       end

data/lib/rebase_attr/version.rb

@@ -1,3 +1,3 @@
 module RebaseAttr
-  VERSION = "1.1.0"
+  VERSION = "2.0.0"
 end

data/rebase_attr.gemspec

@@ -18,6 +18,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_runtime_dependency "generate_method", "~> 1.0"
+
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rspec", "~> 3.1"
   spec.add_development_dependency "rspec-its", "~> 1.0"

data/spec/rebase_attr_spec.rb

@@ -1,17 +1,49 @@
 require 'rebase_attr'
 
-class RebaseTestBase
+class RebaseWithAccessorTestBase
   attr_accessor :x
 end
 
+class RebaseWithoutAccessorTestBase
+  def method_missing(method, *args, &block)
+    case method
+      when :x
+        @x
+      when :x=
+        @x = args.first
+      else
+        super
+    end
+  end
+end
+
 # This converts options to local varaibels so they can be used inside the Class.new { }
 def rebase_class(**options, &block)
-  Class.new(RebaseTestBase) { rebase_attr(:x, **options, &block) }
+  Class.new(RebaseWithAccessorTestBase) { rebase_attr(:x, **options, &block) }
+end
+
+def rebase_classes(options_proc, &block)
+  context "with accessor" do
+    let(:klass) do
+      options = instance_eval(&options_proc) # converting to local variable before going inside the Class
+      Class.new(RebaseWithAccessorTestBase) { rebase_attr(:x, **options) }
+    end
+    @with_accessors = true
+    instance_eval(&block)
+  end
+  context "without accessor" do
+    let(:klass) do
+      options = instance_eval(&options_proc) # converting to local variable before going inside the Class
+      Class.new(RebaseWithoutAccessorTestBase) { rebase_attr(:x, **options) }
+    end
+    @with_accessors = false
+    instance_eval(&block)
+  end
 end
 
 describe RebaseAttr::Generator do
   #requires: decoded, encoded
-  shared_examples_for "values" do
+  shared_examples_for "values" do |with_accessors|
     subject(:instance) { klass.new }
 
     describe "#encode" do
@@ -41,13 +73,13 @@ describe RebaseAttr::Generator do
 
     describe "#without_rebase" do
       context "when not nil" do
-        before { d = decoded; instance.instance_eval { @x = d } } # converting decoded to local variable so I can use it inside instance_eval
-        its(:x_without_rebase) { should == decoded }
+        before { d = decoded; instance.instance_eval { @x = d } if with_accessors } # converting decoded to local variable so I can use it inside instance_eval
+        specify { expect(instance.x_without_rebase).to eq(decoded) if with_accessors }
       end
 
       context "when nil" do
-        before { instance.instance_eval { @x = nil } } # converting decoded to local variable so I can use it inside instance_eval
-        its(:x_without_rebase) { should be_nil }
+        before { instance.instance_eval { @x = nil } if with_accessors } # converting decoded to local variable so I can use it inside instance_eval
+        specify { expect(instance.x_without_rebase).to be_nil if with_accessors }
       end
     end
 
@@ -65,13 +97,13 @@ describe RebaseAttr::Generator do
 
     describe "#without_rebase=" do
       context "when not nil" do
-        before { instance.x_without_rebase = decoded }
-        specify { expect(instance.instance_eval { @x }).to eq(decoded) }
+        before { instance.x_without_rebase = decoded if with_accessors }
+        specify { expect(instance.instance_eval { @x }).to eq(decoded) if with_accessors }
       end
 
       context "when nil" do
-        before { instance.x_without_rebase = nil }
-        specify { expect(instance.instance_eval { @x }).to be_nil }
+        before { instance.x_without_rebase = nil if with_accessors }
+        specify { expect(instance.instance_eval { @x }).to be_nil if with_accessors }
       end
     end
   end
@@ -81,42 +113,47 @@ describe RebaseAttr::Generator do
   shared_context "all except readable" do
     context "without from" do
       context "not converted" do
-        let(:klass) { rebase_class to: to }
-        let(:decoded) { decoded_default }
-        let(:encoded) { encoded_default }
-        it_behaves_like "values"
+        rebase_classes proc { { to: to } } do
+          let(:decoded) { decoded_default }
+          let(:encoded) { encoded_default }
+          it_behaves_like "values", @with_accessors
+        end
       end
 
       context "converted" do
         context "named" do
-          let(:klass) { rebase_class to: to, convert: convert_name, deconvert: deconvert }
-          let(:decoded) { decoded_default }
-          let(:encoded) { encoded_convert }
-          it_behaves_like "values"
+          rebase_classes proc { { to: to, convert: convert_name, deconvert: deconvert } } do
+            let(:decoded) { decoded_default }
+            let(:encoded) { encoded_convert }
+            it_behaves_like "values", @with_accessors
+          end
         end
 
         context "block" do
-          let(:klass) { rebase_class to: to, convert: convert_block, deconvert: deconvert }
-          let(:decoded) { decoded_default }
-          let(:encoded) { encoded_convert }
-          it_behaves_like "values"
+          rebase_classes proc { { to: to, convert: convert_block, deconvert: deconvert } } do
+            let(:decoded) { decoded_default }
+            let(:encoded) { encoded_convert }
+            it_behaves_like "values", @with_accessors
+          end
         end
       end
     end
 
     context "from" do
       context "not converted" do
-        let(:klass) { rebase_class from: from, to: to }
-        let(:decoded) { decoded_from }
-        let(:encoded) { encoded_default }
-        it_behaves_like "values"
+        rebase_classes proc { { from: from, to: to } } do
+          let(:decoded) { decoded_from }
+          let(:encoded) { encoded_default }
+          it_behaves_like "values", @with_accessors
+        end
       end
 
       context "converted" do
-        let(:klass) { rebase_class from: from, to: to, convert: convert_name, deconvert: deconvert }
-        let(:decoded) { decoded_from }
-        let(:encoded) { encoded_convert }
-        it_behaves_like "values"
+        rebase_classes proc { { from: from, to: to, convert: convert_name, deconvert: deconvert } } do
+          let(:decoded) { decoded_from }
+          let(:encoded) { encoded_convert }
+          it_behaves_like "values", @with_accessors
+        end
       end
     end
   end
@@ -129,33 +166,37 @@ describe RebaseAttr::Generator do
     context "readable" do # 0 => x, 1 => y, l => w, o => z
       context "without from" do
         context "not converted" do
-          let(:klass) { rebase_class to: to, readable: true }
-          let(:decoded) { decoded_default }
-          let(:encoded) { encoded_readable }
-          it_behaves_like "values"
+          rebase_classes proc { { to: to, readable: true } } do
+            let(:decoded) { decoded_default }
+            let(:encoded) { encoded_readable }
+            it_behaves_like "values", @with_accessors
+          end
         end
 
         context "converted" do
-          let(:klass) { rebase_class to: to, readable: true, convert: convert_name, deconvert: deconvert }
-          let(:decoded) { decoded_default }
-          let(:encoded) { encoded_convert_readable }
-          it_behaves_like "values"
+          rebase_classes proc { { to: to, readable: true, convert: convert_name, deconvert: deconvert } } do
+            let(:decoded) { decoded_default }
+            let(:encoded) { encoded_convert_readable }
+            it_behaves_like "values", @with_accessors
+          end
         end
       end
 
       context "from" do
         context "not converted" do
-          let(:klass) { rebase_class from: from, to: to, readable: true }
-          let(:decoded) { decoded_from }
-          let(:encoded) { encoded_readable }
-          it_behaves_like "values"
+          rebase_classes proc { { from: from, to: to, readable: true } } do
+            let(:decoded) { decoded_from }
+            let(:encoded) { encoded_readable }
+            it_behaves_like "values", @with_accessors
+          end
         end
 
         context "converted" do
-          let(:klass) { rebase_class from: from, to: to, readable: true, convert: convert_name, deconvert: deconvert }
-          let(:decoded) { decoded_from }
-          let(:encoded) { encoded_convert_readable }
-          it_behaves_like "values"
+          rebase_classes proc { { from: from, to: to, readable: true, convert: convert_name, deconvert: deconvert } } do
+            let(:decoded) { decoded_from }
+            let(:encoded) { encoded_convert_readable }
+            it_behaves_like "values", @with_accessors
+          end
         end
       end
     end
@@ -235,26 +276,27 @@ describe RebaseAttr::Generator do
     specify { expect { rebase_class(to: 33, readable: true) }.to raise_error(ArgumentError, "#rebase_attr does not allow :readable option with bases higher than 32, 33 given") }
 
     context "input" do
-      let(:klass) { rebase_class(to: 16) }
-      let(:instance) { klass.new }
+      rebase_classes proc { { to: 16 } } do
+        let(:instance) { klass.new }
 
-      describe "#encode" do
-        specify { expect { klass.encode_x(:a) }.to raise_error(TypeError, "decoded value must implement #to_i, :a given") }
-        specify { expect { instance.encode_x(:a) }.to raise_error(TypeError, "decoded value must implement #to_i, :a given") }
-      end
+        describe "#encode" do
+          specify { expect { klass.encode_x(:a) }.to raise_error(TypeError, "decoded value must implement #to_i, :a given") }
+          specify { expect { instance.encode_x(:a) }.to raise_error(TypeError, "decoded value must implement #to_i, :a given") }
+        end
 
-      describe "#decode" do
-        specify { expect { klass.decode_x(:a) }.to raise_error(TypeError, "encoded value must implement #to_i, :a given") }
-        specify { expect { instance.decode_x(:a) }.to raise_error(TypeError, "encoded value must implement #to_i, :a given") }
-      end
+        describe "#decode" do
+          specify { expect { klass.decode_x(:a) }.to raise_error(TypeError, "encoded value must implement #to_i, :a given") }
+          specify { expect { instance.decode_x(:a) }.to raise_error(TypeError, "encoded value must implement #to_i, :a given") }
+        end
 
-      describe "reader" do
-        before { instance.instance_eval { @x = :a } }
-        specify { expect { instance.x }.to raise_error(TypeError, "decoded value must implement #to_i, :a given") }
-      end
+        describe "reader" do
+          before { instance.instance_eval { @x = :a } }
+          specify { expect { instance.x }.to raise_error(TypeError, "decoded value must implement #to_i, :a given") }
+        end
 
-      describe "writer" do
-        specify { expect { instance.x = :a }.to raise_error(TypeError, "encoded value must implement #to_i, :a given") }
+        describe "writer" do
+          specify { expect { instance.x = :a }.to raise_error(TypeError, "encoded value must implement #to_i, :a given") }
+        end
       end
     end
   end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: rebase_attr
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Oded Niv
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-25 00:00:00.000000000 Z
+date: 2014-11-17 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: generate_method
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement