rom 0.8.1 → 0.9.0.beta1

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

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-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

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-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

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-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

@@ -1,89 +0,0 @@
-require 'spec_helper'
-
-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

@@ -1,119 +0,0 @@
-require 'spec_helper'
-
-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::InvalidOptionKeyError, /:unexpected/)
-    end
-
-    it 'checks option type' do
-      expect { klass.new(name: :foo) }
-        .to raise_error(ROM::InvalidOptionValueError, /:foo/)
-    end
-
-    it 'checks option value' do
-      expect { klass.new(name: 'invalid') }
-        .to raise_error(ROM::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