feat: rename to Atom::Model

BREAKING CHANGE: this repository is now the official SQL ORM of @atomframework!

Author: vladfaust

README.md

@@ -1,60 +1,57 @@
 > ⚠️ Master branch requires Crystal master to compile. See [installation instructions for Crystal](https://crystal-lang.org/docs/installation/from_source_repository.html).
 
-# ![Core](https://user-images.githubusercontent.com/7955682/40578252-6f1929b2-6119-11e8-9348-81505cec939f.png)
+# Atom::Model
 
 [![Built with Crystal](https://img.shields.io/badge/built%20with-crystal-000000.svg?style=flat-square)](https://crystal-lang.org/)
-[![Build status](https://img.shields.io/travis/vladfaust/core/master.svg?style=flat-square)](https://travis-ci.org/vladfaust/core)
-[![Docs](https://img.shields.io/badge/docs-available-brightgreen.svg?style=flat-square)](https://github.vladfaust.com/core)
-[![Releases](https://img.shields.io/github/release/vladfaust/core.svg?style=flat-square)](https://github.com/vladfaust/core/releases)
-[![Gitter Chat](https://img.shields.io/badge/style-chat-ed1965.svg?longCache=true&style=flat-square&label=&logo=gitter-white&colorA=555)](https://gitter.im/core-orm/Lobby)
+[![Build status](https://img.shields.io/travis/atomframework/model/master.svg?style=flat-square)](https://travis-ci.org/atomframework/model)
+[![Docs](https://img.shields.io/badge/docs-available-brightgreen.svg?style=flat-square)](http://api.model.atomframework.org)
+[![Releases](https://img.shields.io/github/release/atomframework/model.svg?style=flat-square)](https://github.com/atomframework/model/releases)
 [![Awesome](https://github.com/vladfaust/awesome/blob/badge-flat-alternative/media/badge-flat-alternative.svg)](https://github.com/veelenga/awesome-crystal)
-[![vladfaust.com](https://img.shields.io/badge/style-.com-lightgrey.svg?longCache=true&style=flat-square&label=vladfaust&colorB=0a83d8)](https://vladfaust.com)
-[![Patrons count](https://img.shields.io/badge/dynamic/json.svg?label=patrons&url=https://www.patreon.com/api/user/11296360&query=$.included[0].attributes.patron_count&style=flat-square&colorB=red&maxAge=86400)](https://www.patreon.com/vladfaust)
 
-Type-safe and expressive SQL ORM for [Crystal](https://crystal-lang.org).
+The official SQL ORM for [Atom Framework](https://github.com/atomframework/atom).
 
-[![Become Patron](https://vladfaust.com/img/patreon-small.svg)](https://www.patreon.com/vladfaust)
-
-## Projects using Core
+## Projects using Atom::Model
 
 * [Crystal Jobs](https://crystaljobs.org)
 * [Crystal World](https://github.com/vladfaust/crystalworld)
 * *add yours!*
 
 ## About
 
-Core is a [crystal-db](https://github.com/crystal-lang/crystal-db) ORM which does not follow Active Record pattern, it's more like a data-mapping solution. There is a concept of Repository, which is basically a gateway to the database. For example:
+Atom::Model is a [crystal-db](https://github.com/crystal-lang/crystal-db) ORM which does not follow Active Record pattern, it's more like a data-mapping solution. There is a concept of Repository, which is basically a gateway to the database. For example:
 
 ```crystal
-repo = Core::Repository.new(db)
+repo = Atom::Repository.new(db)
 users = repo.query(User.where(id: 42)).first
 users.class # => User
 ```
 
-Core also has a plently of features, including:
+Atom::Model also has a plently of features, including:
 
 - Expressive and **type-safe** Query builder, allowing to use constructions like `Post.join(:author).where(author: user)`, which turns into a plain SQL
 - References preloader (the example above would return a `Post` which has `#author = <User @id=42>` attribute set)
 - Beautiful schema definition syntax
 
-However, Core is designed to be minimal, so it doesn't perform tasks you may got used to, for example, it doesn't do database migrations itself. You may use [migrate](https://github.com/vladfaust/migrate.cr) instead. Also its Query builder is not intended to fully replace SQL but instead to help a developer to write less and safer code.
+However, Atom::Model is designed to be minimal, so it doesn't perform tasks you may got used to, for example, it doesn't do database migrations itself. You may use [migrate](https://github.com/vladfaust/migrate.cr) instead. Also its Query builder is not intended to fully replace SQL but instead to help a developer to write less and safer code.
 
-Also note that although Core code is designed to be abstract sutiable for any [crystal-db](https://github.com/crystal-lang/crystal-db) driver, it currently works with PostgreSQL only. But it's fairly easy to implement other drivers like MySQL or SQLite (see `/src/core/ext/pg` and `/src/core/repository.cr`).
+Also note that although Atom::Model code is designed to be abstract sutiable for any [crystal-db](https://github.com/crystal-lang/crystal-db) driver, it currently works with PostgreSQL only. But it's fairly easy to implement other drivers like MySQL or SQLite (see `/src/model/ext/pg` and `/src/model/repository.cr`).
 
 ## Installation
 
 Add this to your application's `shard.yml`:
 
 ```yaml
 dependencies:
-  core:
-    github: vladfaust/core
+  atom-model:
+    github: atomframework/model
     version: ~> 0.5.0
 ```
 
-This shard follows [Semantic Versioning v2.0.0](http://semver.org/), so check [releases](https://github.com/vladfaust/core/releases) and change the `version` accordingly.
+This shard follows [Semantic Versioning v2.0.0](http://semver.org/), so check [releases](https://github.com/atomframework/model/releases) and change the `version` accordingly.
+
+## Using
 
-## Basic example
+### Basic example
 
 Assuming following database migration:
 
@@ -79,10 +76,10 @@ Crystal code:
 
 ```crystal
 require "pg"
-require "core"
+require "atom-model"
 
 class User
-  include Core::Schema
+  include Atom::Model
 
   schema users do
     pkey uuid : UUID # UUIDs are supported out of the box
@@ -96,7 +93,7 @@ class User
 end
 
 class Post
-  include Core::Schema
+  include Atom::Model
 
   schema posts do
     pkey id : Int32
@@ -109,8 +106,8 @@ class Post
   end
 end
 
-query_logger = Core::Logger::IO.new(STDOUT)
-repo = Core::Repository.new(DB.open(ENV["DATABASE_URL"]), query_logger)
+logger = Atom::Repository::Logger::IO.new(STDOUT)
+repo = Atom::Repository.new(DB.open(ENV["DATABASE_URL"]), logger)
 
 # Most of the query builder methods (e.g. insert) are type-safe
 user = repo.query(User.insert(name: "Vlad")).first
@@ -139,16 +136,39 @@ puts posts.first.inspect
 # => <Post @id=42 @author=<User @name="Vlad" @uuid="..."> @content="What a beautiful day!">
 ```
 
+### With [Atom](https://github.com/atomframework/atom)
+
+Define your models as above, but with `Model` as an alias of `Atom::Model` and [`Validations`](https://github.com/vladfaust/validations.cr) included by default. You also don't need to initialize repository explicitly when using Atom:
+
+```crystal
+require "atom"
+
+Atom.model(PG)
+
+class User
+  include Model
+
+  schema do
+    type name : String
+  end
+
+  validate name, size: (3..50)
+end
+
+users = query(User.all) # Top-level `query`, `exec` and `scalar` methods
+User.new("Jo").valid?   # Validations
+```
+
 ## Testing
 
 1. Run generic specs with `crystal spec`
 2. Apply migrations from `./db_spec/*/migration.sql`
-3. Run DB-specific specs with `env POSTGRESQL_URL=postgres://postgres:postgres@localhost:5432/core crystal spec db_spec`
+3. Run DB-specific specs with `env POSTGRESQL_URL=postgres://postgres:postgres@localhost:5432/model crystal spec db_spec`
 4. Optionally run benchmarks with `crystal bench.cr --release`
 
 ## Contributing
 
-1. Fork it ( https://github.com/vladfaust/core/fork )
+1. Fork it ( https://github.com/atomframework/model/fork )
 2. Create your feature branch (git checkout -b my-new-feature)
 3. Commit your changes (git commit -am 'Add some feature')
 4. Push to the branch (git push origin my-new-feature)

bench/logger_bench.cr

@@ -1,6 +1,6 @@
 require "./bench_helper"
 
-puts "\nRunning Core::Logger benchmarks...\n".colorize(COLORS["header"])
+puts "\nRunning Atom::Repository::Logger benchmarks...\n".colorize(COLORS["header"])
 
 def devnull
   File.open(File::DEVNULL, mode: "w")
@@ -10,25 +10,25 @@ logger = Logger.new(devnull, Logger::DEBUG)
 
 elapsed = Time.measure do
   Benchmark.ips do |x|
-    io = Core::Logger::IO.new(devnull)
+    io = Atom::Repository::Logger::IO.new(devnull)
 
     x.report "io w/  colors" do
       io.wrap("foo") { nil }
     end
 
-    io = Core::Logger::IO.new(devnull, false)
+    io = Atom::Repository::Logger::IO.new(devnull, false)
 
     x.report "io w/o colors" do
       io.wrap("foo") { nil }
     end
 
-    std_logger = Core::Logger::Standard.new(logger, Logger::Severity::INFO)
+    std_logger = Atom::Repository::Logger::Standard.new(logger, Logger::Severity::INFO)
 
     x.report "logger w/  colors" do
       std_logger.wrap("foo") { nil }
     end
 
-    std_logger = Core::Logger::Standard.new(logger, Logger::Severity::INFO, false)
+    std_logger = Atom::Repository::Logger::Standard.new(logger, Logger::Severity::INFO, false)
 
     x.report "logger w/o colors" do
       std_logger.wrap("foo") { nil }

db_spec/repository_spec.cr

@@ -5,5 +5,5 @@ enum Database
 end
 
 def repo(database : Database)
-  Core::Repository.new(DB.open(ENV["#{database.to_s.upcase}_URL"]), Core::Logger::IO.new(STDOUT))
+  Atom::Repository.new(DB.open(ENV["#{database.to_s.upcase}_URL"]), Atom::Repository::Logger::IO.new(STDOUT))
 end

db_spec/spec_helper.cr

@@ -1,2 +1,3 @@
 require "spec"
+require "../src/atom-model"
 require "../spec/models"

shard.yml

@@ -1,4 +1,4 @@
-name: core
+name: atom-model
 version: 0.5.0
 
 authors:

spec/logger/dummy_spec.cr

@@ -1,6 +1,6 @@
 require "../models"
 
-describe "Schema changes" do
+describe "Atom::Model schema changes" do
   user = User.new(name: "John")
 
   it "has initially empty changes" do

spec/logger/io_spec.cr

@@ -1,85 +1,85 @@
 require "../query/**"
 
-describe "Schema query shortcuts" do
+describe "Atom::Model schema query shortcuts" do
   describe ".group_by" do
     it do
-      User.group_by("foo", "bar").should eq Core::Query(User).new.group_by("foo", "bar")
+      User.group_by("foo", "bar").should eq Atom::Query(User).new.group_by("foo", "bar")
     end
   end
 
   describe ".having" do
     it do
-      User.having("foo").having("bar = ?", 42).should eq Core::Query(User).new.having("foo").having("bar = ?", 42)
+      User.having("foo").having("bar = ?", 42).should eq Atom::Query(User).new.having("foo").having("bar = ?", 42)
     end
   end
 
   describe ".insert" do
     it do
-      User.insert(name: "John").should eq Core::Query(User).new.insert(name: "John")
+      User.insert(name: "John").should eq Atom::Query(User).new.insert(name: "John")
     end
   end
 
   describe ".limit" do
     it do
-      User.limit(1).should eq Core::Query(User).new.limit(1)
+      User.limit(1).should eq Atom::Query(User).new.limit(1)
     end
   end
 
   describe ".offset" do
     it do
-      User.offset(1).should eq Core::Query(User).new.offset(1)
+      User.offset(1).should eq Atom::Query(User).new.offset(1)
     end
   end
 
   describe ".set" do
     it do
-      User.set(active: true).should eq Core::Query(User).new.set(active: true)
+      User.set(active: true).should eq Atom::Query(User).new.set(active: true)
     end
   end
 
   describe ".where" do
     it do
-      User.where(active: true).should eq Core::Query(User).new.where(active: true)
+      User.where(active: true).should eq Atom::Query(User).new.where(active: true)
     end
   end
 
   {% for m in %w(update delete all one first last) %}
     describe {{m}} do
       it do
-        User.{{m.id}}.should eq Core::Query(User).new.{{m.id}}
+        User.{{m.id}}.should eq Atom::Query(User).new.{{m.id}}
       end
     end
   {% end %}
 
   describe ".join" do
     context "with table" do
       it do
-        Post.join("users", "author.id = posts.author_id", as: "author").should eq Core::Query(Post).new.join("users", "author.id = posts.author_id", as: "author")
+        Post.join("users", "author.id = posts.author_id", as: "author").should eq Atom::Query(Post).new.join("users", "author.id = posts.author_id", as: "author")
       end
     end
 
     context "with reference" do
       it do
-        Post.join(:author, select: {'*'}).should eq Core::Query(Post).new.join(:author, select: {'*'})
+        Post.join(:author, select: {'*'}).should eq Atom::Query(Post).new.join(:author, select: {'*'})
       end
     end
   end
 
   describe ".order_by" do
     it do
-      User.order_by(:uuid, :asc).order_by("foo").should eq Core::Query(User).new.order_by(:uuid, :asc).order_by("foo")
+      User.order_by(:uuid, :asc).order_by("foo").should eq Atom::Query(User).new.order_by(:uuid, :asc).order_by("foo")
     end
   end
 
   describe ".returning" do
     it do
-      User.returning(:name).returning('*').should eq Core::Query(User).new.returning(:name).returning('*')
+      User.returning(:name).returning('*').should eq Atom::Query(User).new.returning(:name).returning('*')
     end
   end
 
   describe ".select" do
     it do
-      User.select(:name).select('*').should eq Core::Query(User).new.select(:name).select('*')
+      User.select(:name).select('*').should eq Atom::Query(User).new.select(:name).select('*')
     end
   end
 

spec/schema/changes_spec.cr spec/model/changes_spec.crspec/schema/changes_spec.cr renamed to spec/model/changes_spec.cr

@@ -1,7 +1,7 @@
-require "../src/core"
+require "./spec_helper"
 
 class User
-  include Core::Schema
+  include Atom::Model
 
   enum Role
     Writer
@@ -43,7 +43,7 @@ class User
 end
 
 class Tag
-  include Core::Schema
+  include Atom::Model
 
   schema tags do
     pkey id : Int32
@@ -53,7 +53,7 @@ class Tag
 end
 
 class Post
-  include Core::Schema
+  include Atom::Model
 
   schema posts do
     pkey id : Int32