yadm 0.1

data/lib/yadm/mapping/attribute.rb

@@ -0,0 +1,31 @@
+module YADM
+  class Mapping
+    class Attribute
+      COERCIONS = {
+        Integer => -> (value) { value.to_i },
+        String  => -> (value) { value.to_s }
+      }.tap do |hash|
+        hash.default = -> (value) { value }
+      end
+      
+      attr_reader :type
+      protected :type
+      
+      def initialize(type)
+        @type = type
+      end
+      
+      def ==(other)
+        type == other.type
+      end
+      
+      def coerce(value)
+        if value.nil?
+          nil
+        else
+          COERCIONS[type].call(value)
+        end
+      end
+    end
+  end
+end

data/lib/yadm/query.rb

@@ -0,0 +1,28 @@
+module YADM
+  class Query
+    attr_reader :criteria, :arguments
+    
+    include Enumerable
+    
+    def initialize(criteria = Criteria.new, arguments = {})
+      @criteria  = criteria
+      @arguments = arguments
+    end
+    
+    def merge(new_criteria, new_arguments)
+      self.class.new(criteria.merge(new_criteria), arguments.merge(new_arguments))
+    end
+    
+    def to_a
+      repository.send_query(self)
+    end
+    
+    def each(&block)
+      to_a.each(&block)
+    end
+    
+    def repository
+      raise NotImplementedError
+    end
+  end
+end

data/lib/yadm/repository.rb

@@ -0,0 +1,103 @@
+module YADM
+  module Repository
+    class << self
+      def included(including_class)
+        including_class.const_set(:Query, query_class_for(including_class))
+        
+        including_class.extend(ClassMethods)
+        including_class.extend(DSL)
+      end
+      
+    private
+      def query_class_for(repository)
+        Class.new(YADM::Query) do
+          define_method :repository do
+            repository
+          end
+        end
+      end
+    end
+    
+    module ClassMethods
+      include Enumerable
+      
+      def find(id)
+        wrap_object(mapping.get(id))
+      end
+      
+      def persist(entity)
+        if entity.id.nil?
+          entity.id = mapping.add(entity.attributes)
+        else
+          new_attributes = entity.attributes
+          mapping.change(new_attributes.delete(:id), new_attributes)
+        end
+      end
+      
+      def delete(entity)
+        mapping.remove(entity.id)
+      end
+      
+      def each(&block)
+        default_query.each(&block)
+      end
+      
+      def count
+        mapping.count
+      end
+      
+      def send_query(query)
+        mapping.send_query(query).map do |attributes|
+          wrap_object(attributes)
+        end
+      end
+      
+      def default_query
+        query_class.new
+      end
+      
+    private
+      def wrap_object(attributes)
+        entity_class.new(attributes)
+      end
+      
+      def mapping
+        YADM.mapper.mapping_for(self)
+      end
+      
+      def query_class
+        const_get(:Query)
+      end
+    end
+    
+    module DSL
+      
+    private
+      def criteria(name, &block)
+        criteria = CriteriaParser.parse(block, name)
+        
+        query_class.class_eval do
+          define_method(name) do |*args|
+            merge(criteria, name => args)
+          end
+        end
+        
+        define_singleton_method(name) do |*args|
+          default_query.public_send(name, *args)
+        end
+      end
+      
+      def entity(entity_class)
+        @entity_class = entity_class
+      end
+      
+      def entity_class
+        if @entity_class.nil?
+          raise ArgumentError, "Entity is not declared for repository #{self.name}"
+        else
+          @entity_class
+        end
+      end
+    end
+  end
+end

data/lib/yadm/version.rb

@@ -0,0 +1,3 @@
+module YADM
+  VERSION = '0.1'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require 'yadm'
+
+support_glob = Pathname.new('../support/*.rb').expand_path(__FILE__)
+Dir.glob(support_glob) { |path| require(path) }
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+  
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+  
+  config.disable_monkey_patching!
+  config.profile_examples = 5
+  
+  config.order = :random
+  Kernel.srand config.seed
+  
+  config.include CriteriaHelpers
+  config.include SequelHelpers
+end

data/spec/support/criteria_helpers.rb

@@ -0,0 +1,33 @@
+module CriteriaHelpers
+  def build_criteria(components)
+    YADM::Criteria.new(components)
+  end
+  
+  def build_condition(expression)
+    YADM::Criteria::Condition.new(expression)
+  end
+  
+  def build_order(clauses)
+    YADM::Criteria::Order.new(clauses)
+  end
+  
+  def build_order_clause(type, expression)
+    YADM::Criteria::Order::Clause.new(type, expression)
+  end
+  
+  def build_limit(limit)
+    YADM::Criteria::Limit.new(limit)
+  end
+  
+  def build_expression(receiver, method, argument)
+    YADM::Criteria::Expression.new(receiver, method, [argument])
+  end
+  
+  def build_attribute(name)
+    YADM::Criteria::Attribute.new(name)
+  end
+  
+  def build_argument(group, index)
+    YADM::Criteria::Argument.new(group, index)
+  end
+end

data/spec/support/sequel_helpers.rb

@@ -0,0 +1,25 @@
+module SequelHelpers
+  def setup_table
+    connection.create_table! :posts do
+      primary_key :id
+      
+      String   :title
+      Integer  :comments_count
+      DateTime :created_at
+    end
+    
+    [
+      ['First',  7,  now - 10],
+      ['Second', 10, now - 20],
+      ['Third',  4,  now - 10],
+      ['Fourth', 13, now]
+    ].each do |title, comments_count, created_at|
+      subject.add(
+        :posts,
+        title:          title,
+        comments_count: comments_count,
+        created_at:     created_at
+      )
+    end
+  end
+end

data/spec/support/shared_examples_for_a_sequel_adapter.rb

@@ -0,0 +1,173 @@
+RSpec.shared_examples 'a sequel adapter' do
+  let(:connection) { subject.send(:connection) }
+  let(:now)        { Time.now }
+  
+  before(:each) do
+    connection.create_table! :people do
+      primary_key :id
+      
+      String :name
+      String :email
+    end
+  end
+  
+  let(:person_attributes) do
+    { name: 'John', email: 'john@example.com' }
+  end
+  
+  describe '#get' do
+    before(:each) do
+      subject.add(:people, person_attributes)
+    end
+    
+    it 'returns the record with the specified id' do
+      expect(subject.get(:people, 1)).to eq(person_attributes.merge(id: 1))
+    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 the id of the created record' do
+      expect(subject.add(:people, person_attributes)).to eq(1)
+    end
+    
+    context 'with a nil id attribute' do
+      it 'ignores the id' do
+        expect {
+          subject.add(:people, person_attributes.merge(id: nil))
+        }.to change { subject.count(:people) }.by(1)
+      end
+    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 '#send_query' do
+    before(:each) do
+      setup_table
+    end
+    
+    let(:criteria) do
+      build_criteria(
+        condition: build_condition(
+          build_expression(build_attribute(:comments_count), :<, 10)
+        ),
+        order: build_order(
+          [
+            build_order_clause(:desc, build_attribute(:comments_count))
+          ]
+        ),
+        limit: build_limit(1)
+      )
+    end
+    
+    let(:query) { YADM::Query.new(criteria, {}) }
+    
+    it 'filters, orders and limits the records' do
+      data = subject.send_query(:posts, query)
+      
+      expect(data.count).to eq(1)
+      expect(data.first[:id]).to eq(1)
+    end
+  end
+  
+  describe '#filter' do
+    before(:each) do
+      setup_table
+    end
+    
+    let(:condition) do
+      build_condition(
+        build_expression(build_attribute(:comments_count), :<, 10)
+      )
+    end
+    
+    it 'returns a dataset with the condition' do
+      result = subject.filter(subject.from(:posts), condition, {})
+      
+      expect(result.count).to eq(2)
+      expect(result.to_a.first[:title]).to eq('First')
+      expect(result.to_a.last[:title]).to eq('Third')
+    end
+  end
+  
+  describe '#order' do
+    before(:each) do
+      setup_table
+    end
+    
+    let(:order) do
+      build_order(
+        [
+          build_order_clause(:desc, build_attribute(:created_at)),
+          build_order_clause(:asc, build_attribute(:comments_count))
+        ]
+      )
+    end
+    
+    it 'returns a dataset with the specified order' do
+      result = subject.order(subject.from(:posts), order, {})
+      titles = result.map { |record| record[:title] }
+      
+      expect(titles).to eq(%w(Fourth Third First Second))
+    end
+  end
+  
+  describe '#limit' do
+    before(:each) do
+      setup_table
+    end
+    
+    let(:limit) { build_limit(2) }
+    
+    it 'returns a dataset with the specified limit' do
+      result = subject.limit(subject.from(:posts), limit, {})
+      expect(result.count).to eq(2)
+    end
+    
+    context 'with arguments' do
+      let(:limit) { build_limit(build_argument(:first, 0)) }
+      
+      it 'returns a dataset with the specified limit' do
+        result = subject.limit(subject.from(:posts), limit, first: [3])
+        expect(result.count).to eq(3)
+      end
+    end
+  end
+  
+  describe '#migrate' do
+    let(:block) { double('Block') }
+    
+    it 'calls the given block passing it the database connection' do
+      expect(block).to receive(:call).with(connection)
+      subject.migrate(block)
+    end
+  end
+end

data/spec/yadm/adapters/common_sql_spec.rb

@@ -0,0 +1,89 @@
+require 'yadm/adapters/common_sql'
+
+RSpec.describe YADM::Adapters::CommonSQL do
+  describe '.sequelize' do
+    %i(< > <= >= + - * / !=).each do |operator|
+      context "with '#{operator}' operator" do
+        let(:expression) do
+          build_expression(
+            build_attribute(:comments_count),
+            operator,
+            1
+          )
+        end
+        
+        it "creates an expression with '#{operator}' operator" do
+          result = described_class.sequelize(expression, {})
+          
+          expect(result.args.first).to eq(Sequel::SQL::Identifier.new(:comments_count))
+          expect(result.op).to eq(operator)
+          expect(result.args.last).to eq(1)
+        end
+      end
+    end
+    
+    context "with '==' operator" do
+      let(:expression) do
+        build_expression(build_attribute(:comments_count), :==, 10)
+      end
+      
+      it "creates an expression with '=' operator" do
+        result = described_class.sequelize(expression, {})
+        expect(result.op).to eq(:'=')
+      end
+    end
+    
+    context "with '&' operator" do
+      let(:subexpression1) do
+        build_expression(build_attribute(:comments_count), :>, 25)
+      end
+      
+      let(:subexpression2) do
+        build_expression(build_attribute(:comments_count), :<=, 30)
+      end
+      
+      let(:expression) do
+        build_expression(subexpression1, :&, subexpression2)
+      end
+      
+      it "creates an expression with 'AND' operator" do
+        result = described_class.sequelize(expression, {})
+        expect(result.op).to eq(:AND)
+      end
+    end
+    
+    context "with '|' operator" do
+      let(:subexpression1) do
+        build_expression(build_attribute(:comments_count), :<, 25)
+      end
+      
+      let(:subexpression2) do
+        build_expression(build_attribute(:comments_count), :>, 40)
+      end
+      
+      let(:expression) do
+        build_expression(subexpression1, :|, subexpression2)
+      end
+      
+      it "creates an expression with 'OR' operator" do
+        result = described_class.sequelize(expression, {})
+        expect(result.op).to eq(:OR)
+      end
+    end
+    
+    context 'with arguments' do
+      let(:expression) do
+        build_expression(
+          build_attribute(:comments_count),
+          :>,
+          build_argument(:first, 0)
+        )
+      end
+      
+      it "creates an expression with argument replaced with it's value" do
+        result = described_class.sequelize(expression, first: [20])
+        expect(result.args.last).to eq(20)
+      end
+    end
+  end
+end