rom-support 0.1.0

data/lib/rom/support/version.rb

@@ -0,0 +1,5 @@
+module ROM
+  module Support
+    VERSION = '0.1.0'.freeze
+  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-support.gemspec

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require File.expand_path('../lib/rom/support/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = 'rom-support'
+  gem.summary       = 'Ruby Object Mapper - Support libraries'
+  gem.description   = gem.summary
+  gem.author        = 'Piotr Solnica'
+  gem.email         = 'piotr.solnica@gmail.com'
+  gem.homepage      = 'http://rom-rb.org'
+  gem.require_paths = ['lib']
+  gem.version       = ROM::Support::VERSION.dup
+  gem.files         = `git ls-files`.split("\n").reject { |name| name.include?('benchmarks') }
+  gem.test_files    = `git ls-files -- {spec}/*`.split("\n")
+  gem.license       = 'MIT'
+
+  gem.add_runtime_dependency 'wisper', '~> 1.6', '>= 1.6.0'
+
+  gem.add_development_dependency 'rake', '~> 10.3'
+  gem.add_development_dependency 'rspec', '~> 3.3'
+end

data/spec/shared/enumerable_dataset.rb

@@ -0,0 +1,52 @@
+shared_examples_for "an enumerable dataset" do
+  subject(:dataset) { klass.new(data) }
+
+  let(:data) do
+    [{ 'name' => 'Jane' }, { 'name' => 'Joe' }]
+  end
+
+  describe '#each' do
+    it 'yields tuples through row_proc' do
+      result = []
+
+      dataset.each do |tuple|
+        result << tuple
+      end
+
+      expect(result).to match_array([{ name: 'Jane' }, { name: 'Joe' }])
+    end
+  end
+
+  describe '#to_a' do
+    it 'casts dataset to an array' do
+      expect(dataset.to_a).to eql([{ name: 'Jane' }, { name: 'Joe' }])
+    end
+  end
+
+  describe '#find_all' do
+    it 'yields tuples through row_proc' do
+      result = dataset.find_all { |tuple| tuple[:name] == 'Jane' }
+
+      expect(result).to be_instance_of(klass)
+      expect(result).to match_array([{ name: 'Jane' }])
+    end
+  end
+
+  describe '#kind_of?' do
+    it 'does not forward to data object' do
+      expect(dataset).to be_kind_of(klass)
+    end
+  end
+
+  describe '#instance_of?' do
+    it 'does not forward to data object' do
+      expect(dataset).to be_instance_of(klass)
+    end
+  end
+
+  describe '#is_a?' do
+    it 'does not forward to data object' do
+      expect(dataset.is_a?(klass)).to be(true)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,46 @@
+# this is needed for guard to work, not sure why :(
+require "bundler"
+Bundler.setup
+
+if RUBY_ENGINE == "rbx"
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
+end
+
+require 'rom-support'
+require 'rom-mapper'
+
+begin
+  require 'byebug'
+rescue LoadError
+end
+
+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
+
+# Namespace holding all objects created during specs
+module Test
+  def self.remove_constants
+    constants.each(&method(:remove_const))
+  end
+end
+
+RSpec.configure do |config|
+  config.after do
+    Test.remove_constants
+  end
+
+  config.around do |example|
+    ConstantLeakFinder.find(example)
+  end
+end
+
+def T(*args)
+  ROM::Processor::Transproc::Functions[*args]
+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/support/array_dataset_spec.rb

@@ -0,0 +1,59 @@
+require 'rom/support/array_dataset'
+
+describe ROM::ArrayDataset do
+  let(:klass) do
+    Class.new do
+      include ROM::ArrayDataset
+
+      def self.row_proc
+        T(:symbolize_keys)
+      end
+    end
+  end
+
+  it_behaves_like 'an enumerable dataset' do
+    describe '#flatten' do
+      let(:data) { [[{ 'name' => 'Jane' }], [{ 'name' => 'Joe' }]] }
+
+      it 'returns a new dataset with flattened data' do
+        result = dataset.flatten
+
+        expect(result).to match_array([{ name: 'Jane' }, { name: 'Joe' }])
+      end
+    end
+
+    describe '#map!' do
+      context 'with a block' do
+        it 'returns a new dataset with mapped data' do
+          dataset.map! do |row|
+            row.merge(age: 21)
+          end
+
+          expect(dataset).to match_array([
+            { name: 'Jane', age: 21 }, { name: 'Joe', age: 21 }
+          ])
+        end
+      end
+
+      context 'without a block' do
+        it 'returns an enumerator' do
+          result = dataset.map!
+
+          expect(result).to be_instance_of(Enumerator)
+
+          expect(result).to match_array([
+            { name: 'Jane' }, { name: 'Joe' }
+          ])
+        end
+      end
+    end
+
+    describe '#values_at' do
+      it 'returns a new dataset with rows at given indices' do
+        result = dataset.values_at(1)
+
+        expect(result).to match_array([{ name: 'Joe' }])
+      end
+    end
+  end
+end

data/spec/unit/rom/support/class_builder_spec.rb

@@ -0,0 +1,42 @@
+require 'rom/support/class_builder'
+
+describe ROM::ClassBuilder do
+  subject(:builder) { ROM::ClassBuilder.new(options) }
+
+  let(:klass) { builder.call }
+
+  describe '#call' do
+    let(:options) do
+      { name: 'Test', parent: parent }
+    end
+
+    let(:parent) { Class.new }
+
+    it 'returns a class constant' do
+      expect(klass).to be_instance_of(Class)
+    end
+
+    it 'sets class name based on provided :name option' do
+      expect(klass.name).to eql(options[:name])
+    end
+
+    it 'uses a parent class provided by :parent option' do
+      expect(klass).to be < parent
+    end
+
+    it 'defines to_s and inspect' do
+      expect(klass.to_s).to eql(options[:name])
+      expect(klass.inspect).to eql(options[:name])
+    end
+
+    it 'yields created class' do
+      klass = builder.call { |yielded_class|
+        yielded_class.class_eval do
+          def self.testing; end
+        end
+      }
+
+      expect(klass).to respond_to(:testing)
+    end
+  end
+end

data/spec/unit/rom/support/enumerable_dataset_spec.rb

@@ -0,0 +1,15 @@
+require 'rom/support/enumerable_dataset'
+
+describe ROM::EnumerableDataset do
+  let(:klass) do
+    Class.new do
+      include ROM::EnumerableDataset
+
+      def self.row_proc
+        T(:symbolize_keys)
+      end
+    end
+  end
+
+  it_behaves_like 'an enumerable dataset'
+end

data/spec/unit/rom/support/inflector_spec.rb

@@ -0,0 +1,89 @@
+require 'rom/support/inflector'
+
+describe ROM::Inflector do
+  shared_examples 'an inflector' do
+    it 'singularises' do
+      expect(api.singularize('tasks')).to eq 'task'
+    end
+
+    it 'pluralizes' do
+      expect(api.pluralize('task')).to eq 'tasks'
+    end
+
+    it 'camelizes' do
+      expect(api.camelize('task_user')).to eq 'TaskUser'
+    end
+
+    it 'underscores' do
+      expect(api.underscore('TaskUser')).to eq 'task_user'
+    end
+
+    it 'demodulizes' do
+      expect(api.demodulize('Task::User')).to eq 'User'
+    end
+
+    it 'constantizes' do
+      expect(api.constantize('String')).to equal String
+    end
+
+    it 'classifies' do
+      expect(api.classify('task_user/name')).to eq 'TaskUser::Name'
+    end
+  end
+
+  subject(:api) { ROM::Inflector }
+
+  context 'with detected inflector' do
+    before do
+      if api.instance_variables.include?(:@inflector)
+        api.__send__(:remove_instance_variable, :@inflector)
+      end
+    end
+
+    it 'prefers ActiveSupport::Inflector' do
+      expect(api.inflector == ::ActiveSupport::Inflector).to be true
+    end
+  end
+
+  context 'with automatic detection' do
+    before do
+      if api.instance_variables.include?(:@inflector)
+        api.__send__(:remove_instance_variable, :@inflector)
+      end
+    end
+
+    it 'automatically selects an inflector backend' do
+      expect(api.inflector).not_to be nil
+    end
+  end
+
+  context 'with ActiveSupport::Inflector' do
+    before do
+      api.select_backend(:activesupport)
+    end
+
+    it 'is ActiveSupport::Inflector' do
+      expect(api.inflector).to be(::ActiveSupport::Inflector)
+    end
+
+    it_behaves_like 'an inflector'
+  end
+
+  context 'with Inflecto' do
+    before do
+      api.select_backend(:inflecto)
+    end
+
+    it 'is Inflecto' do
+      expect(api.inflector).to be(::Inflecto)
+    end
+
+    it_behaves_like 'an inflector'
+  end
+
+  context 'an unrecognized inflector library is selected' do
+    it 'raises a NameError' do
+      expect { api.select_backend(:foo) }.to raise_error(NameError)
+    end
+  end
+end

data/spec/unit/rom/support/options_spec.rb

@@ -0,0 +1,119 @@
+require 'rom/support/options'
+
+describe ROM::Options do
+  let(:klass) do
+    Class.new do
+      include ROM::Options
+
+      option :name, type: String, reader: true, allow: %w(foo bar)
+      option :repo, reader: true
+      option :other
+    end
+  end
+
+  describe '.new' do
+    it 'works without passing a hash' do
+      expect { klass.new }.not_to raise_error
+    end
+
+    it 'sets options hash' do
+      object = klass.new(name: 'foo')
+      expect(object.options).to eql(name: 'foo')
+    end
+
+    it 'allows any value when :allow is not specified' do
+      repo = double('repo')
+      object = klass.new(repo: repo)
+      expect(object.options).to eql(repo: repo)
+    end
+
+    it 'sets readers for options when specified' do
+      object = klass.new(name: 'bar', repo: 'default')
+      expect(object.name).to eql('bar')
+      expect(object.repo).to eql('default')
+      expect(object).to_not respond_to(:other)
+    end
+
+    it 'checks option key' do
+      expect { klass.new(unexpected: 'foo') }
+        .to raise_error(ROM::Options::InvalidOptionKeyError, /:unexpected/)
+    end
+
+    it 'checks option type' do
+      expect { klass.new(name: :foo) }
+        .to raise_error(ROM::Options::InvalidOptionValueError, /:foo/)
+    end
+
+    it 'checks option value' do
+      expect { klass.new(name: 'invalid') }
+        .to raise_error(ROM::Options::InvalidOptionValueError, /invalid/)
+    end
+
+    it 'copies klass options to descendant' do
+      other = Class.new(klass).new(name: 'foo')
+      expect(other.options).to eql(name: 'foo')
+    end
+
+    it 'does not interfere with its parent`s option definitions' do
+      Class.new(klass) do
+        option :child, default: :nope
+      end
+      object = klass.new
+      expect(object.options).to eql({})
+    end
+
+    it 'sets option defaults statically' do
+      default_value = []
+      klass.option :args, default: default_value
+
+      object = klass.new
+
+      expect(object.options).to eql(args: default_value)
+      expect(object.options[:args]).to equal(default_value)
+    end
+
+    it 'sets option defaults dynamically via proc' do
+      klass.option :args, default: proc { |*a| a }
+
+      object = klass.new
+
+      expect(object.options).to eql(args: [object])
+    end
+
+    it 'allow nil as default value' do
+      klass.option :args, default: nil
+
+      object = klass.new
+
+      expect(object.options).to eql(args: nil)
+    end
+
+    it 'options are frozen' do
+      object = klass.new
+
+      expect { object.options[:foo] = :bar }
+        .to raise_error(RuntimeError, /frozen/)
+    end
+
+    it 'call parent`s `inherited` hook' do
+      m = Module.new do
+        def inherited(_base)
+          raise "hook called"
+        end
+      end
+      klass.extend m
+
+      expect { Class.new(klass).new }
+        .to raise_error(/hook called/)
+    end
+
+    it 'does not modify passed options' do
+      options = {}
+      klass.option :foo, default: :bar
+
+      klass.new(options)
+
+      expect(options).to eq({})
+    end
+  end
+end