rom-sql 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b33ebf8637ba61f769f9ef29bef9f8669600a5ec
+  data.tar.gz: e6aa49e9b572394bd11cabfb2af4901a2f7c2d49
+SHA512:
+  metadata.gz: 7cbd522a297fad97d735728bdbb501a96a5660a41d4129a56d7cd9e829bd04f18dae86ff58db1f92d32b2d445a9dc30d1f71a9fb5faacbb70ba682921e827a50
+  data.tar.gz: c7a8943d94016f88a5782cfa0b1a83c802649831841be8fe04093e1b0a49e76d5a74502dedb5742fc76852fafe205824af56145164244eeb17aa812a68ffaf72

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--order random

data/.travis.yml

@@ -0,0 +1,23 @@
+language: ruby
+bundler_args: --without yard guard benchmarks
+env:
+  - CODECLIMATE_REPO_TOKEN=03d7f66589572702b12426d2bc71c4de6281a96139e33b335b894264b1f8f0b0
+before_script:
+  - psql -c 'create database rom;' -U postgres
+script: "bundle exec rake spec"
+rvm:
+  - 2.0
+  - 2.1
+  - rbx-2
+  - jruby
+  - ruby-head
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+notifications:
+  webhooks:
+    urls:
+      - https://webhooks.gitter.im/e/39e1225f489f38b0bd09
+    on_success: change
+    on_failure: always
+    on_start: false

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# v0.3.0 2014-11-24
+
+First release powered by Sequel

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'rom', git: 'https://github.com/rom-rb/rom.git', branch: 'master'
+  gem 'rspec', '~> 3.1'
+  gem 'codeclimate-test-reporter', require: false
+  gem 'pg', platforms: [:mri, :rbx]
+  gem 'pg_jruby', platforms: :jruby
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Piotr Solnica
+
+MIT License
+
+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,153 @@
+[gem]: https://rubygems.org/gems/rom-sql
+[travis]: https://travis-ci.org/rom-rb/rom-sql
+[gemnasium]: https://gemnasium.com/rom-rb/rom-sql
+[codeclimate]: https://codeclimate.com/github/rom-rb/rom-sql
+[inchpages]: http://inch-ci.org/github/rom-rb/rom-sql
+
+# ROM::SQL
+
+[![Gem Version](https://badge.fury.io/rb/rom-sql.svg)][gem]
+[![Build Status](https://travis-ci.org/rom-rb/rom-sql.svg?branch=master)][travis]
+[![Dependency Status](https://gemnasium.com/rom-rb/rom-sql.png)][gemnasium]
+[![Code Climate](https://codeclimate.com/github/rom-rb/rom-sql/badges/gpa.svg)][codeclimate]
+[![Test Coverage](https://codeclimate.com/github/rom-rb/rom-sql/badges/coverage.svg)][codeclimate]
+[![Inline docs](http://inch-ci.org/github/rom-rb/rom-sql.svg?branch=master)][inchpages]
+
+
+RDBMS suport for [Ruby Object Mapper](https://github.com/rom-rb/rom).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rom-sql'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rom-sql
+
+## Setup
+
+ROM uses [Sequel](http://sequel.jeremyevans.net) under the hood and exposes its
+[Dataset API](http://sequel.jeremyevans.net/rdoc/files/doc/dataset_basics_rdoc.html)
+in relation objects. For schema migrations you can use its
+[Migration API](http://sequel.jeremyevans.net/rdoc/files/doc/migration_rdoc.html)
+which is available via repositories.
+
+``` ruby
+setup = ROM.setup(sqlite: "memory::sqlite")
+
+setup.sqlite.connection.create_table(:users) do
+  primary_key :id
+  String :name
+  Boolean :admin
+end
+
+setup.sqlite.connection.create_table(:tasks) do
+  primary_key :id
+  Integer :user_id
+  String :title
+end
+```
+
+## Relations
+
+ROM doesn't have a relationship concept like in ActiveRecord or Sequel. Instead
+it provides a convenient interface for building joined relations that can be
+mapped to [aggregate objects](http://martinfowler.com/bliki/Aggregate.html).
+
+There's no lazy-loading, eager-loading or any other magic happening behind the
+scenes. You're in full control of how data are fetched from the database and it's
+an explicit operation.
+
+``` ruby
+
+setup.relation(:tasks)
+
+setup.relation(:users) do
+  one_to_many :tasks, key: :user_id
+
+  def by_name(name)
+    where(name: name)
+  end
+
+  def with_tasks
+    association_join(:tasks)
+  end
+end
+
+rom = setup.finalize
+
+users = rom.relations.users
+tasks = rom.relations.tasks
+
+users.insert(name: "Piotr")
+tasks.insert(title: "Be happy")
+
+puts users.by_name("Piotr").with_tasks.to_a.inspect
+# => [{:id=>1, :name=>"Piotr", :user_id=>1, :title=>"Be happy"}]
+```
+
+## Mapping
+
+Mapping joined relations can be simplified using `wrap` and `group` in-memory
+operations:
+
+``` ruby
+setup.relation(:tasks)
+
+setup.relation(:users) do
+  one_to_many :tasks, key: :user_id
+
+  def by_name(name)
+    where(name: name)
+  end
+
+  def with_tasks
+    in_memory { group(association_join(:tasks), tasks: [:title]) }
+  end
+end
+
+setup.mappers do
+  define(:users) do
+    model name: 'User'
+
+    group :tasks do
+      attribute :title
+    end
+  end
+end
+
+rom = setup.finalize
+
+users = rom.relations.users
+tasks = rom.relations.tasks
+
+users.insert(name: "Piotr")
+tasks.insert(title: "Be happy")
+
+rom.read(:users).with_tasks.by_name("Piotr").to_a
+# => [#<User:0x007fb31542a098 @id=1, @name="Piotr", @tasks=[{:title=>"Be happy"}]>]
+```
+
+## ROADMAP
+
+On a very high level:
+
+* Make it dead simple to join relations and support all types of joins
+* Make it dead simple to select and alias column names
+* Discover conventions for typical query scenarios and make common things trivial,
+  less common things simple and super rare cases possible
+* Make mapper interface smart enough to figure out when columns are aliased
+
+For details please refer to [issues](https://github.com/rom-rb/rom-sql/issues).
+
+## License
+
+See `LICENSE` file.

data/Rakefile

@@ -0,0 +1,3 @@
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)

data/lib/rom-sql.rb

@@ -0,0 +1 @@
+require 'rom/sql'

data/lib/rom/sql.rb

@@ -0,0 +1,10 @@
+require "sequel"
+
+require "rom"
+require "rom/sql/version"
+require "rom/sql/header"
+require "rom/sql/relation_extension"
+require "rom/sql/relation_inclusion"
+require "rom/sql/adapter"
+
+require "rom/sql/support/sequel_dataset_ext"

data/lib/rom/sql/adapter.rb

@@ -0,0 +1,62 @@
+module ROM
+  module SQL
+
+    class Adapter < ROM::Adapter
+      attr_reader :connection
+
+      def self.schemes
+        [:ado, :amalgalite, :cubrid, :db2, :dbi, :do, :fdbsql, :firebird, :ibmdb,
+         :informix, :jdbc, :mysql, :mysql2, :odbc, :openbase, :oracle, :postgres,
+         :sqlanywhere, :sqlite, :swift, :tinytds]
+      end
+
+      def initialize(*args)
+        super
+        @connection = ::Sequel.connect(uri.to_s)
+      end
+
+      def [](name)
+        connection[name]
+      end
+
+      def schema
+        tables.map { |table| [table, dataset(table), dataset(table).columns] }
+      end
+
+      def extend_relation_class(klass)
+        klass.send(:include, RelationInclusion)
+      end
+
+      def extend_relation_instance(relation)
+        relation.extend(RelationExtension)
+      end
+
+      private
+
+      def tables
+        connection.tables
+      end
+
+      def dataset(table)
+        connection[table]
+      end
+
+      def attributes(table)
+        map_attribute_types connection.schema(table)
+      end
+
+      def map_attribute_types(attrs)
+        attrs.map do |column, opts|
+          [column, { type: map_schema_type(opts[:type]) }]
+        end.to_h
+      end
+
+      def map_schema_type(type)
+        connection.class::SCHEMA_TYPE_CLASSES.fetch(type)
+      end
+
+      ROM::Adapter.register(self)
+    end
+
+  end
+end

data/lib/rom/sql/header.rb

@@ -0,0 +1,54 @@
+module ROM
+  module SQL
+
+    class Header
+      include Charlatan.new(:columns)
+      include Equalizer.new(:columns, :name)
+
+      attr_reader :table
+
+      def initialize(columns, table)
+        super
+        @table = table
+      end
+
+      def to_ary
+        columns
+      end
+      alias_method :to_a, :to_ary
+
+      def to_h
+        columns.each_with_object({}) { |col, h|
+          left, right = col.to_s.split('___')
+          h[left.to_sym] = (right || left).to_sym
+        }
+      end
+
+      def project(*names)
+        find_all { |col| names.include?(col) }
+      end
+
+      def qualified
+        map { |col| :"#{table}__#{col}" }
+      end
+
+      def rename(options)
+        map { |col|
+          new_name = options[col]
+
+          if new_name
+            :"#{col}___#{new_name}"
+          else
+            col
+          end
+        }
+      end
+
+      def prefix(col_prefix)
+        rename(Hash[map { |col| [col, :"#{col_prefix}_#{col}"] }])
+      end
+
+    end
+
+  end
+end

data/lib/rom/sql/relation_extension.rb

@@ -0,0 +1,15 @@
+module ROM
+  module SQL
+
+    module RelationExtension
+      attr_reader :model
+
+      def self.extended(relation)
+        relation.model.set_dataset(relation.dataset)
+        relation.model.dataset.naked!
+      end
+
+    end
+
+  end
+end

data/lib/rom/sql/relation_inclusion.rb

@@ -0,0 +1,133 @@
+module ROM
+  module SQL
+
+    # Sequel-specific relation extensions
+    #
+    module RelationInclusion
+
+      def self.included(klass)
+        klass.extend(AssociationDSL)
+
+        klass.send(:undef_method, :select)
+
+        klass.class_eval {
+          class << self
+            attr_accessor :model
+          end
+
+          self.model = Class.new(Sequel::Model)
+        }
+      end
+
+      def initialize(*args)
+        super
+        @model = self.class.model
+        @header = dataset.header
+      end
+
+      # Join configured association.
+      #
+      # Uses INNER JOIN type.
+      #
+      # @example
+      #
+      #   setup.relation(:tasks)
+      #
+      #   setup.relations(:users) do
+      #     one_to_many :tasks, key: :user_id
+      #
+      #     def with_tasks
+      #       association_join(:tasks, select: [:title])
+      #     end
+      #   end
+      #
+      # @api public
+      def association_join(*args)
+        send(:append_association, __method__, *args)
+      end
+
+      # Join configured association
+      #
+      # Uses LEFT JOIN type.
+      #
+      # @example
+      #
+      #   setup.relation(:tasks)
+      #
+      #   setup.relations(:users) do
+      #     one_to_many :tasks, key: :user_id
+      #
+      #     def with_tasks
+      #       association_left_join(:tasks, select: [:title])
+      #     end
+      #   end
+      #
+      # @api public
+      def association_left_join(*args)
+        send(:append_association, __method__, *args)
+      end
+
+      private
+
+      # @api private
+      def append_association(type, name, options = {})
+        self.class.new(
+          dataset.public_send(type, name).
+          select_append(*columns_for_association(name, options))
+        )
+      end
+
+      # @api private
+      def columns_for_association(name, options)
+        col_names = options[:select]
+
+        return send(Inflecto.pluralize(name)).qualified_columns unless col_names
+
+        relations = col_names.is_a?(Hash) ? col_names.keys : [name]
+
+        columns = relations.each_with_object([]) do |rel_name, a|
+          relation = send(Inflecto.pluralize(rel_name))
+          names = col_names.is_a?(Hash) ? col_names[rel_name] : col_names
+
+          a.concat(relation.select(*names).prefix.qualified_columns)
+        end
+
+        columns
+      end
+
+      module AssociationDSL
+
+        def one_to_many(name, options)
+          associations << [__method__, name, options.merge(relation: name)]
+        end
+
+        def many_to_many(name, options = {})
+          associations << [__method__, name, options.merge(relation: name)]
+        end
+
+        def many_to_one(name, options = {})
+          associations << [__method__, name, options.merge(relation: Inflecto.pluralize(name).to_sym)]
+        end
+
+        def finalize(relations, relation)
+          associations.each do |*args, options|
+            model = relation.model
+            other = relations[options.fetch(:relation)].model
+
+            model.public_send(*args, options.merge(class: other))
+          end
+
+          model.freeze
+
+          super
+        end
+
+        def associations
+          @associations ||= []
+        end
+
+      end
+    end
+
+  end
+end

data/lib/rom/sql/spec/support.rb

@@ -0,0 +1,24 @@
+if defined? JRUBY_VERSION
+  USING_JRUBY = true
+else
+  USING_JRUBY = false
+end
+
+if USING_JRUBY
+  SEQUEL_TEST_DB_URI = "jdbc:sqlite::memory:"
+else
+  SEQUEL_TEST_DB_URI = "sqlite::memory"
+end
+
+DB = Sequel.connect(SEQUEL_TEST_DB_URI)
+
+def seed(db = DB)
+  db.run("CREATE TABLE users (id INTEGER PRIMARY KEY, name STRING)")
+
+  db[:users].insert(id: 1, name: 'Jane')
+  db[:users].insert(id:2, name: 'Joe')
+end
+
+def deseed(db = DB)
+  db.drop_table? :users
+end

data/lib/rom/sql/support/sequel_dataset_ext.rb

@@ -0,0 +1,33 @@
+class Sequel::Dataset
+
+  def header
+    ROM::SQL::Header.new(opts.fetch(:select) { columns }, opts[:from].first)
+  end
+
+  def project(*names)
+    select(*header.project(*names))
+  end
+
+  def rename(options)
+    select(*header.rename(options))
+  end
+
+  def prefix(col_prefix = default_prefix)
+    rename(header.prefix(col_prefix).to_h)
+  end
+
+  def qualified
+    select(*qualified_columns)
+  end
+
+  def qualified_columns
+    header.qualified.to_a
+  end
+
+  private
+
+  def default_prefix
+    Inflecto.singularize(opts[:from].first)
+  end
+
+end

data/lib/rom/sql/version.rb

@@ -0,0 +1,5 @@
+module ROM
+  module SQL
+    VERSION = "0.1.0"
+  end
+end

data/rom-sql.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rom/sql/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rom-sql"
+  spec.version       = ROM::SQL::VERSION
+  spec.authors       = ["Piotr Solnica"]
+  spec.email         = ["piotr.solnica@gmail.com"]
+  spec.summary       = %q{RDBMS support for ROM}
+  spec.description   = spec.summary
+  spec.homepage      = "http://rom-rb.org"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "sequel", "~> 4.16"
+  spec.add_runtime_dependency "equalizer", "~> 0.0", ">= 0.0.9"
+  spec.add_runtime_dependency "rom", "~> 0.3", "~> 0.3.0"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/spec/shared/users_and_tasks.rb

@@ -0,0 +1,37 @@
+shared_context 'users and tasks' do
+  subject(:rom) { setup.finalize }
+
+  let(:setup) { ROM.setup(postgres: 'postgres://localhost/rom') }
+  let(:conn) { setup.postgres.connection }
+
+  before do
+    [:users, :tasks, :tags, :task_tags].each { |name| conn.drop_table?(name) }
+
+    conn.create_table :users do
+      primary_key :id
+      String :name
+    end
+
+    conn.create_table :tasks do
+      primary_key :id
+      Integer :user_id
+      String :title
+    end
+
+    conn.create_table :tags do
+      primary_key :id
+      String :name
+    end
+
+    conn.create_table :task_tags do
+      primary_key :tag_id, :task_id
+      Integer :tag_id
+      Integer :task_id
+    end
+
+    conn[:users].insert id: 1, name: 'Piotr'
+    conn[:tasks].insert id: 1, user_id: 1, title: 'Finish ROM'
+    conn[:tags].insert id: 1, name: 'important'
+    conn[:task_tags].insert(tag_id: 1, task_id: 1)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+if RUBY_ENGINE == 'rbx'
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
+end
+
+require 'rom-sql'
+
+root = Pathname(__FILE__).dirname
+
+Dir[root.join('shared/*.rb').to_s].each { |f| require f }

data/spec/unit/combined_associations_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe 'Defining multiple associations' do
+  include_context 'users and tasks'
+
+  before do
+    conn[:tasks].insert id: 2, user_id: 1, title: 'Go to sleep'
+  end
+
+  it 'extends relation with association methods' do
+    setup.relation(:users)
+    setup.relation(:tags)
+
+    setup.relation(:tasks) do
+
+      many_to_one :users, key: :user_id
+
+      many_to_many :tags,
+        join_table: :task_tags,
+        left_key: :task_id,
+        right_key: :tag_id
+
+      def with_user_and_tags
+        all.with_tags.with_user
+      end
+
+      def all
+        select(:id, :title).qualified
+      end
+
+      def by_tag(name)
+        where(tags__name: name)
+      end
+
+      def with_tags
+        association_left_join(:tags, select: :name)
+      end
+
+      def with_user
+        association_join(:users, select: :name)
+      end
+
+      def sorted_by_tag_name
+        order(Sequel.desc(:tasks__title))
+      end
+
+    end
+
+    expect(rom.relations.tasks.with_user_and_tags.to_a).to eql([
+      { id: 1, title: 'Finish ROM', user_name: 'Piotr', tag_name: 'important' },
+      { id: 2, title: 'Go to sleep', user_name: 'Piotr',  tag_name: nil }
+    ])
+
+    expect(rom.relations.tasks.with_user_and_tags.sorted_by_tag_name.to_a).to eql([
+      { id: 2, title: 'Go to sleep', user_name: 'Piotr',  tag_name: nil },
+      { id: 1, title: 'Finish ROM', user_name: 'Piotr', tag_name: 'important' }
+    ])
+
+    expect(rom.relations.tasks.with_user_and_tags.by_tag('important').to_a).to eql([
+      { id: 1, title: 'Finish ROM', user_name: 'Piotr', tag_name: 'important' }
+    ])
+
+    expect(rom.relations.tasks.all.with_user.to_a).to eql([
+      { id: 1, title: 'Finish ROM', user_name: 'Piotr' },
+      { id: 2, title: 'Go to sleep', user_name: 'Piotr'  }
+    ])
+
+    expect(rom.relations.tasks.where(title: 'Go to sleep').to_a).to eql(
+      [{ id: 2, user_id: 1, title: 'Go to sleep'}]
+    )
+  end
+end

data/spec/unit/many_to_many_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe 'Defining many-to-one association' do
+  include_context 'users and tasks'
+
+  before do
+    conn[:tasks].insert id: 2, user_id: 1, title: 'Go to sleep'
+  end
+
+  it 'extends relation with association methods' do
+    setup.relation(:tasks) do
+
+      many_to_many :tags,
+        join_table: :task_tags,
+        left_key: :task_id,
+        right_key: :tag_id
+
+      def with_tags
+        association_left_join(:tags).select(:tasks__id, :tasks__title, :tags__name)
+      end
+
+      def by_tag(name)
+        with_tags.where(tags__name: name)
+      end
+    end
+
+    setup.relation(:tags)
+
+    tasks = rom.relations.tasks
+
+    expect(tasks.with_tags.to_a).to eql([
+      { id: 1, title: 'Finish ROM', name: 'important' },
+      { id: 2, title: 'Go to sleep', name: nil }
+    ])
+
+    expect(tasks.by_tag("important").to_a).to eql([
+      { id: 1, title: 'Finish ROM', name: 'important' }
+    ])
+
+    expect(tasks.by_tag("not-here").to_a).to be_empty
+  end
+end

data/spec/unit/many_to_one_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe 'Defining many-to-one association' do
+  include_context 'users and tasks'
+
+  it 'extends relation with association methods' do
+    setup.relation(:tasks) do
+      many_to_one :users, key: :user_id
+
+      def all
+        select(:id, :title).rename(title: :task_title).qualified
+      end
+
+      def with_user
+        association_join(:users, select: [:name])
+      end
+    end
+
+    setup.relation(:users)
+
+    tasks = rom.relations.tasks
+
+    expect(tasks.all.with_user.to_a).to eql(
+      [{ id: 1, user_name: 'Piotr', task_title: 'Finish ROM' }]
+    )
+  end
+end

data/spec/unit/one_to_many_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe 'Defining one-to-many association' do
+  include_context 'users and tasks'
+
+  it 'extends relation with association methods' do
+    setup.relation(:tasks)
+
+    setup.relation(:users) do
+      one_to_many :tasks, key: :user_id
+
+      def by_name(name)
+        where(name: name)
+      end
+
+      def with_tasks
+        association_join(:tasks)
+      end
+    end
+
+    users = rom.relations.users
+
+    expect(users.with_tasks.by_name("Piotr").to_a).to eql(
+      [{ id: 1, user_id: 1, name: 'Piotr', title: 'Finish ROM' }]
+    )
+  end
+end

data/spec/unit/relation_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe ROM::Relation do
+  include_context 'users and tasks'
+
+  subject(:users) { rom.relations.users }
+
+  before do
+    setup.relation(:users) do
+      def sorted
+        order(:id)
+      end
+    end
+  end
+
+  describe '#project' do
+    it 'projects the dataset using new column names' do
+      projected = users.sorted.project(:name)
+
+      expect(projected.header).to match_array([:name])
+      expect(projected.to_a).to eql([{ name: 'Piotr'}])
+    end
+  end
+
+  describe '#rename' do
+    it 'projects the dataset using new column names' do
+      renamed = users.sorted.rename(id: :user_id, name: :user_name)
+
+      expect(renamed.to_a).to eql([{ user_id: 1, user_name: 'Piotr'}])
+    end
+  end
+
+  describe '#prefix' do
+    it 'projects the dataset using new column names' do
+      prefixed = users.sorted.prefix(:user)
+
+      expect(prefixed.to_a).to eql([{ user_id: 1, user_name: 'Piotr'}])
+    end
+
+    it 'uses singularized table name as the default prefix' do
+      prefixed = users.sorted.prefix
+
+      expect(prefixed.to_a).to eql([{ user_id: 1, user_name: 'Piotr'}])
+    end
+  end
+
+  describe '#qualified_columns' do
+    it 'returns qualified column names' do
+      columns = users.sorted.prefix(:user).qualified_columns
+
+      expect(columns).to eql([:users__id___user_id, :users__name___user_name])
+    end
+
+    it 'returns projected qualified column names' do
+      columns = users.sorted.project(:id).prefix(:user).qualified_columns
+
+      expect(columns).to eql([:users__id___user_id])
+    end
+  end
+end

data/spec/unit/schema_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe 'Inferring schema from database' do
+  let(:setup) { ROM.setup(postgres: "postgres://localhost/rom") }
+
+  context "when database schema exists" do
+    after { rom.postgres.connection.drop_table?(:people) }
+
+    let(:rom) { setup.finalize }
+
+    it "infers the schema from the database relations" do
+      setup.postgres.connection.create_table :people do
+        primary_key :id
+        String :name
+      end
+
+      schema = rom.schema
+
+      expect(schema.people.to_a).to eql(rom.postgres.people.to_a)
+      expect(schema.people.header).to eql([:id, :name])
+    end
+  end
+
+  context "for empty database schemas" do
+    it "returns an empty schema" do
+      rom = setup.finalize
+      schema = rom.schema
+
+      expect(schema.postgres).to be(nil)
+    end
+  end
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: rom-sql
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Piotr Solnica
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.16'
+- !ruby/object:Gem::Dependency
+  name: equalizer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.9
+- !ruby/object:Gem::Dependency
+  name: rom
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.3'
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !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'
+description: RDBMS support for ROM
+email:
+- piotr.solnica@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rom-sql.rb
+- lib/rom/sql.rb
+- lib/rom/sql/adapter.rb
+- lib/rom/sql/header.rb
+- lib/rom/sql/relation_extension.rb
+- lib/rom/sql/relation_inclusion.rb
+- lib/rom/sql/spec/support.rb
+- lib/rom/sql/support/sequel_dataset_ext.rb
+- lib/rom/sql/version.rb
+- rom-sql.gemspec
+- spec/shared/users_and_tasks.rb
+- spec/spec_helper.rb
+- spec/unit/combined_associations_spec.rb
+- spec/unit/many_to_many_spec.rb
+- spec/unit/many_to_one_spec.rb
+- spec/unit/one_to_many_spec.rb
+- spec/unit/relation_spec.rb
+- spec/unit/schema_spec.rb
+homepage: http://rom-rb.org
+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.0.14
+signing_key: 
+specification_version: 4
+summary: RDBMS support for ROM
+test_files:
+- spec/shared/users_and_tasks.rb
+- spec/spec_helper.rb
+- spec/unit/combined_associations_spec.rb
+- spec/unit/many_to_many_spec.rb
+- spec/unit/many_to_one_spec.rb
+- spec/unit/one_to_many_spec.rb
+- spec/unit/relation_spec.rb
+- spec/unit/schema_spec.rb