shoden 0.4.0 → 1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 28a3009afa5b70167a8c9128a356002e11224695
-  data.tar.gz: 77efc3fd3a51f5d98ad27591657e96e56f7b9628
+SHA256:
+  metadata.gz: d83a4046d2ee009631a461d017eb91587d878950b5bd2ccdd71caff7d1cbff18
+  data.tar.gz: 16d8fd4fd98795d99727440786ef56e7afc5a25b772753831c21dade14cb28c2
 SHA512:
-  metadata.gz: 0ae31056c6817127730fdebeddd82ecf8cbff424c9dbedef97dd1674825a421c4b9725670ddaf5094828703fdb0214de600011b718aa5bdbfa4bb0c7dc837853
-  data.tar.gz: 72d6ca3fa679e24c8201ba4231228f56f6a59c6b4f399b8ec70b9566b9eda835c00750759402ceb126d684b87095d48a28d0c811422b06c7c97b6b06f9bb2e74
+  metadata.gz: 1790591d549b5d230962ad6b72d718857e536a040f32c7c2f6a7ea04db6ae52dbe42575904d0ea2210e09f23d6c9076114440f2ba888ba487e0a1ba570256f63
+  data.tar.gz: 21bd29c0a876cbce995a9a833e03c453c179db0bae6e51a209995196dbac156633fd91120618759b25016dfa2b8c63dca68a5c9b25b93792b66edb22bcfa8cfb

data/.gitignore

@@ -0,0 +1 @@
+coverage

data/.travis.yml

@@ -1,10 +1,14 @@
 language: ruby
 
 rvm:
-  - "1.9.3"
-  - "2.0.0"
+  - 2.4
+  - 2.5
 
-services: postgresql
+services:
+  - postgresql
+
+addons:
+    postgresql: "9.6"
 
 before_script:
   - psql -c 'create database shoden_test;' -U postgres

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "rake"

data/Gemfile.lock

@@ -0,0 +1,33 @@
+PATH
+  remote: .
+  specs:
+    shoden (1.0)
+      pg (~> 1.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    clap (1.0.0)
+    cutest (1.2.3)
+      clap
+    docile (1.3.1)
+    json (2.2.0)
+    pg (1.1.4)
+    rake (12.3.2)
+    simplecov (0.16.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  cutest (~> 1.2)
+  rake
+  shoden!
+  simplecov (~> 0.16)
+
+BUNDLED WITH
+   1.17.2

data/README.md

@@ -1,10 +1,9 @@
-# Shôden - [![Gem Version](https://badge.fury.io/rb/shoden.svg)](http://badge.fury.io/rb/shoden)
+# Shôden - [![Build Status](https://travis-ci.org/elcuervo/shoden.svg)](https://travis-ci.org/elcuervo/shoden)
 
-![Elephant god](http://www.redprintdna.com/wp-content/uploads/2011/09/L-Elephant-Against-Sky.jpg)
+![Elephant god](https://images.unsplash.com/photo-1523190301657-195ef118bb36?ixlib=rb-1.2.1&ixid=eyJhcHBfaWQiOjEyMDd9&auto=format&fit=crop&w=1500&q=80)
 
 Shôden is a persistance library on top of Postgres.
-It is basically an [Ohm](https://github.com/soveran/ohm) clone but using
-Postgres as a main database.
+Uses JSONB as an storage abstraction so no need for migrations.
 
 ## Installation
 
@@ -12,6 +11,20 @@ Postgres as a main database.
 gem install shoden
 ```
 
+## Connect
+
+Shoden connects by default using a `DATABASE_URL` env variable.
+But you can change the connection string by calling `Shoden.url=`
+
+## Setup
+
+Shoden needs a setup method to create the proper tables.
+You should do that after connecting
+
+```ruby
+Shoden.setup
+```
+
 ## Models
 
 ```ruby
@@ -47,6 +60,17 @@ class Post < Shoden::Model
 end
 ```
 
+## Attributes
+
+Shoden attributes offer you a way to type cast the values, or to perform changes
+in the data itself.
+
+```ruby
+class Shout < Shoden::Model
+  attribute :what, ->(x) { x.uppcase }
+end
+```
+
 ## Indexing
 
 ```ruby
@@ -58,3 +82,17 @@ class User < Shoden::Model
   unique :email
 end
 ```
+
+## Querying
+
+You can query models or relations using the `filter` method.
+
+```ruby
+User.filter(email: "elcuervo@elcuervo.net")
+User.first
+User.last
+User.count
+```
+
+You can go through the entire set using: `User.all` which will give you a
+`Enumerator::Lazy`

data/Rakefile

@@ -5,4 +5,4 @@ Rake::TestTask.new("test") do |t|
   t.pattern = "test/**/*_test.rb"
 end
 
-task :default => [:test]
+task default: [:test]

data/lib/shoden.rb

@@ -1,7 +1,6 @@
-require 'sequel'
-require 'set'
-
-Sequel.extension :pg_hstore, :pg_hstore_ops
+require "pg"
+require "set"
+require "shoden/model"
 
 module Shoden
   Error                = Class.new(StandardError)
@@ -9,56 +8,12 @@ module Shoden
   NotFound             = Class.new(Error)
   UniqueIndexViolation = Class.new(Error)
 
-  Proxy = Struct.new(:klass, :parent) do
-    def create(args = {})
-      klass.create(args.merge(key => parent.id))
-    end
-
-    def all
-      klass.filter(parent_filter)
-    end
-
-    def count
-      klass.count
-    end
-
-    def any?
-      count > 0
-    end
-
-    def first
-      filter = { order: "id ASC LIMIT 1" }.merge!(parent_filter)
-      klass.filter(filter).first
-    end
-
-    def last
-      filter = { order: "id DESC LIMIT 1" }.merge!(parent_filter)
-      klass.filter(filter).first
-    end
-
-    def [](id)
-      filter = { id: id }.merge!(parent_filter)
-
-      klass.filter(filter).first
-    end
-
-    private
-
-    def parent_filter
-      { key => parent.id }
-    end
-
-    def key
-      "#{parent.class.to_reference}_id".freeze
-    end
-  end
-
   def self.url=(url)
     @_url = url
   end
 
   def self.url
-    @_url ||= ENV['DATABASE_URL']
+    @_url ||= ENV["DATABASE_URL"]
   end
 
   def self.models
@@ -66,263 +21,17 @@ module Shoden
   end
 
   def self.connection
-    loggers = []
-
-    if ENV["DEBUG"]
-      require 'logger'
-      loggers << Logger.new($stdout)
+    @_connection ||= begin
+      uri = URI.parse(url)
+      PG.connect(uri.hostname, uri.port, nil, nil, uri.path[1..-1], uri.user, uri.password)
     end
-
-    @_connection ||= Sequel.connect(url, loggers: loggers)
   end
 
   def self.setup
-    connection.execute("CREATE EXTENSION IF NOT EXISTS hstore")
-    models.each { |m| m.setup }
+    models.each(&:setup)
   end
 
   def self.destroy_tables
-    models.each { |m| m.destroy_table }
-  end
-
-  class Model
-    def initialize(attrs = {})
-      @_id = attrs.delete(:id) if attrs[:id]
-      @attributes = {}
-      update(attrs)
-    end
-
-    def id
-      return nil if !defined?(@_id)
-      @_id.to_i
-    end
-
-    def destroy
-      self.class.lookup(id).delete
-    end
-
-    def update(attrs = {})
-      attrs.each { |name, value| send(:"#{name}=", value) }
-    end
-
-    def update_attributes(attrs = {})
-      update(attrs)
-      save
-    end
-
-    def save
-      self.class.save(self)
-      self
-    end
-
-    def load!
-      ret = self.class.lookup(@_id)
-      return nil if ret.nil?
-      update(ret.to_a.first[:data])
-      self
-    end
-
-    def self.inherited(model)
-      Shoden.models.add(model)
-    end
-
-    def self.save(record)
-      if record.id
-        table.where(id: record.id).update(data: record.attributes)
-      else
-        begin
-          id = table.insert(data: record.attributes)
-          record.instance_variable_set(:@_id, id)
-        rescue Sequel::UniqueConstraintViolation
-          raise UniqueIndexViolation
-        end
-      end
-    end
-
-    def self.all
-      collect
-    end
-
-    def self.count
-      size = 0
-      Shoden.connection.fetch("SELECT COUNT(*) FROM \"#{table_name}\"") do |r|
-        size = r[:count]
-      end
-
-      size
-    end
-
-    def self.first
-      collect("ORDER BY id ASC LIMIT 1").first
-    end
-
-    def self.last
-      collect("ORDER BY id DESC LIMIT 1").first
-    end
-
-    def self.create(attrs = {})
-      new(attrs).save
-    end
-
-    def self.attributes
-      @attributes ||= []
-    end
-
-    def self.indices
-      @indices ||= []
-    end
-
-    def self.uniques
-      @uniques ||= []
-    end
-
-    def self.[](id)
-      new(id: id).load!
-    end
-
-    def self.index(name)
-      indices << name if !indices.include?(name)
-    end
-
-    def self.unique(name)
-      uniques << name if !uniques.include?(name)
-    end
-
-    def self.attribute(name, caster = ->(x) { x })
-      attributes << name if !attributes.include?(name)
-
-      define_method(name) { caster[@attributes[name]] }
-      define_method(:"#{name}=") { |value| @attributes[name] = value }
-    end
-
-    def self.collection(name, model)
-      define_method(name) do
-        klass = Kernel.const_get(model)
-        Proxy.new(klass, self)
-      end
-    end
-
-    def self.reference(name, model)
-      reader = :"#{name}_id"
-      writer = :"#{name}_id="
-
-      attributes << name if !attributes.include?(name)
-
-      define_method(reader) { @attributes[reader] }
-      define_method(writer) { |value| @attributes[reader] = value }
-
-      define_method(name) do
-        klass = Kernel.const_get("Shoden::#{model}")
-        klass[send(reader)]
-      end
-    end
-
-    def self.filter(conditions = {})
-      query = []
-      id = conditions.delete(:id)
-      order = conditions.delete(:order)
-
-      if id && !conditions.any?
-        rows = table.where(id: id)
-      else
-        conditions.each { |k,v| query << "data->'#{k}' = '#{v}'" }
-        seek_conditions = query.join(" AND ")
-
-        where = "WHERE (#{seek_conditions})"
-
-        where += " AND id = '#{id}'"          if id
-        order_condition = "ORDER BY #{order}" if order
-
-        sql = "#{base_query} #{where} #{order_condition}"
-
-        rows = Shoden.connection.fetch(sql) || []
-      end
-
-      rows.lazy.map do |row|
-        attrs = row[:data].merge({ id: row[:id] })
-
-        new(attrs)
-      end
-    end
-
-    def attributes
-      sanitized = @attributes.map do |k, _|
-        val = send(k)
-        return if val.nil?
-        [k, val.to_s]
-      end.compact
-
-      Sequel::Postgres::HStore.new(sanitized)
-    end
-
-    private
-
-    def self.base_query
-      "SELECT * FROM \"#{table_name}\""
-    end
-
-    def self.collect(condition = '')
-      records = []
-      Shoden.connection.fetch("SELECT * FROM \"#{table_name}\" #{condition}") do |r|
-        attrs = r[:data].merge(id: r[:id])
-        records << new(attrs)
-      end
-      records
-    end
-
-    def self.table_name
-      :"Shoden::#{self.name}"
-    end
-
-    def self.to_reference
-      name.to_s.
-        match(/^(?:.*::)*(.*)$/)[1].
-        gsub(/([a-z\d])([A-Z])/, '\1_\2').
-        downcase.to_sym
-    end
-
-    def self.create_index(name, type = '')
-      conn.execute <<EOS
-        CREATE #{type.upcase} INDEX index_#{self.name}_#{name}
-        ON "#{table_name}" (( data -> '#{name}'))
-        WHERE ( data ? '#{name}' );
-EOS
-    rescue
-    end
-
-    def self.lookup(id)
-      row = table.where(id: id)
-      return nil if !row.any?
-
-      row
-    end
-
-    def self.setup
-      conn.create_table? table_name do
-        primary_key :id
-        hstore      :data
-      end
-
-      indices.each { |i| create_index(i) }
-      uniques.each { |i| create_index(i, :unique) }
-    end
-
-    def self.destroy_all
-      conn.execute("DELETE FROM \"#{table_name}\"")
-    rescue Sequel::DatabaseError
-    end
-
-    def self.destroy_table
-      conn.drop_table(table_name)
-    rescue Sequel::DatabaseError
-    end
-
-    def self.table
-      conn[table_name]
-    end
-
-    def self.conn
-      Shoden.connection
-    end
+    models.each(&:destroy_table)
   end
 end

data/lib/shoden/model.rb

@@ -0,0 +1,259 @@
+require "json"
+require "shoden/proxy"
+
+module Shoden
+  class Model
+    attr_reader :attributes
+
+    def initialize(attrs = {})
+      @_id = attrs.delete(:id) if attrs[:id]
+      @attributes = {}
+      update(attrs)
+    end
+
+    def id
+      return nil unless defined?(@_id)
+      @_id.to_i
+    end
+
+    def destroy
+      query = "DELETE FROM \"#{self.class.table_name}\" WHERE id = $1 RETURNING id"
+      ret = Shoden.connection.exec_params(query, [id])
+      ret.first["id"]
+    end
+
+    def update(attrs = {})
+      attrs.each { |name, value| send(:"#{name}=", value) }
+    end
+
+    def update_attributes(attrs = {})
+      update(attrs)
+      save
+    end
+
+    def save
+      self.class.save(self)
+      self
+    end
+
+    def load!
+      ret = self.class.lookup(@_id)
+      return nil if ret.nil?
+      data = self.class.from_json(ret.first["data"])
+      update(data)
+
+      self
+    end
+
+    def self.inherited(model)
+      Shoden.models.add(model)
+    end
+
+    def self.save(record)
+      if record.id
+        query = "UPDATE \"#{table_name}\" SET data = $1 WHERE id = $2"
+        Shoden.connection.exec_params(query, [record.attributes, record.id])
+      else
+        begin
+          query = "INSERT INTO \"#{table_name}\" (data) VALUES ($1) RETURNING id"
+          res = Shoden.connection.exec_params(query, [record.attributes.to_json])
+          record.instance_variable_set(:@_id, res.first["id"])
+        rescue PG::UniqueViolation
+          raise Shoden::UniqueIndexViolation
+        end
+      end
+    end
+
+    def self.all
+      collect
+    end
+
+    def self.count
+      query = "SELECT COUNT(*) FROM \"#{table_name}\""
+      Shoden.connection.exec(query).first["count"].to_i
+    end
+
+    def self.first
+      collect(order: "id ASC", limit: 1).first
+    end
+
+    def self.last
+      collect(order: "id DESC", limit: 1).first
+    end
+
+    def self.create(attrs = {})
+      new(attrs).save
+    end
+
+    def self.attributes
+      @attributes ||= []
+    end
+
+    def self.indices
+      @indices ||= []
+    end
+
+    def self.uniques
+      @uniques ||= []
+    end
+
+    def self.[](id)
+      new(id: id).load!
+    end
+
+    def self.index(name)
+      indices << name unless indices.include?(name)
+    end
+
+    def self.unique(name)
+      uniques << name unless uniques.include?(name)
+    end
+
+    def self.attribute(name, caster = ->(x) { x })
+      attributes << name unless attributes.include?(name)
+
+      define_method(name) { caster[@attributes[name]] }
+      define_method(:"#{name}=") { |value| @attributes[name] = value }
+    end
+
+    def self.collection(name, model)
+      define_method(name) do
+        klass = Kernel.const_get(model)
+        Shoden::Proxy.new(klass, self)
+      end
+    end
+
+    def self.reference(name, model)
+      reader = :"#{name}_id"
+      writer = :"#{name}_id="
+
+      attributes << name unless attributes.include?(name)
+
+      define_method(reader) { @attributes[reader] }
+      define_method(writer) { |value| @attributes[reader] = value }
+
+      define_method(name) do
+        klass = Kernel.const_get("Shoden::#{model}")
+        klass[send(reader)]
+      end
+    end
+
+    def self.filter(conditions = {})
+      rows = query(conditions: conditions)
+
+      rows.lazy.map do |row|
+        data = from_json(row["data"])
+        data[:id] = row["id"].to_i
+
+        new(data)
+      end
+    end
+
+    def self.query(fields: "*", conditions: {})
+      id = conditions.delete(:id)
+      order = conditions.delete(:order)
+
+      if id && conditions.none?
+        sql = "#{base_query(fields)} WHERE id = $1"
+        Shoden.connection.exec_params(sql, [id]) || []
+      else
+        count = conditions.count
+        where = count.times.map { |i| "data->>$#{2 * i + 1} = $#{2 * i + 2}" }
+        params = conditions.flatten
+
+        if id
+          where << "id = $#{count * 2 + 1}"
+          params << id
+        end
+
+        where = where.join(" AND ")
+        order_condition = "ORDER BY #{order}" if order
+        sql = "#{base_query(fields)} WHERE #{where} #{order_condition}"
+
+        Shoden.connection.exec_params(sql, params) || []
+      end
+    end
+
+    private
+
+    def self.from_json(string)
+      JSON.parse(string, symbolize_names: true)
+    end
+
+    def self.base_query(fields = "*")
+      "SELECT #{fields} FROM \"#{table_name}\""
+    end
+
+    def self.collect(order: :id, limit: 0)
+      query = base_query("*")
+
+      params = [].tap do |item|
+        item << order
+        query << " ORDER BY $1"
+
+        if limit > 0
+          item << limit
+          query << " LIMIT $2 "
+        end
+      end
+
+      [].tap do |records|
+        Shoden.connection.exec_params(query, params).each do |row|
+          data = from_json(row["data"])
+          data[:id] = row["id"].to_i
+
+          records << new(data)
+        end
+      end
+    end
+
+    def self.table_name
+      :"Shoden::#{name}"
+    end
+
+    def self.to_reference
+      name.to_s
+          .match(/^(?:.*::)*(.*)$/)[1]
+          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .downcase.to_sym
+    end
+
+    def self.create_index(name, type = "")
+      query = <<~EOS
+        CREATE #{type.upcase} INDEX index_#{self.name}_#{name}
+        ON "#{table_name}" (( data ->> '#{name}'))
+        WHERE ( data ? '#{name}' );
+      EOS
+
+      Shoden.connection.exec(query)
+    end
+
+    def self.lookup(id)
+      query = "SELECT * FROM \"#{table_name}\" WHERE id = $1"
+      row = Shoden.connection.exec_params(query, [id])
+      return nil if row.none?
+
+      row
+    end
+
+    def self.setup
+      Shoden.connection.exec <<~EOS
+        CREATE TABLE IF NOT EXISTS \"#{table_name}\" (
+          id   SERIAL NOT NULL PRIMARY KEY,
+          data JSONB
+        )
+      EOS
+
+      indices.each { |i| create_index(i) }
+      uniques.each { |i| create_index(i, :unique) }
+    end
+
+    def self.destroy_all
+      Shoden.connection.exec("DELETE FROM \"#{table_name}\"")
+    end
+
+    def self.destroy_table
+      Shoden.connection.exec("DROP TABLE IF EXISTS \"#{table_name}\"")
+    end
+  end
+end

data/lib/shoden/proxy.rb

@@ -0,0 +1,46 @@
+module Shoden
+  Proxy = Struct.new(:klass, :parent) do
+    def create(args = {})
+      klass.create(args.merge(key => parent.id))
+    end
+
+    def all
+      klass.filter(parent_filter)
+    end
+
+    def count
+      row = klass.query(fields: "COUNT(id)", conditions: parent_filter)
+      row.first["count"].to_i
+    end
+
+    def any?
+      count > 0
+    end
+
+    def first
+      filter = { order: "id ASC LIMIT 1" }.merge!(parent_filter)
+      klass.filter(filter).first
+    end
+
+    def last
+      filter = { order: "id DESC LIMIT 1" }.merge!(parent_filter)
+      klass.filter(filter).first
+    end
+
+    def [](id)
+      filter = { id: id }.merge!(parent_filter)
+
+      klass.filter(filter).first
+    end
+
+    private
+
+    def parent_filter
+      { key => parent.id }
+    end
+
+    def key
+      "#{parent.class.to_reference}_id".freeze
+    end
+  end
+end

data/shoden.gemspec

@@ -1,15 +1,17 @@
 Gem::Specification.new do |s|
   s.name              = "shoden"
-  s.version           = "0.4.0"
+  s.version           = "1.0"
   s.summary           = "Object hash mapper for postgres"
   s.description       = "Slim postgres models"
   s.authors           = ["elcuervo"]
-  s.licenses          = ["MIT", "HUGWARE"]
+  s.licenses          = %w[MIT HUGWARE]
   s.email             = ["yo@brunoaguirre.com"]
   s.homepage          = "http://github.com/elcuervo/shoden"
   s.files             = `git ls-files`.split("\n")
   s.test_files        = `git ls-files test`.split("\n")
 
-  s.add_dependency("sequel", "~> 4.11.0")
-  s.add_development_dependency("cutest", "~> 1.2.1")
+  s.add_dependency("pg", "~> 1.1")
+
+  s.add_development_dependency("cutest", "~> 1.2")
+  s.add_development_dependency("simplecov", "~> 0.16")
 end

data/test/shoden_test.rb

@@ -1,5 +1,9 @@
-require 'cutest'
-require 'shoden'
+require "cutest"
+require "simplecov"
+
+SimpleCov.start
+
+require "shoden"
 
 Model = Class.new(Shoden::Model)
 
@@ -12,8 +16,8 @@ class Person < Shoden::Model
 end
 
 class Tree < Shoden::Model
-  attribute   :name
-  collection  :sprouts, :Sprout
+  attribute  :name
+  collection :sprouts, :Sprout
 end
 
 class Sprout < Shoden::Model
@@ -34,61 +38,70 @@ setup do
   Shoden.setup
 end
 
-test 'model' do
+test "url setup" do
+  Shoden.url = ENV["DATABASE_URL"]
+end
+
+test "model" do
   model = Model.create
-  assert_equal model.id.class, Fixnum
+
+  assert Model.count
+  assert_equal model.id.class, Integer
 end
 
-test 'attributes' do
-  user = User.create name: 'Michel'
-  assert_equal user.name, 'Michel'
+test "attributes" do
+  user = User.create name: "Michel"
+  assert_equal user.name, "Michel"
 end
 
-test 'update' do
-  user = User.create name: 'Cyril'
+test "update" do
+  user = User.create name: "Cyril"
   id = user.id
 
-  assert_equal user.name, 'Cyril'
+  assert_equal user.name, "Cyril"
 
-  user.name = 'cyx'
+  user.name = "cyx"
   user.save
 
-  assert_equal user.name, 'cyx'
+  assert_equal user.name, "cyx"
   assert_equal user.id, id
 
-  user.update_attributes(name: 'Cyril')
-  assert_equal user.name, 'Cyril'
+  user.update_attributes(name: "Cyril")
+  assert_equal user.name, "Cyril"
 end
 
-test 'filtering' do
-  person = { email: 'elcuervo@elcuervo.net' }
+test "filtering" do
+  person = { email: "edgar@poe.com" }
   Person.create(person)
   p = Person.filter(person).first
 
-  assert p.email == 'elcuervo@elcuervo.net'
+  assert p.email == "edgar@poe.com"
 end
 
-test 'relations' do
-  tree = Tree.create(name: 'asd')
+test "relations" do
+  tree = Tree.create(name: "asd")
+  tree2 = Tree.create(name: "qwe")
 
   assert tree.id
-  assert_equal tree.name, 'asd'
+  assert_equal tree.name, "asd"
 
   sprout = tree.sprouts.create(leaves: 4)
+  tree2.sprouts.create(leaves: 5)
 
   assert sprout.is_a?(Sprout)
   assert tree.sprouts.all.each.is_a?(Enumerator)
 
   assert tree.sprouts[sprout.id].id == sprout.id
 
+  assert tree.sprouts.any?
   assert_equal tree.sprouts.count, 1
   assert_equal sprout.tree.id, tree.id
-  assert tree.sprouts.first != nil
-  assert tree.sprouts.last != nil
+  assert !tree.sprouts.first.nil?
+  assert !tree.sprouts.last.nil?
 end
 
-test 'deletion' do
-  user = User.create(name: 'Damian')
+test "deletion" do
+  user = User.create(name: "Damian")
   id = user.id
 
   user.destroy
@@ -96,27 +109,28 @@ test 'deletion' do
   assert_equal User[id], nil
 end
 
-test 'casting' do
+test "casting" do
   a = A.create(n: 1)
   a_prime = A[a.id]
 
   assert_equal a_prime.n, 1
 end
 
-test 'indices' do
-  person = Person.create(email: 'elcuervo@elcuervo.net', origin: 'The internerd')
+test "indices" do
+  person = Person.create(email: "edgar@poe.com", origin: "The internerd")
 
   assert person.id
 
   assert_raise Shoden::UniqueIndexViolation do
-    Person.create(email: 'elcuervo@elcuervo.net', origin: 'Montevideo City')
+    Person.create(email: "edgar@poe.com", origin: "Montevideo City")
   end
 end
 
-test 'basic querying' do
+test "basic querying" do
   User.destroy_all
   5.times { User.create }
 
+  assert User.query(conditions: { id: 1 })
+  assert User.first != User.last
   assert_equal User.all.size, 5
-
 end

metadata

@@ -1,43 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: shoden
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: '1.0'
 platform: ruby
 authors:
 - elcuervo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-15 00:00:00.000000000 Z
+date: 2019-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: sequel
+  name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.11.0
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.11.0
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: cutest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.1
+        version: '1.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.1
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
 description: Slim postgres models
 email:
 - yo@brunoaguirre.com
@@ -45,13 +59,18 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gems
-- .travis.yml
+- ".gems"
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
 - HUGS
 - LICENSE
 - README.md
 - Rakefile
 - lib/shoden.rb
+- lib/shoden/model.rb
+- lib/shoden/proxy.rb
 - shoden.gemspec
 - test/shoden_test.rb
 homepage: http://github.com/elcuervo/shoden
@@ -65,17 +84,16 @@ 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.0.14
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Object hash mapper for postgres