passive_record 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bae7d40e8ae674093246626a73f247c24cfdd442
+  data.tar.gz: d02d5675a5ec0857d1e15e24a7fb7149a880d362
+SHA512:
+  metadata.gz: b0a66bb01e629e8b313aad8febe2085ad4b00a36af23e925393068501d01c988fe3b001d20822c640b4fcdbe7224b192bc93f23cacd78dbbbbbe743cb29d40c5
+  data.tar.gz: 23ccde9e6bc44c98080e854746b4078edf4585c4b59e53a278754c234e1c7d99add543e04dc7d5199ab699fd5e887d1f3e8a42a2025c19e416e3c63c9141f090

data/.document

@@ -0,0 +1,3 @@
+- 
+ChangeLog.md
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,6 @@
+/.bundle
+/.yardoc/
+/Gemfile.lock
+/doc/
+/pkg/
+/vendor/cache/*.gem

data/.rspec

@@ -0,0 +1 @@
+--colour --format documentation

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown --title "passive_record Documentation" --protected

data/ChangeLog.md

@@ -0,0 +1,4 @@
+### 0.1.0 / 2016-02-19
+
+* Initial release:
+

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'activesupport'
+
+group :development do
+  gem 'pry'
+  gem 'kramdown'
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2016 Joseph Weissman
+
+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,81 @@
+# passive_record
+
+* [Homepage](https://rubygems.org/gems/passive_record)
+* [Documentation](http://rubydoc.info/gems/passive_record/frames)
+* [Email](mailto:jweissman1986 at gmail.com)
+
+[![Code Climate GPA](https://codeclimate.com/github//passive_record/badges/gpa.svg)](https://codeclimate.com/github//passive_record)
+
+## Description
+
+PassiveRecord is an extremely lightweight in-memory pseudo-relational algebra.
+
+We implement a simplified subset of AR's interface in pure Ruby.
+
+## Why?
+
+Do you need to track objects by ID and look them up again,
+or look them up based on attributes, or even utilize some limited relational semantics,
+but have no real need for persistence?
+
+PassiveRecord may be right for you.
+
+
+## Features
+
+  - Just 'include PassiveRecord' to activate a PORO in the system
+  - New objects are tracked and assigned IDs
+  - Query on attributes and simple relations (belongs_to, has_one, has_many)
+  - No database required!
+
+## Examples
+
+    require 'passive_record'
+
+    class Model
+      include PassiveRecord
+    end
+
+    class Dog < Model
+      belongs_to :child
+    end
+
+    class Child < Model
+      has_one :dog
+      belongs_to :parent
+    end
+
+    class Parent < Model
+      has_many :children
+      has_many :dogs, :through => :children
+    end
+
+    # Let's create some models!
+    parent = Parent.create
+
+    child = parent.create_child
+    dog = child.create_dog
+
+    # inverse relationships
+    dog.child # ===> dog
+
+    Child.find_by(child_id: dog.child_id) # ===> dog
+
+    # has many thru
+    parent.dogs # ==> [dog]
+
+## Requirements
+
+## Install
+
+    $ gem install passive_record
+
+## Synopsis
+
+    $ passive_record
+
+## Copyright
+
+Copyright (c) 2016 Joseph Weissman
+
+See {file:LICENSE.txt} for details.

data/Rakefile

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'rubygems'
+
+begin
+  require 'bundler/setup'
+rescue LoadError => e
+  abort e.message
+end
+
+require 'rake'
+
+
+require 'rubygems/tasks'
+Gem::Tasks.new
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+task :test    => :spec
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new  
+task :doc => :yard
+
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new do |t|
+  t.cucumber_opts = %w[--format pretty]
+end

data/bin/passive_record

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+root = File.expand_path(File.join(File.dirname(__FILE__),'..'))
+if File.directory?(File.join(root,'.git'))
+  Dir.chdir(root) do
+    begin
+      require 'bundler/setup'
+    rescue LoadError => e
+      warn e.message
+      warn "Run `gem install bundler` to install Bundler"
+      exit -1
+    end
+  end
+end

data/features/passive_record.feature

@@ -0,0 +1 @@
+Feature: Blah blah blah

data/features/step_definitions/passive_record_steps.rb

@@ -0,0 +1 @@
+@wip

data/gemspec.yml

@@ -0,0 +1,16 @@
+name: passive_record
+summary: "no-persistence relational algebra"
+description: "lightweight in-memory simplified subset of AR"
+license: MIT
+authors: Joseph Weissman
+email: jweissman1986@gmail.com
+homepage: https://rubygems.org/gems/passive_record
+
+development_dependencies:
+  bundler: ~> 1.10
+  codeclimate-test-reporter: ~> 0.1
+  cucumber: ~> 0.10.2
+  rake: ~> 10.0
+  rspec: ~> 3.0
+  rubygems-tasks: ~> 0.2
+  yard: ~> 0.8

data/lib/passive_record.rb

@@ -0,0 +1,111 @@
+require 'active_support'
+require 'active_support/core_ext/string/inflections'
+
+require 'passive_record/version'
+require 'passive_record/core/identifier'
+require 'passive_record/core/query'
+
+require 'passive_record/associations'
+
+module PassiveRecord
+  def self.included(base)
+    base.send :include, InstanceMethods
+    base.extend(ClassMethods)
+  end
+
+  module InstanceMethods
+    def relationships
+      @relata ||= self.class.associations.map do |assn|
+        assn.to_relation(self)
+      end
+    end
+
+    def method_missing(meth, *args, &blk)
+      matching_relation = relationships.detect do |relation|  # matching relation...
+        meth == relation.association.target_name_symbol ||
+          meth.to_s == relation.association.target_name_symbol.to_s + "=" ||
+          meth.to_s == relation.association.target_name_symbol.to_s + "_id" ||
+          meth.to_s == relation.association.target_name_symbol.to_s + "_id=" ||
+          meth.to_s == "create_" + relation.association.target_name_symbol.to_s ||
+          meth.to_s == "create_" + (relation.association.target_name_symbol.to_s).singularize
+      end
+
+      if matching_relation
+        if meth.to_s.end_with?("_id")
+          matching_relation.parent_model_id
+        elsif meth.to_s.end_with?("_id=")
+          matching_relation.parent_model_id = args.first
+        elsif meth.to_s.end_with?("=")
+          matching_relation.parent_model_id = args.first.id
+        elsif meth.to_s.start_with?("create_")
+          matching_relation.create(*args)
+        else
+          # lookup the matching associated entities
+          matching_relation.lookup
+        end
+      else
+        super(meth,*args,&blk)
+      end
+    end
+  end
+
+  module ClassMethods
+    include PassiveRecord::Core
+    include PassiveRecord::Associations
+
+    include Enumerable
+    extend Forwardable
+
+    def all
+      instances_by_id.values
+    end
+    def_delegators :all, :each
+
+    def find_by(conditions)
+      if conditions.is_a?(Identifier)
+        find_by_id(conditions)
+      elsif conditions.is_a?(Array) && conditions.all? { |c| c.is_a?(Identifier) }
+        find_by_ids(conditions)
+      else
+        where(conditions).first
+      end
+    end
+
+    def where(conditions)
+      Query.new(self, conditions)
+    end
+
+    def create(attrs={})
+      registrable = new #(*args)
+
+      registrable.singleton_class.class_eval { attr_accessor :id }
+      registrable.send(:"id=", Identifier.generate)
+      register(registrable)
+
+      attrs.each do |(k,v)|
+        registrable.send("#{k}=", v)
+      end
+
+      registrable
+    end
+
+    protected
+    def find_by_id(id)
+      instances_by_id[id]
+    end
+
+    def find_by_ids(ids)
+      instances_by_id.select { |id,_| ids.include?(id) }.values
+    end
+
+    private
+    def instances_by_id
+      @instances ||= {}
+    end
+
+    def register(model)
+      instances_by_id[model.id] = model
+      self
+    end
+  end
+end

data/lib/passive_record/associations.rb

@@ -0,0 +1,42 @@
+require 'passive_record/associations/belongs_to'
+require 'passive_record/associations/has_one'
+require 'passive_record/associations/has_many'
+require 'passive_record/associations/has_many_through'
+
+module PassiveRecord
+  module Associations
+    def associations
+      @associations ||= []
+    end
+
+    def belongs_to(parent_name_sym, opts={})
+      target_class_name = opts.delete(:class_name) { (parent_name_sym.to_s).split('_').map(&:capitalize).join }
+      association = BelongsToAssociation.new(self, target_class_name, parent_name_sym)
+      associations.push(association)
+    end
+
+    def has_one(child_name_sym)
+      child_class_name = (child_name_sym.to_s).split('_').map(&:capitalize).join
+      association = HasOneAssociation.new(self, child_class_name, child_name_sym)
+      associations.push(association)
+    end
+
+    def has_many(collection_name_sym, opts={})
+      target_class_name = (collection_name_sym.to_s).split('_').map(&:capitalize).join
+
+      if opts.key?(:through)
+        through_class_collection_name = opts.delete(:through)
+
+        through_class_name = (through_class_collection_name.to_s).split('_').map(&:capitalize).join
+        base_association = associations.detect { |assn| assn.child_class_name == through_class_name }
+
+        association = HasManyThroughAssociation.new(self, target_class_name, collection_name_sym, through_class_collection_name, base_association)
+
+        associations.push(association)
+      else # simple has-many
+        association = HasManyAssociation.new(self, target_class_name, collection_name_sym)
+        associations.push(association)
+      end
+    end
+  end
+end

data/lib/passive_record/associations/belongs_to.rb

@@ -0,0 +1,27 @@
+module PassiveRecord
+  module Associations
+    class BelongsToAssociation < Struct.new(:child_class, :parent_class_name, :target_name_symbol)
+      def to_relation(child_model)
+        BelongsToRelation.new(self, child_model)
+      end
+
+      def parent_class
+        Object.const_get(parent_class_name)
+      end
+    end
+
+    class BelongsToRelation < Struct.new(:association, :child_model)
+      def lookup
+        association.parent_class.find_by(parent_model_id)
+      end
+
+      def parent_model_id
+        @parent_model_id ||= nil
+      end
+
+      def parent_model_id=(id)
+        @parent_model_id = id
+      end
+    end
+  end
+end

data/lib/passive_record/associations/has_many.rb

@@ -0,0 +1,19 @@
+module PassiveRecord
+  module Associations
+    class HasManyAssociation < Struct.new(:parent_class, :child_class_name, :children_name_sym)
+      def to_relation(parent_model)
+        HasManyRelation.new(self, parent_model)
+      end
+
+      def target_name_symbol
+        children_name_sym
+      end
+    end
+
+    class HasManyRelation < HasOneRelation
+      def lookup
+        child_class.where(parent_model_id_field => parent_model.id).all
+      end
+    end
+  end
+end

data/lib/passive_record/associations/has_many_through.rb

@@ -0,0 +1,24 @@
+module PassiveRecord
+  module Associations
+    class HasManyThroughAssociation < Struct.new(:parent_class, :child_class_name, :target_name_symbol, :through_class, :base_association)
+      def to_relation(parent_model)
+        HasManyThroughRelation.new(self, parent_model)
+      end
+    end
+
+    class HasManyThroughRelation < HasManyRelation
+      def lookup
+        association.base_association.
+          to_relation(parent_model).
+          lookup.
+          flat_map(&association.target_name_symbol.to_s.singularize.to_sym)
+      end
+
+      def create(attrs={})
+        # binding.pry
+        raise "missing intermediate relational key #{association.through_class}" unless attrs.key?(association.through_class)
+        super(attrs)
+      end
+    end
+  end
+end

data/lib/passive_record/associations/has_one.rb

@@ -0,0 +1,38 @@
+module PassiveRecord
+  module Associations
+    class HasOneAssociation < Struct.new(:parent_class, :child_class_name, :child_name_sym)
+
+      def to_relation(parent_model)
+        HasOneRelation.new(self, parent_model)
+      end
+
+      def target_name_symbol
+        child_name_sym
+      end
+    end
+
+    class HasOneRelation < Struct.new(:association, :parent_model)
+      def lookup
+        child_class.find_by(parent_model_id_field => parent_model.id)
+      end
+
+      def create(*args)
+        model = child_class.create(*args)
+        model.send(parent_model_id_field + "=", parent_model.id)
+        model
+      end
+
+      def parent_model_id_field
+        parent_class_name + "_id"
+      end
+
+      def parent_class_name
+        association.parent_class.name.underscore
+      end
+
+      def child_class
+        Object.const_get(association.child_class_name.singularize)
+      end
+    end
+  end
+end

data/lib/passive_record/core/identifier.rb

@@ -0,0 +1,7 @@
+module PassiveRecord
+  class Identifier < Struct.new(:value)
+    def self.generate
+      new(SecureRandom.uuid)
+    end
+  end
+end

data/lib/passive_record/core/query.rb

@@ -0,0 +1,25 @@
+module PassiveRecord
+  module Core
+    class Query < Struct.new(:klass, :conditions)
+      def all
+        klass.all.select do |instance|
+          conditions.all? do |(field,value)|
+            instance.send(field) == value
+          end
+        end
+      end
+
+      def first
+        all.first
+      end
+
+      def create
+        klass.create(conditions)
+      end
+
+      def first_or_create
+        first || create
+      end
+    end
+  end
+end

data/lib/passive_record/hstruct.rb

@@ -0,0 +1,38 @@
+#
+# build a hash-initialized 'record' class
+#
+# singleton_class pattern taken from http://stackoverflow.com/questions/15256940/in-ruby-how-do-i-implement-a-class-whose-new-method-creates-subclasses-of-itsel
+#
+class HStruct
+  singleton_class.class_eval { alias :old_new :new }
+
+  def initialize(attributes={})
+    attributes.each do |k,v|
+      send("#{k}=",v)
+    end
+  end
+
+  def fetch_values(*args)
+    to_h.fetch_values(*args)
+  end
+
+  def to_h
+    attribute_names.inject({}) do |hsh,k|
+      hsh[k] = send("#{k}"); hsh
+    end
+  end
+
+  def self.new(*attribute_names)
+    Class.new(self){
+      singleton_class.class_eval {
+        alias :new :old_new
+      }
+
+      attribute_names.each do |k|
+        attr_accessor k.to_sym
+      end
+
+      define_method(:attribute_names) { attribute_names }
+    }
+  end
+end

data/lib/passive_record/version.rb

@@ -0,0 +1,4 @@
+module PassiveRecord
+  # passive_record version
+  VERSION = "0.1.0"
+end

data/passive_record.gemspec

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+require 'yaml'
+
+Gem::Specification.new do |gem|
+  gemspec = YAML.load_file('gemspec.yml')
+
+  gem.name    = gemspec.fetch('name')
+  gem.version = gemspec.fetch('version') do
+                  lib_dir = File.join(File.dirname(__FILE__),'lib')
+                  $LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
+
+                  require 'passive_record/version'
+                  PassiveRecord::VERSION
+                end
+
+  gem.summary     = gemspec['summary']
+  gem.description = gemspec['description']
+  gem.licenses    = Array(gemspec['license'])
+  gem.authors     = Array(gemspec['authors'])
+  gem.email       = gemspec['email']
+  gem.homepage    = gemspec['homepage']
+
+  glob = lambda { |patterns| gem.files & Dir[*patterns] }
+
+  gem.files = `git ls-files`.split($/)
+  gem.files = glob[gemspec['files']] if gemspec['files']
+
+  gem.executables = gemspec.fetch('executables') do
+    glob['bin/*'].map { |path| File.basename(path) }
+  end
+  gem.default_executable = gem.executables.first if Gem::VERSION < '1.7.'
+
+  gem.extensions       = glob[gemspec['extensions'] || 'ext/**/extconf.rb']
+  gem.test_files       = glob[gemspec['test_files'] || '{test/{**/}*_test.rb']
+  gem.extra_rdoc_files = glob[gemspec['extra_doc_files'] || '*.{txt,md}']
+
+  gem.require_paths = Array(gemspec.fetch('require_paths') {
+    %w[ext lib].select { |dir| File.directory?(dir) }
+  })
+
+  gem.requirements              = Array(gemspec['requirements'])
+  gem.required_ruby_version     = gemspec['required_ruby_version']
+  gem.required_rubygems_version = gemspec['required_rubygems_version']
+  gem.post_install_message      = gemspec['post_install_message']
+
+  split = lambda { |string| string.split(/,\s*/) }
+
+  if gemspec['dependencies']
+    gemspec['dependencies'].each do |name,versions|
+      gem.add_dependency(name,split[versions])
+    end
+  end
+
+  if gemspec['development_dependencies']
+    gemspec['development_dependencies'].each do |name,versions|
+      gem.add_development_dependency(name,split[versions])
+    end
+  end
+end

data/spec/passive_record_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Model do
+  describe "with a simple model including PR" do
+    let!(:model) { SimpleModel.create(foo: value) }
+    let(:value) { 'foo_value' }
+
+    describe "#id" do
+      it 'should be retrievable by id' do
+        expect(SimpleModel.find_by(model.id)).to eq(model)
+      end
+    end
+
+    describe "#count" do
+      it 'should indicate the size of the models list' do
+        expect { SimpleModel.create }.to change { SimpleModel.count }.by(1)
+      end
+    end
+
+    describe "#find_by" do
+      it 'should be retrievable by query' do
+        expect(SimpleModel.find_by(foo: 'foo_value')).to eq(model)
+      end
+    end
+  end
+
+  context 'one-to-one relationships' do
+    let(:child) { Child.create }
+    let(:another_child) { Child.create }
+
+    it 'should create children' do
+      expect { child.create_dog }.to change { Dog.count }.by(1)
+      expect(child.dog).to eq(Dog.first)
+    end
+
+    it 'should have inverse relationships' do
+      dog = child.create_dog
+      expect(dog.child).to eq(child)
+      another_dog = another_child.create_dog
+      expect(another_dog.child).to eq(another_child)
+    end
+  end
+
+  context 'one-to-many relationships' do
+    let(:parent) { Parent.create }
+
+    it 'should create children' do
+      expect { parent.create_child }.to change{ Child.count }.by(1)
+      expect(parent.children).to all(be_a(Child))
+    end
+
+    it 'should create inverse relationships' do
+      child = parent.create_child
+      expect(child.parent).to eq(parent)
+
+      another_child = parent.create_child
+      expect(another_child.parent).to eq(parent)
+
+      expect(child.id).not_to eq(another_child.id)
+      expect(parent.children).to eq([child, another_child])
+    end
+  end
+
+  context 'one-to-many through relationships' do
+    let(:parent) { Parent.create }
+    let(:child) { parent.create_child }
+    subject(:dogs) { parent.dogs }
+
+    it 'should collect children of children' do
+      child.create_dog
+      expect(dogs).to all(be_a(Dog))
+      expect(dogs.first).to eq(child.dog)
+    end
+  end
+
+  context 'many-to-many' do
+    let(:patient) { Patient.create }
+    let(:doctor)  { Doctor.create }
+    let!(:appointment) { Appointment.create(patient: patient, doctor: doctor) }
+
+    it 'should manage many-to-many relations' do
+      expect(appointment.doctor).to eq(doctor)
+      expect(appointment.patient).to eq(patient)
+
+      expect(patient.doctors).to eq([doctor])
+      expect(doctor.patients).to eq([patient])
+    end
+  end
+
+  context 'self-referential many-to-many' do
+    let!(:user_a) { User.create }
+    let!(:user_b) { User.create }
+
+    it 'should permit relations' do
+      expect(user_a.friends).to be_empty
+
+      # need to create bidirectional friendship
+      Friendship.create(user: user_a, friend: user_b)
+      Friendship.create(user: user_b, friend: user_a)
+
+      expect(user_a.friends).to eq([user_b])
+      expect(user_b.friends).to eq([user_a])
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,56 @@
+require 'rspec'
+require 'pry'
+require 'passive_record'
+
+class Model
+  include PassiveRecord
+end
+
+class SimpleModel < Struct.new(:foo)
+  include PassiveRecord
+end
+
+class Dog < Model
+  belongs_to :child
+end
+
+class Child < Model
+  has_one :dog
+  belongs_to :parent
+end
+
+class Parent < Model
+  has_many :children
+  has_many :dogs, :through => :children
+end
+
+###
+
+class Patient < Model
+  has_many :appointments
+  has_many :doctors, :through => :appointments
+end
+
+class Appointment < Model
+  belongs_to :patient
+  belongs_to :doctor
+end
+
+class Doctor < Model
+  has_many :appointments
+  has_many :patients, :through => :appointments
+end
+
+###
+#
+# self-referential case
+#
+class Friendship < Model
+  belongs_to :user
+  belongs_to :friend, class_name: "User"
+end
+
+class User < Model
+  has_many :friendships
+  has_many :friends, :through => :friendships
+end

metadata

@@ -0,0 +1,174 @@
+--- !ruby/object:Gem::Specification
+name: passive_record
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Joseph Weissman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.2
+- !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: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubygems-tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: lightweight in-memory simplified subset of AR
+email: jweissman1986@gmail.com
+executables:
+- passive_record
+extensions: []
+extra_rdoc_files:
+- ChangeLog.md
+- LICENSE.txt
+- README.md
+files:
+- ".document"
+- ".gitignore"
+- ".rspec"
+- ".yardopts"
+- ChangeLog.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/passive_record
+- features/.gitkeep
+- features/passive_record.feature
+- features/step_definitions/.gitkeep
+- features/step_definitions/passive_record_steps.rb
+- gemspec.yml
+- lib/passive_record.rb
+- lib/passive_record/associations.rb
+- lib/passive_record/associations/belongs_to.rb
+- lib/passive_record/associations/has_many.rb
+- lib/passive_record/associations/has_many_through.rb
+- lib/passive_record/associations/has_one.rb
+- lib/passive_record/core/identifier.rb
+- lib/passive_record/core/query.rb
+- lib/passive_record/hstruct.rb
+- lib/passive_record/version.rb
+- passive_record.gemspec
+- spec/passive_record_spec.rb
+- spec/spec_helper.rb
+homepage: https://rubygems.org/gems/passive_record
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: no-persistence relational algebra
+test_files: []
+has_rdoc: