yinum 2.0.2 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: df8ede855dacae3d39136e39fb7e2655a9250581
-  data.tar.gz: 5a6df32c4d26a9be9b395adc52455fc348b19208
+  metadata.gz: 8c450598a4dcf89038e0691a37b91587dc5fe9cf
+  data.tar.gz: 6fff7a2b55d125bd61fa1bae626fb58f9792edaf
 SHA512:
-  metadata.gz: 671e06737cdb207fd2fb6216a00a2cf0472d3b81e56fe86e79ce4a8c76182fbd852463e0e57599d4c1e40e9bf8ddad0f206bef89369a4d11f1f1ddeef16f2914
-  data.tar.gz: f73919ef6fc65ba2839288a2990da531845cdf564f98d619b091d03fa526f5493aada44eeb881ad3d1e1f450e8eff44702661348d4c5220854303fca7ec11b4b
+  metadata.gz: 0dd0e387e139a4a0b14ad32ac2fe60a171620ff7a56c0e2c65bdd8a5a5b11586dfa691c4cfda9c2cc020360e9c7ea5034cb57a1ad193e5a07739b144ac10659a
+  data.tar.gz: 8066897d9d060b68c3b10ab3e9b4a52f9965b5a8e5c954cbacae5828fbede143aca8c7eb3465d7dc8c15eb9d81781ed5ae27e2cdee9f7ab94ab42b0c64bbc4c9

data/.gitignore

@@ -3,7 +3,6 @@
 *.sassc
 .sass-cache
 capybara-*.html
-.rspec
 /.bundle
 /vendor/bundle
 /log/*

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+**2.1.0**
+* Use generate_method in attr_enum. This is backward incompatible for using
+  attr_enum on accessors defined on the class level. Use modules.
+
 **2.0.0**
 * Use `#alias_attr` instead of calling super in `Enum::Helpers::EnumAttribute`.
 * Allow valueless enums (given with `Array` instead of `Hash`), that map to the

data/Gemfile.lock

@@ -1,12 +1,14 @@
 PATH
   remote: .
   specs:
-    yinum (2.0.2)
+    yinum (2.1.0)
+      generate_method (~> 1.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
     diff-lcs (1.2.5)
+    generate_method (1.0.0)
     nil_or (2.0.0)
     rspec (2.14.1)
       rspec-core (~> 2.14.0)

data/README.md

@@ -104,7 +104,11 @@ Generating enum attribute methods for your class:
 
 ```ruby
 class Car
-  attr_accessor :color
+  module Colorful
+    attr_accessor :color # using attr_accessor on Car will create methods with higher priority than attr_enum.
+  end
+  include Colorful
+
   attr_enum :color, :COLORS, :red => 1, :black => 2
 end
 car = Car.new
@@ -124,7 +128,11 @@ If this is a defining attribute for the class, add `:qualifier => true` to gener
 
 ```ruby
 class Car
-  attr_accessor :color
+  module Colorful
+    attr_accessor :color # using attr_accessor on Car will create methods with higher priority than attr_enum.
+  end
+  include Colorful
+
   attr_enum :color, :COLORS, { :qualifier => true }, :red => 1, :black => 2
 end
 car = Car.new

data/lib/enum/helpers/enum_attribute.rb

@@ -1,4 +1,5 @@
 require 'enum/helpers/enum_generator'
+require 'generate_method'
 
 module Enum::Helpers::EnumAttribute
   include Enum::Helpers::EnumGenerator
@@ -18,38 +19,30 @@ module Enum::Helpers::EnumAttribute
       yinum name_or_enum, hash if hash.any?
       e = const_get(name_or_enum)
     end
-    # attribute reader
-    reader, reader_without_enum = attr, :"#{attr}_without_enum"
-    begin
-      alias_method reader_without_enum, reader
-    rescue NameError # reader does not exist
-      no_reader = true
-    end
-    define_method(reader) do
-      v = no_reader ? super() : send(reader_without_enum)
-      (ev = e.get(v)).nil? ? Enum::EnumValue.new(e, v) : ev
-    end
-    # attribute writer
-    writer, writer_without_enum = :"#{attr}=", :"#{attr}_without_enum="
-    begin
-      alias_method writer_without_enum, writer
-    rescue NameError # writer does not exist
-      no_writer = true
-    end
-    define_method(writer) do |v|
-      v = case
-            when v.enum_value? then v.value
-            # might be received from forms
-            when v.nil?, v == "" then v
-            else e[v].value
-          end
-      no_writer ? super(v) : send(writer_without_enum, v)
-    end
+    generate_methods overrider: :enum do
+      # attribute reader
+      reader, reader_without_enum = attr, :"#{attr}_without_enum"
+      define_method(reader) do
+        v = respond_to?(reader_without_enum) ? send(reader_without_enum) : super()
+        (ev = e.get(v)).nil? ? Enum::EnumValue.new(e, v) : ev
+      end
+      # attribute writer
+      writer, writer_without_enum = :"#{attr}=", :"#{attr}_without_enum="
+      define_method(writer) do |v|
+        v = case
+              when v.enum_value? then v.value
+              # might be received from forms
+              when v.nil?, v == "" then v
+              else e[v].value
+            end
+        respond_to?(writer_without_enum) ? send(writer_without_enum, v) : super(v)
+      end
 
-    if options[:qualifier]
-      # generating scopes and questioning methods
-      e.by_name.each do |n, ev|
-        define_method("#{n}?") { send(attr) == ev }
+      if options[:qualifier]
+        # generating scopes and questioning methods
+        e.by_name.each do |n, ev|
+          define_method("#{n}?") { send(attr) == ev }
+        end
       end
     end
 

data/lib/enum/version.rb

@@ -1,3 +1,3 @@
 class Enum
-  VERSION = '2.0.2'
+  VERSION = '2.1.0'
 end

data/spec/lib/enum/enum_value_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 class I18n
   def self.t(path, scope: nil, default: nil)
     "#{scope}.#{path}"

data/spec/lib/enum/helpers/common_specs.rb

@@ -18,51 +18,51 @@ shared_examples_for Enum::Helpers::EnumGenerator do
   its(:by_name) { should == { :red => 1, :blue => 2 } }
 end
 
-shared_examples_for Enum::Helpers::EnumAttribute do
+shared_examples_for Enum::Helpers::EnumAttribute do |attribute = :color|
   subject(:record) { klass.new }
-  before { record.instance_eval { @color = :unknown } }
+  before { record.instance_variable_set("@#{attribute}", :unknown) }
 
   describe "setter" do
     context "nil" do
-      before { record.color = nil }
-      specify { record.instance_eval { @color }.should be_nil }
-      specify { record.instance_eval { @color }.should_not be_enum_value }
+      before { record.send(:"#{attribute}=", nil) }
+      specify { record.instance_variable_get("@#{attribute}").should be_nil }
+      specify { record.instance_variable_get("@#{attribute}").should_not be_enum_value }
     end
 
     context "name" do
-      before { record.color = :red }
-      specify { record.instance_eval { @color }.should == 1 }
-      specify { record.instance_eval { @color }.should_not be_enum_value }
+      before { record.send(:"#{attribute}=", :red) }
+      specify { record.instance_variable_get("@#{attribute}").should == 1 }
+      specify { record.instance_variable_get("@#{attribute}").should_not be_enum_value }
     end
 
     context "value" do
-      before { record.color = 2 }
-      specify { record.instance_eval { @color }.should == 2 }
-      specify { record.instance_eval { @color }.should_not be_enum_value }
+      before { record.send(:"#{attribute}=", 2) }
+      specify { record.instance_variable_get("@#{attribute}").should == 2 }
+      specify { record.instance_variable_get("@#{attribute}").should_not be_enum_value }
     end
 
     specify "invalid" do
-      expect { @record.color = 3 }.to raise_error(StandardError)
+      expect { record.send(:"#{attribute}=", 3) }.to raise_error(StandardError, /does not know/)
     end
   end
 
   describe "getter" do
     context "nil" do
-      before { record.instance_eval { @color = nil } }
-      specify { record.color.should be_nil }
-      specify { record.color.should be_enum_value }
+      before { record.instance_variable_set("@#{attribute}", nil) }
+      specify { record.send(attribute).should be_nil }
+      specify { record.send(attribute).should be_enum_value }
     end
 
     context "value" do
-      before { record.instance_eval { @color = 2 } }
-      specify { record.color.should be_blue }
-      specify { record.color.should be_enum_value }
+      before { record.instance_variable_set("@#{attribute}", 2) }
+      specify { record.send(attribute).should be_blue }
+      specify { record.send(attribute).should be_enum_value }
     end
 
     context "invalid" do
-      before { record.instance_eval { @color = 3 } }
-      specify { record.color.should == 3 }
-      specify { record.color.should be_enum_value }
+      before { record.instance_variable_set("@#{attribute}", 3) }
+      specify { record.send(attribute).should == 3 }
+      specify { record.send(attribute).should be_enum_value }
     end
   end
 end

data/spec/lib/enum/helpers/enum_attribute_spec.rb

@@ -1,43 +1,55 @@
-require 'spec_helper'
 require 'lib/enum/helpers/common_specs'
 
 class EnumAttributeUser < EnumUserBase
   extend Enum::Helpers::EnumAttribute
+
+  def method_missing(method_name, *attributes, &block)
+    case method_name
+      when :color2  then @color2
+      when :color2= then @color2 = attributes.first
+      else super
+    end
+  end
 end
 
 describe Enum::Helpers::EnumAttribute do
   subject(:klass) { EnumAttributeUser.create_class }
 
-  context "not qualifier" do
-    before { klass.attr_enum(:color, :COLORS, :red => 1, :blue => 2) }
+  shared_examples_for "attr_enum" do |attribute|
+    context "not qualifier" do
+      before { klass.attr_enum(attribute, :COLORS, :red => 1, :blue => 2) }
 
-    it_behaves_like Enum::Helpers::EnumGenerator
-    it_behaves_like Enum::Helpers::EnumAttribute
-  end
+      it_behaves_like Enum::Helpers::EnumGenerator
+      it_behaves_like Enum::Helpers::EnumAttribute, attribute
+    end
 
-  context "qualifier" do
-    before { klass.attr_enum(:color, :COLORS, { :qualifier => true }, :red => 1, :blue => 2) }
+    context "qualifier" do
+      before { klass.attr_enum(attribute, :COLORS, { :qualifier => true }, :red => 1, :blue => 2) }
 
-    it_behaves_like Enum::Helpers::EnumGenerator
-    it_behaves_like Enum::Helpers::EnumAttribute
+      it_behaves_like Enum::Helpers::EnumGenerator
+      it_behaves_like Enum::Helpers::EnumAttribute, attribute
 
-    context "questions" do
-      subject(:record) { klass.new }
-      before { record.color = :red }
+      context "questions" do
+        subject(:record) { klass.new }
+        before { record.send(:"#{attribute}=", :red) }
 
-      it { should be_red }
-      it { should_not be_blue }
+        it { should be_red }
+        it { should_not be_blue }
+      end
     end
-  end
 
-  context "use another enum" do
-    before do
-      klass.attr_enum(:color, :COLORS, { :qualifier => true }, :red => 1, :blue => 2)
-      another_klass = EnumAttributeUser.create_class(:AnotherEnumAttributeUser)
-      another_klass.attr_enum(:color, klass::COLORS)
-    end
+    context "use another enum" do
+      before do
+        klass.attr_enum(attribute, :COLORS, { :qualifier => true }, :red => 1, :blue => 2)
+        another_klass = EnumAttributeUser.create_class(:AnotherEnumAttributeUser)
+        another_klass.attr_enum(attribute, klass::COLORS)
+      end
 
-    it_behaves_like Enum::Helpers::EnumGenerator
-    it_behaves_like Enum::Helpers::EnumAttribute
+      it_behaves_like Enum::Helpers::EnumGenerator
+      it_behaves_like Enum::Helpers::EnumAttribute, attribute
+    end
   end
+
+  it_behaves_like "attr_enum", :color
+  it_behaves_like "attr_enum", :color2
 end

data/spec/lib/enum/helpers/enum_column_spec.rb

@@ -1,4 +1,3 @@
-require 'spec_helper'
 require 'lib/enum/helpers/common_specs'
 
 class EnumColumnUser < EnumUserBase

data/spec/lib/enum/helpers/enum_generator_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe Enum::Helpers::EnumGenerator do
   let(:klass) { EnumUserBase.create_class }
   before { klass.enum(:COLORS, :red => 1, :blue => 2) }

data/spec/lib/enum_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe Enum do
   describe "accessors" do
     subject(:enum) { Enum.new(:MY_COLORS, :red => 1, :blue => 2) }

data/yinum.gemspec

@@ -1,24 +1,25 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "enum/version"
 
-Gem::Specification.new do |s|
-  s.name        = "yinum"
-  s.version     = Enum::VERSION
-  s.authors     = ["Oded Niv"]
-  s.email       = ["oded.niv@gmail.com"]
-  s.homepage    = "https://github.com/odedniv/enum"
-  s.summary     = %q{Enum implementation}
-  s.description = %q{Yummy implementation of enum that gives integer values with a special wrapping.}
-  s.license     = 'UNLICENSE'
+Gem::Specification.new do |spec|
+  spec.name          = "yinum"
+  spec.version       = Enum::VERSION
+  spec.authors       = ["Oded Niv"]
+  spec.email         = ["oded.niv@gmail.com"]
+  spec.summary       = %q{Enum implementation}
+  spec.description   = %q{Yummy implementation of enum that gives integer values with a special wrapping.}
+  spec.homepage      = "https://github.com/odedniv/enum"
+  spec.license       = "UNLICENSE"
 
-  s.rubyforge_project = "yinum"
+  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"]
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  spec.add_runtime_dependency "generate_method", "~> 1.0"
 
-  s.add_development_dependency 'rspec', '~> 2.0'
-  s.add_development_dependency 'nil_or', '~> 2.0'
+  spec.add_development_dependency "rspec", "~> 2.0"
+  spec.add_development_dependency "nil_or", "~> 2.0"
 end

metadata

@@ -1,41 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: yinum
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.1.0
 platform: ruby
 authors:
 - Oded Niv
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-31 00:00:00.000000000 Z
+date: 2014-11-20 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: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
   name: nil_or
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ~>
       - !ruby/object:Gem::Version
         version: '2.0'
 description: Yummy implementation of enum that gives integer values with a special
@@ -46,7 +60,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
+- .gitignore
+- .rspec
 - CHANGELOG.md
 - Gemfile
 - Gemfile.lock
@@ -79,17 +94,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: yinum
-rubygems_version: 2.2.0
+rubyforge_project: 
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Enum implementation