has_attributes 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3-p392

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/History.md

@@ -0,0 +1,4 @@
+0.0.1 / 2014-02-03
+==================
+
+* Initial commit

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Ben Reinhart
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,86 @@
+# has_attributes
+
+has_attributes is a ruby gem which provides a module for extending your classes with simple methods for creating elegant plain-ruby models.
+
+## API
+
+has_attributes delivers the following class and instance methods:
+
+#### .model_attributes() → Set
+
+An attribute accessor on the class that contains a set of attributes specified with `has_attributes`
+
+#### .has_attributes(*args) → nil
+
+Takes any number of symbols or strings and defines attribute accessors for those attributes. It also defines a `model_attributes` method on the class which will return the set of attributes. `has_attributes` will attempt to copy any existing attributes from the parent class unless the last argument is a `Hash` and contains an `inherit` key set to `false`.
+
+#### #attributes() → Hash
+
+Returns a hash whose keys are all the attributes declared `has_attributes` and the values are their corresponding values. If the values have not been set, the key will still be present in the hash but with a value of `nil`.
+
+#### #attributes=(attrs) → Hash
+
+Takes a hash `attrs` and sets all the attributes declared with `has_attributes` to either a corresponding value in `attrs` or `nil`.
+
+## Examples
+
+```ruby
+require 'has_attributes'
+
+class Person
+  include HasAttributes
+  has_attributes :first_name, :last_name
+end
+
+class President < Person
+  # invoked multiple times
+  has_attributes :party
+  has_attributes :term
+end
+
+class Student < Person
+  has_attributes :id, :major, inherit: false
+end
+
+Person.model_attributes # #<Set: {:first_name, :last_name}>
+President.model_attributes # #<Set: {:first_name, :last_name, :party, :term}>
+Student.model_attributes # #<Set: {:id, :major}>
+
+person = Person.new
+person.first_name = "John"
+person.last_name = "Smith"
+
+person.first_name # "John"
+person.last_name  # "Smith"
+
+person.attributes # {:first_name=>"John", :last_name=>"Smith"}
+
+president = President.new
+president.first_name = "Barack"
+president.last_name = "Obama"
+president.party = "democratic"
+president.term = "8 years"
+
+president.attributes # {:first_name=>"Barack", :last_name=>"Obama", :party=>"democratic", :term=>"8 years"}
+
+president.attributes = {}
+president.attributes # {}
+
+president.attributes = {:first_name=>"Barack", :last_name=>"Obama", :party=>"democratic", :term=>"8 years"}
+president.attributes # {:first_name=>"Barack", :last_name=>"Obama", :party=>"democratic", :term=>"8 years"}
+
+student = Student.new
+# Student did not inherit attributes from Person
+student.first_name = "lilly" # Exception: undefined method "first_name=" ...
+student.id = 123
+student.major = "CS"
+
+student.id    # 123
+student.major # "CS"
+
+student.attributes # {:id=>123, :major=>"CS"}
+```
+
+## License
+
+[MIT](https://github.com/benjreinhart/has_attributes/blob/master/LICENSE.txt)

data/Rakefile

@@ -0,0 +1,5 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/has_attributes.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'has_attributes/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "has_attributes"
+  spec.version       = HasAttributes::VERSION
+  spec.authors       = ["Ben Reinhart"]
+  spec.email         = ["benjreinhart@gmail.com"]
+  spec.summary       = %q{Better plain-ruby models}
+  spec.description   = %q{Extend your classes with simple methods for creating elegant plain-ruby models}
+  spec.homepage      = "https://github.com/benjreinhart/has_attributes"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/has_attributes/version.rb

@@ -0,0 +1,3 @@
+module HasAttributes
+  VERSION = "0.0.1"
+end

data/lib/has_attributes.rb

@@ -0,0 +1,50 @@
+require "has_attributes/version"
+require "set"
+
+module HasAttributes
+  def self.included(base)
+    base.class.send(:attr_accessor, :model_attributes)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def has_attributes(*attrs)
+      options = attrs.last.instance_of?(Hash) ? attrs.pop : {}
+      inherit_parent_attributes = options[:inherit] != false
+
+      parent_attributes = if superclass.respond_to?(:model_attributes) && superclass.model_attributes.is_a?(Set)
+        superclass.model_attributes.dup
+      else
+        Set.new
+      end
+
+      attrs = (model_attributes || Set.new).merge(attrs.map(&:to_sym))
+
+      if inherit_parent_attributes
+        attrs = parent_attributes.merge(attrs)
+      elsif !parent_attributes.empty?
+        methods_to_remove = parent_attributes.reduce([]) do |memo, getter|
+          setter = (getter.to_s << "=").to_sym
+          memo.push(getter) if public_method_defined?(getter)
+          memo.push(setter) if public_method_defined?(setter)
+          memo
+        end
+        instance_eval {undef_method *methods_to_remove}
+      end
+
+      self.model_attributes = attrs
+      instance_eval {attr_accessor *attrs}
+    end
+  end
+
+  def attributes=(attrs)
+    self.class.model_attributes.each {|attr| send((attr.to_s << "=").to_sym, attrs[attr])}
+    attributes
+  end
+
+  def attributes
+    self.class.model_attributes.reduce({}) do |memo, attr|
+      memo.merge(attr => send(attr))
+    end
+  end
+end

data/spec/has_attributes_spec.rb

@@ -0,0 +1,115 @@
+require 'has_attributes'
+
+describe HasAttributes do
+  def subclass_model(model, *attrs)
+    Class.new(model) do
+      include HasAttributes
+      has_attributes *attrs
+    end
+  end
+
+  def create_model(*attrs)
+    Class.new do
+      include HasAttributes
+      has_attributes *attrs
+    end
+  end
+
+  describe ".has_attributes" do
+    context "with a single class" do
+      let(:klass) { create_model :attr1, :attr2 }
+
+      it "adds the attributes to the model_attributes accessor" do
+        expect(klass.model_attributes).to eq(Set.new [:attr1, :attr2])
+      end
+
+      it "defines attributes accessors" do
+        expect(klass.public_method_defined?(:attr1)).to be_true
+        expect(klass.public_method_defined?(:attr1=)).to be_true
+
+        expect(klass.public_method_defined?(:attr2)).to be_true
+        expect(klass.public_method_defined?(:attr2=)).to be_true
+      end
+    end
+
+    context "when subclassing" do
+      let(:parent) { create_model :attr1, :attr2 }
+
+      context "when inheriting parent attributes" do
+        let(:child) { subclass_model parent, :attr3 }
+
+        it "adds the attributes of both parent and child to the model_attributes accessor" do
+          expect(child.model_attributes).to eq(Set.new [:attr1, :attr2, :attr3])
+        end
+
+        it "defines new accessors in addition to the parent accessors" do
+          expect(child.public_method_defined?(:attr1)).to be_true
+          expect(child.public_method_defined?(:attr1=)).to be_true
+
+          expect(child.public_method_defined?(:attr2)).to be_true
+          expect(child.public_method_defined?(:attr2=)).to be_true
+
+          expect(child.public_method_defined?(:attr3)).to be_true
+          expect(child.public_method_defined?(:attr3=)).to be_true
+        end
+      end
+
+      context "when not inheriting parent attributes" do
+        let(:child) { subclass_model parent, :attr3, inherit: false }
+
+        it "adds attributes of the child only to the model_attributes accessor" do
+          expect(child.model_attributes).to eq(Set.new [:attr3])
+        end
+
+        it "defines new accessors only" do
+          expect(child.public_method_defined?(:attr1)).to be_false
+          expect(child.public_method_defined?(:attr1=)).to be_false
+
+          expect(child.public_method_defined?(:attr2)).to be_false
+          expect(child.public_method_defined?(:attr2=)).to be_false
+
+          expect(child.public_method_defined?(:attr3)).to be_true
+          expect(child.public_method_defined?(:attr3=)).to be_true
+        end
+      end
+    end
+  end
+
+  describe "#attributes" do
+    let(:klass) { create_model :attr1, :attr2 }
+
+    it "sets a hash of attributes on the instance" do
+      instance = klass.new
+
+      instance.attributes = {attr1: true, attr2: false}
+
+      expect(instance.attr1).to be_true
+      expect(instance.attr2).to be_false
+
+      expect(instance.attributes).to eq(attr1: true, attr2: false)
+    end
+
+    it "overrides existing values" do
+      instance = klass.new
+      instance.attr1 = true
+
+      instance.attributes = {attr2: false}
+
+      expect(instance.attr1).to be_nil
+      expect(instance.attr2).to be_false
+
+      expect(instance.attributes).to eq(attr1: nil, attr2: false)
+    end
+
+    it "only sets attributes that were declared with .has_attributes" do
+      instance = klass.new
+
+      instance.attributes = {attr1: true, another_attr: false}
+
+      expect(instance.attr1).to be_true
+      expect(instance.attr2).to be_nil
+
+      expect(instance.attributes).to eq(attr1: true, attr2: nil)
+    end
+  end
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: has_attributes
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ben Reinhart
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Extend your classes with simple methods for creating elegant plain-ruby
+  models
+email:
+- benjreinhart@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .ruby-version
+- Gemfile
+- History.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- has_attributes.gemspec
+- lib/has_attributes.rb
+- lib/has_attributes/version.rb
+- spec/has_attributes_spec.rb
+homepage: https://github.com/benjreinhart/has_attributes
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Better plain-ruby models
+test_files:
+- spec/has_attributes_spec.rb