attr_required 0.0.1 → 0.0.2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    attr_required (0.0.1)
+    attr_required (0.0.2)
 
 GEM
   specs:

data/README.rdoc

@@ -1,15 +1,57 @@
 = attr_required
 
-Provide attr_required with presence validation
+Provide attr_required and attr_optional
 
 == Installation
 
   gem install attr_required
 
-== Resources
-
 == Usage
 
+Include <code>AttrRequired</code>, and use <code>attr_required</code> like <code>attr_accessor</code>
+
+# Attributes Definitions
+
+  class A
+    include AttrRequired, AttrOptional
+    attr_required :required_a
+    attr_optional :optional_a
+  end
+
+  class B < A
+    attr_required :required_b
+    attr_optional :optional_b
+  end
+
+# Class Methods
+
+  A.required_attributes #=> [:required_a]
+  B.required_attributes #=> [:required_a, :required_b]
+  A.required_attributes #=> [:optional_a]
+  B.required_attributes #=> [:optional_a, :optional_b]
+
+# Instance Methods
+
+  @a = A.new
+  @b = B.new
+
+  @a.required_attributes #=> [:required_a]
+  @b.required_attributes #=> [:required_a, :required_b]
+  @a.optional_attributes #=> [:optional_a]
+  @b.optional_attributes #=> [:optional_a, :optional_b]
+
+  @a.attr_required?(:required_a) #=> true
+  @a.attr_optional?(:optiona_a)  #=> true
+  @a.attr_missing? #=> true
+  @a.attr_missing  #=> [:required_a]
+  @a.attr_missing! #=> raise AttrRequired::AttrMissing
+  @a.required_a = "foo"
+  @a.attr_missing? #=> false
+  @a.attr_missing  #=> []
+  @a.attr_missing! #=> do nothing
+
+Check spec/attr_(required|optional).rb for more details.
+
 == Note on Patches/Pull Requests
  
 * Fork the project.

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/attr_required.gemspec

@@ -3,8 +3,8 @@ Gem::Specification.new do |s|
   s.version = File.read("VERSION")
   s.required_rubygems_version = Gem::Requirement.new(">= 1.3.6") if s.respond_to? :required_rubygems_version=
   s.authors = ["nov matake"]
-  s.description = %q{Provide attr_required with presence validation}
-  s.summary = %q{Provide attr_required with presence validation}
+  s.description = %q{attr_required and attr_optional}
+  s.summary = %q{attr_required and attr_optional}
   s.email = "nov@matake.jp"
   s.extra_rdoc_files = ["LICENSE", "README.rdoc"]
   s.rdoc_options = ["--charset=UTF-8"]

data/lib/attr_optional.rb

@@ -0,0 +1,45 @@
+module AttrOptional
+
+  def self.included(klass)
+    klass.send :include, Includable
+    klass.send :extend, Extendable
+  end
+
+  module Extendable
+
+    def inherited(klass)
+      super
+      unless optional_attributes.empty?
+        klass.attr_optional *optional_attributes
+      end
+    end
+
+    def attr_optional(*keys)
+      @optional_attributes ||= []
+      @optional_attributes += Array(keys)
+      attr_accessor *keys
+    end
+
+    def attr_optional?(key)
+      optional_attributes.include?(key)
+    end
+
+    def optional_attributes
+      Array(@optional_attributes)
+    end
+
+  end
+
+  module Includable
+
+    def optional_attributes
+      self.class.optional_attributes
+    end
+
+    def attr_optional?(key)
+      self.class.attr_optional? key
+    end
+
+  end
+
+end

data/lib/attr_required.rb

@@ -1,59 +1,68 @@
 module AttrRequired
+
   class AttrMissing < StandardError; end
 
   def self.included(klass)
-    class << klass
+    klass.send :include, Includable
+    klass.send :extend, Extendable
+  end
 
-      def attr_required(*keys)
-        @required_attributes ||= []
-        @required_attributes += Array(keys)
-        attr_accessor *keys
-      end
+  module Extendable
 
-      def attr_required?(key)
-        required_attributes.include?(key)
+    def inherited(klass)
+      super
+      unless required_attributes.empty?
+        klass.attr_required *required_attributes
       end
+    end
 
-      def required_attributes
-        Array(@required_attributes)
-      end
+    def attr_required(*keys)
+      @required_attributes ||= []
+      @required_attributes += Array(keys)
+      attr_accessor *keys
+    end
 
-      def inherited(subclass)
-        unless required_attributes.empty?
-          subclass.attr_required *required_attributes
-        end
-      end
+    def attr_required?(key)
+      required_attributes.include?(key)
+    end
 
+    def required_attributes
+      Array(@required_attributes)
     end
-  end
 
-  def required_attributes
-    self.class.required_attributes
   end
 
-  def attr_required?(key)
-    self.class.attr_required? key
-  end
+  module Includable
 
-  def attr_missing?
-    !attr_missing.empty?
-  end
+    def required_attributes
+      self.class.required_attributes
+    end
 
-  def attr_missing!
-    if attr_missing?
-      raise AttrMissing.new("'#{attr_missing.join('\', \'')}' required.")
+    def attr_required?(key)
+      self.class.attr_required? key
+    end
+
+    def attr_missing?
+      !attr_missing.empty?
     end
-  end
 
-  def attr_missing
-    required_attributes.select do |key|
-      value = send(key)
-      if value.respond_to?(:empty?)
-        value.empty?
-      else
-        value.nil?
+    def attr_missing!
+      if attr_missing?
+        raise AttrMissing.new("'#{attr_missing.join('\', \'')}' required.")
       end
     end
+
+    def attr_missing
+      required_attributes.select do |key|
+        value = send(key)
+        if value.respond_to?(:empty?)
+          value.empty?
+        else
+          value.nil?
+        end
+      end
+    end
+
   end
 
 end

data/spec/attr_optional_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper.rb'
+
+describe AttrOptional, '.attr_optional' do
+  before do
+    @a, @b = A.new, B.new
+  end
+
+  it 'should define accessible attributes' do
+    @a.should respond_to(:attr_optional_a)
+    @a.should respond_to(:attr_optional_a=)
+    @b.should respond_to(:attr_optional_b)
+    @b.should respond_to(:attr_optional_b=)
+  end
+
+  it 'should be inherited' do
+    @b.should respond_to(:attr_optional_a)
+    @b.should respond_to(:attr_optional_a=)
+  end
+end
+
+describe AttrOptional, '.attr_optional?' do
+  it 'should answer whether the attributes is optional or not' do
+    A.attr_optional?(:attr_optional_a).should be_true
+    B.attr_optional?(:attr_optional_a).should be_true
+    B.attr_optional?(:attr_optional_b).should be_true
+    B.attr_optional?(:to_s).should be_false
+  end
+end
+
+describe AttrOptional, '#attr_optional?' do
+  before do
+    @a, @b = A.new, B.new
+  end
+
+  it 'should answer whether the attributes is optional or not' do
+    @a.attr_optional?(:attr_optional_a).should be_true
+    @b.attr_optional?(:attr_optional_a).should be_true
+    @b.attr_optional?(:attr_optional_b).should be_true
+    @b.attr_optional?(:to_s).should be_false
+  end
+end
+
+describe AttrOptional, '.optional_attributes' do
+  it 'should return all optional attributes keys' do
+    A.optional_attributes.should == [:attr_optional_a]
+    B.optional_attributes.should == [:attr_optional_a, :attr_optional_b]
+  end
+end
+
+describe AttrOptional, '#optional_attributes' do
+  before do
+    @a, @b = A.new, B.new
+  end
+
+  it 'should return optional attributes keys' do
+    @a.optional_attributes.should == [:attr_optional_a]
+    @b.optional_attributes.should == [:attr_optional_a, :attr_optional_b]
+  end
+end

data/spec/attr_required_spec.rb

@@ -1,37 +1,28 @@
 require 'spec_helper.rb'
 
-class A
-  include AttrRequired
-  attr_required :attr_a
-end
-
-class B < A
-  attr_required :attr_b
-end
-
 describe AttrRequired, '.attr_required' do
   before do
     @a, @b = A.new, B.new
   end
 
   it 'should define accessible attributes' do
-    @a.should respond_to(:attr_a)
-    @a.should respond_to(:attr_a=)
-    @b.should respond_to(:attr_b)
-    @b.should respond_to(:attr_b=)
+    @a.should respond_to(:attr_required_a)
+    @a.should respond_to(:attr_required_a=)
+    @b.should respond_to(:attr_required_b)
+    @b.should respond_to(:attr_required_b=)
   end
 
   it 'should be inherited' do
-    @b.should respond_to(:attr_a)
-    @b.should respond_to(:attr_a=)
+    @b.should respond_to(:attr_required_a)
+    @b.should respond_to(:attr_required_a=)
   end
 end
 
 describe AttrRequired, '.attr_required?' do
   it 'should answer whether the attributes is required or not' do
-    A.attr_required?(:attr_a).should be_true
-    B.attr_required?(:attr_a).should be_true
-    B.attr_required?(:attr_b).should be_true
+    A.attr_required?(:attr_required_a).should be_true
+    B.attr_required?(:attr_required_a).should be_true
+    B.attr_required?(:attr_required_b).should be_true
     B.attr_required?(:to_s).should be_false
   end
 end
@@ -42,9 +33,10 @@ describe AttrRequired, '#attr_required?' do
   end
 
   it 'should answer whether the attributes is required or not' do
-    @a.attr_required?(:attr_a).should be_true
-    @b.attr_required?(:attr_a).should be_true
-    @b.attr_required?(:attr_b).should be_true
+    @a.attr_required?(:attr_required_a).should be_true
+    @b.attr_required?(:attr_required_a).should be_true
+    @b.attr_required?(:attr_required_b).should be_true
+    @a.attr_required?(:attr_required_b).should be_false
     @b.attr_required?(:to_s).should be_false
   end
 end
@@ -57,11 +49,11 @@ describe AttrRequired, '#attr_missing?' do
   it 'should answer whether any attributes are missing' do
     @a.attr_missing?.should be_true
     @b.attr_missing?.should be_true
-    @a.attr_a = 'attr_a'
-    @b.attr_a = 'attr_a'
+    @a.attr_required_a = 'attr_required_a'
+    @b.attr_required_a = 'attr_required_a'
     @a.attr_missing?.should be_false
     @b.attr_missing?.should be_true
-    @b.attr_b = 'attr_b'
+    @b.attr_required_b = 'attr_required_b'
     @b.attr_missing?.should be_false
   end
 end
@@ -74,44 +66,44 @@ describe AttrRequired, '#attr_missing!' do
   it 'should raise AttrMissing error when any attributes are missing' do
     lambda { @a.attr_missing! }.should raise_error(AttrRequired::AttrMissing)
     lambda { @b.attr_missing! }.should raise_error(AttrRequired::AttrMissing)
-    @a.attr_a = 'attr_a'
-    @b.attr_a = 'attr_a'
+    @a.attr_required_a = 'attr_required_a'
+    @b.attr_required_a = 'attr_required_a'
     lambda { @a.attr_missing! }.should_not raise_error(AttrRequired::AttrMissing)
     lambda { @b.attr_missing! }.should raise_error(AttrRequired::AttrMissing)
-    @b.attr_b = 'attr_b'
+    @b.attr_required_b = 'attr_required_b'
     lambda { @b.attr_missing! }.should_not raise_error(AttrRequired::AttrMissing)
   end
 end
 
-describe AttrRequired, '.required_attributes' do
-  it 'should return all required attributes keys' do
-    A.required_attributes.should == [:attr_a]
-    B.required_attributes.should == [:attr_a, :attr_b]
-  end
-end
-
-describe AttrRequired, '#required_attributes' do
+describe AttrRequired, '#attr_missing' do
   before do
     @a, @b = A.new, B.new
   end
 
-  it 'should return required attributes keys' do
-    @a.required_attributes.should == [:attr_a]
-    @b.required_attributes.should == [:attr_a, :attr_b]
+  it 'should return missing attributes keys' do
+    @a.attr_missing.should == [:attr_required_a]
+    @b.attr_missing.should == [:attr_required_a, :attr_required_b]
+    @a.attr_required_a = 'attr_required_a'
+    @b.attr_required_a = 'attr_required_a'
+    @a.attr_missing.should == []
+    @b.attr_missing.should == [:attr_required_b]
   end
 end
 
-describe AttrRequired, '#attr_missing' do
+describe AttrRequired, '.required_attributes' do
+  it 'should return all required attributes keys' do
+    A.required_attributes.should == [:attr_required_a]
+    B.required_attributes.should == [:attr_required_a, :attr_required_b]
+  end
+end
+
+describe AttrRequired, '#required_attributes' do
   before do
     @a, @b = A.new, B.new
   end
 
-  it 'should return missing attributes keys' do
-    @a.attr_missing.should == [:attr_a]
-    @b.attr_missing.should == [:attr_a, :attr_b]
-    @a.attr_a = 'attr_a'
-    @b.attr_a = 'attr_a'
-    @a.attr_missing.should == []
-    @b.attr_missing.should == [:attr_b]
+  it 'should return required attributes keys' do
+    @a.required_attributes.should == [:attr_required_a]
+    @b.required_attributes.should == [:attr_required_a, :attr_required_b]
   end
 end

data/spec/spec_helper.rb

@@ -2,4 +2,16 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 require 'attr_required'
-require 'rspec'
+require 'attr_optional'
+require 'rspec'
+
+class A
+  include AttrRequired, AttrOptional
+  attr_required :attr_required_a
+  attr_optional :attr_optional_a
+end
+
+class B < A
+  attr_required :attr_required_b
+  attr_optional :attr_optional_b
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: attr_required
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - nov matake
@@ -62,7 +62,7 @@ dependencies:
         version: "2"
   type: :development
   version_requirements: *id003
-description: Provide attr_required with presence validation
+description: attr_required and attr_optional
 email: nov@matake.jp
 executables: []
 
@@ -81,7 +81,9 @@ files:
 - Rakefile
 - VERSION
 - attr_required.gemspec
+- lib/attr_optional.rb
 - lib/attr_required.rb
+- spec/attr_optional_spec.rb
 - spec/attr_required_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true
@@ -119,7 +121,8 @@ rubyforge_project:
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Provide attr_required with presence validation
+summary: attr_required and attr_optional
 test_files: 
+- spec/attr_optional_spec.rb
 - spec/attr_required_spec.rb
 - spec/spec_helper.rb