smart_properties 1.0.0

data/.gitignore

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

data/.yardopts

@@ -0,0 +1 @@
+--protected

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in smart_properties.gemspec
+gemspec
+
+gem "ruby_gntp"

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Konstantin Tennhard
+
+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,164 @@
+# SmartProperties
+
+Ruby accessors on steroids.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'smart_properties'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install smart_properties
+
+## Usage
+
+`SmartProperties` are meant to extend standard Ruby classes. Simply include
+the `SmartProperties` module and use the `property` method along with a name
+and optional configuration parameters to define new properties. Calling this
+method results in the generation of a getter and setter pair. In contrast to
+traditional Ruby accessors -- created by calling `attr_accessor`,
+`SmartProperties` provide much more functionality:
+
+1. input conversion,
+2. input validation,
+3. default values, and
+4. presence checking.
+
+These features can be configured by calling the `property` method with
+additional configuration parameters. The module also provides a default
+implementation for a constructor that accepts a set of attributes. This is
+comparable to the constructor of `ActiveRecord` objects.
+
+Before we discuss the configuration of properties in more detail, we first
+present a short synopsis of all the functionality provided by
+`SmartProperties`.
+
+### Synopsis
+
+The example below shows how to implement a class called `Message` which has
+three properties: `subject`, `body`, and `priority`. The two properties,
+`subject` and `priority`, are required whereas `body` is optional.
+Furthermore, all properties use input conversion. The `priority` property also
+uses validation and has a default value.
+
+    class Message
+      property :subject,  :converts => :to_s
+      
+      property :body,     :converts => :to_s
+      
+      property :priority, :converts => :to_sym, 
+                          :accepts  => [:low, :normal, :high],
+                          :default  => :normal
+                          :required => true
+    end
+    
+Creating an instance of this class without specifying any attributes will
+result in an `ArgumentError` telling you to specify the required property
+`subject`.
+
+    Message.new # => raises ArgumentError, "Message requires the property subject to be set"
+
+Providing the constructor with a title but with an invalid value for the
+property `priority` will also result in an `ArgumentError` telling you to
+provide a proper value for the property `priority`.
+
+    m = Message.new :subject => 'Lorem ipsum'
+    m.priority # => :normal
+    m.priority = :urgent # => raises ArgumentError, Message does not accept :urgent as value for the property priority
+
+Next, we discuss the various configuration options `SmartProperties` provide.
+
+### Property Configuration
+
+This subsection explains the various configuration options `SmartProperties`
+provide.
+
+#### Input conversion
+
+To automatically convert a given value for a property, you can use the
+`:converts` configuration parameter. The parameter can either be a `Symbol` or
+a `lambda` statement. Using a `Symbol` will instruct the setter to call the
+method identified by this symbol on the object provided as input data and take
+the result of this method call as value instead. The example below shows how
+to implement a property that automatically converts all given input to a
+`String` by calling `#to_s` on the object provided as input.
+
+    class Article
+      property :title, :converts => :to_s
+    end
+
+If you need more fine-grained control, you can use a lambda statement to
+specify how the conversion should be done. The statement will be evaluated in
+the context of the class defining the property and takes the given value as
+input. The example below shows how to implement a property that automatically
+converts all given input to a slug representation.
+
+    class Article
+      property :slug, :converts => lambda { |slug| slug.downcase.gsub(/\s+/, '-').gsub(/\W/, '') }
+    end
+
+#### Input validation
+
+To ensure that a given value for a property is always of a certain type, you
+can specify the `:accepts` configuration parameter. This will result in an
+automatic validation whenever the setter for a certain property is called. The
+example below shows how to implement a property which only accepts instances
+of type `String` as input.
+
+    class Article
+      property :title, :accepts => String
+    end
+
+Instead of using a class, you can also use a list of permitted values. The
+example below shows how to implement a property that only accepts `true` or
+`false` as values.
+
+    class Article
+      property :published, :accepts => [true, false]
+    end
+
+You can also use a `lambda` statement for input validation if a more complex
+validation procedure is required. The `lambda` statement is evaluated in the
+context of the class that defines the property and receives the given value as
+input. The example below shows how to implement a property called title that
+only accepts values which match the given regular expression.
+
+    class Article
+      property :title, :accepts => lambda { |title| /^Lorem \w+$/ =~ title }
+    end
+
+#### Default values
+
+There is also support for default values. Simply use the `:default`
+configuration parameter to configure a default value for a certain property.
+The example below demonstrates how to implement a property that has 42 as
+default value.
+
+    class Article
+      property :id, :default => 42
+    end
+
+#### Presence checking
+
+To ensure that a property is always set set and never `nil`, you can use the
+`:required` configuration parameter. If present, this parameter will instruct
+the setter of a property to not accept nil as input. The example below shows
+how to implement a property that may not be `nil`.
+
+    class Article
+      property :title, :required => true
+    end
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env rake
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+require 'yard'
+
+YARD::Rake::YardocTask.new do |t|
+  t.files   = ['lib/**/*.rb', 'README.md']
+end

data/lib/smart_properties.rb

@@ -0,0 +1,217 @@
+##
+# {SmartProperties} can be used to easily build more full-fledged accessors 
+# for standard Ruby classes. In contrast to regular accessors, 
+# {SmartProperties} support validation and conversion of input data, as well 
+# as, the specification of default values. Additionally, individual 
+# {SmartProperties} can be marked as required. This causes the runtime to
+# throw an +ArgumentError+ whenever a required property has not been
+# specified.
+#
+# In order to use {SmartProperties}, simply include the {SmartProperties} 
+# module and use the {ClassMethods#property} method to define properties.
+#
+# @see ClassMethods#property 
+#   More information on how to configure properties
+#
+# @example Definition of a property that makes use of all {SmartProperties} features.
+#
+#  property :language_code, :accepts => [:de, :en],
+#                           :converts => :to_sym,
+#                           :default  => :de,
+#                           :required => true
+#
+module SmartProperties
+  
+  VERSION = "1.0.0"
+  
+  class Property
+
+    attr_reader :name
+    attr_reader :default
+    attr_reader :converter
+    attr_reader :accepter
+
+    def initialize(name, attrs = {})
+      @name      = name.to_sym
+      @default   = attrs[:default]
+      @converter = attrs[:converts]
+      @accepter  = attrs[:accepts]
+      @required  = !!attrs[:required]
+    end
+
+    def required=(value)
+      @required = !!value
+    end
+
+    def required?
+      @required
+    end
+
+    def convert(value, scope)
+      return value unless converter
+
+      if converter.respond_to?(:call)
+        scope.instance_exec(value, &converter)
+      else
+        begin
+          value.send(:"#{converter}")
+        rescue NoMethodError
+          raise ArgumentError, "#{value.class.name} does not respond to ##{converter}"
+        end
+      end
+    end
+
+    def accepts?(value, scope)
+      return true unless value
+      return true unless accepter
+      
+      if accepter.kind_of?(Enumerable)
+        accepter.include?(value)
+      elsif !accepter.kind_of?(Proc)
+        accepter === value
+      else
+        !!scope.instance_exec(value, &accepter)
+      end
+    end
+    
+    def prepare(value, scope)
+      if required? && value.nil?
+        raise ArgumentError, "#{scope.class.name} requires the property #{self.name} to be set"
+      end
+
+      value = convert(value, scope) unless value.nil?
+
+      unless accepts?(value, scope)
+        raise ArgumentError, "#{scope.class.name} does not accept #{value.inspect} as value for the property #{self.name}"
+      end
+
+      @value = value
+    end
+    
+    def define(klass)
+      property = self
+      
+      scope = klass.instance_variable_get(:"@_smart_properties_method_scope") || begin
+        m = Module.new
+        klass.send(:include, m)
+        klass.instance_variable_set(:"@_smart_properties_method_scope", m)
+        m
+      end
+
+      scope.send(:attr_reader, name)
+      scope.send(:define_method, :"#{name}=") do |value|
+        instance_variable_set("@#{property.name}", property.prepare(value, self))
+      end
+    end
+
+  end
+  
+  module ClassMethods
+
+    ##
+    # Returns the list of smart properties that for this class. This 
+    # includes the properties than have been defined in the parent classes.
+    #
+    # @return [Array<Property>] The list of properties.
+    #
+    def properties
+      (@_smart_properties || {}).dup
+    end
+
+    ##
+    # Defines a new property from a name and a set of options. This results
+    # results in creating an accessor that has additional features:
+    #
+    # 1. Validation of input data by specifiying the +:accepts+ option:
+    #    If you use a class as value for this option, the setter will check
+    #    if the value it is about to assign is of this type. If you use an
+    #    array, the setter will check if the value it is about to assign is
+    #    included in this array. Finally, if you specify a block, it will
+    #    invoke the block with the value it is about to assign and check if
+    #    the block returns a thruthy value, meaning anything but +false+ and
+    #    +nil+.
+    #
+    # 2. Conversion of input data by specifiying the +:converts+ option:
+    #    If you use provide a symbol as value for this option, the setter will
+    #    invoke this method on the object it is about to assign and take the
+    #    result of this call instead. If you provide a block, it will invoke
+    #    the block with the value it is about to assign and take the result
+    #    of the block instead.
+    #
+    # 3. Providing a default value by specifiying the +:default+ option.
+    #
+    # 4. Forcing a property to be present by setting the +:required+ option
+    #    to true.
+    #
+    #
+    # @param [Symbol] name the name of the property
+    #
+    # @param [Hash] options the list of options used to configure the property
+    # @option options [Array, Class, Proc] :accepts
+    #   specifies how the validation is done
+    # @option options [Proc, Symbol] :converts
+    #   specifies how the conversion is done
+    # @option options :default
+    #   specifies the default value of the property
+    # @option options [true, false] :required
+    #   specifies whether or not this property is required
+    #
+    # @return [Property] The defined property.
+    #
+    # @example Definition of a property that makes use of all {SmartProperties} features.
+    #
+    #  property :language_code, :accepts => [:de, :en],
+    #                           :converts => :to_sym,
+    #                           :default  => :de,
+    #                           :required => true
+    #
+    def property(name, options = {})
+      @_smart_properties ||= begin        
+        parent = if self != SmartProperties
+          (ancestors[1..-1].find { |klass| klass.ancestors.include?(SmartProperties) && klass != SmartProperties })
+        end
+        
+        parent ? parent.properties : {}
+      end
+      
+      p = Property.new(name, options)
+      p.define(self)
+      
+      @_smart_properties[name] = p
+    end
+    protected :property
+
+  end
+  
+  class << self
+    
+    private
+    
+      ##
+      # Extends the class, which this module is included in, with a property 
+      # method to define properties.
+      #
+      # @param [Class] base the class this module is included in
+      #
+      def included(base)
+        base.extend(ClassMethods)
+      end
+    
+  end
+  
+  ##
+  # Implements a key-value enabled constructor that acts as default
+  # constructor for all {SmartProperties}-enabled classes.
+  #
+  # @param [Hash] attrs the set of attributes that is used for initialization
+  #
+  def initialize(attrs = {})
+    attrs ||= {}
+
+    self.class.properties.each do |_, property|
+      value = attrs.key?(property.name) ? attrs.delete(property.name) : property.default
+      send(:"#{property.name}=", value)
+    end
+  end
+
+end

data/smart_properties.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/smart_properties', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Konstantin Tennhard"]
+  gem.email         = ["me@t6d.de"]
+  gem.description   = <<-DESCRIPTION
+  SmartProperties are a more flexible and feature-rich alternative to
+  traditional Ruby accessors. They provide support for input conversion,
+  input validation, specifying default values and presence checking.
+  DESCRIPTION
+  gem.summary       = %q{SmartProperties – Ruby accessors on steroids}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "smart_properties"
+  gem.require_paths = ["lib"]
+  gem.version       = SmartProperties::VERSION
+  
+  gem.add_development_dependency "rspec", "~> 2.0"
+  gem.add_development_dependency "rake", "~> 0.8"
+  gem.add_development_dependency "yard", "~> 0.8"
+  gem.add_development_dependency "redcarpet", "~> 2.1"
+  gem.add_development_dependency "guard-rspec", "~> 0.7"
+end

data/spec/smart_properties_spec.rb

@@ -0,0 +1,325 @@
+require 'spec_helper'
+
+describe SmartProperties do
+
+  context "when extending an other class" do
+
+    subject do
+      Class.new.tap do |c|
+        c.send(:include, described_class)
+      end
+    end
+
+    it "should add a .property method" do
+      subject.should respond_to(:property)
+    end
+
+  end
+
+  context "when used to build a class that has a property called :title on a class" do
+    
+    subject do
+      title = Object.new.tap do |o|
+        def o.to_title; 'chunky'; end
+      end
+      
+      klass = Class.new.tap do |c|
+        c.send(:include, described_class)
+        c.instance_eval do
+          def name; "TestDummy"; end
+          
+          property :title, :accepts => String,
+                                 :converts => :to_title,
+                                 :required => true,
+                                 :default => title
+        end
+      end
+      
+      klass
+    end
+
+    context "instances of this class" do
+      
+      klass = subject.call
+      
+      subject do
+        klass.new
+      end
+      
+      it { should respond_to(:title) }
+      it { should respond_to(:title=) }
+      
+      it "should have 'chucky' as default value for title" do
+        subject.title.should be == 'chunky'
+      end
+      
+      it "should convert all values that are assigned to title into strings" do
+        subject.title = double(:to_title => 'bacon')
+        subject.title.should be == 'bacon'
+      end
+      
+      it "should not allow to set nil as title" do
+        expect { subject.title = nil }.to raise_error(ArgumentError, "TestDummy requires the property title to be set")
+      end
+      
+      it "should not allow to set objects as title that do not respond to #to_title" do
+        expect { subject.title = Object.new }.to raise_error(ArgumentError, "Object does not respond to #to_title")
+      end
+      
+      it "should not influence other instances that have been initialized with different attributes" do
+        other = klass.new :title => double(:to_title => 'Lorem ipsum')
+        
+        subject.title.should be == 'chunky'
+        other.title.should   be == 'Lorem ipsum'
+      end
+
+    end
+    
+    context "when subclassed and extended with a property called text" do
+      
+      superklass = subject.call
+      
+      subject do
+        Class.new(superklass).tap do |c|
+          c.instance_eval do
+            property :text
+          end
+        end
+      end
+      
+      context "instances of this subclass" do
+        
+        klass = subject.call
+        
+        subject do
+          klass.new
+        end
+        
+        it { should respond_to(:title) }
+        it { should respond_to(:title=) }
+        it { should respond_to(:text) }
+        it { should respond_to(:text=) }
+        
+      end
+      
+      context "instances of the super class" do
+        
+        subject do
+          superklass.new
+        end
+        
+        it { should_not respond_to(:text) }
+        it { should_not respond_to(:text=) }
+        
+      end
+      
+      context "instances of this subclass that have been intialized from a set of attributes" do
+        
+        klass = subject.call
+        
+        subject do
+          klass.new :title => stub(:to_title => 'Message'), :text => "Hello"
+        end
+        
+        it "should have the correct title" do
+          subject.title.should be == 'Message'
+        end
+        
+        it "should have the correct text" do
+          subject.text.should be == 'Hello'
+        end
+        
+      end
+      
+    end
+    
+    context "when extended with a :type property at runtime" do
+      
+      klass = subject.call
+      
+      subject do
+        klass.tap do |c|
+          c.instance_eval do
+            property :type, :converts => :to_sym
+          end
+        end
+      end
+      
+      context "instances of this class" do
+        
+        klass = subject.call
+        
+        subject do
+          klass.new :title => double(:to_title => 'Lorem ipsum')
+        end
+        
+        it { should respond_to(:type)  }
+        it { should respond_to(:type=) }
+        
+      end
+      
+      context "when subclassing this class" do
+        
+        superklass = subject.call
+        
+        subject do
+          Class.new(superklass)
+        end
+        
+        context "instances of this class" do
+          
+          klass = subject.call
+          
+          subject do
+            klass.new :title => double(:to_title => 'Lorem ipsum')
+          end
+          
+          it { should respond_to :title }
+          it { should respond_to :title= }
+          
+          it { should respond_to :type }
+          it { should respond_to :type= }
+          
+        end
+        
+      end
+      
+    end
+    
+  end
+  
+  context "when used to build a class that has a property called :title which a lambda statement for conversion" do
+    
+    subject do
+      Class.new.tap do |c|
+        c.send(:include, described_class)
+        c.instance_eval do
+          property :title, :converts => lambda { |t| "<title>#{t.to_s}</title>"}
+        end
+      end
+    end
+    
+    context "instances of this class" do
+      
+      klass = subject.call
+      
+      subject do
+        klass.new
+      end
+      
+      it "should convert the property title as specified the lambda statement" do
+        subject.title = "Lorem ipsum"
+        subject.title.should be == "<title>Lorem ipsum</title>"
+      end
+      
+    end
+    
+  end
+  
+  context "when used to build a class that has a property called :visible which uses an array of valid values for acceptance checking" do
+    
+    subject do
+      Class.new.tap do |c|
+        def c.name; "TestDummy"; end
+        
+        c.send(:include, described_class)
+        
+        c.instance_eval do
+          property :visible, :accepts => [true, false]
+        end
+      end
+    end
+    
+    context "instances of this class" do
+      
+      klass = subject.call
+
+      subject do
+        klass.new
+      end
+      
+      it "should allow to set true as value for visible" do
+        expect { subject.visible = true }.to_not raise_error
+      end
+      
+      it "should allow to set false as value for visible" do
+        expect { subject.visible = false }.to_not raise_error
+      end
+      
+      it "should not allow to set :maybe as value for visible" do
+        expect { subject.visible = :maybe }.to raise_error(ArgumentError, "TestDummy does not accept :maybe as value for the property visible")
+      end
+      
+    end
+    
+  end
+  
+  context 'when used to build a class that has a property called :license_plate which uses a lambda statement for accpetance checking' do
+    
+    subject do
+      Class.new.tap do |c|
+        def c.name; 'TestDummy'; end
+        
+        c.send(:include, described_class)
+        
+        c.instance_eval do
+          property :license_plate, :accepts => lambda { |v| /\w{1,2} \w{1,2} \d{1,4}/.match(v) }
+        end
+      end
+    end
+    
+    context 'instances of this class' do
+      
+      klass = subject.call
+      
+      subject do
+        klass.new
+      end
+      
+      it 'should not a accept "invalid" as value for license_plate' do
+        expect { subject.license_plate = "invalid" }.to raise_error(ArgumentError, 'TestDummy does not accept "invalid" as value for the property license_plate')
+      end
+      
+      it 'should accept "NE RD 1337" as license plate' do
+        expect { subject.license_plate = "NE RD 1337" }.to_not raise_error
+      end
+      
+    end
+    
+  end
+  
+  context 'when used to build a class that has a property called :text whose getter is overriden' do
+    
+    subject do
+      Class.new.tap do |c|
+        c.send(:include, described_class)
+        
+        c.instance_eval do
+          property :text, :default => 'Hello'
+        end
+        
+        c.class_eval do
+          def text
+            "<em>#{super}</em>"
+          end
+        end
+      end
+    end
+    
+    context "instances of this class" do
+      
+      klass = subject.call
+      
+      subject do
+        klass.new
+      end
+      
+      it "should return the accepted value for the property called :text" do
+        subject.text.should be == '<em>Hello</em>'
+      end
+      
+    end
+    
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'bundler/setup'
+require 'rspec'
+
+require 'smart_properties'
+
+Dir[File.join(File.dirname(__FILE__), 'support', '**', '*.rb')].each { |f| require f }
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: smart_properties
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Konstantin Tennhard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+description: ! "  SmartProperties are a more flexible and feature-rich alternative
+  to\n  traditional Ruby accessors. They provide support for input conversion,\n  input
+  validation, specifying default values and presence checking.\n"
+email:
+- me@t6d.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .yardopts
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/smart_properties.rb
+- smart_properties.gemspec
+- spec/smart_properties_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2007724824068192771
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 2007724824068192771
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: SmartProperties – Ruby accessors on steroids
+test_files:
+- spec/smart_properties_spec.rb
+- spec/spec_helper.rb
+has_rdoc: