mini_model 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a8e0f797ba49f5f53cd9f8951740f3be6cfd0106
+  data.tar.gz: 60127c7c9cf2997c7ffcc33b0eb99a8ac69293ba
+SHA512:
+  metadata.gz: b28d1b7ea7b1d3d3fb356eca45294c528beaab5f6d96addc8ceb633a76a003e2437c3160e24182b500f0c0d455c5c576d6250f0dbd8aecde05c13001256d7d74
+  data.tar.gz: 9ce5cc6657617da3953f50897cdc2e71432efe0f419821c652a4bf26bb2b850ac4fb0e49a54fdb80deffad8849ed7c14f1b26002bf28a29d6f05dddb7dc133c8

data/.gems

@@ -0,0 +1,3 @@
+cutest -v 1.2.3
+sequel -v 5.1.0
+sqlite3 -v 1.3.13

data/.gitignore

@@ -0,0 +1 @@
+/.gs

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Michel Martens and Damian Janowski
+Copyright (c) 2017 Steven Weiss
+
+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,238 @@
+# MiniModel
+
+MiniModel is an alternative active record implementation to Sequel::Model.
+It is designed to work with Sequel::Dataset, but aims to be a much smaller api
+than Sequel::Model. The api is largely based on the lovely [Ohm][ohm] gem,
+an ORM in Ruby for Redis.
+
+## Installation
+
+`$ gem install mini_model`
+
+You must also install [Sequel][sequel] and the database of your choice.
+
+## Usage
+
+Checkout the tests and `./examples` for more advanced use cases,
+but the basics look something like:
+
+```ruby
+  require 'mini_model'
+  require 'sequel'
+  require 'sqlite' # Or any Sequel supported database.
+
+  DB = Sequel.sqlite
+
+  class Model
+    include MiniModel
+
+    # ...
+  end
+
+  Model.dataset = DB[:models]
+```
+
+## API
+
+### Class Methods
+
+`::dataset=` Sets the dataset for the given model.
+
+`::dataset` Gets the assigned dataset.
+
+`::attribute` Macro for generating an accessor for the attributes hash.
+
+`::build` Builds a new instance of the model when given attributes.
+
+`::create` Convenience for `new(attributes).create`.
+
+`::[]` Fetches a record for the given id via Sequel::Datase#first.
+
+`::first` Fetches the first record for the given args, see Sequel::Dataset#first.
+
+`::all` Fetch all records for the current dataset, see Sequel::Dataset#all.
+
+`::where` Fetch records for the given conditions, see Sequel::Dataset#where.
+
+`::to_foreign_key` Contains the covention for converting class names into foreign keys.
+`Person` becomes `person_id`.
+
+`::children` Association macro for "1 to n". See the section on associations below.
+
+`::child` Association macro for "1 to 1" where the foreign key is on the other table.
+
+`::parent` Association macro for "1 to 1/n" where the foreign key is on our table.
+
+### Instance Methods
+
+`#initialize` Sets the given attributes on the model instance, note that if the id
+is in the attributes hash it will also be assigned.
+
+`#dataset` Delegates to the class' dataset.
+
+`#id` The current id value, if it exists, or raises an error.
+Raising the error is to stop anything right away that may depend on the id.
+We don't want to be assigning nil all over our associations and what have you.
+
+`#id=` Assigns the id.
+
+`#attributes` Gets the attributes hash.
+
+`#attributes=` For each key/value in the given hash, sends the writer to self.
+This means it'll be a missing method if you have not created the writer via the
+`::attribute` macro, or manually. This is not safe to use with user input.
+
+`#==` Compares two models to see if they are equals. It ensures that the class,
+id, and attributes of each are the same.
+
+`#persisted?` Used to check if a model has an id or not. It is assumed if
+it has an id it's in the database.
+
+`#save` Delegates to the proper persistence method.
+
+`#create` Inserts attributes in the database. Returns self on success, nil
+on failure.
+
+`#update` Updates attributes in the database for id. Returns self on success,
+nil on failure.
+
+`#delete` Deletes itself from the database and unassigns the id. If you want
+to do anything with the id after deletion, copy it before calling delete.
+
+## Attributes
+
+Attributes in MiniModel are all stored internally inside the `@attributes` hash.
+The `::attribute` macro is really just an easy way of defining accessors
+similar to `attr_accessor`, but getting and setting on that hash.
+
+There is plans to implement a more robust attribute api,
+but right now it is not implemented.
+
+## Associations
+
+Associations in MiniModel are largely inspired by [Ohm][ohm].
+They are pretty much the same, but where Ohm uses a collection/reference metaphor,
+MiniModel uses parent/child(ren).
+
+Note that associations finders are not cached at this time, a small caching
+layer will be added in the future.
+
+### Parent
+
+Lets take a look at the `::parent` macro.
+
+```ruby
+class Photo
+  include MiniModel
+
+  # It turns this...
+
+  parent :user, :User
+
+  # Into something like this...
+
+  def user_id
+    @attributes[:user_id]
+  end
+
+  def user_id=(user_id)
+    @attributes[:user_id] = user_id
+  end
+
+  def user
+    User[user_id]
+  end
+
+  def user=(user)
+    self.user_id = user.id
+  end
+end
+```
+
+This means that when we say `parent :user, :User` user is our parent, and the foreign
+key is on our table. You can customize the foreign key by passing a third symbol argument,
+but with this convention the primary key on the parent must be id. You can always
+skip the parent macro and implement things manually if you're using a different
+primary key.
+
+### Children
+
+Children are even simpler than parents, as it's just a finder.
+
+```ruby
+  class User
+    include MiniModel
+
+    children :photos, :Photo
+
+    # Roughly becomes...
+
+    def photos
+      Photo.where(user_id: id)
+    end
+  end
+```
+
+Once again you can customize the foreign key (user_id) with a third argument,
+but not that it's referring to the id on ourself. These macros are just
+conveniences for the 90% use case, unique situations are easy to implement
+yourself like...
+
+```ruby
+  def photos
+    Photo.where(user_email: email)
+  end
+```
+
+An **important** thing to note when dealing with associations is that MiniModel
+only provides the association writer on the "child" side of the relationship. That
+means the parent must be saved to start assign associations, but also you can't do
+something like `user.photos << photo` and have it persist. Another note is the relationship
+will not be persisted until calling save (or create/update) on the child.
+
+On our User model, if we want to work from that side of the association, you could
+create delegation methods like so:
+
+```
+  def add_photo(photo)
+    photo.user_id = id
+  end
+```
+
+### Child
+
+The final association macro is `child`. It works the same exact way as
+`children` though uses the `.first` finder to get a single record.
+
+```ruby
+  class User
+    include MiniModel
+
+    child :profile, :Profile
+
+    # This roughly expands to...
+
+    def profile
+      Profile.first(user_id: id)
+    end
+  end
+```
+
+## Non-SQL Databases
+
+MiniModel is designed to work with Sequel (and SQL Databases),
+though it will work with anything that implements a subset of Sequel::DataSet.
+
+If you would like your write your own adapter/dataset for a non SQL database,
+MiniMapper depends on the following Sequel::DataSet methods:
+
+`Sequel::Dataset#all`
+`Sequel::Dataset#delete`
+`Sequel::Dataset#first`
+`Sequel::Dataset#insert`
+`Sequel::Dataset#update`
+`Sequel::Dataset#where`
+
+[ohm]: http://github.com/soveran/ohm
+[sequel]: https://github.com/jeremyevans/sequel
+

data/Rakefile

@@ -0,0 +1,16 @@
+desc 'open irb in gs context'
+task :console do
+  sh 'gs irb'
+end
+
+desc 'installs gems'
+task :install do
+  sh 'mkdir -p .gs & gs dep install'
+end
+
+desc 'tests the given [test].rb'
+task :test, :name do |t, args|
+  name = args[:name] || '*'
+
+  sh "gs cutest -r ./test/#{name}.rb"
+end

data/examples/associations.rb

@@ -0,0 +1,61 @@
+class User
+  include MiniModel
+
+  attribute :email
+
+  child :profile, :Profile
+
+  children :photos, :Photo
+
+  children :photo_comments, :PhotoComment
+
+  children :videos, :Video
+
+  children :video_comments, :VideoComment
+
+  def comments
+    photo_comments + video_comments
+  end
+end
+
+class Profile
+  include MiniModel
+
+  parent :user, :User
+end
+
+class Photo
+  include MiniModel
+
+  attribute :url
+
+  parent :user, :User
+
+  children :comments, :PhotoComment
+end
+
+class Video
+  include MiniModel
+
+  attribute :url
+
+  parent :user, :User
+
+  children :comments, :VideoComment
+end
+
+class Comment
+  include MiniModel
+
+  attribute :body
+
+  parent :user, :User
+end
+
+class PhotoComment < Comment
+  parent :photo, :Photo
+end
+
+class VideoComment < Comment
+  parent :video, :Video
+end

data/examples/callbacks.rb

@@ -0,0 +1,39 @@
+class Model
+  include MiniModel
+
+  attribute :created_at
+
+  attribute :updated_at
+
+  def before_create
+    self.created_at = Time.noew
+  end
+
+  def after_create; end
+
+  def create
+    before_create
+
+    ret = super
+
+    after_create
+
+    ret
+  end
+
+  def before_update
+    self.updated_at = Time.noew
+  end
+
+  def after_update; end
+
+  def update
+    before_update
+
+    ret = super
+
+    after_update
+
+    ret
+  end
+end

data/examples/multi_database.rb

@@ -0,0 +1,15 @@
+db1 = Sequel.sqlite
+
+db2 = Sequel.sqlite # sorry ibm
+
+class User
+  include MiniModel
+end
+
+User.dataset = db1[:users]
+
+class Post
+  include MiniModel
+end
+
+Post.dataset = db2[:posts]

data/examples/single_database.rb

@@ -0,0 +1,13 @@
+db = Sequel.sqlite
+
+class User
+  include MiniModel
+end
+
+User.dataset = db[:users]
+
+class Post
+  include MiniModel
+end
+
+Post.dataset = db[:posts]

data/examples/soft_deletes.rb

@@ -0,0 +1,15 @@
+class Model
+  include MiniModel
+
+  attribute :deleted_at
+
+  def deleted?
+    !!deleted_at
+  end
+
+  def delete
+    self.deleted_at = Time.now
+
+    update
+  end
+end

data/lib/mini_model.rb

@@ -0,0 +1,237 @@
+module MiniModel
+  VERSION = '0.0.0'
+
+  class Error < StandardError; end
+
+  class MissingId < Error; end
+
+  def self.included(model)
+    model.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def dataset
+      @dataset
+    end
+
+    def dataset=(dataset)
+      @dataset = dataset
+    end
+
+    # Defines an accessor for the attributes hash. The whole point
+    # of the attributes hash vs. instance variables is for easily
+    # passing a hash to the dataset for persistence. Maybe this is a bad
+    # idea and we should use plain ol' attr_accessor and build the hash
+    # when needed.
+    def attribute(key, type = nil)
+      reader = :"#{key}"
+      writer = :"#{key}="
+
+      define_method(reader) do
+        self.attributes[reader]
+      end
+
+      define_method(writer) do |value|
+        self.attributes[reader] = value
+      end
+    end
+
+    def build(attributes)
+      if attributes
+        new(attributes)
+      else
+        nil
+      end
+    end
+
+    # Convenience for initializin and persisting a
+    # new model instance.
+    def create(attributes = {})
+      new(attributes).create
+    end
+
+    def [](id)
+      build(dataset.first(id: id))
+    end
+
+    def first(*args, &block)
+      build(dataset.first(*args, &block))
+    end
+
+    def all(&block)
+      dataset.all(&block).map { |each| build(each) }
+    end
+
+    def where(*args, &block)
+      dataset.where(*args, &block).map { |each| build(each) }
+    end
+
+    def to_foreign_key
+      name.
+        to_s.
+        match(/^(?:.*::)*(.*)$/)[1].
+        gsub(/([a-z\d])([A-Z])/, '\1_\2').
+        downcase.
+        concat('_id').
+        to_sym
+    end
+
+    def children(association, model_name, foreign_key = to_foreign_key)
+      define_method(association) do
+        model = self.class.const_get(model_name)
+
+        model.where(foreign_key => id)
+      end
+    end
+
+    def child(association, model_name, foreign_key = to_foreign_key)
+      define_method(association) do
+        model = self.class.const_get(model_name)
+
+        model.first(foreign_key => id)
+      end
+    end
+
+    def parent(association, model_name, foreign_key = :"#{association}_id")
+      reader = foreign_key
+      writer = :"#{foreign_key}="
+
+      define_method(reader) do
+        self.attributes[reader]
+      end
+
+      define_method(writer) do |value|
+        self.attributes[reader] = value
+      end
+
+      define_method(association) do
+        model = self.class.const_get(model_name)
+
+        model[send(foreign_key)]
+      end
+
+      define_method(:"#{association}=") do |value|
+        if value
+          send(writer, value.id)
+        else
+          send(writer, value)
+        end
+      end
+    end
+  end
+
+  def initialize(attributes = {})
+    self.attributes = attributes # Will set the id if it exists.
+  end
+
+  def dataset
+    self.class.dataset
+  end
+
+  def id
+    if @id
+      @id
+    else
+      # If our model does not have an id, raise at the first occurence
+      # of anyone expecting it. This prevents us from assigning associations
+      # and other logical paths for things that do not exist in the db.
+      raise MissingId
+    end
+  end
+
+  def id=(id)
+    @id = id
+  end
+
+  def attributes
+    @attributes
+  end
+
+  # #attributes= is vulnerable to mass assignment attacks if used
+  # directly with user input. Some sort of filter must be in place
+  # before setting attributes or initializing a new model. Sending
+  # a key in the hash argument that doesn't have an accessor raises an error.
+  def attributes=(attributes)
+    @attributes = {}
+
+    attributes.each do |key, value|
+      send(:"#{key}=", value)
+    end
+  end
+
+  # Strap in, the is probably the most complicated method
+  # in the entire library.
+  def ==(other)
+    # If the classes don't match, they cannot possibly be equal.
+    if self.class != other.class
+      return false
+    end
+
+    # If the persisted state doesn't match, they also can never be equal.
+    if persisted? != other.persisted?
+      return false
+    end
+
+    # When persisted, check the other's id to see if it's the same,
+    # cannot possible be equals if they have different ids.
+    if persisted? && id != other.id
+      return false
+    end
+
+    # Finally, compare the attributes hash. If all key/values match,
+    # they are considered equal.
+    attributes == other.attributes
+  end
+
+  def persisted?
+    !!@id
+  end
+
+  # Use #save to write generic persistence code in things like form objects
+  # so you don't have to reach inside the model to determine the proper
+  # method to call.
+  def save
+    if persisted?
+      update
+    else
+      create
+    end
+  end
+
+  # #create (as well as #update, and #delete) return self on
+  # success and nil on failure. This lets us use these actions
+  # as if conditions which is convenience though dangerous.
+  def create
+    id = dataset.insert(attributes)
+
+    if id
+      self.id = id
+
+      self
+    else
+      nil
+    end
+  end
+
+  def update
+    count = dataset.where(id: id).update(attributes)
+
+    if count.to_i > 0
+      self
+    else
+      nil
+    end
+  end
+
+  def delete
+    count = dataset.where(id: id).delete
+
+    if count.to_i > 0
+      self.id = nil
+
+      self
+    else
+      nil
+    end
+  end
+end

data/mini_model.gemspec

@@ -0,0 +1,16 @@
+require_relative "./lib/mini_model"
+
+Gem::Specification.new do |s|
+  s.name     = "mini_model"
+  s.summary  = "MiniModel"
+  s.version  = MiniModel::VERSION
+  s.authors  = ["Steve Weiss"]
+  s.email    = ["weissst@mail.gvsu.edu"]
+  s.homepage = "https://github.com/sirscriptalot/mini_model"
+  s.license  = "MIT"
+  s.files    = `git ls-files`.split("\n")
+
+  s.add_development_dependency "cutest", "~> 1.2"
+  s.add_development_dependency "sequel", "~> 5.1"
+  s.add_development_dependency "sqlite3", "~> 1.3"
+end

data/test/all.rb

@@ -0,0 +1,467 @@
+require 'sequel'
+require 'sqlite3'
+require_relative '../lib/mini_model'
+
+db = Sequel.sqlite
+
+db.create_table :users do
+  primary_key :id
+
+  String :email, size: 255, unique: true, not_null: true
+end
+
+db.create_table :profiles do
+  primary_key :id
+
+  foreign_key :user_id, :users, on_delete: :cascade
+end
+
+
+db.create_table :photos do
+  primary_key :id
+
+  foreign_key :user_id, :users, on_delete: :cascade
+
+  String :url, unique: true, not_null: true
+end
+
+db.create_table :videos do
+  primary_key :id
+
+  foreign_key :user_id, :users, on_delete: :cascade
+
+  String :url, unique: true, not_null: true
+end
+
+db.create_table :photo_comments do
+  primary_key :id
+
+  foreign_key :user_id, :users, on_delete: :cascade
+
+  foreign_key :photo_id, :photos, on_delete: :cascade
+
+  # Make sure we can spam user comments to Twitter, we need attention.
+  String :body, size: 140, nut_null: true
+end
+
+db.create_table :video_comments do
+  primary_key :id
+
+  foreign_key :user_id, :users, on_delete: :cascade
+
+  foreign_key :video_id, :videos, on_delete: :cascade
+
+  # Make sure we can spam user comments to Twitter, we need attention.
+  String :body, size: 140, nut_null: true
+end
+
+require_relative '../examples/associations'
+
+User.dataset = db[:users]
+
+Photo.dataset = db[:photos]
+
+Video.dataset = db[:videos]
+
+PhotoComment.dataset = db[:photo_comments]
+
+VideoComment.dataset = db[:video_comments]
+
+prepare do
+  # Ensure each test runs with a clean database.
+  [User, Photo, Video, PhotoComment, VideoComment].each do |model|
+    model.dataset.delete
+  end
+end
+
+test '::dataset= sets dataset' do
+  original = User.dataset
+
+  User.dataset = :fake
+
+  assert_equal User.dataset, :fake
+
+  User.dataset = original
+end
+
+test '::dataset gets dataset' do
+  assert_equal User.dataset, db[:users]
+end
+
+test '::attribute defines accessor methods' do
+  user = User.new
+
+  assert user.respond_to?(:email)
+  assert user.respond_to?(:email=)
+end
+
+test '::build returns an instance when given a hash' do
+  user = User.build({})
+
+  assert user.is_a?(User)
+end
+
+test '::build returns nil when given a falsey value' do
+  user = User.build(false)
+
+  assert user.nil?
+end
+
+test '::create creates an instance and persists it in the database' do
+  user = User.create(email: 'name@example.com')
+
+  assert user.is_a?(User)
+  assert user.persisted?
+end
+
+test '::[] fetchs record for a given id' do
+  left = User.create(email: 'name@example.com')
+
+  right = User[left.id]
+
+  assert_equal left, right
+end
+
+test '::first fetchs one record for for the give conditions' do
+  email = 'name@example.com'
+
+  user = User.create(email: email)
+
+  assert_equal User.first(email: email), user
+end
+
+test '::all fetchs all records in the dataset' do
+  one = User.create(email: 'one@example.com')
+
+  two = User.create(email: 'two@example.com')
+
+  all = User.all
+
+  assert all.include?(one)
+  assert all.include?(two)
+end
+
+test '::where fetch all records in the dataset matching condition' do
+  email = 'one@example.com'
+
+  one = User.create(email: email)
+
+  two = User.create(email: 'two@example.com')
+
+  assert User.where(email: email).include?(one)
+end
+
+test '::to_foreign_key snake cases and appends _id to model name' do
+  assert_equal User.to_foreign_key, :user_id
+  assert_equal PhotoComment.to_foreign_key, :photo_comment_id
+end
+
+test '::children defines getter' do
+  user = User.new
+
+  assert user.respond_to?(:photos)
+  assert user.respond_to?(:photo_comments)
+end
+
+test '::child defines getter' do
+  user = User.new
+
+  assert user.respond_to?(:profile)
+end
+
+test '::parent defines getters and setters' do
+  profile = Profile.new
+
+  assert profile.respond_to?(:user)
+  assert profile.respond_to?(:user=)
+  assert profile.respond_to?(:user_id)
+  assert profile.respond_to?(:user_id=)
+end
+
+test '#dataset is delegates to class' do
+  user = User.new
+
+  assert_equal user.dataset, User.dataset
+end
+
+test '#id returns id when it exists' do
+  id = 1
+
+  user = User.new(id: id)
+
+  assert_equal user.id, id
+end
+
+test '#id raises when missing an id' do
+  user = User.new
+
+  assert_raise MiniModel::MissingId do
+    user.id
+  end
+end
+
+test '#id= sets the id' do
+  id = 2
+
+  user = User.new
+
+  user.id = id
+
+  assert_equal user.id, id
+end
+
+test '#attributes returns a hash' do
+  user = User.new
+
+  assert user.attributes.is_a?(Hash)
+end
+
+test '#attributes= sets key/value in attributes hash that exist' do
+  id = 1
+
+  email = 'name@example.com'
+
+  user = User.new
+
+  user.attributes = { id: id, email: email }
+
+  assert_equal user.id, id
+  assert_equal user.email, email
+  assert_equal user.email, user.attributes[:email]
+end
+
+test '#attributes= resets all attributes, but not id' do
+  id = 1
+
+  email = 'name@example.com'
+
+  user = User.new
+
+  user.attributes = { id: id, email: email }
+
+  assert_equal user.id, id
+  assert_equal user.email, email
+  assert_equal user.email, user.attributes[:email]
+
+  user.attributes = {}
+
+  assert_equal user.id, id
+  assert_equal user.email, nil
+  assert_equal user.email, user.attributes[:email]
+end
+
+test '#attributes= raises when there is no accessor for a key' do
+  user = User.new
+
+  assert_raise do
+    user.attributes = { foo: :bar }
+  end
+end
+
+setup do
+  one = User.new(id: 1, email: 'one')
+  two = User.new(id: 1, email: 'one')
+
+  [one, two]
+end
+
+test '#== must have class the same' do |one, two|
+  assert_equal one.class, two.class
+  assert_equal one, two
+end
+
+test '#== must have id the same' do |one, two|
+  assert_equal one.id, two.id
+  assert_equal one, two
+
+  two.id = 2
+
+  assert one != two
+end
+
+test '#== must have attributes the same' do |one, two|
+  assert_equal one.attributes, two.attributes
+  assert_equal one, two
+
+  two.attributes = { email: 'two' }
+
+  assert one != two
+end
+
+test '#persisted? checks if the model has an id or not' do
+  user = User.new
+
+  assert !user.persisted?
+
+  user.id = 1
+
+  assert user.persisted?
+end
+
+test '#save delegates to the proper persistence method' do
+  klass = Class.new(User) do
+    def created?
+      @did_create
+    end
+
+    def create
+      @did_create = true
+    end
+
+    def updated?
+      @did_update
+    end
+
+    def update
+      @did_update = true
+    end
+  end
+
+  to_create = klass.new
+
+  to_create.save
+
+  assert to_create.created? && !to_create.updated?
+
+  to_update = klass.new
+
+  to_update.id = 1
+
+  to_update.save
+
+  assert !to_update.created? && to_update.updated?
+end
+
+class SuccessDataset
+  def insert(*args)
+    9
+  end
+
+  def where(*args)
+    self
+  end
+
+  def update(*args)
+    1
+  end
+
+  def delete(*args)
+    1
+  end
+end
+
+class FailureDataset
+  def insert(*args)
+    nil
+  end
+
+  def where(*args)
+    self
+  end
+
+  def update(*args)
+    0
+  end
+
+  def delete(*args)
+    0
+  end
+end
+
+setup do
+  klass = Class.new(User)
+
+  klass.dataset = SuccessDataset.new
+
+  klass.new
+end
+
+test '#create assigns id on success' do |instance|
+  instance.create
+
+  assert instance.id
+end
+
+test '#create returns self on success' do |instance|
+  ret = instance.create
+
+  assert_equal ret, instance
+end
+
+setup do
+  klass = Class.new(User)
+
+  klass.dataset = FailureDataset.new
+
+  klass.new
+end
+
+test '#create returns nil on failure' do |instance|
+  ret = instance.create
+
+  assert ret.nil?
+end
+
+setup do
+  klass = Class.new(User)
+
+  klass.dataset = SuccessDataset.new
+
+  klass.new(id: 1)
+end
+
+test '#update returns self on success' do |instance|
+  ret = instance.update
+
+  assert_equal ret, instance
+end
+
+setup do
+  klass = Class.new(User)
+
+  klass.dataset = FailureDataset.new
+
+  klass.new(id: 1)
+end
+
+test '#update returns nil on failure' do |instance|
+  ret = instance.update
+
+  assert ret.nil?
+end
+
+setup do
+  klass = Class.new(User)
+
+  klass.dataset = SuccessDataset.new
+
+  klass.new(id: 1)
+end
+
+test '#delete unassigns id on success' do |instance|
+  assert instance.persisted?
+
+  instance.delete
+
+  assert !instance.persisted?
+end
+
+test '#delete returns self on success' do |instance|
+  ret = instance.delete
+
+  assert_equal ret, instance
+end
+
+setup do
+  klass = Class.new(User)
+
+  klass.dataset = FailureDataset.new
+
+  klass.new(id: 1)
+end
+
+test '#delete returns nil on failure' do |instance|
+  ret = instance.delete
+
+  assert ret.nil?
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: mini_model
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Steve Weiss
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-10-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cutest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: 
+email:
+- weissst@mail.gvsu.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gems"
+- ".gitignore"
+- LICENSE
+- README.md
+- Rakefile
+- examples/associations.rb
+- examples/callbacks.rb
+- examples/multi_database.rb
+- examples/single_database.rb
+- examples/soft_deletes.rb
+- lib/mini_model.rb
+- mini_model.gemspec
+- test/all.rb
+homepage: https://github.com/sirscriptalot/mini_model
+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.6.11
+signing_key: 
+specification_version: 4
+summary: MiniModel
+test_files: []