yadm 0.1

data/lib/yadm/criteria/argument.rb

@@ -0,0 +1,22 @@
+module YADM
+  class Criteria
+    class Argument
+      attr_reader :group, :index
+      
+      def initialize(group, index)
+        @group = group
+        @index = index
+      end
+      
+      def ==(other)
+        %i(group index).all? do |method|
+          other.respond_to?(method) && send(method) == other.send(method)
+        end
+      end
+      
+      def fetch_from(values)
+        values[group][index]
+      end
+    end
+  end
+end

data/lib/yadm/criteria/attribute.rb

@@ -0,0 +1,15 @@
+module YADM
+  class Criteria
+    class Attribute
+      attr_reader :name
+      
+      def initialize(name)
+        @name = name
+      end
+      
+      def ==(other)
+        other.respond_to?(:name) && name == other.name
+      end
+    end
+  end
+end

data/lib/yadm/criteria/condition.rb

@@ -0,0 +1,31 @@
+module YADM
+  class Criteria
+    class Condition
+      attr_reader :expression
+      
+      def initialize(expression)
+        @expression = expression
+      end
+      
+      def ==(other)
+        other.respond_to?(:expression) && expression == other.expression
+      end
+      
+      class << self
+        def merge(first_condition, second_condition)
+          if first_condition && second_condition
+            expression = Expression.new(
+              first_condition.expression,
+              :&,
+              [second_condition.expression]
+            )
+            
+            new(expression)
+          else
+            [first_condition, second_condition].compact.first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yadm/criteria/expression.rb

@@ -0,0 +1,19 @@
+module YADM
+  class Criteria
+    class Expression
+      attr_reader :receiver, :method_name, :arguments
+      
+      def initialize(receiver, method_name, arguments)
+        @receiver    = receiver
+        @method_name = method_name
+        @arguments   = arguments
+      end
+      
+      def ==(other)
+        %i(receiver method_name arguments).all? do |method|
+          other.respond_to?(method) && send(method) == other.send(method)
+        end
+      end
+    end
+  end
+end

data/lib/yadm/criteria/limit.rb

@@ -0,0 +1,25 @@
+module YADM
+  class Criteria
+    class Limit
+      attr_reader :limit
+      
+      def initialize(limit)
+        @limit = limit
+      end
+      
+      def ==(other)
+        other.respond_to?(:limit) && limit == other.limit
+      end
+      
+      class << self
+        def merge(first_limit, second_limit)
+          if first_limit && second_limit
+            new(second_limit.limit) unless second_limit.limit.nil?
+          else
+            [first_limit, second_limit].compact.first
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yadm/criteria/order.rb

@@ -0,0 +1,48 @@
+module YADM
+  class Criteria
+    class Order
+      attr_reader :clauses
+      
+      def initialize(clauses)
+        @clauses = clauses
+      end
+      
+      def ==(other)
+        other.respond_to?(:clauses) && clauses == other.clauses
+      end
+      
+      class << self
+        def merge(first_order, second_order)
+          if first_order && second_order
+            new(first_order.clauses + second_order.clauses)
+          else
+            [first_order, second_order].compact.first
+          end
+        end
+      end
+      
+      class Clause
+        attr_reader :type, :expression
+        
+        def initialize(type, expression)
+          @type = type.to_sym
+          @expression = expression
+        end
+        
+        def asc?
+          type == :asc
+        end
+        
+        def desc?
+          type == :desc
+        end
+        
+        def ==(other)
+          %i(type expression).all? do |method|
+            other.respond_to?(method) && send(method) == other.send(method)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yadm/criteria_parser.rb

@@ -0,0 +1,62 @@
+require 'yadm/criteria_parser/expression_parser'
+
+module YADM
+  class CriteriaParser
+    attr_reader :block
+    
+    def initialize(block)
+      @block = block
+    end
+    
+    def result(arguments_group)
+      arguments = block.arity.times.map do |index|
+        YADM::Criteria::Argument.new(arguments_group, index)
+      end
+      
+      instance_exec(*arguments, &block).result
+    end
+    
+    %i(with ascending_by descending_by first).each do |method_name|
+      define_method(method_name) do |*args, &block|
+        Criteria.new.send(method_name, *args, &block)
+      end
+    end
+    
+    class << self
+      def parse(block, arguments_group)
+        new(block).result(arguments_group)
+      end
+    end
+    
+    class Criteria < YADM::Criteria
+      def result
+        YADM::Criteria.new(
+          condition: condition,
+          order:     order,
+          limit:     limit
+        )
+      end
+      
+      def with(&block)
+        expression = ExpressionParser.parse(block)
+        merge Criteria.new(condition: Condition.new(expression))
+      end
+      
+      def ascending_by(&block)
+        expression = ExpressionParser.parse(block)
+        clause = Order::Clause.new(:asc, expression)
+        merge Criteria.new(order: Order.new([clause]))
+      end
+      
+      def descending_by(&block)
+        expression = ExpressionParser.parse(block)
+        clause = Order::Clause.new(:desc, expression)
+        merge Criteria.new(order: Order.new([clause]))
+      end
+      
+      def first(limit)
+        merge Criteria.new(limit: Limit.new(limit))
+      end
+    end
+  end
+end

data/lib/yadm/criteria_parser/expression_parser.rb

@@ -0,0 +1,77 @@
+module YADM
+  class CriteriaParser
+    class ExpressionParser
+      attr_reader :block
+      
+      def initialize(block)
+        @block = block
+      end
+      
+      def result
+        instance_eval(&block).result
+      end
+      
+      def method_missing(method_name, *args, &block)
+        Attribute.new(method_name)
+      end
+      
+      class << self
+        def parse(block)
+          new(block).result
+        end
+      end
+      
+      module Operand
+        %i(== != < > <= >= + - * / & |).each do |symbol|
+          define_method(symbol) do |arg|
+            Expression.new(self, symbol, [arg])
+          end
+        end
+      end
+      
+      class Expression
+        include Operand
+        
+        attr_reader :receiver, :method_name, :arguments
+        
+        def initialize(receiver, method_name, arguments)
+          @receiver    = receiver
+          @method_name = method_name
+          @arguments   = arguments
+        end
+        
+        def result
+          Criteria::Expression.new(
+            receiver.result,
+            method_name,
+            arguments_result
+          )
+        end
+        
+        def arguments_result
+          arguments.map do |argument|
+            if argument.respond_to?(:result)
+              argument.result
+            else
+              argument
+            end
+          end
+        end
+      end
+      
+      class Attribute
+        include Operand
+        
+        attr_reader :name
+        
+        def initialize(name)
+          @name = name
+        end
+        
+        def result
+          Criteria::Attribute.new(name)
+        end
+      end
+    end
+  end
+end

data/lib/yadm/entity.rb

@@ -0,0 +1,53 @@
+module YADM
+  module Entity
+    def initialize(new_attributes)
+      @attributes = {}
+      
+      self.class.attributes.each do |attr_name|
+        @attributes[attr_name] = fetch(new_attributes, attr_name)
+      end
+    end
+    
+    def attributes
+      @attributes.dup
+    end
+    
+  private
+    def fetch(hash, key)
+      hash[key] || hash[key.to_s]
+    end
+    
+    class << self
+      def included(including_class)
+        including_class.extend(DSL)
+        including_class.attribute(:id)
+      end
+    end
+    
+    module DSL
+      def attribute(attr_name, readonly: false)
+        attr_name = attr_name.to_sym
+        
+        attributes.add(attr_name)
+        
+        define_method(attr_name) do
+          @attributes[attr_name]
+        end
+        
+        define_method("#{attr_name}=") do |new_value|
+          @attributes[attr_name] = new_value
+        end unless readonly
+      end
+      
+      def attributes(*attr_names)
+        if attr_names.empty?
+          @attributes ||= Set.new
+        else
+          attr_names.each do |attr_name|
+            attribute(attr_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yadm/identity_map.rb

@@ -0,0 +1,51 @@
+module YADM
+  class IdentityMap
+    attr_reader :data_source, :map
+    private :data_source, :map
+    
+    def initialize(data_source)
+      @data_source = data_source
+      
+      @map = Hash.new do |map, collection|
+        map[collection] = {}
+      end
+    end
+    
+    def get(collection, id)
+      map[collection][id] ||= data_source.get(collection, id).dup
+    end
+    
+    def add(collection, attributes)
+      data_source.add(collection, attributes).tap do |id|
+        map[collection][id] = attributes.merge(id: id)
+      end
+    end
+    
+    def change(collection, id, new_attributes)
+      data_source.change(collection, id, new_attributes)
+      
+      if attributes = map[collection][id]
+        attributes.update(new_attributes)
+      else
+        map[collection][id] = new_attributes.merge(id: id)
+      end
+    end
+    
+    def remove(collection, id)
+      data_source.remove(collection, id)
+      map[collection].delete(id)
+    end
+    
+    def count(collection)
+      data_source.count(collection)
+    end
+    
+    def send_query(collection, query)
+      data_source.send_query(collection, query)
+    end
+    
+    def migrate(block)
+      data_source.migrate(block)
+    end
+  end
+end

data/lib/yadm/mapper.rb

@@ -0,0 +1,16 @@
+module YADM
+  class Mapper
+    def repository(repository_class, &block)
+      mappings[repository_class] = Mapping.new(&block)
+    end
+    
+    def mapping_for(repository)
+      mappings.fetch(repository)
+    end
+    
+  private
+    def mappings
+      @mappings ||= {}
+    end
+  end
+end

data/lib/yadm/mapping.rb

@@ -0,0 +1,71 @@
+require 'yadm/mapping/attribute'
+
+module YADM
+  class Mapping
+    def initialize(&block)
+      instance_eval(&block) unless block.nil?
+    end
+    
+    def get(id)
+      coerce(data_source.get(collection, id))
+    end
+    
+    def add(attributes)
+      data_source.add(collection, attributes)
+    end
+    
+    def change(id, attributes)
+      data_source.change(collection, id, attributes)
+    end
+    
+    def remove(id)
+      data_source.remove(collection, id)
+    end
+    
+    def count
+      data_source.count(collection)
+    end
+    
+    def send_query(query)
+      data_source.send_query(collection, query).map do |attribute_values|
+        coerce(attribute_values)
+      end
+    end
+    
+  private
+    def coerce(attribute_values)
+      attributes.each_with_object(Hash.new) do |(attr_name, attribute), hash|
+        raw_value = attribute_values[attr_name]
+        hash[attr_name] = attribute.coerce(raw_value)
+      end
+    end
+    
+    module DSL
+      def data_source(data_source_identifier = nil)
+        if data_source_identifier.nil?
+          @data_source
+        else
+          @data_source = YADM.data_sources.fetch(data_source_identifier)
+        end
+      end
+      
+      def collection(new_collection = nil)
+        if new_collection.nil?
+          @collection
+        else
+          @collection = new_collection
+        end
+      end
+      
+      def attribute(name, type)
+        attributes[name] = Attribute.new(type)
+      end
+      
+      def attributes
+        @attributes ||= {}
+      end
+    end
+    
+    include DSL
+  end
+end