engrel 0.10.0

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Matt Lightner
+
+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.rdoc

@@ -0,0 +1,62 @@
+= **ENG**lish **REL**ational Framework
+
+*A simple and elegant way to specify relations without explicitly making a table for each one.*
+
+*Modify or delete this text in the editor above.*
+
+WMD's context-sensitive commands pack a lot of power into a simple user interface.  Here are some advanced features to try:
+
+== Why use English/Sentences instead of Join Tables?
+
+In a way, we are using join tables--but just one instead of dozens of hundreds.  Normal join tables serve one single purpose--to connect A to B under circumstance C.  Like to link all of the users who were tagged in a specific photo ID.  But if you step back, all that join tables really do is link one object to another with a little bit of context.  Engrel puts the context into the join table and voila, one join table can link any two objects **and** provide (often even more) useful context than a full join table.  No really.
+
+== Prepositional Phrases
+
+Sounds like something only a linguistics professor would care about, but in reality, you use them all the time and they're very helpful in describing relations.  For instance, taking an example from Facebook:
+
+    I was tagged in photo ID 23982930   (technically there's already a preposition there, but watch now)
+    I was tagged in photo ID 23982930 by user ID 850932
+
+More info, right?  And more data is always better, we think.
+
+
+== Console Usage
+
+        irb(main):022:0> s = Engrel::Sentence.claim(User["00002394802384"], :likes, Page["overwerk"])
+        => #<Engrel::Sentence id: 1, subject_id:  00002394802384, subject_type: "User", direct_object_id: 133241766707287, direct_object_type: "Page", verb: "likes", data: nil, created_at: "2010-11-18 18:41:27", updated_at: "2010-11-18 18:41:27">
+
+        irb(main):024:0> s = Engrel::Sentence.claim(User["00002394802384"], :likes, Page["overwerk"])
+        => #<Engrel::Sentence id: 1, subject_id:  00002394802384, subject_type: "User", direct_object_id: 133241766707287, direct_object_type: "Page", verb: "likes", data: nil, created_at: "2010-11-18 18:41:27", updated_at: "2010-11-18 18:41:27">
+
+        irb(main):025:0> s.prep(:via, User["00002394804563"])
+        => #<Engrel::PrepositionalPhrase id: 2, parent_id: 1, parent_type: "Engrel::Sentence", preposition: "via", modifier: nil, indirect_object_id: 00002394804563, indirect_object_type: "User", created_at: "2010-11-18 20:15:39", updated_at: "2010-11-18 20:15:39", started_at: nil, ended_at: nil>
+
+        irb(main):026:0> pp s
+        => #<Engrel::Sentence id: 1, subject_id:  00002394802384, subject_type: "User", direct_object_id: 133241766707287, direct_object_type: "Page", verb: "likes", data: nil, created_at: "2010-11-18 18:41:27", updated_at: "2010-11-18 18:41:27">
+
+        irb(main):027:0> pp s.prepositional_phrases
+        => [#<Engrel::PrepositionalPhrase id: 2, parent_id: 1, parent_type: "Engrel::Sentence", preposition: "via", modifier: nil, indirect_object_id: 00002394804563, indirect_object_type: "User", created_at: "2010-11-18 20:15:39", updated_at: "2010-11-18 20:15:39", started_at: nil, ended_at: nil>]
+
+        irb(main):028:0> pp s.to_sentence
+        => "User[Matt Lightner#00002394802384] likes Page[OVERWERK#133241766707287] via User[Some Friend#00002394804563 indirect_object])
+
+
+== Use with FBGraph
+
+
+This was originally designed to solve a problem I ran into while trying to persist Facebook Graph data, and works well with the fbgraph (not fb_graph) library.  I recommend you check that out too!
+
+== Contributing to engrel
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2010 Matt Lightner. See LICENSE.txt for
+further details.

data/lib/engrel.rb

@@ -0,0 +1,43 @@
+require 'active_record'
+require 'enumerated_attribute'
+require 'engrel/sentence'
+require 'engrel/prepositional_phrase'
+require 'engrel/mixin'
+
+# Helper methods that make creating new sentences a joy!
+module Engrel
+  module Helpers
+
+    # Creates a new relation from scratch--that is, without an implicit subject.  Takes arguments in the order they would be written in
+    # an anglish sentence.
+    #
+    # @param [Object] an object, usually an actor.
+    # @param [Symbol] a verb from the vast pre-approved list that decsribes this relation.
+    # @param [Object] the direct object in this
+    # @returns [Sentence] The new Sentence object created to represent this relation.
+    def sentence(*args, &block)
+      Engrel::Sentence.claim(*args, &block)
+    end
+    alias :fact :sentence
+    alias :claim :sentence
+
+    module AciveRecordInstanceMethods
+      # Helper method that gets included into AR::Base that allows any model object to specify a relationship between it and any other
+      # object (the direct object (they're both polymorphic, of course).
+      #
+      # @param [Symbol] The downcased, underscored word representing the transitive verb i.e. (:is_friends_with)
+      # @param [Object] The direct object that is the second receiver for the trasitive verb above.
+      # @returns [Sentence] The new Sentence object created to represent this relation.
+      def fact(verb, direct_object, &block)
+        Engrel::Sentence.claim(self, verb, direct_object, &block)
+      end
+      alias :claim :fact
+      alias :sentence :claim
+    end
+
+  end
+end
+
+
+ActiveRecord::Base.send(:include, ::Engrel::Helpers::AciveRecordInstanceMethods) if (defined?(ActiveRecord::Base) rescue false)
+include ::Engrel::Helpers

data/lib/engrel/mixin.rb

@@ -0,0 +1,34 @@
+require 'active_support'
+
+module Engrel
+  module Mixin
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Who knows--maybe I'll think of something to put here someday.
+    end
+    
+    module InstanceMethods
+
+      # This is very specific to Facebook--it stores a reference to the object through whose access token the intermediate object was initially fetched.
+      def set_fetcher!(newfetcher = nil)
+        write_attribute(:fetcher_id, newfetcher[:id])
+        write_attribute(:fetcher_type, newfetcher.class.to_s)
+        save(:validate => false)
+        reload
+        fetcher
+      end
+
+      # Make sure we can make an object before we go trying to save the "association".
+      def instantiate_object!(key)
+        key = key.to_sym
+        id_key, type_key = "#{key}_id".to_sym, "#{key}_type".to_sym
+        return true if !self[key].blank? && !(self[key][:id].blank? rescue true)
+        class_name = self[type_key] || (self.send(key).class.to_s rescue "Page")
+        raise "Could not determine class name for #{key} (#{self.to_s})" if class_name.blank?
+        newid = self[id_key] || (self[key][:id] rescue nil)
+        class_name.constantize.spec(newid) rescue raise("Unable to instantiate #{class_name} object with ID #{newid || '[unavailable]'}")
+      end
+    end
+  end
+end

data/lib/engrel/prepositional_phrase.rb

@@ -0,0 +1,83 @@
+require 'engrel/mixin'
+
+class Engrel::PrepositionalPhrase < ActiveRecord::Base
+  include Engrel::Mixin
+
+  # This whole top declaration will need changing if you're not using AR.
+  set_table_name "engrel_prepositional_phrases"
+
+  # A prepositional phrase, which answers the questions: how?, which one?, when? with whom? by whom? etc.
+  # http://www.chompchomp.com/terms/prepositionalphrase.htm
+  belongs_to :indirect_object, :polymorphic => true
+
+  # The sentence that owns us.
+  belongs_to :sentence, :class_name => "::Engrel::Sentence"
+
+  enum_attr  :preposition, %w( ^about at_time on_date since beginning beginning_at before and as_well_as in_addition_to along_with together_with in_conjunction_with at_time on_date before prior_to after following since beginning beginning_at dring while at_the_sae_time_as about on in_reference_to concerning regarding in inside within inside_of included_in as_part_of via through by_way_of from by at located_at
+                                with_location at_venue at_place and as_well_as in_addition_to along_with together_with in_conjunction_with ) do
+     at_time?  %w( at_time on_date )
+     before?   %w( before prior_to )
+     after?    %w( after following )
+     since?    %w( since beginning beginning_at )
+     during?   %w( dring while at_the_sae_time_as )
+     about?    %w( about on in_reference_to concerning regarding )
+     in?       %w( in inside within inside_of included_in as_part_of )
+     via?      %w( via through by_way_of from by )
+     at?       %w( at located_at with_location at_venue at_place )
+     and?      %w( and as_well_as in_addition_to along_with together_with in_conjunction_with )
+
+     references_time?     { at_time? || before? || after? || during? || since? }
+     references_object?   { in? || via? || about? }
+     references_location? { at? || via? }  # Yes via is both?
+  end
+
+  alias :ind :indirect_object
+
+  before_save do
+    instantiate_object!(:indirect_object) unless !indirect_object.blank?
+  end
+
+  def has_indirect_object?
+    (self.indirect_object.present? && self.indirect_object[:id].present?) rescue false
+  end
+  
+
+
+  #### Time Helpers! ####
+
+  def started_at
+    (references_time? && has_indirect_object?) && (ind.started_time rescue nil || ind.started_at rescue nil || ind.created_time rescue nil)
+  end
+
+  def started?; started_at.present?; end
+  alias :starts_at :started_at
+  alias :starts? :started?
+
+  def ended_at
+    (references_time? && has_indirect_object?) && (ind.ended_time rescue nil || ind.ended_at rescue nil || ind.created_time rescue nil)
+  end
+
+  def ended?; ended_at.present?; end
+  alias :ends_at :ended_at
+  alias :ends? :ended?
+
+  def now
+    @now ||= Time.now
+  end
+
+  def active?
+    (started? && !ended?) rescue nil
+  end
+  alias :ongoing? :active?
+
+  # Returning anything here is misleading.  Maybe nil?
+  def ended?
+    (started_at < now && ended_at > now) rescue nil
+  end
+  alias :over? :ended?
+
+  def started?
+    (started_at < now) rescue nil
+  end
+
+end

data/lib/engrel/sentence.rb

@@ -0,0 +1,132 @@
+require 'engrel/mixin'
+require 'engrel/prepositional_phrase'
+
+class Engrel::Sentence < ActiveRecord::Base
+  # This is the main backbone of Engrel.  A sentence is just a has and belongs to many relation with a verb attached that tells you the nature of the relationship.
+  # Prepositional phrases are optional and can make relationships ternary and more specific.  A sentence can have as many prepositional phrases as is appropriate.
+
+  include Engrel::Mixin
+
+  # NOTE: TO non-AR users--this whole top declaration will need changing if you're not using AR.
+
+  # Set the table name so as not to clash with other tables.
+  set_table_name "engrel_sentences"
+
+  # Usually a user, since they're the "actors" in most systems.  The "Who" of the sentence.
+  belongs_to :subject, :polymorphic => true
+
+  # The thing we're being related with.  The "What" of the sentence, and the recipieit of theeffect of the transitive verb.
+  # http://www.chompchomp.com/terms/directobject.htm
+  belongs_to :direct_object, :polymorphic => true
+
+  # Prepositions are stored as children.  Each has a preposition and an object (i.e. "beside the chair")
+  has_many :prepositional_phrases, :uniq => true
+
+  # There's obviously the possibility that dynamic accessors could be defined to access these "indirect object" so you could say like sentence.well post if the ternary
+  # relation was "Bob posted about Mary on his wall", where the post is the indirect object, mary is the direct object, and Bob is the subject.
+  has_many :indirect_objects, :through => :prepositional_phrases
+
+  # The verb.  Specifically a transitive verb (it needs two objects).
+  # commented_on: Something comments on a direct_object.
+  # likes: Something likes a direct_object object.
+  # manages: Something manages a page.
+  # is_friends_with: A user knows another user.
+  # dates: A user dates another user (acts like: knows)
+  # is_related_to: A user is related to another user.
+  # attended: A user attended an event.
+  # worked_for/works_for: User employed by organization.
+  # attended/attends: User attends a school.
+  # checked_in: A user checks in to a page (through a subject)
+  # posted: Something posts an object (photo/video/album/link)
+  # messaged: Someone messages someone else.
+  # wall_messaged: Something posts on something's wall (about a subject/tagged_in user)
+  # subscribes_to: Something subscribes to a feed.
+  # write_note: Something wrote a note (about a subject)
+  # is: A status message.
+  # hosts: Something hosts an event..
+  # is_invited_to: A user is invited to an event/group.
+  enum_attr :verb, %w(^is_friends_with commented_on likes belongs_to manages dates is_related_to attended
+    is_friends_with dates is_related_to worked_for was_employed_by works_for was_laid_off_from founded works_part_time_for attended is_an_avid_alumni teaches_at subscribes_to wall_messaged
+    commented_on checked_in tagged_in posted messaged is wrote_note is_invited_to belongs_to worked_for works_for attends attended is_invited_to religiously_attends tagged_in visited
+    appears_to_be_having_fun_in is_posing_generically_in attends attended is_invited_to does_not_want_to_attend disliked_the_crowd_at ) do 
+
+    # When the link acts like "knows" relation
+    # Facebook-specific verbs
+    knows?        %w( is_friends_with dates is_related_to )
+    job?          %w( worked_for was_employed_by works_for was_laid_off_from founded works_part_time_for)
+    education?    %w( attended is_an_avid_alumni teaches_at)
+    subscription? %w( subscribes_to wall_messaged commented_on checked_in tagged_in posted messaged is wrote_note is_invited_to )
+    membership?   %w( belongs_to worked_for works_for attends attended is_invited_to religiously_attends )
+    tag?          %w( tagged_in visited appears_to_be_having_fun_in is_posing_generically_in )
+    event?        %w( attends attended is_invited_to does_not_want_to_attend disliked_the_crowd_at )
+  end
+
+
+  # How we make a new sentence while ensuring an existing one doesn't exist.
+  def self.claim(subject, verb, direct_object)
+    params = {:subject_type => subject.class.to_s, :subject_id => subject[:id], :direct_object_type => direct_object.class.to_s, :direct_object_id => direct_object[:id], :verb => verb.to_s}.stringify_keys
+    s = self.where(params).first
+    s = create(params) if s.blank?
+    s.reload
+    block_given? ? yield(s) : s
+  end
+
+  # This describes the relationship of the subject to the fact.
+  # You can determine your own meaning for these, but try to document your use as you see fit.
+  before_save do
+    instantiate_object!(:subject)
+    instantiate_object!(:direct_object)
+  end
+
+  def object_list
+    [ subject, direct_object ].concat(indirect_objects).compact
+  end
+
+  def has_subject?
+    (self.subject.present? && self.subject[:id].present?) rescue false
+  end
+
+  def has_direct_object?
+    (self.direct_object.present? && self.direct_object[:id].present?) rescue false
+  end
+
+  def verb_enums
+    self.enums(:verb)
+  end
+
+  def verb_label(element = nil)
+    element ||= self.verb
+    verb_enums.label(element.to_sym)
+  end
+
+  def only(*args)
+    self.prepositional_phrases.clear
+    prep(*args)
+    self
+  end
+
+  def prep(prep, indirect_object)
+    if self.prepositional_phrases.include?(preposition: prep, indirect_object_id: indirect_object.id, indirect_object_type: indirect_object.class.to_s)
+      warn "PREP ALREADY EXISTS!"
+    else
+      self.prepositional_phrases.create(preposition: prep, indirect_object: indirect_object)
+    end
+    self
+  end
+
+  def to_sentence_colored
+    sen = "#{subject_type.humanize}[#{subject.name rescue subject_id}\##{subject_id}]".green +
+          " #{verb_label.downcase} " + "#{direct_object_type.humanize}[#{direct_object.name rescue direct_object_id}\##{direct_object_id}]".cyan
+    sen += " " unless prepositional_phrases.blank? rescue true
+    preps = prepositional_phrases.collect { |p| "#{p.preposition.to_s.humanize.downcase} " + "#{p.indirect_object_type.humanize}[#{p.object.name rescue p.indirect_object_id}\##{p.indirect_object_id}]".yellow }.join(" ") rescue nil
+    sen << preps unless preps.blank?
+    sen += '.'
+    sen
+  end
+
+  # TODO: Properly strip ANSI color chars
+  def to_sentence
+    to_sentence_colored
+  end
+end
+

data/lib/generators/engrel_generator.rb

@@ -0,0 +1,19 @@
+require 'rails/generators/migration'
+
+# Very simple--we're doing a straight copy of the migration.
+class EngrelGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+
+  def self.source_root
+    @_acts_as_engrelable_source_root ||= File.expand_path("../templates", __FILE__)
+  end
+
+  def self.next_migration_number(path)
+    Time.now.utc.strftime("%Y%m%d%H%M%S")
+  end
+
+  def create_model_file
+    template "engrel.rb", "app/models/engrel.rb"
+    migration_template "create_engrel_tables.rb", "db/migrate/create_engrel_tables.rb"
+  end
+end

data/lib/generators/templates/create_engrel_tables.rb

@@ -0,0 +1,47 @@
+class CreateEngrelTables < ActiveRecord::Migration
+  def self.up
+    create_table :engrel_sentences, :force => true do |t|
+      t.column :subject_id, "BIGINT"
+      t.column :subject_type, :string 
+
+      t.column :direct_object_id, "BIGINT"
+      t.column :direct_object_type, :string 
+
+      t.enum :verb
+      t.string :direct_object_data
+
+      t.datetime :created_at
+      t.datetime :updated_at
+    end     
+
+    add_index :engrel_sentences, :direct_object_id, :name => "direct_object_index"
+    add_index :engrel_sentences, :subject_id, :name => "subject_index"
+    add_index :engrel_sentences, :verb, :name => "verb_index"
+    change_column :engrel_sentences, :id, 'BIGINT NOT NULL AUTO_INCREMENT'  # For big IDs like Facebook
+
+    create_table :engrel_prepositional_phrases, :force => true do |t|
+      t.references :sentence
+
+      t.enum :preposition
+      t.enum :modifier
+
+      t.column :indirect_object_id, "BIGINT"
+      t.column :indirect_object_type, :string
+
+      t.string :indirect_object_data
+
+      t.datetime :created_at
+      t.datetime :updated_at
+    end
+
+    add_index :engrel_prepositional_phrases, :indirect_object_id, :name => "indirect_object_index"
+    add_index :engrel_prepositional_phrases, :preposition, :name => "preposition_index"
+    change_column :engrel_prepositional_phrases, :id, 'BIGINT NOT NULL AUTO_INCREMENT'
+  end
+
+  def self.down
+    drop_table :engrel_sentences
+    drop_table :engrel_prepositional_phrases
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'engrel'
+
+class Test::Unit::TestCase
+end

data/test/test_engrel.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestEngrel < Test::Unit::TestCase
+  def test_something_for_real
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

metadata

@@ -0,0 +1,204 @@
+--- !ruby/object:Gem::Specification 
+name: engrel
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 10
+  - 0
+  version: 0.10.0
+platform: ruby
+authors: 
+- Matt Lightner
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-24 00:00:00 -06:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: text-highlight
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: enumerated_attribute
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: yard
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 6
+        - 0
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 5
+        - 1
+        version: 1.5.1
+  type: :development
+  prerelease: false
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: rcov
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: active_support
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *id009
+description: Allows for natural grammar to specify object relationships based on parts of speech.
+email: mlightner@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- README.rdoc
+- lib/engrel.rb
+- lib/engrel/mixin.rb
+- lib/engrel/prepositional_phrase.rb
+- lib/engrel/sentence.rb
+- lib/generators/engrel_generator.rb
+- lib/generators/templates/create_engrel_tables.rb
+- LICENSE.txt
+- test/helper.rb
+- test/test_engrel.rb
+has_rdoc: true
+homepage: http://engrel.com
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3076847749877114109
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A highly flexible entity relationship management system that requires only two tables and lots of clever.
+test_files: 
+- test/helper.rb
+- test/test_engrel.rb