yadm 0.1

data/spec/yadm/adapters/memory_spec.rb

@@ -0,0 +1,230 @@
+require 'yadm/adapters/memory'
+
+RSpec.describe YADM::Adapters::Memory do
+  let(:person_attributes) do
+    { name: 'John', email: 'john@example.com' }
+  end
+  
+  describe '#get' do
+    before(:each) do
+      subject.add(:people, person_attributes)
+    end
+    
+    context 'with a valid id' do
+      it 'returns the record with the specified id' do
+        expect(subject.get(:people, 1)).to eq(person_attributes.merge(id: 1))
+      end
+    end
+    
+    context 'with an invalid id' do
+      it 'raises' do
+        expect {
+          subject.get(:people, 11)
+        }.to raise_error(KeyError)
+      end
+    end
+  end
+  
+  describe '#add' do
+    it 'adds a new record' do
+      expect {
+        subject.add(:people, person_attributes)
+      }.to change { subject.count(:people) }.by(1)
+    end
+    
+    it 'returns id of the created record' do
+      expect(subject.add(:people, person_attributes)).to eq(1)
+    end
+    
+    it 'adds the id attribute to the created record' do
+      id = subject.add(:people, person_attributes)
+      expect(subject.get(:people, id)[:id]).to eq(id)
+    end
+    
+    it 'increments the id with each record' do
+      5.times { subject.add(:people, person_attributes) }
+      
+      expect(subject.count(:people)).to eq(5)
+      expect(subject.get(:people, 5)).to eq(person_attributes.merge(id: 5))
+    end
+  end
+  
+  describe '#change' do
+    before(:each) do
+      subject.add(:people, person_attributes)
+    end
+    
+    it 'changes an existing record' do
+      expect {
+        subject.change(:people, 1, name: 'Jack')
+      }.to change { subject.get(:people, 1)[:name] }.to('Jack')
+    end
+  end
+  
+  describe '#remove' do
+    before(:each) do
+      subject.add(:people, person_attributes)
+    end
+    
+    it 'removes the record with the specified id' do
+      expect {
+        subject.remove(:people, 1)
+      }.to change { subject.count(:people) }.by(-1)
+    end
+  end
+  
+  describe '#migrate' do
+    it 'does nothing' do
+      expect {
+        subject.migrate(:block)
+      }.not_to raise_error
+    end
+  end
+  
+  describe YADM::Adapters::Memory::Collection do
+    describe '#send_query' do
+      let(:criteria) do
+        YADM::Criteria.new(
+          condition: :some_condition,
+          order: :some_order,
+          limit: :some_limit
+        )
+      end
+      
+      let(:query) { double('Query', criteria: criteria, arguments: {}) }
+      
+      let(:records) { %i(first second third fourth) }
+      let(:filtered_records) { %i(first third fourth) }
+      let(:ordered_records) { %i(third first fourth) }
+      let(:limited_records) { %i(third first) }
+      
+      before(:each) do
+        allow(subject).to receive(:all).and_return(records)
+      end
+      
+      it 'returns the transformed records collection' do
+        expect(subject).to receive(:filter).with(records, :some_condition, {}).and_return(filtered_records)
+        expect(subject).to receive(:order).with(filtered_records, :some_order, {}).and_return(ordered_records)
+        expect(subject).to receive(:limit).with(ordered_records, :some_limit, {}).and_return(limited_records)
+        
+        expect(subject.send_query(query)).to eq(limited_records)
+      end
+    end
+    
+    describe '#filter' do
+      before(:each) do
+        subject.add(title: 'First post',  comments_count: 14)
+        subject.add(title: 'Second post', comments_count: 7)
+        subject.add(title: 'Third post',  comments_count: 17)
+      end
+      
+      let(:condition) do
+        attribute  = build_attribute(:comments_count)
+        expression = build_expression(attribute, :>, 10)
+        
+        build_condition(expression)
+      end
+      
+      it 'returns all records matching the condition' do
+        result = subject.filter(subject.all, condition, {})
+        
+        expect(result.count).to eq(2)
+        expect(result.first[:title]).to eq('First post')
+        expect(result.last[:title]).to eq('Third post')
+      end
+      
+      context 'with arguments' do
+        let(:condition) do
+          attribute  = build_attribute(:comments_count)
+          argument   = build_argument(:first, 0)
+          expression = build_expression(attribute, :>, argument)
+          
+          build_condition(expression)
+        end
+        
+        it 'returns all records matching the condition' do
+          result = subject.filter(subject.all, condition, first: [15])
+          
+          expect(result.count).to eq(1)
+          expect(result.first[:title]).to eq('Third post')
+        end
+      end
+    end
+    
+    describe '#order' do
+      before(:each) do
+        now = Time.now
+        
+        subject.add(name: 'Past',     created_at: now - 5)
+        subject.add(name: 'Future',   created_at: now + 5)
+        subject.add(name: 'Present',  created_at: now)
+        subject.add(name: 'Pre-past', created_at: now - 5)
+      end
+      
+      let(:order) do
+        created_at = build_attribute(:created_at)
+        timestamp_clause = build_order_clause(:asc, created_at)
+        
+        id = build_attribute(:id)
+        id_clause = build_order_clause(:desc, id)
+        
+        build_order([timestamp_clause, id_clause])
+      end
+      
+      it 'returns records in the specified order' do
+        result = subject.order(subject.all, order, {})
+        names  = result.map { |record| record[:name] }
+        
+        expect(names).to eq(%w(Pre-past Past Present Future))
+      end
+      
+      context 'with arguments' do
+        let(:order) do
+          name       = build_attribute(:name)
+          argument   = build_argument(:first, 0)
+          expression = build_expression(name, :[], argument)
+          
+          clause = build_order_clause(:asc, expression)
+          build_order([clause])
+        end
+        
+        it 'returns records in the specified order' do
+          result = subject.order(subject.all, order, first: [1])
+          names = result.map { |record| record[:name] }
+          
+          expect(names).to eq(%w(Past Present Pre-past Future))
+        end
+      end
+    end
+    
+    describe '#limit' do
+      before(:each) do
+        subject.add(name: 'First')
+        subject.add(name: 'Second')
+        subject.add(name: 'Third')
+      end
+      
+      let(:limit) { build_limit(2) }
+      
+      it 'returns first N records' do
+        result = subject.limit(subject.all, limit, {})
+        
+        expect(result.count).to eq(2)
+        expect(result.first[:name]).to eq('First')
+        expect(result.last[:name]).to eq('Second')
+      end
+      
+      context 'with arguments' do
+        let(:limit) do
+          argument = build_argument(:first, 0)
+          build_limit(argument)
+        end
+        
+        it 'returns first N records' do
+          result = subject.limit(subject.all, limit, first: [1])
+          expect(result.count).to eq(1)
+        end
+      end
+    end
+  end
+end

data/spec/yadm/adapters/mysql_spec.rb

@@ -0,0 +1,9 @@
+require 'yadm/adapters/mysql'
+
+RSpec.describe YADM::Adapters::MySQL do
+  subject do
+    described_class.new(database: 'yadm_test', user: 'yadm', password: 'yadm')
+  end
+  
+  it_behaves_like 'a sequel adapter'
+end

data/spec/yadm/adapters/postgresql_spec.rb

@@ -0,0 +1,9 @@
+require 'yadm/adapters/postgresql'
+
+RSpec.describe YADM::Adapters::PostgreSQL do
+  subject do
+    described_class.new(database: 'yadm_test', user: 'yadm', password: 'yadm')
+  end
+  
+  it_behaves_like 'a sequel adapter'
+end

data/spec/yadm/adapters/sqlite_spec.rb

@@ -0,0 +1,5 @@
+require 'yadm/adapters/sqlite'
+
+RSpec.describe YADM::Adapters::Sqlite do
+  it_behaves_like 'a sequel adapter'
+end

data/spec/yadm/adapters_spec.rb

@@ -0,0 +1,32 @@
+RSpec.describe YADM::Adapters do
+  describe '.register' do
+    let(:adapter) { double('Adapter') }
+    
+    it 'stores a new adapter in the registry' do
+      subject.register(:some_adapter, adapter)
+      expect(subject.fetch(:some_adapter)).to eq(adapter)
+    end
+  end
+  
+  describe '.fetch' do
+    context 'with a registered adapter name' do
+      let(:adapter) { double('Adapter') }
+      
+      before(:each) do
+        subject.register(:some_adapter, adapter)
+      end
+      
+      it 'returns the corresponding adapter' do
+        expect(subject.fetch(:some_adapter)).to eq(adapter)
+      end
+    end
+    
+    context 'with an unknown adapter_name' do
+      it 'raises a NotImplementedError' do
+        expect {
+          subject.fetch(:unknown)
+        }.to raise_error(NotImplementedError, "Adapter `:unknown` isn't registered.")
+      end
+    end
+  end
+end

data/spec/yadm/criteria/condition_spec.rb

@@ -0,0 +1,50 @@
+RSpec.describe YADM::Criteria::Condition do
+  describe '.merge' do
+    let(:first_condition) do
+      attribute  = build_attribute(:age)
+      expression = build_expression(attribute, :>, 20)
+      
+      described_class.new(expression)
+    end
+    
+    let(:second_condition) do
+      attribute  = build_attribute(:age)
+      expression = build_expression(attribute, :<, 35)
+      
+      described_class.new(expression)
+    end
+    
+    subject { described_class.merge(first_condition, second_condition) }
+    
+    it 'concatenates the conditions with a logical AND' do
+      expect(subject.expression.receiver).to eq(first_condition.expression)
+      expect(subject.expression.method_name).to eq(:&)
+      expect(subject.expression.arguments).to eq([second_condition.expression])
+    end
+    
+    context 'with first argument being nil' do
+      let(:first_condition) { nil }
+      
+      it 'returns the second argument' do
+        expect(subject).to eq(second_condition)
+      end
+    end
+    
+    context 'with second argument being nil' do
+      let(:second_condition) { nil }
+      
+      it 'returns the first argument' do
+        expect(subject).to eq(first_condition)
+      end
+    end
+    
+    context 'with both arguments being nil' do
+      let(:first_condition)  { nil }
+      let(:second_condition) { nil }
+      
+      it 'returns nil' do
+        expect(subject).to be_nil
+      end
+    end
+  end
+end

data/spec/yadm/criteria/limit_spec.rb

@@ -0,0 +1,45 @@
+RSpec.describe YADM::Criteria::Limit do
+  describe '.merge' do
+    let(:first_limit)  { described_class.new(10) }
+    let(:second_limit) { described_class.new(15) }
+    
+    subject { described_class.merge(first_limit, second_limit) }
+    
+    it 'respects the last value' do
+      expect(subject.limit).to eq(15)
+    end
+    
+    context 'with second argument having a nil limit' do
+      let(:second_limit) { described_class.new(nil) }
+      
+      it 'returns nil' do
+        expect(subject).to be_nil
+      end
+    end
+    
+    context 'with first argument being nil' do
+      let(:first_limit) { nil }
+      
+      it 'returns the second argument' do
+        expect(subject).to eq(second_limit)
+      end
+    end
+    
+    context 'with second argument being nil' do
+      let(:second_limit) { nil }
+      
+      it 'returns the first argument' do
+        expect(subject).to eq(first_limit)
+      end
+    end
+    
+    context 'with both arguments being nil' do
+      let(:first_limit)  { nil }
+      let(:second_limit) { nil }
+      
+      it 'returns nil' do
+        expect(subject).to be_nil
+      end
+    end
+  end
+end

data/spec/yadm/criteria/order_spec.rb

@@ -0,0 +1,50 @@
+RSpec.describe YADM::Criteria::Order do
+  describe '.merge' do
+    let(:first_order) do
+      attribute = build_attribute(:last_name)
+      clause    = build_order_clause(:asc, attribute)
+      
+      described_class.new([clause])
+    end
+    
+    let(:second_order) do
+      attribute = build_attribute(:first_name)
+      clause    = build_order_clause(:asc, attribute)
+      
+      described_class.new([clause])
+    end
+    
+    subject { described_class.merge(first_order, second_order) }
+    
+    it 'sums up the clauses' do
+      expect(subject.clauses.count).to eq(2)
+      expect(subject.clauses.first).to eq(first_order.clauses.first)
+      expect(subject.clauses.last).to eq(second_order.clauses.first)
+    end
+    
+    context 'with first argument being nil' do
+      let(:first_order) { nil }
+      
+      it 'returns the second argument' do
+        expect(subject).to eq(second_order)
+      end
+    end
+    
+    context 'with second argument being nil' do
+      let(:second_order) { nil }
+      
+      it 'returns the first argument' do
+        expect(subject).to eq(first_order)
+      end
+    end
+    
+    context 'with both arguments being nil' do
+      let(:first_order)  { nil }
+      let(:second_order) { nil }
+      
+      it 'returns nil' do
+        expect(subject).to be_nil
+      end
+    end
+  end
+end

data/spec/yadm/criteria_parser/expression_parser_spec.rb

@@ -0,0 +1,47 @@
+RSpec.describe YADM::CriteriaParser::ExpressionParser do
+  subject { described_class.new(block) }
+  
+  describe '#result' do
+    let(:result) { subject.result }
+    
+    context 'with a simple block' do
+      let(:block) do
+        proc do
+          age > 12
+        end
+      end
+      
+      let(:expected_expression) do
+        build_expression(build_attribute(:age), :>, 12)
+      end
+      
+      it 'returns a Criteria::Expression' do
+        expect(result).to eq(expected_expression)
+      end
+    end
+    
+    context 'with a nested expression in the block' do
+      let(:block) do
+        proc do
+          (age >= 18) & (age <= 27) & (sex == 'male')
+        end
+      end
+      
+      let(:expected_expression) do
+        build_expression(
+          build_expression(
+            build_expression(build_attribute(:age), :>=, 18),
+            :&,
+            build_expression(build_attribute(:age), :<=, 27)
+          ),
+          :&,
+          build_expression(build_attribute(:sex), :==, 'male')
+        )
+      end
+      
+      it 'returns a nested Criteria::Expression' do
+        expect(result).to eq(expected_expression)
+      end
+    end
+  end
+end