rom-mapper 0.1.1 → 0.2.0

data/rakelib/benchmark.rake

@@ -0,0 +1,15 @@
+desc "Run benchmarks (tweak count via COUNT envvar)"
+task :benchmark do
+  FileList["benchmarks/**/*_bench.rb"].each do |bench|
+    sh "ruby #{bench}"
+  end
+end
+
+namespace :benchmark do
+  desc "Verify benchmarks"
+  task :verify do
+    ENV['VERIFY'] = "true"
+    ENV['COUNT'] = "1"
+    Rake::Task[:benchmark].invoke
+  end
+end

data/rakelib/mutant.rake

@@ -0,0 +1,16 @@
+desc "Run mutant against a specific subject"
+task :mutant do
+  subject = ARGV.last
+  if subject == 'mutant'
+    abort "usage: rake mutant SUBJECT\nexample: rake mutant ROM::Header"
+  else
+    opts = {
+      'include' => 'lib',
+      'require' => 'rom',
+      'use' => 'rspec',
+      'ignore-subject' => "#{subject}#respond_to_missing?"
+    }.to_a.map { |k, v| "--#{k} #{v}" }.join(' ')
+
+    exec("bundle exec mutant #{opts} #{subject}")
+  end
+end

data/rakelib/rubocop.rake

@@ -0,0 +1,18 @@
+begin
+  require "rubocop/rake_task"
+
+  Rake::Task[:default].enhance [:rubocop]
+
+  RuboCop::RakeTask.new do |task|
+    task.options << "--display-cop-names"
+  end
+
+  namespace :rubocop do
+    desc 'Generate a configuration file acting as a TODO list.'
+    task :auto_gen_config do
+      exec "bundle exec rubocop --auto-gen-config"
+    end
+  end
+
+rescue LoadError
+end

data/rom-mapper.gemspec

@@ -4,7 +4,7 @@ require File.expand_path('../lib/rom/mapper/version', __FILE__)
 
 Gem::Specification.new do |gem|
   gem.name          = "rom-mapper"
-  gem.description   = "rom-mapper"
+  gem.description   = "ROM mapper component"
   gem.summary       = gem.description
   gem.authors       = 'Piotr Solnica'
   gem.email         = 'piotr.solnica@gmail.com'
@@ -15,9 +15,10 @@ Gem::Specification.new do |gem|
   gem.test_files    = `git ls-files -- {spec}/*`.split("\n")
   gem.license       = 'MIT'
 
-  gem.add_dependency 'concord',             '~> 0.1.4'
-  gem.add_dependency 'equalizer',           '~> 0.0.7'
-  gem.add_dependency 'descendants_tracker', '~> 0.0.1'
-  gem.add_dependency 'abstract_type',       '~> 0.0.6'
-  gem.add_dependency 'adamantium',          '~> 0.1'
+  gem.add_dependency 'transproc', '~> 0.3'
+  gem.add_dependency 'equalizer', '~> 0.0', '>= 0.0.10'
+  gem.add_dependency 'rom-support', '~> 0.1', '>= 0.1.0'
+
+  gem.add_development_dependency 'rake', '~> 10.3'
+  gem.add_development_dependency 'rspec', '~> 3.3'
 end

data/spec/spec_helper.rb

@@ -1,48 +1,47 @@
 # encoding: utf-8
 
-if ENV['COVERAGE'] == 'true'
-  require 'simplecov'
-  require 'coveralls'
+# this is needed for guard to work, not sure why :(
+require "bundler"
+Bundler.setup
 
-  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-    SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
-  ]
-
-  SimpleCov.start do
-    command_name 'spec:unit'
-
-    add_filter 'config'
-    add_filter 'lib/rom/support'
-    add_filter 'spec'
-  end
+if RUBY_ENGINE == "rbx"
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
 end
 
 require 'rom-mapper'
-require 'axiom'
-
-require 'devtools/spec_helper'
-require 'bogus/rspec'
 
-Bogus.configure do |config|
-  config.search_modules << ROM
+begin
+  require 'byebug'
+rescue LoadError
 end
 
-RSpec.configure do |config|
-  config.mock_with Bogus::RSpecAdapter
+root = Pathname(__FILE__).dirname
+
+Dir[root.join('support/*.rb').to_s].each do |f|
+  require f
+end
+Dir[root.join('shared/*.rb').to_s].each do |f|
+  require f
 end
 
-include ROM
+# Namespace holding all objects created during specs
+module Test
+  def self.remove_constants
+    constants.each(&method(:remove_const))
+  end
+end
 
-def mock_model(*attributes)
-  Class.new {
-    include Equalizer.new(*attributes)
+def T(*args)
+  ROM::Processor::Transproc::Functions[*args]
+end
 
-    attributes.each { |attribute| attr_accessor attribute }
+RSpec.configure do |config|
+  config.after do
+    Test.remove_constants
+  end
 
-    def initialize(attrs, &block)
-      attrs.each { |name, value| send("#{name}=", value) }
-      instance_eval(&block) if block
-    end
-  }
+  config.around do |example|
+    ConstantLeakFinder.find(example)
+  end
 end

data/spec/support/constant_leak_finder.rb

@@ -0,0 +1,14 @@
+# Finds leaking constants created during ROM specs
+module ConstantLeakFinder
+  def self.find(example)
+    constants = Object.constants
+
+    example.run
+
+    added_constants = (Object.constants - constants)
+    added = added_constants.map(&Object.method(:const_get))
+    if added.any? { |mod| mod.ancestors.map(&:name).grep(/\AROM/).any? }
+      raise "Leaking constants: #{added_constants.inspect}"
+    end
+  end
+end

data/spec/support/mutant.rb

@@ -0,0 +1,10 @@
+module Mutant
+  class Selector
+    # Expression based test selector
+    class Expression < self
+      def call(_subject)
+        integration.all_tests
+      end
+    end # Expression
+  end # Selector
+end # Mutant

data/spec/unit/rom/mapper/dsl_spec.rb

@@ -0,0 +1,467 @@
+require 'spec_helper'
+
+describe ROM::Mapper do
+  subject(:mapper) do
+    klass = Class.new(parent)
+    options.each do |k, v|
+      klass.send(k, v)
+    end
+    klass
+  end
+
+  let(:parent) { Class.new(ROM::Mapper) }
+
+  let(:options) { {} }
+  let(:header) { mapper.header }
+
+  let(:expected_header) { ROM::Header.coerce(attributes) }
+
+  describe '#attribute' do
+    context 'simple attribute' do
+      let(:attributes) { [[:name]] }
+
+      it 'adds an attribute for the header' do
+        mapper.attribute :name
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'aliased attribute' do
+      let(:attributes) { [[:name, from: :user_name]] }
+
+      it 'adds an aliased attribute for the header' do
+        mapper.attribute :name, from: :user_name
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'prefixed attribute' do
+      let(:attributes) { [[:name, from: :user_name]] }
+      let(:options) { { prefix: :user } }
+
+      it 'adds an aliased attribute for the header using configured :prefix' do
+        mapper.attribute :name
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'prefixed attribute using custom separator' do
+      let(:attributes) { [[:name, from: :'u.name']] }
+      let(:options) { { prefix: :u, prefix_separator: '.' } }
+
+      it 'adds an aliased attribute for the header using configured :prefix' do
+        mapper.attribute :name
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'symbolized attribute' do
+      let(:attributes) { [[:name, from: 'name']] }
+      let(:options) { { symbolize_keys: true } }
+
+      it 'adds an attribute with symbolized alias' do
+        mapper.attribute :name
+
+        expect(header).to eql(expected_header)
+      end
+    end
+  end
+
+  describe 'reject_keys' do
+    let(:attributes) { [[:name, type: :string]] }
+    let(:options) { { reject_keys: true } }
+
+    it 'sets rejected_keys for the header' do
+      mapper.reject_keys true
+      mapper.attribute :name, type: :string
+
+      expect(header).to eql(expected_header)
+    end
+  end
+
+  describe 'overriding inherited attributes' do
+    context 'when name matches' do
+      let(:attributes) { [[:name, type: :string]] }
+
+      it 'excludes the inherited attribute' do
+        parent.attribute :name
+
+        mapper.attribute :name, type: :string
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'when alias matches' do
+      let(:attributes) { [[:name, from: 'name', type: :string]] }
+
+      it 'excludes the inherited attribute' do
+        parent.attribute 'name'
+
+        mapper.attribute :name, from: 'name', type: :string
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'when name in a wrapped attribute matches' do
+      let(:attributes) do
+        [
+          [:city, type: :hash, wrap: true, header: [[:name, from: :city_name]]]
+        ]
+      end
+
+      it 'excludes the inherited attribute' do
+        parent.attribute :city_name
+
+        mapper.wrap :city do
+          attribute :name, from: :city_name
+        end
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'when name in a grouped attribute matches' do
+      let(:attributes) do
+        [
+          [:tags, type: :array, group: true, header: [[:name, from: :tag_name]]]
+        ]
+      end
+
+      it 'excludes the inherited attribute' do
+        parent.attribute :tag_name
+
+        mapper.group :tags do
+          attribute :name, from: :tag_name
+        end
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'when name in a hash attribute matches' do
+      let(:attributes) do
+        [
+          [:city, type: :hash, header: [[:name, from: :city_name]]]
+        ]
+      end
+
+      it 'excludes the inherited attribute' do
+        parent.attribute :city
+
+        mapper.embedded :city, type: :hash do
+          attribute :name, from: :city_name
+        end
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'when name of an array attribute matches' do
+      let(:attributes) do
+        [
+          [:tags, type: :array, header: [[:name, from: :tag_name]]]
+        ]
+      end
+
+      it 'excludes the inherited attribute' do
+        parent.attribute :tags
+
+        mapper.embedded :tags, type: :array do
+          attribute :name, from: :tag_name
+        end
+
+        expect(header).to eql(expected_header)
+      end
+    end
+  end
+
+  describe '#exclude' do
+    let(:attributes) { [[:name, from: 'name']] }
+
+    it 'removes an attribute from the inherited header' do
+      mapper.attribute :name, from: 'name'
+      expect(header).to eql(expected_header)
+    end
+  end
+
+  describe '#embedded' do
+    context 'when :type is set to :hash' do
+      let(:attributes) { [[:city, type: :hash, header: [[:name]]]] }
+
+      it 'adds an embedded hash attribute' do
+        mapper.embedded :city, type: :hash do
+          attribute :name
+        end
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'when :type is set to :array' do
+      let(:attributes) { [[:tags, type: :array, header: [[:name]]]] }
+
+      it 'adds an embedded array attribute' do
+        mapper.embedded :tags, type: :array do
+          attribute :name
+        end
+
+        expect(header).to eql(expected_header)
+      end
+    end
+  end
+
+  describe '#wrap' do
+    let(:attributes) { [[:city, type: :hash,  wrap: true, header: [[:name]]]] }
+
+    it 'adds an wrapped hash attribute using a block to define attributes' do
+      mapper.wrap :city do
+        attribute :name
+      end
+
+      expect(header).to eql(expected_header)
+    end
+
+    it 'adds an wrapped hash attribute using a options define attributes' do
+      mapper.wrap city: [:name]
+
+      expect(header).to eql(expected_header)
+    end
+
+    it 'raises an exception when using a block and options to define attributes' do
+      expect {
+        mapper.wrap(city: [:name]) { attribute :other_name }
+      }.to raise_error(ROM::MapperMisconfiguredError)
+    end
+
+    it 'raises an exception when using options and a mapper to define attributes' do
+      task_mapper = Class.new(ROM::Mapper) { attribute :title }
+      expect {
+        mapper.wrap city: [:name], mapper: task_mapper
+      }.to raise_error(ROM::MapperMisconfiguredError)
+    end
+  end
+
+  describe '#group' do
+    let(:attributes) { [[:tags, type: :array, group: true, header: [[:name]]]] }
+
+    it 'adds a group attribute using a block to define attributes' do
+      mapper.group :tags do
+        attribute :name
+      end
+
+      expect(header).to eql(expected_header)
+    end
+
+    it 'adds a group attribute using a options define attributes' do
+      mapper.group tags: [:name]
+
+      expect(header).to eql(expected_header)
+    end
+
+    it 'raises an exception when using a block and options to define attributes' do
+      expect {
+        mapper.group(cities: [:name]) { attribute :other_name }
+      }.to raise_error(ROM::MapperMisconfiguredError)
+    end
+
+    it 'raises an exception when using options and a mapper to define attributes' do
+      task_mapper = Class.new(ROM::Mapper) { attribute :title }
+      expect {
+        mapper.group cities: [:name], mapper: task_mapper
+      }.to raise_error(ROM::MapperMisconfiguredError)
+    end
+  end
+
+  describe 'top-level :prefix option' do
+    let(:options) do
+      { prefix: :user }
+    end
+
+    context 'when no attribute overrides top-level setting' do
+      let(:attributes) do
+        [
+          [:name, from: :user_name],
+          [:address, from: :user_address, type: :hash, header: [
+            [:city, from: :user_city]]
+          ],
+          [:contact, type: :hash, wrap: true, header: [
+            [:mobile, from: :user_mobile]]
+          ],
+          [:tasks, type: :array, group: true, header: [
+            [:title, from: :user_title]]
+          ]
+        ]
+      end
+
+      it 'sets aliased attributes using prefix automatically' do
+        mapper.attribute :name
+
+        mapper.embedded :address, type: :hash do
+          attribute :city
+        end
+
+        mapper.wrap :contact do
+          attribute :mobile
+        end
+
+        mapper.group :tasks do
+          attribute :title
+        end
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    context 'when an attribute overrides top-level setting' do
+      let(:attributes) do
+        [
+          [:name, from: :user_name],
+          [:birthday, from: :user_birthday, type: :hash, header: [
+            [:year, from: :bd_year],
+            [:month, from: :bd_month],
+            [:day, from: :bd_day]]
+          ],
+          [:address, from: :user_address, type: :hash, header: [[:city]]],
+          [:contact, type: :hash, wrap: true, header: [
+            [:mobile, from: :contact_mobile]]
+          ],
+          [:tasks, type: :array, group: true, header: [
+            [:title, from: :task_title]]
+          ]
+        ]
+      end
+
+      it 'excludes from aliasing the ones which override it' do
+        mapper.attribute :name
+
+        mapper.embedded :birthday, type: :hash, prefix: :bd do
+          attribute :year
+          attribute :month
+          attribute :day
+        end
+
+        mapper.embedded :address, type: :hash, prefix: false do
+          attribute :city
+        end
+
+        mapper.wrap :contact, prefix: :contact do
+          attribute :mobile
+        end
+
+        mapper.group :tasks, prefix: :task do
+          attribute :title
+        end
+
+        expect(header).to eql(expected_header)
+      end
+    end
+  end
+
+  context 'reusing mappers' do
+    describe '#group' do
+      let(:task_mapper) do
+        Class.new(ROM::Mapper) { attribute :title }
+      end
+
+      let(:attributes) do
+        [
+          [:name],
+          [:tasks, type: :array, group: true, header: task_mapper.header]
+        ]
+      end
+
+      it 'uses other mapper header' do
+        mapper.attribute :name
+        mapper.group :tasks, mapper: task_mapper
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    describe '#wrap' do
+      let(:task_mapper) do
+        Class.new(ROM::Mapper) { attribute :title }
+      end
+
+      let(:attributes) do
+        [
+          [:name],
+          [:task, type: :hash, wrap: true, header: task_mapper.header]
+        ]
+      end
+
+      it 'uses other mapper header' do
+        mapper.attribute :name
+        mapper.wrap :task, mapper: task_mapper
+
+        expect(header).to eql(expected_header)
+      end
+    end
+
+    describe '#embedded' do
+      let(:task_mapper) do
+        Class.new(ROM::Mapper) { attribute :title }
+      end
+
+      let(:attributes) do
+        [
+          [:name],
+          [:task, type: :hash, header: task_mapper.header]
+        ]
+      end
+
+      it 'uses other mapper header' do
+        mapper.attribute :name
+        mapper.embedded :task, mapper: task_mapper, type: :hash
+
+        expect(header).to eql(expected_header)
+      end
+    end
+  end
+
+  describe '#combine' do
+    let(:attributes) do
+      [
+        [:title],
+        [:tasks, combine: true, type: :array, header: [[:title]]]
+      ]
+    end
+
+    it 'adds combine attributes' do
+      mapper.attribute :title
+
+      mapper.combine :tasks, on: { title: :title } do
+        attribute :title
+      end
+
+      expect(header).to eql(expected_header)
+    end
+
+    it 'works without a block' do
+      expected_header = ROM::Header.coerce(
+        [
+          [:title],
+          [:tasks, combine: true, type: :array, header: []]
+        ]
+      )
+
+      mapper.attribute :title
+
+      mapper.combine :tasks, on: { title: :title }
+
+      expect(header).to eql(expected_header)
+    end
+  end
+
+  describe '#method_missing' do
+    it 'responds to DSL methods' do
+      expect(mapper).to respond_to(:attribute)
+    end
+  end
+end