yadm 0.1

data/lib/yadm.rb

@@ -0,0 +1,39 @@
+require 'yadm/version'
+require 'yadm/entity'
+require 'yadm/adapters'
+require 'yadm/identity_map'
+require 'yadm/mapping'
+require 'yadm/mapper'
+require 'yadm/criteria'
+require 'yadm/query'
+require 'yadm/criteria_parser'
+require 'yadm/repository'
+
+module YADM
+  class << self
+    def setup(&block)
+      instance_eval(&block) unless block.nil?
+    end
+    
+    def data_source(name, adapter:, **connection_params)
+      data_source = Adapters.fetch(adapter).new(connection_params)
+      data_sources[name] = IdentityMap.new(data_source)
+    end
+    
+    def map(&block)
+      mapper.instance_eval(&block) unless block.nil?
+    end
+    
+    def migrate(data_source_name, &block)
+      data_sources.fetch(data_source_name).migrate(block)
+    end
+    
+    def data_sources
+      @data_sources ||= {}
+    end
+    
+    def mapper
+      @mapper ||= Mapper.new
+    end
+  end
+end

data/lib/yadm/adapters.rb

@@ -0,0 +1,32 @@
+module YADM
+  module Adapters
+    class << self
+      def fetch(name)
+        registry.fetch(name)
+      rescue KeyError
+        raise NotImplementedError, "Adapter `#{name.inspect}` isn't registered."
+      end
+      
+      def register(name, adapter)
+        registry[name] = adapter
+      end
+      
+    private
+      def registry
+        @registry ||= {}
+      end
+    end
+    
+    module Base
+      def self.included(including_module)
+        including_module.extend ClassMethods
+      end
+      
+      module ClassMethods
+        def register(name)
+          Adapters.register(name, self)
+        end
+      end
+    end
+  end
+end

data/lib/yadm/adapters/common_sql.rb

@@ -0,0 +1,120 @@
+require 'sequel'
+
+module YADM
+  module Adapters
+    module CommonSQL
+      attr_reader :connection
+      private :connection
+      
+      def get(table_name, id)
+        connection[table_name][id: id]
+      end
+      
+      def add(table_name, new_attributes)
+        new_attributes = new_attributes.dup
+        new_attributes.delete(:id)
+        connection[table_name].insert(new_attributes)
+      end
+      
+      def change(table_name, id, new_attributes)
+        connection[table_name].where(id: id).update(new_attributes)
+      end
+      
+      def remove(table_name, id)
+        connection[table_name].where(id: id).delete
+      end
+      
+      def count(table_name)
+        connection[table_name].count
+      end
+      
+      def send_query(table_name, query)
+        result = filter(from(table_name), query.criteria.condition, query.arguments)
+        result = order(result, query.criteria.order, query.arguments)
+        result = limit(result, query.criteria.limit, query.arguments)
+        
+        result.to_a
+      end
+      
+      def from(table_name)
+        connection[table_name]
+      end
+      
+      def filter(dataset, condition, arguments)
+        if condition.nil?
+          dataset
+        else
+          sequel_expression = sequelize(condition.expression, arguments)
+          dataset.where(sequel_expression)
+        end
+      end
+      
+      def order(dataset, order, arguments)
+        if order.nil?
+          dataset
+        else
+          order.clauses.inject(dataset) do |dataset, clause|
+            sequel_expression = sequelize(clause.expression, arguments)
+            dataset.order_more(sequel_expression.send(clause.type))
+          end
+        end
+      end
+      
+      def limit(dataset, limit, arguments)
+        if limit.nil? || limit.limit.nil?
+          dataset
+        else
+          take(dataset, limit.limit, arguments)
+        end
+      end
+      
+      def migrate(block)
+        block.call(connection)
+      end
+      
+    private
+      def sequelize(node, arguments)
+        CommonSQL.sequelize(node, arguments)
+      end
+      
+      def take(dataset, limit, arguments)
+        number = if limit.is_a?(Criteria::Argument)
+          limit.fetch_from(arguments)
+        else
+          limit
+        end
+        
+        dataset.limit(number)
+      end
+      
+      class << self
+        def sequelize(node, arguments)
+          case node
+          when Criteria::Expression
+            operator  = sequelize_operator(node.method_name)
+            receiver  = sequelize(node.receiver, arguments)
+            arguments = node.arguments.map { |arg| sequelize(arg, arguments) }
+            
+            Sequel::SQL::ComplexExpression.new(operator, receiver, *arguments)
+          when Criteria::Attribute
+            Sequel::SQL::Identifier.new(node.name)
+          when Criteria::Argument
+            node.fetch_from(arguments)
+          else
+            node
+          end
+        end
+        
+      private
+        def sequelize_operator(operator)
+          case operator
+          when :== then :'='
+          when :&  then :AND
+          when :|  then :OR
+          else operator
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yadm/adapters/memory.rb

@@ -0,0 +1,175 @@
+module YADM
+  module Adapters
+    class Memory
+      include Base
+      
+      register :memory
+      
+      attr_reader :collections
+      private :collections
+      
+      def initialize(connection_params = {})
+        # Memory adapter doesn't need any connection.
+        @collections = Hash.new do |hash, collection_name|
+          hash[collection_name] = Collection.new
+        end
+      end
+      
+      def get(collection_name, id)
+        collections[collection_name].get(id)
+      end
+      
+      def add(collection_name, record)
+        collections[collection_name].add(record)
+      end
+      
+      def change(collection_name, id, new_attributes)
+        collections[collection_name].change(id, new_attributes)
+      end
+      
+      def remove(collection_name, id)
+        collections[collection_name].remove(id)
+      end
+      
+      def count(collection_name)
+        collections[collection_name].count
+      end
+      
+      def send_query(collection_name, query)
+        collections[collection_name].send_query(query)
+      end
+      
+      def migrate(block)
+        # do nothing here (memory adapter doesn't need migrations)
+      end
+      
+      class Collection
+        attr_reader :records
+        private :records
+        
+        def initialize
+          @records = {}
+        end
+        
+        def get(id)
+          records.fetch(id)
+        end
+        
+        def add(record)
+          next_id.tap do |new_id|
+            records[new_id] = record.merge(id: new_id)
+          end
+        end
+        
+        def change(id, new_attributes)
+          records[id].update(new_attributes)
+        end
+        
+        def remove(id)
+          records.delete(id)
+        end
+        
+        def count
+          records.count
+        end
+        
+        def send_query(query)
+          result = filter(all, query.criteria.condition, query.arguments)
+          result = order(result, query.criteria.order, query.arguments)
+          result = limit(result, query.criteria.limit, query.arguments)
+        end
+        
+        def all
+          records.values.dup
+        end
+        
+        def filter(dataset, condition, arguments)
+          if condition.nil?
+            dataset
+          else
+            dataset.select { |record| matches?(record, condition.expression, arguments) }
+          end
+        end
+        
+        def order(dataset, order, arguments)
+          if order.nil?
+            dataset
+          else
+            dataset.sort { |*records| compare(records, order.clauses, arguments) }
+          end
+        end
+        
+        def limit(dataset, limit, arguments)
+          if limit.nil? || limit.limit.nil?
+            dataset
+          else
+            take(dataset, limit.limit, arguments)
+          end
+        end
+        
+      private
+        def next_id
+          id_sequence.next
+        end
+        
+        def id_sequence
+          @sequence ||= Enumerator.new do |yielder|
+            id = 0
+            loop do
+              id += 1
+              yielder.yield id
+            end
+          end
+        end
+        
+        def matches?(record, expression, arguments)
+          !!record_eval(record, expression, arguments)
+        end
+        
+        def compare(records, clauses, arguments)
+          clauses.inject(0) do |comparison, clause|
+            return comparison unless comparison.zero?
+            
+            values = records.map do |record|
+              record_eval(record, clause.expression, arguments)
+            end
+            
+            if clause.asc?
+              values.first <=> values.last
+            else
+              values.last <=> values.first
+            end
+          end
+        end
+        
+        def take(records, limit, arguments)
+          number = if limit.is_a?(Criteria::Argument)
+            limit.fetch_from(arguments)
+          else
+            limit
+          end
+          
+          records.take(number)
+        end
+        
+        def record_eval(record, node, arguments)
+          case node
+          when Criteria::Expression
+            receiver  = record_eval(record, node.receiver, arguments)
+            arguments = node.arguments.map { |arg| record_eval(record, arg, arguments) }
+            
+            receiver.send(node.method_name, *arguments)
+          when Criteria::Attribute
+            record.fetch(node.name) do
+              raise ArgumentError, "#{node.name.inspect} attribute not found."
+            end
+          when Criteria::Argument
+            node.fetch_from(arguments)
+          else
+            node
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yadm/adapters/mysql.rb

@@ -0,0 +1,17 @@
+require 'yadm/adapters/common_sql'
+require 'mysql2'
+
+module YADM
+  module Adapters
+    class MySQL
+      include Base
+      include CommonSQL
+      
+      register :mysql
+      
+      def initialize(connection_parameters = {})
+        @connection = Sequel.connect(adapter: :mysql2, **connection_parameters)
+      end
+    end
+  end
+end

data/lib/yadm/adapters/postgresql.rb

@@ -0,0 +1,17 @@
+require 'yadm/adapters/common_sql'
+require 'pg'
+
+module YADM
+  module Adapters
+    class PostgreSQL
+      include Base
+      include CommonSQL
+      
+      register :postgresql
+      
+      def initialize(connection_parameters = {})
+        @connection = Sequel.connect(adapter: :postgres, **connection_parameters)
+      end
+    end
+  end
+end

data/lib/yadm/adapters/sqlite.rb

@@ -0,0 +1,17 @@
+require 'yadm/adapters/common_sql'
+require 'sqlite3'
+
+module YADM
+  module Adapters
+    class Sqlite
+      include Base
+      include CommonSQL
+      
+      register :sqlite
+      
+      def initialize(connection_parameters = {})
+        @connection = Sequel.connect(adapter: :sqlite, **connection_parameters)
+      end
+    end
+  end
+end

data/lib/yadm/criteria.rb

@@ -0,0 +1,32 @@
+require 'yadm/criteria/expression'
+require 'yadm/criteria/attribute'
+require 'yadm/criteria/argument'
+require 'yadm/criteria/condition'
+require 'yadm/criteria/order'
+require 'yadm/criteria/limit'
+
+module YADM
+  class Criteria
+    attr_reader :condition, :order, :limit
+    
+    def initialize(condition: nil, order: nil, limit: nil)
+      @condition = condition
+      @order     = order
+      @limit     = limit
+    end
+    
+    def merge(other_criteria)
+      self.class.new(
+        condition: Condition.merge(condition, other_criteria.condition),
+        order:     Order.merge(order, other_criteria.order),
+        limit:     Limit.merge(limit, other_criteria.limit)
+      )
+    end
+    
+    def ==(other)
+      %i(condition order limit).all? do |method|
+        other.respond_to?(method) && send(method) == other.send(method)
+      end
+    end
+  end
+end