interfaces 0.0.2.pre

data/.gitignore

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

data/.rspec

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

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3-p429

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in interfaces.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Justin
+
+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,178 @@
+# Interfaces
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'interfaces'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install interfaces
+
+## Usage
+
+Ruby is a fun, super-flexible language that lets us as developers do almost anything we can dream of.  Sometimes we do great with that kind of freedom, but other times we need stricter rules to help guide us.  Interfaces is a library designed to help put some enforcement around the way that duck-typing is used in ruby.  It allows us to ask the question 'does this object have the methods I need?' and then to say 'thanks, I promise to only call these methods.'  It also helps to make code more readable, by stating 'I'm expecting you to give me an object that has these methods.'
+
+Let's role play a development scenario.  Let's say you are writing an application that will send mail through a user's mail server.  You're going to store the user's configuration on the User model.  To keep this example simple, we won't use ActiveRecord for our model, just a plain old class:
+
+    class User
+      # some properties of the user
+      attr_accessor :username
+
+      # some options specifically for sending mail
+      attr_accessor :email_server, :use_ssl?, :port, :use_html?
+
+	  def email_sent_callback(mailer)
+	  	# do something after mail is sent
+	  end
+    end
+
+And we create a MailerService to send mail:
+
+    class MailerService
+      attr_accessor :user, :to, :subject, :message
+
+      def initialize(user, to, subject, message)
+      	self.user = user
+      	self.to = to
+      	self.subject = subject
+      	self.message = message
+      end
+
+      def deliver
+        # ... implement mail sending here
+        user.email_sent_callback(self)
+      end
+    end
+
+This works, but we've needlessly coupled our MailerService to our User model.  The Mailer service does not really need a User, what it needs is configuration.  To be slightly more explicit then we could simply rename the first parameter to 'configuration':
+
+    class MailerService
+      attr_accessor :configuration, :to, :subject, :message
+
+      def initialize(configuration, to, subject, message)
+      	self.configuration = configuration
+      	self.to = to
+      	self.subject = subject
+      	self.message = message
+      end
+
+      def deliver
+        # ... implement mail sending here
+      end
+    end
+
+This also works fine.  We can call the Mailer service and pass it a user:
+
+	MailerService.new(user, 'bob@example.com', 'test message', 'hello world!').deliver
+
+The problem isn't that it doesn't work, it does.  The problem is that the readability is low.  Looking at the line of code above, one might wonder why a user is being passed into the mailer service.  One might also wonder what properties of 'user' the mailer service is actually using.  Is the mailer only reading properties of my user or is it *changing* the user?  What if another developer comes along, noticing that the mailer is receiving a User model, and inadvertantly tightly couples MailerService to the User model?  That may not cause immediate problems, but down the road services and models can become more and more tightly coupled.  When you find yourself needing to use your service somewhere else you might find the de-coupling refactor to be a daunting task...
+
+So let's re-write this code using Interfaces.  First, let's define an interface:
+
+	class MailerConfiguration < Interface
+		abstract :email_server, :use_ssl?, :port, :use_html?, :email_sent_callback
+	end
+
+Then, when we call our mailer service we cast the 'user' object to be a MailerConfiguration object:
+
+	MailerService.new(user.as(MailerConfiguration), 'bob@example.com', 'test message', 'hello world!').deliver
+
+
+Now it's clear that the user is being passed in because it contains configuration information.  Further, there is enforcement taking place-- if User did not implement one of the four required methods, a clear exception would be fired at runtime.  And if MailerService tries to call another method of User that is not defined in the MailerConfiguration interface, an exception will be thrown.  Lastly, there's one place to look to determine what methods are needed by MailerConfiguration-- the code is self documenting.
+
+Behind the scenes what is really happening here is that a new MailerConfiguration instance is being created, and then the abstract methods are being redefined on that instance to proxy to the equivalent methods on the 'user' object.
+
+Interfaces have a few other capabilities.  First, they can be instantiated using a hash if you don't want to use duck typing, making them much more like a Struct that can also contain arbitrary methods.
+
+	config = MailerConfiguration.new(:email_server => 'myemailserver.com',
+									  :port => 443,
+									  :use_ssl? => true,
+									  :use_html? => true,
+									  :email_sent_callback => lambda { |s| puts "Mail sent!"})
+	MailerService.new(config, 'bob@example.com', 'test message', 'hello world!').deliver
+
+Interfaces can also be derived from other interfaces, both adding or removing abstract methods:
+
+	class SecureMailerConfiguration < MailerConfiguration
+		abstract :vpn
+
+		# always use ssl
+		def use_ssl?
+			true
+		end
+	end
+
+This breaks away from the traditional notion of 'interfaces' in that we're now implementing methods directly on an interface.  This practice is much more similar to the notion of abstract classes in other languages.  Let's view the abstract methods of both of these interfaces:
+
+	MailerConfiguration.abstract_methods
+	=> [:email_server, :use_ssl?, :port, :use_html?, :email_sent_callback]
+
+	SecureMailerConfiguration.abstract_methods
+	=> [:vpn, :email_server, :port, :use_html?, :email_sent_callback]
+
+Note that the use_ssl? method is no longer abstract in the SecureMailerConfiguration interface because it has been implemented.
+
+## Optional methods
+
+An interface may contain optional methods. If they are defined by a class then they will be delegated to, but if they are not defined they will simply return nil.  This alleviates the developer from having to add respond_to? checks before calling methods that may or may not be defined.
+
+    class TestInterface < Interface
+      abstract :field1
+      optional :field2
+    end
+
+    TestInterface.new.field2
+    => nil
+
+## Typed accessors
+
+The typed_attr_accessor and typed_attr_writer helpers make it easy to create attributes that always conform to an interface:
+
+    class MailerService
+      typed_attr_accessor :config => MailerConfiguration
+      # ...
+    end
+
+Now when the 'config' attribute is assigned it will be automatically converted to an instance of MailerConfiguration or it will raise an exception if it cannot be converted.
+
+## Built-in and custom conversions for non-interfaces
+
+For the basic ruby types (String, Symbol, Integer, Float, Array, Hash (on ruby 2.0)) there are built-in conversions that simply call the corresponding standard ruby conversion method (to_s, to_sym, to_i, to_f, to_a, to_h):
+
+    "test".as(Symbol) == :test
+
+This allows the typed_attr_accessor to be used with these standard types.
+
+Additional custom conversions can be defined by overriding the 'as' method in a class.
+
+## Interface caching and state
+
+Interfaces are full-fledged ruby classes, and as such they can have methods and instance variables (state).  To ensure that this state is maintained each time the object is cast, an interface cache is maintained on any object that has been casted at least once.  This means that the following is always true:
+
+	user.as(MailerConfiguration) === user.as(MailerConfiguration)
+
+## Usage with the 'contracts' gem
+
+The 'interfaces' gem does not enforce that a parameter passed to a method conforms to an interface, but this can be achieved by using the [contracts gem](https://github.com/egonSchiele/contracts.ruby):
+
+	class MailerService
+      attr_accessor :configuration, :to, :subject, :message
+
+	  Contract MailerConfiguration, String, String, String => MailerService
+      def initialize(configuration, to, subject, message)
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new("spec")
+
+# If you want to make this the default task
+task :default => :spec

data/interfaces.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'interfaces/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "interfaces"
+  spec.version       = Interfaces::VERSION
+  spec.authors       = ["Justin Schumacher"]
+  spec.email         = ["justin@thethinkingtree.com"]
+  spec.description   = %q{This library provides a concept of Interfaces and abstract classes to the ruby language}
+  spec.summary       = %q{Interfaces for ruby}
+  spec.homepage      = "https://github.com/thinkingtree/ruby-interfaces"
+  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/interfaces/castable.rb

@@ -0,0 +1,76 @@
+module Interfaces
+  # a mixin that defines the 'as' method to allow an object to be cast as an interface
+  module Castable
+    BUILT_IN_CONVERSIONS = {
+      Array => :to_a,
+      String => :to_s,
+      Symbol => :to_sym,
+      Integer => :to_i,
+      Float => :to_f,
+      Hash => :to_h # only on ruby 2.0
+    }
+
+    # attempts to convert non-interface types
+    def self.convert_type(instance, type)
+      method = BUILT_IN_CONVERSIONS[type]
+      if method && instance.respond_to?(method)
+        instance.send(method)
+      else
+        raise NonConvertableObjectError, "Don't know how to convert #{instance} to #{type}"
+      end
+    end
+
+    def as(interface)
+      # interface must be a class
+      raise InterfaceError, "#{interface} is not a class" unless interface.is_a?(Class)
+
+      # check if object already is an instance of interface
+      return self if self.kind_of?(interface)
+
+      # check if interface is really an interface
+      if interface < Interface
+        # cache the resulting interface so that we can load it faster next
+        # time and so that it can save state
+        cache = self.instance_variable_get(:@interface_cache)
+        unless cache
+          cache = {}
+          self.instance_variable_set(:@interface_cache, cache)
+        end
+
+        cache[interface] ||= begin
+          i = interface.new
+          delegate = self
+          non_implemented_methods = []
+
+          # define singleton methods that delegate back to this object for each abstract method
+          interface.abstract_methods.each do |method|
+            non_implemented_methods << method unless self.respond_to?(method)
+            i.define_singleton_method(method) do |*args|
+              delegate.send(method, *args)
+            end
+          end
+
+          # raise an exception if all abstract methods are not overridden
+          unless non_implemented_methods.empty?
+            raise NonConformingObjectError, "#{self} does not conform to interface #{interface}.  Expected methods not implemented: #{non_implemented_methods.join(", ")}"
+          end
+
+          # define singleton methods that delegate back to this object for each optional method
+          interface.optional_methods.each do |method|
+            if self.respond_to?(method)
+              i.define_singleton_method(method) do |*args|
+                delegate.send(method, *args)
+              end
+            end
+          end
+
+          i
+        end
+      else
+        # interface is not really an interface, it's just a Class
+        # use some built-in conversions
+        Castable.convert_type(self, interface)
+      end
+    end
+  end
+end

data/lib/interfaces/interface.rb

@@ -0,0 +1,80 @@
+require 'set'
+
+module Interfaces
+  # Interface is meant to be used as a base class for the definition of Interfaces
+  class Interface
+    # Define methods as asbtract
+    def self.abstract(*methods)
+      @abstract_methods ||= Set.new
+      methods.each do |method|
+        # the default implmentation of an abstract method is to
+        # raise the AbstractMethodInvokedError exception
+        define_method(method) do
+          raise AbstractMethodInvokedError, "Abstract method #{method} called"
+        end
+        @abstract_methods << method.to_sym
+      end
+    end
+
+    # Lists all abstract methods of a class
+    def self.abstract_methods
+      if self == Interface
+        []
+      else
+        # determine which methods of superclass are still undefined
+        nonoverrided_superclass_abtract_methods = superclass.abstract_methods.reject do |m|
+          self.instance_methods.include?(m) && self.instance_method(m).owner == self
+        end
+        ( (@abstract_methods || Set.new) + nonoverrided_superclass_abtract_methods ).to_a
+      end
+    end
+
+    # True if a class has abstract methods
+    def self.abstract?
+      !abstract_methods.empty?
+    end
+
+    # List all optional methods of a class
+    def self.optional_methods
+      if self == Interface
+        []
+      else
+        ( (@optional_methods || Set.new) + superclass.optional_methods ).to_a
+      end
+    end
+
+    # Define methods as optional
+    def self.optional(*methods)
+      @optional_methods ||= Set.new
+      methods.each do |method|
+        # the default implmentation of an optional method is to return nil
+        define_method(method) do
+          nil
+        end
+        @optional_methods << method.to_sym
+      end
+    end
+
+    # allow interfaces to be instantiated directly by passing
+    # in values for each of the abstract methods
+    def initialize(opts = {})
+      opts.each_pair do |key, value|
+
+        # only allow initializers for abstract methods
+        unless self.class.abstract_methods.include?(key.to_sym) || self.class.optional_methods.include?(key.to_sym)
+          raise InterfaceError, "Attempted to assign value to method '#{key}' which is not an abstract or optional method of #{self.class}"
+        end
+
+        if value.is_a?(Proc)
+          # if the value is a proc then the abstract method
+          # override should call that proc
+          self.define_singleton_method(key, &value)
+        else
+          # if the value is not a proc, then the abstract
+          # method override should just return the value
+          self.define_singleton_method(key) { value }
+        end
+      end
+    end
+  end
+end

data/lib/interfaces/typed_accessors.rb

@@ -0,0 +1,31 @@
+module Interfaces
+  module TypedAccessors
+    # use like:
+    # typed_attr_accessor :field_name => InterfaceName
+    def typed_attr_accessor(attrs)
+      # attrs.each_pair |attr_name,interface|
+      #   inst_variable_name = "@#{attr_name}"
+      #   define_method method_name do
+      #     instance_variable_get inst_variable_name
+      #   end
+      # end
+
+      # use the standard reader
+      attrs.keys.each do |attr|
+        attr_reader attr
+      end
+
+      # also define writers
+      typed_attr_writer attrs
+    end
+
+    def typed_attr_writer(attrs)
+      attrs.each_pair do |attr_name,interface|
+        inst_variable_name = "@#{attr_name}"
+        define_method "#{attr_name}=" do |new_value|
+          instance_variable_set inst_variable_name, new_value ? new_value.as(interface) : nil
+        end
+      end
+    end
+  end
+end

data/lib/interfaces/version.rb

@@ -0,0 +1,3 @@
+module Interfaces
+  VERSION = "0.0.2.pre"
+end

data/lib/interfaces.rb

@@ -0,0 +1,20 @@
+require "interfaces/version"
+require "interfaces/interface"
+require "interfaces/castable"
+require "interfaces/typed_accessors"
+
+module Interfaces
+  class InterfaceError < StandardError; end
+  class AbstractMethodInvokedError < InterfaceError; end
+  class NonConformingObjectError < InterfaceError; end
+  class NonConvertableObjectError < InterfaceError; end
+end
+
+class Object
+  include Interfaces::Castable
+  Interface = Interfaces::Interface
+end
+
+class Class
+  include Interfaces::TypedAccessors
+end

data/spec/castable_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe Interfaces::Castable do
+  it 'raises an exception when attempting to cast to a non-Class' do
+    expect { Object.new.as("something") }.to raise_error(Interfaces::InterfaceError)
+  end
+
+  describe 'conversions' do
+    it 'can convert to String' do
+      :test.as(String).should == "test"
+    end
+
+    it 'can convert to Symbol' do
+      "test".as(Symbol).should == :test
+    end
+
+    it 'can convert to an Array' do
+      {:test => 1}.as(Array).should == [[:test, 1]]
+    end
+
+    it 'can convert to an Integer' do
+      "1".as(Integer).should == 1
+    end
+
+    it 'can convert to a Float' do
+      "1.1".as(Float).should == 1.1
+    end
+  end
+
+  describe ClassConformingToTestInterface do
+    let(:instance) { ClassConformingToTestInterface.new }
+    let(:casted_instance) { instance.as(TestInterface) }
+
+    it 'casted_instance should be an instance of TestInterface' do
+      casted_instance.should be_a(TestInterface)
+    end
+
+    it 'casted_instance should delegate to the overridden methods' do
+      casted_instance.method1.should == 1
+      casted_instance.method2.should == 2
+      casted_instance.method3(2).should == 8
+      casted_instance.opt_method.should == 5
+    end
+
+    it 'should return the same casted instance if cast is called multiple times' do
+      instance.as(TestInterface).should === casted_instance
+    end
+  end
+
+  describe FullyImplimentedClass do
+    let(:instance) { FullyImplimentedClass.new }
+
+    it 'should just return self if attempting to cast an object that is already the right kind of object' do
+      instance.as(TestInterface).should === instance
+    end
+  end
+
+  describe ClassNotConformingToTestInterface do
+    let(:instance) { ClassNotConformingToTestInterface.new }
+
+    it 'should raise an error when casted to TestInterface' do
+      expected_message = "#{instance.to_s} does not conform to interface TestInterface.  Expected methods not implemented: method3"
+      expect { instance.as(TestInterface) }.to raise_error(Interfaces::NonConformingObjectError, expected_message)
+    end
+  end
+end

data/spec/fixtures/fixtures.rb

@@ -0,0 +1,42 @@
+class TestInterface < Interface
+  abstract :method1, :method2
+  abstract :method3
+
+  optional :opt_method
+end
+
+class TestSubInterface < TestInterface
+  abstract :method4
+end
+
+class TestSubInterfaceWithOverride < TestInterface
+  abstract :method4
+
+  # sub interface overrides method3
+  def method3(x)
+    x * 2
+  end
+end
+
+class FullyImplimentedClass < TestInterface
+  def method1; end
+  def method2; end
+  def method3; end
+end
+
+class ClassConformingToTestInterface
+  def method1; 1; end
+  def method2; 2; end
+  def method3(x); x * 4; end
+  def opt_method; 5; end
+end
+
+class ClassNotConformingToTestInterface
+  def method1; 1; end
+  def method2; 2; end
+end
+
+class ClassWithTypedAttributes
+  typed_attr_accessor :field1 => TestInterface
+  typed_attr_writer :field2 => TestInterface
+end

data/spec/interface_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Interfaces::Interface do
+  describe TestInterface do
+    subject  { TestInterface }
+
+    it { should be_abstract}
+
+    it 'can define abstract methods' do
+      subject.abstract_methods.should =~ [:method1, :method2, :method3]
+    end
+
+    it 'can define optional methods' do
+      subject.optional_methods.should =~ [:opt_method]
+    end
+
+    it 'can be instantiated with a hash to override abstract methods with constants or Procs' do
+      i = subject.new(:method1 => 1, :method2 => 2, :method3 => lambda { |x| x + 1 }, :opt_method => 4)
+      i.method1.should == 1
+      i.method2.should == 2
+      i.method3(2).should == 3
+      i.opt_method.should == 4
+    end
+
+    it 'will raise an exception if an abstract method is called' do
+      expect { subject.new(:method1 => 1, :method2 => 2).method3 }.to raise_error(Interfaces::AbstractMethodInvokedError)
+    end
+
+    it 'will return nil if a non-overridden optional method is called' do
+      subject.new(:method1 => 1, :method2 => 2).opt_method.should be_nil
+    end
+  end
+
+  describe TestSubInterface do
+    subject  { TestSubInterface }
+
+    it { should be_abstract }
+
+    it 'should inherit abstract methods of base interface' do
+      subject.abstract_methods.should =~ [:method1, :method2, :method3, :method4]
+    end
+  end
+
+  describe TestSubInterfaceWithOverride do
+    subject  { TestSubInterfaceWithOverride }
+
+    it 'should be able to override an abstract method defined in its base interface' do
+      subject.abstract_methods.should =~ [:method1, :method2, :method4]
+    end
+  end
+
+  describe FullyImplimentedClass do
+    subject  { FullyImplimentedClass }
+
+    it { should_not be_abstract }
+    its(:abstract_methods) { should be_empty }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'interfaces'
+require 'fixtures/fixtures.rb'
+
+RSpec.configure do |config|
+  # some (optional) config here
+end

data/spec/typed_accessor_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Interfaces::TypedAccessors do
+  describe ClassWithTypedAttributes do
+    let(:instance) { ClassWithTypedAttributes.new }
+
+    it 'should convert an object to the correct type when it is assigned' do
+      instance.field1 = FullyImplimentedClass.new
+      instance.field1.should be_a_kind_of(TestInterface)
+    end
+
+    it 'should throw an exception if an object that does not conform to the interface is passed' do
+      expect { instance.field1 = Object.new }.to raise_error(Interfaces::NonConformingObjectError)
+    end
+
+    it 'should allow nil to be assigned' do
+      instance.field1 = nil
+      instance.field1.should be_nil
+    end
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: interfaces
+version: !ruby/object:Gem::Version
+  version: 0.0.2.pre
+  prerelease: 6
+platform: ruby
+authors:
+- Justin Schumacher
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-05 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: This library provides a concept of Interfaces and abstract classes to
+  the ruby language
+email:
+- justin@thethinkingtree.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .ruby-version
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- interfaces.gemspec
+- lib/interfaces.rb
+- lib/interfaces/castable.rb
+- lib/interfaces/interface.rb
+- lib/interfaces/typed_accessors.rb
+- lib/interfaces/version.rb
+- spec/castable_spec.rb
+- spec/fixtures/fixtures.rb
+- spec/interface_spec.rb
+- spec/spec_helper.rb
+- spec/typed_accessor_spec.rb
+homepage: https://github.com/thinkingtree/ruby-interfaces
+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: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Interfaces for ruby
+test_files:
+- spec/castable_spec.rb
+- spec/fixtures/fixtures.rb
+- spec/interface_spec.rb
+- spec/spec_helper.rb
+- spec/typed_accessor_spec.rb
+has_rdoc: