activeoopish 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 256e008c0ef28562a42f0b9250ddfa37096abd72
+  data.tar.gz: e1e3b3fefbd6db22dfd6049b92d5918299111b0a
+SHA512:
+  metadata.gz: bf0203fca919d91c95e622300bb53ea52c960ab2477893651173c23113337a844959a6f070ec6f7e40d4dce8ffe9f60822420f589e3850851cee5138f70dae28
+  data.tar.gz: bd3eee6bfba42b3e75d5b7150d846e29959746af601868da40a203ec3d93fac963c3eb0741b80594ec5fece2929d318cbff479754bb779da5929eb6956b4dd9d

data/.gitignore

@@ -0,0 +1,34 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/.rspec

@@ -0,0 +1,3 @@
+-f doc
+--colour
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+- 2.0.0

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in activeoopish.gemspec
+gemspec
+
+group :test do
+  gem 'coveralls', require: false
+end

data/README.md

@@ -0,0 +1,72 @@
+# AvtiveOOPish
+
+[![Build Status](https://travis-ci.org/yuku-t/activeoopish.svg?branch=master)](https://travis-ci.org/yuku-t/activeoopish) [![Code Climate](https://codeclimate.com/github/yuku-t/activeoopish/badges/gpa.svg)](https://codeclimate.com/github/yuku-t/activeoopish) [![Coverage Status](https://coveralls.io/repos/yuku-t/activeoopish/badge.svg)](https://coveralls.io/r/yuku-t/activeoopish) [![Dependency Status](https://gemnasium.com/yuku-t/activeoopish.svg)](https://gemnasium.com/yuku-t/activeoopish)
+
+Simple tools for better OOP in Rails projects.
+
+## ActiveOOPish::Validator
+
+Encapsulates the responsibility of validating a model into a validator.
+
+```rb
+class BookValidator < ActiveOOPish::Validator
+  declear do
+    validates :author, presence: true
+
+    validates :title, length: { minimum: 3, maximum: 255 }
+
+    validate :title_must_include_author_name, if: :biography?
+  end
+
+  def title_must_include_author_name(book)
+    unless book.title.include?(book.author.name)
+      book.errors.add(:author, "cannot write a biography for other people")
+    end
+  end
+
+  def biography?(book)
+    book.category == :biography
+  end
+end
+
+class Book < ActiveRecord::Base
+  belongs_to :author, class_name: 'User'
+
+  BookValidator.monitor(self)
+end
+```
+
+### RSpec
+
+```rb
+require 'activeoopish/rspec'
+require 'shoulda-matchers'
+
+declear BookValidator, :with_activeoopish_helper do
+  include_context 'describe declaration' do
+    it { should validate_presence_of(:author) }
+
+    it { should validate_length_of(:title).is_at_least(3).is_at_most(255) }
+
+    context 'when #biography? returns true' do
+      before do
+        allow_any_instance_of(described_class).to receive(:biography?).and_return(true)
+      end
+
+      it 'calls #title_must_include_author_name' do
+        expect_any_instance_of(described_class)
+          .to receive(:title_must_include_author_name).with(subject).once
+        subject.valid?
+      end
+    end
+  end
+
+  describe '#biography?' do
+    # ...
+  end
+
+  describe '#title_must_include_author_name' do
+    # ...
+  end
+end
+```

data/Rakefile

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

data/activeoopish.gemspec

@@ -0,0 +1,24 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "activeoopish/version"
+
+Gem::Specification.new do |spec|
+  spec.name            = 'activeoopish'
+  spec.version         = ActiveOOPish::VERSION
+  spec.authors         = ['Yuku Takahashi']
+  spec.email           = ['yuku@qiita.com']
+  spec.summary         = 'Simple OOP-ish tools for Rails'
+  spec.homepage        = 'https://github.com/increments/activeoopish'
+  spec.license         = 'MIT'
+
+  spec.files           = `git ls-files -z`.split("\x0")
+  spec.require_paths   = ['lib']
+
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'activemodel'
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'shoulda-matchers'
+end

data/lib/activeoopish/rspec_helper.rb

@@ -0,0 +1,66 @@
+require 'rspec/core'
+require 'rspec/matchers'
+require 'active_model'
+require 'active_support'
+
+RSpec::Matchers.define :be_monitored_by do |validator_class|
+  match do |actual|
+    validator_class.respond_to?(:monitoring?) && validator_class.monitoring?(actual)
+  end
+end
+
+module ActiveOOPish
+  module RSpecHelper
+    module SharedContext
+      extend ActiveSupport::Concern
+
+      included do
+        let(:model_class) do
+          Class.new(ActiveOOPish::RSpecHelper::ValidationTarget) do
+            def self.name
+              'ValidationTarget'
+            end
+          end
+        end
+
+        shared_context 'describe declaration', :describe_declaration do
+          subject do
+            described_class.monitor(model_class)
+            model_class.new
+          end
+        end
+      end
+    end
+
+    class ValidationTarget
+      include ActiveModel::Validations
+
+      def initialize(attributes = {})
+        @attributes = attributes
+      end
+
+      def read_attribute_for_validation(key)
+        @attributes[key.to_sym]
+      end
+
+      private
+
+      def remove_trailing_equal(string)
+        string[0...-1].to_sym
+      end
+
+      def method_missing(name, *args)
+        if name.to_s.end_with?('=')
+          name = remove_trailing_equal(name)
+          @attributes[name] = args.first
+        elsif @attributes.include?(name)
+          read_attribute_for_validation(name)
+        end
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include ActiveOOPish::RSpecHelper::SharedContext, :with_activeoopish_helpers
+end

data/lib/activeoopish/validator.rb

@@ -0,0 +1,220 @@
+require 'active_support/core_ext/module/delegation'
+
+module ActiveOOPish
+  # Public: Base class for validators.
+  #
+  # Example
+  #
+  #   class BookValidator < ActiveOOPish::Validator
+  #     declear do
+  #       validates :author, presence: true
+  #       validate :title_must_include_author_name, if: :biography?
+  #     end
+  #
+  #     private
+  #
+  #     def title_must_include_author_name(book)
+  #       unless book.title.include?(book.author.name)
+  #         book.errors.add(:author, "cannot write a biography for other people")
+  #       end
+  #     end
+  #
+  #     def biography?(book)
+  #       book.category == :biography
+  #     end
+  #   end
+  #
+  #   class Book < ActiveRecord::Base
+  #     belongs_to :author, class_name: 'User'
+  #     BookValidator.monitor(self)
+  #   end
+  #
+  #   BookValidator.monitor?(Book)
+  #   # => true
+  #
+  #   book = Book.new(title: 'Qiitan biography', author: User.new(name: 'Yaotti'))
+  #
+  #   book.valid?
+  #   # => false
+  #
+  #   book.errors.full_messages_for(:author).first
+  #   # => "author cannot write a biography of another person"
+  #
+  class Validator
+    # Public: Generic ActiveOOPish::Validator related error.
+    # Exceptions raised in this class should inherit from Error.
+    class Error < StandardError
+    end
+
+    # Public: Raised when
+    class AlreadyMonitored < Error
+    end
+
+    # Public: Raised when a non-decleared validator tries to validate a model.
+    class DeclarationNotFound < Error
+    end
+
+    class << self
+      # Public: Start validating the given model_class's instances.
+      #
+      # model_class - A model Class to be validated by it.
+      #
+      # Raises AlreadyMonitored if the given model_class has already been
+      #   monitored.
+      # Raises DeclarationNotFound when it has not decleared yet.
+      # Returns nothing.
+      def monitor(model_class)
+        fail AlreadyMonitored if monitoring?(model_class)
+        define_accessor_to_model_class(model_class)
+        apply_decleared_rules_to_model_class(model_class)
+        monitoring_model_classes << model_class
+      end
+
+      # Public: Whether the given model_class is watched by it.
+      #
+      # target - A class which includes ActiveModel::Validations or its instance.
+      #
+      # Returns true or false.
+      def monitoring?(target)
+        model_class = target.is_a?(ActiveModel::Validations) ? target.class : target
+        monitoring_model_classes.include?(model_class)
+      end
+
+      # Internal: Its name.
+      #
+      # Returns a Symbol.
+      def injection_name
+        @method_name ||= "__validator_#{name.downcase.gsub('::', '_')}"
+      end
+
+      def inspect
+        name
+      end
+
+      private
+
+      def monitoring_model_classes
+        @monitoring_model_classes ||= []
+      end
+
+      # Internal: Declear how to validate a model class.
+      #
+      # block - A block which will be applied later.
+      #         It may call `validates`, `validates_with` and `validate`
+      #         methods to self of the block context.
+      #
+      # Example
+      #
+      #   Validator.declear do
+      #     # Delegated to @model_class.
+      #     validates :name, presence: true
+      #     validates_with AnActiveModelValidator
+      #
+      #     # Create a proxy method to the corresponding validator method.
+      #     validate :validate_method
+      #   end
+      #
+      # Returns nothing.
+      def declear(&block)
+        @declaration = block
+      end
+
+      # Internal: Define a private instance method something like
+      #
+      #   def __validator_bookvalidator
+      #     @__validator_bookvalidator ||= BookValidator.new
+      #   end
+      #
+      # to the given model_class.
+      #
+      # model_class - A model Class to be validated by it.
+      #
+      # Returns nothing.
+      def define_accessor_to_model_class(model_class)
+        validator_class = self
+
+        model_class.class_eval do
+          unless private_instance_methods(false).include?(validator_class.injection_name)
+            define_method(validator_class.injection_name) do
+              instance_variable_set("@#{validator_class.injection_name}", validator_class.new)
+            end
+            private validator_class.injection_name
+          end
+        end
+      end
+
+      def apply_decleared_rules_to_model_class(model_class)
+        fail DeclarationNotFound unless @declaration
+        @model_class = model_class
+        begin
+          class_eval(&@declaration)
+        ensure
+          @model_class = nil
+        end
+      end
+
+      # TODO: Support `validate` in `with_options` block.
+      delegate(
+        :validates, :validates_with, :validates_associated, :with_options,
+        to: :@model_class
+      )
+
+      # Internal: Define a private method to the model class which works as a
+      # proxy for the validator's corresponding method. The validator method
+      # will be called with the model instance as the first argument.
+      #
+      # Suppose a `UserValidator` declears:
+      #
+      #   validate :must_be_qiitan, if: :active?
+      #
+      # then, this method defines some private methods to the @model_class
+      # something like:
+      #
+      #   def __validator_uservalidator_validate_must_be_qiitan
+      #     __validator_uservalidator.__send__(:must_be_qiitan, self)
+      #   end
+      #
+      #   def __validator_uservalidator_if_active?
+      #     __validator_uservalidator.__send__(:active?, self)
+      #   end
+      #
+      #   validate(
+      #     :__validator_uservalidator_validate_must_be_qiitan,
+      #     if: __validator_user_validator_if_active?
+      #   )
+      #
+      # Note that it does not support a block and a proc for :if and :unless
+      # options, though ActiveModel::Validations::ClassMethods.validate
+      # supports them.
+      #
+      # Returns nothing.
+      def validate(method_name, options = {})
+        validator_class = self
+
+        proxy_method_name = "#{validator_class.injection_name}_validate_#{method_name}"
+        proxy_map = { proxy_method_name => method_name }
+
+        (options.keys & [:if, :unless]).each do |key|
+          value = options[key]
+          proxy_name = "#{validator_class.injection_name}_#{key}_#{value}"
+          proxy_map[proxy_name] = value
+          options[key] = proxy_name
+        end
+
+        @model_class.class_eval do
+          proxy_map.each_pair do |model_method_name, validator_method_name|
+            unless private_instance_methods(false).include?(model_method_name)
+              define_method(model_method_name) do
+                __send__(validator_class.injection_name).__send__(validator_method_name, self)
+              end
+              private model_method_name
+            end
+          end
+
+          # Add the proxy method to the model_class as a validation method.
+          validate(proxy_method_name, **options)
+        end
+      end
+    end
+  end
+end

data/lib/activeoopish/version.rb

@@ -0,0 +1,3 @@
+module ActiveOOPish
+  VERSION = '0.0.1'
+end

data/lib/activeoopish.rb

@@ -0,0 +1,2 @@
+require 'activeoopish/version'
+require 'activeoopish/validator'

data/spec/activeoopish/rspec_helper_spec.rb

@@ -0,0 +1,69 @@
+require 'activeoopish/rspec_helper'
+
+describe 'activeoopish matchers' do
+  describe 'be_monitored_by matcher', :with_activeoopish_helpers do
+    let(:validator_class) do
+      Class.new(ActiveOOPish::Validator) do
+        declear do
+        end
+
+        def self.name
+          'Sample::Validator'
+        end
+      end
+    end
+
+    shared_examples_for 'be_monitored_by' do
+      context 'and the model_class is not monitored by the validator_class' do
+        it { should_not be_monitored_by validator_class }
+      end
+
+      context 'and the model_class is monitored by the validator_class' do
+        before do
+          validator_class.monitor(model_class)
+        end
+
+        it { should be_monitored_by validator_class }
+      end
+    end
+
+    context 'when the subject is the model_class' do
+      subject do
+        model_class
+      end
+
+      include_examples 'be_monitored_by'
+    end
+
+    context 'when the subject is the instance of the model_class' do
+      subject do
+        model_class.new
+      end
+
+      include_examples 'be_monitored_by'
+    end
+  end
+end
+
+class SampleValidator < ActiveOOPish::Validator
+  declear do
+    validates(
+      :attr,
+      exclusion: { in: %w(a b c) },
+      inclusion: { in: %w(x y z) },
+      length: { minimum: 1, maximum: 10 },
+      numericality: { only_integer: true },
+      presence: true
+    )
+  end
+end
+
+describe SampleValidator, :with_activeoopish_helpers do
+  include_context 'describe declaration' do
+    it { should validate_exclusion_of(:attr).in_array(%w(a b c)) }
+    # it { should validate_inclusion_of(:attr).in_array(%w(x y z)) }
+    it { should validate_length_of(:attr).is_at_least(1).is_at_most(10) }
+    it { should validate_numericality_of(:attr).only_integer }
+    it { should validate_presence_of(:attr) }
+  end
+end

data/spec/activeoopish/validator_spec.rb

@@ -0,0 +1,203 @@
+require 'activeoopish/rspec_helper'
+
+describe ActiveOOPish::Validator, :with_activeoopish_helpers do
+  describe '.monitor' do
+    subject do
+      validator_class.monitor(model_class)
+    end
+
+    context 'when the validator_class does not have declaration' do
+      let(:validator_class) do
+        Class.new(described_class) do
+          def self.name
+            'Sample::Validator'
+          end
+        end
+      end
+
+      it { expect { subject }.to raise_error(described_class::DeclarationNotFound) }
+    end
+
+    context 'when the validator_class has declaration' do
+      let(:validator_class) do
+        Class.new(described_class) do
+          declear do
+            validates(
+              :attr,
+              exclusion: { in: %w(a b c) },
+              inclusion: { in: %w(x y z) },
+              length: { minimum: 1, maximum: 10 },
+              numericality: { only_integer: true },
+              presence: true
+            )
+          end
+
+          def self.name
+            'Sample::Validator'
+          end
+        end
+      end
+
+      it 'apply decleared validations to the given model_class' do
+        instance = model_class.new
+        expect(instance).not_to validate_exclusion_of(:attr).in_array(%w(a b c))
+        expect(instance).not_to validate_inclusion_of(:attr).in_array(%w(x y z))
+        expect(instance).not_to validate_length_of(:attr).is_at_least(1).is_at_most(10)
+        expect(instance).not_to validate_numericality_of(:attr).only_integer
+        expect(instance).not_to validate_presence_of(:attr)
+
+        subject
+
+        instance = model_class.new
+        expect(instance).to validate_exclusion_of(:attr).in_array(%w(a b c))
+        # expect(instance).to validate_inclusion_of(:attr).in_array(%w(x y z))
+        expect(instance).to validate_length_of(:attr).is_at_least(1).is_at_most(10)
+        expect(instance).to validate_numericality_of(:attr).only_integer
+        expect(instance).to validate_presence_of(:attr)
+      end
+
+      context 'and it declears `validate` with if and unless options' do
+        let(:validator_class) do
+          Class.new(described_class) do
+            declear do
+              validate :validate_method, if: :if_cond?, unless: :unless_cond?
+            end
+
+            def self.name
+              'Sample::Validator'
+            end
+
+            private
+
+            def if_cond?(_)
+              true
+            end
+
+            def unless_cond?(_)
+              false
+            end
+
+            def validate_method(_)
+            end
+          end
+        end
+
+        it 'makes corresponding methods be called with the instance when validating it' do
+          subject  # Start monitoring
+          instance = model_class.new
+
+          expect_any_instance_of(validator_class)
+            .to receive(:if_cond?).with(instance).once.and_call_original
+          expect_any_instance_of(validator_class)
+            .to receive(:unless_cond?).with(instance).once.and_call_original
+          expect_any_instance_of(validator_class)
+            .to receive(:validate_method).with(instance).once
+
+          instance.valid?  # Validate the instance
+        end
+
+        context 'and if condition returns false' do
+          before do
+            allow_any_instance_of(validator_class).to receive(:if_cond?).and_return(false)
+          end
+
+          it 'skips the corresponding validate method' do
+            subject  # Start monitoring
+            instance = model_class.new
+
+            expect_any_instance_of(validator_class).not_to receive(:validate_method)
+            instance.valid?
+          end
+        end
+
+        context 'and unless condition returns true' do
+          before do
+            allow_any_instance_of(validator_class).to receive(:unless_cond?).and_return(true)
+          end
+
+          it 'skips the corresponding validate method' do
+            subject  # Start monitoring
+            instance = model_class.new
+
+            expect_any_instance_of(validator_class).not_to receive(:validate_method)
+            instance.valid?
+          end
+        end
+      end
+
+      context 'and the model_class has already been monitored' do
+        before do
+          validator_class.monitor(model_class)
+        end
+
+        it { expect { subject }.to raise_error(described_class::AlreadyMonitored) }
+      end
+    end
+  end
+
+  describe '.monitoring?' do
+    subject do
+      validator_class.monitoring?(param)
+    end
+
+    let(:validator_class) do
+      Class.new(described_class) do
+        declear do
+        end
+
+        def self.name
+          'Sample::Validator'
+        end
+      end
+    end
+
+    shared_examples_for '.monitoring?' do
+      context 'and it does not monitor the model_class' do
+        it { should be_falsey }
+      end
+
+      context 'and it monitors the model_class' do
+        before do
+          validator_class.monitor(model_class)
+        end
+
+        it { should be_truthy }
+      end
+    end
+
+    context 'when the given parameter is model_class' do
+      let(:param) do
+        model_class
+      end
+
+      include_examples '.monitoring?'
+    end
+
+    context 'when the given parameter is the instance of model_class' do
+      let(:param) do
+        model_class.new
+      end
+
+      include_examples '.monitoring?'
+    end
+  end
+
+  describe '.injection_name' do
+    subject do
+      validator_class.injection_name
+    end
+
+    let(:validator_class) do
+      Class.new(described_class) do
+        declear do
+        end
+
+        def self.name
+          'Sample::Validator'
+        end
+      end
+    end
+
+    it { should be_a String }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'coveralls'
+Coveralls.wear!
+
+require 'active_model'
+require 'shoulda-matchers'
+
+require 'activeoopish'
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: activeoopish
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Yuku Takahashi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda-matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- yuku@qiita.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- activeoopish.gemspec
+- lib/activeoopish.rb
+- lib/activeoopish/rspec_helper.rb
+- lib/activeoopish/validator.rb
+- lib/activeoopish/version.rb
+- spec/activeoopish/rspec_helper_spec.rb
+- spec/activeoopish/validator_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/increments/activeoopish
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Simple OOP-ish tools for Rails
+test_files: []