mr 0.35.2

data/lib/mr/read_model/querying.rb

@@ -0,0 +1,214 @@
+require 'much-plugin'
+require 'mr/read_model/query_expression'
+require 'mr/record'
+require 'mr/query'
+
+module MR::ReadModel
+
+  module Querying
+    include MuchPlugin
+
+    plugin_included do
+      extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def relation
+        @relation ||= Relation.new
+      end
+
+      def record_class
+        self.relation.from_record_class
+      end
+
+      def find(id, params = nil)
+        self.new(self.relation.build_for_find(id, params || {}).first!)
+      end
+
+      def query(params = nil)
+        MR::Query.new(self, self.relation.build_for_all(params || {}))
+      end
+
+      def count(*args)
+        self.query(*args).count
+      end
+
+      def build_sql(params = nil)
+        self.relation.build_sql(params)
+      end
+
+      def find_attr(column = nil)
+        self.relation.find_attr = column if !column.nil?
+        self.relation.find_attr
+      end
+
+      def select(*args, &block)
+        add_query_expression(:select, *args, &block)
+      rescue InvalidQueryExpressionError, ArgumentError => exception
+        raise ArgumentError, exception.message, caller
+      end
+
+      def from(record_class)
+        relation.from(record_class)
+      rescue ArgumentError => exception
+        raise ArgumentError, exception.message, caller
+      end
+
+      def from_subquery(&block)
+        relation.from_subquery(&block)
+      rescue ArgumentError => exception
+        raise ArgumentError, exception.message, caller
+      end
+
+      def joins(*args, &block)
+        add_query_expression(:joins, *args, &block)
+      rescue InvalidQueryExpressionError, ArgumentError => exception
+        raise ArgumentError, exception.message, caller
+      end
+
+      def inner_join_subquery(&block)
+        add_subquery_expression(:joins, :inner, &block)
+      rescue InvalidQueryExpressionError, ArgumentError => exception
+        raise ArgumentError, exception.message, caller
+      end
+
+      def left_outer_join_subquery(&block)
+        add_subquery_expression(:joins, :left, &block)
+      rescue InvalidQueryExpressionError, ArgumentError => exception
+        raise ArgumentError, exception.message, caller
+      end
+      alias :left_join_subquery :left_outer_join_subquery
+
+      def right_outer_join_subquery(&block)
+        add_subquery_expression(:joins, :right, &block)
+      rescue InvalidQueryExpressionError, ArgumentError => exception
+        raise ArgumentError, exception.message, caller
+      end
+      alias :right_join_subquery :right_outer_join_subquery
+
+      def full_outer_join_subquery(&block)
+        add_subquery_expression(:joins, :full, &block)
+      rescue InvalidQueryExpressionError, ArgumentError => exception
+        raise ArgumentError, exception.message, caller
+      end
+      alias :full_join_subquery :full_outer_join_subquery
+
+      def where(*args, &block)
+        add_merge_query_expression(:where, *args, &block)
+      rescue InvalidQueryExpressionError, ArgumentError => exception
+        raise ArgumentError, exception.message, caller
+      end
+
+      def order(*args, &block)
+        add_merge_query_expression(:order, *args, &block)
+      rescue InvalidQueryExpressionError, ArgumentError => exception
+        raise ArgumentError, exception.message, caller
+      end
+
+      def group(*args, &block)
+        add_query_expression(:group, *args, &block)
+      rescue InvalidQueryExpressionError, ArgumentError => exception
+        raise ArgumentError, exception.message, caller
+      end
+
+      def having(*args, &block)
+        add_query_expression(:having, *args, &block)
+      rescue InvalidQueryExpressionError, ArgumentError => exception
+        raise ArgumentError, exception.message, caller
+      end
+
+      def limit(*args, &block)
+        add_query_expression(:limit, *args, &block)
+      rescue InvalidQueryExpressionError, ArgumentError => exception
+        raise ArgumentError, exception.message, caller
+      end
+
+      def offset(*args, &block)
+        add_query_expression(:offset, *args, &block)
+      rescue InvalidQueryExpressionError, ArgumentError => exception
+        raise ArgumentError, exception.message, caller
+      end
+
+      def merge(*args, &block)
+        add_merge_query_expression(:merge, *args, &block)
+      rescue InvalidQueryExpressionError, ArgumentError => exception
+        raise ArgumentError, exception.message, caller
+      end
+
+      private
+
+      def add_query_expression(type, *args, &block)
+        QueryExpression.new(type, *args, &block).tap do |expression|
+          relation.query_expressions << expression
+        end
+      end
+
+      def add_merge_query_expression(type, *args, &block)
+        MergeQueryExpression.new(type, *args, &block).tap do |expression|
+          relation.query_expressions << expression
+        end
+      end
+
+      def add_subquery_expression(type, *args, &block)
+        SubqueryExpression.new(type, *args, &block).tap do |expression|
+          relation.query_expressions << expression
+        end
+      end
+
+    end
+
+  end
+
+  class Relation
+    attr_reader :from_expression, :query_expressions, :set_expressions
+    attr_writer :find_attr
+
+    def initialize
+      @from_expression   = NullFromExpression.new
+      @query_expressions = []
+      @set_expressions   = []
+    end
+
+    def from(record_class)
+      @from_expression = FromExpression.new(record_class)
+    end
+
+    def from_subquery(&block)
+      @from_expression = FromSubqueryExpression.new(&block)
+    end
+
+    def from_record_class
+      self.from_expression.record_class
+    end
+
+    def find_attr
+      @find_attr ||= self.from_expression.default_find_attr
+    end
+
+    FIND_EXCLUDED_TYPES = [:where, :limit, :offset].freeze
+    def build_for_find(id, params = nil)
+      query_expressions = self.query_expressions.reject do |e|
+        FIND_EXCLUDED_TYPES.include?(e.type)
+      end
+      ar_relation = build_ar_relation_for_all(query_expressions, params)
+      ar_relation.where(self.find_attr => id).limit(1)
+    end
+
+    def build_for_all(params = nil)
+      build_ar_relation_for_all(self.query_expressions, params)
+    end
+
+    def build_sql(params = nil)
+      self.build_for_all(params).to_sql.strip
+    end
+
+    private
+
+    def build_ar_relation_for_all(query_expressions, params)
+      ar_relation = self.from_expression.ar_relation(params)
+      query_expressions.inject(ar_relation){ |r, e| e.apply_to(r, params) }
+    end
+  end
+
+end

data/lib/mr/read_model/set_querying.rb

@@ -0,0 +1,82 @@
+require 'much-plugin'
+require 'mr/read_model/querying'
+
+module MR::ReadModel
+
+  module SetQuerying
+    include MuchPlugin
+
+    plugin_included do
+      include MR::ReadModel::Querying
+      extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def relation
+        @relation ||= Relation.new
+      end
+
+      def union(&block)
+        add_set_expression(:union, &block)
+      rescue ArgumentError => exception
+        raise ArgumentError, exception.message, caller
+      end
+
+      def union_all(&block)
+        add_set_expression(:union_all, &block)
+      rescue ArgumentError => exception
+        raise ArgumentError, exception.message, caller
+      end
+
+      def intersect(&block)
+        add_set_expression(:intersect, &block)
+      rescue ArgumentError => exception
+        raise ArgumentError, exception.message, caller
+      end
+
+      def intersect_all(&block)
+        add_set_expression(:intersect_all, &block)
+      rescue ArgumentError => exception
+        raise ArgumentError, exception.message, caller
+      end
+
+      def except(&block)
+        add_set_expression(:except, &block)
+      rescue ArgumentError => exception
+        raise ArgumentError, exception.message, caller
+      end
+
+      def except_all(&block)
+        add_set_expression(:except_all, &block)
+      rescue ArgumentError => exception
+        raise ArgumentError, exception.message, caller
+      end
+
+      private
+
+      def add_set_expression(type, &block)
+        SetExpression.new(type, &block).tap do |expression|
+          relation.set_expressions << expression
+        end
+      end
+
+    end
+
+    class Relation < MR::ReadModel::Relation
+      attr_reader :set_expressions
+
+      def initialize
+        super
+        @set_expressions = []
+      end
+
+      def build_sql(params = nil)
+        sql = super(params)
+        self.set_expressions.inject(sql){ |s, e| e.combine_sql(s, params) }
+      end
+    end
+
+  end
+
+end

data/lib/mr/read_model/subquery.rb

@@ -0,0 +1,98 @@
+module MR; end
+module MR::ReadModel
+
+  module Subquery
+    attr_reader :read_model_class
+
+    def initialize(&block)
+      self.instance_eval(&block)
+      if !self.read_model_class
+        raise ArgumentError, "invalid subquery - " \
+                             "use `read_model` to define the subquery"
+      end
+    end
+
+    def read_model(&block)
+      @read_model_class = Class.new do
+         # TODO - fix circular require
+        require 'mr/read_model'
+        require 'mr/read_model/set_querying'
+        include MR::ReadModel
+        include MR::ReadModel::SetQuerying
+      end
+      @read_model_class.class_eval(&block)
+    end
+
+    def build_sql(params = nil)
+      "(#{self.read_model_class.build_sql(params)})"
+    end
+
+  end
+
+  module AliasSubquery
+    include Subquery
+
+    def alias_sql
+      @alias_sql ||= ""
+    end
+
+    def as(alias_name)
+      if alias_name.to_s.strip.empty?
+        raise ArgumentError, "alias can't be blank"
+      end
+      @alias_sql = "AS #{alias_name}"
+    end
+
+    def build_sql(params = nil)
+      if self.alias_sql.to_s.strip.empty?
+        raise InvalidSubqueryError, "subquery must have an alias"
+      end
+      "#{super} #{self.alias_sql}".strip
+    end
+
+  end
+
+  class FromSubquery
+    include AliasSubquery
+
+    def record_class
+      self.read_model_class.record_class
+    end
+
+  end
+
+  class JoinSubquery
+    include AliasSubquery
+
+    DEFAULT_JOIN_SQL = 'JOIN'.freeze
+    JOIN_SQL = Hash.new(DEFAULT_JOIN_SQL).tap do |h|
+      h[:inner] = 'INNER JOIN'.freeze
+      h[:left]  = 'LEFT OUTER JOIN'.freeze
+      h[:right] = 'RIGHT OUTER JOIN'.freeze
+      h[:full]  = 'FULL OUTER JOIN'.freeze
+    end.freeze
+
+    attr_reader :join_sql
+
+    def initialize(type, &block)
+      @join_sql = JOIN_SQL[type]
+      super(&block)
+    end
+
+    def conditions_sql
+      @conditions_sql ||= ""
+    end
+
+    def on(conditions)
+      @conditions_sql = "ON #{conditions}"
+    end
+
+    def build_sql(params = nil)
+      "#{self.join_sql} #{super} #{self.conditions_sql}".strip
+    end
+
+  end
+
+  InvalidSubqueryError = Class.new(RuntimeError)
+
+end

data/lib/mr/record.rb

@@ -0,0 +1,35 @@
+require 'much-plugin'
+
+module MR
+
+  module Record
+    include MuchPlugin
+
+    plugin_included do
+      extend ClassMethods
+      include InstanceMethods
+    end
+
+    module InstanceMethods
+
+      attr_writer :model
+
+      def model
+        @model ||= self.class.model_class.new(self)
+      end
+
+      def model_class
+        self.class.model_class
+      end
+
+    end
+
+    module ClassMethods
+
+      attr_accessor :model_class
+
+    end
+
+  end
+
+end

data/lib/mr/test_helpers.rb

@@ -0,0 +1,229 @@
+require 'mr/fake_record'
+require 'mr/model'
+
+module MR
+
+  module TestHelpers
+    module_function
+
+    def model_reset_save_called(model, &block)
+      fake_record = model.record
+      if !fake_record.kind_of?(MR::FakeRecord)
+        raise ArgumentError, "model must be using a fake record"
+      end
+      yield model if block
+      fake_record.reset_save_called
+    end
+
+    def assert_association_saved(model, association, expected_value)
+      with_backtrace(caller) do
+        AssociationSavedAssertion.new(model, association, expected_value).run(self)
+      end
+    end
+
+    def assert_not_association_saved(model, association, expected_value)
+      with_backtrace(caller) do
+        AssociationNotSavedAssertion.new(model, association, expected_value).run(self)
+      end
+    end
+
+    def assert_model_destroyed(model)
+      with_backtrace(caller) do
+        ModelDestroyedAssertion.new(model).run(self)
+      end
+    end
+
+    def assert_not_model_destroyed(model)
+      with_backtrace(caller) do
+        ModelNotDestroyedAssertion.new(model).run(self)
+      end
+    end
+
+    def assert_field_saved(model, field, expected_value)
+      with_backtrace(caller) do
+        FieldSavedAssertion.new(model, field, expected_value).run(self)
+      end
+    end
+
+    def assert_not_field_saved(model, field, expected_value)
+      with_backtrace(caller) do
+        FieldNotSavedAssertion.new(model, field, expected_value).run(self)
+      end
+    end
+
+    def assert_model_saved(model)
+      with_backtrace(caller) do
+        ModelSavedAssertion.new(model).run(self)
+      end
+    end
+
+    def assert_not_model_saved(model)
+      with_backtrace(caller) do
+        ModelNotSavedAssertion.new(model).run(self)
+      end
+    end
+
+    class AssociationSavedAssertionBase
+      def initialize(model, association, expected_value)
+        reflection = model.record.association(association).reflection
+        if reflection.macro != :belongs_to
+          raise ArgumentError, "association must be a belongs to"
+        end
+        @expected_value = expected_value || NULL_MODEL
+        # use `record.class` instead of `record_class` here, the configured
+        # `record_class` won't match the actual `record` class because `record` is
+        # a fake record
+        expected_foreign_type = @expected_value.record.class.to_s
+        expected_foreign_key  = @expected_value.id
+        @assertions = [
+          build_assertion(model, reflection.foreign_type, expected_foreign_type),
+          build_assertion(model, reflection.foreign_key,  expected_foreign_key)
+        ].compact
+      end
+
+      def run(context)
+        @assertions.each{ |a| a.run(context) }
+      end
+
+      private
+
+      def build_assertion(model, field, expected_value)
+        return unless field
+        self.field_assertion_class.new(model, field, expected_value)
+      end
+
+      NullModel = Struct.new(:id, :record)
+      NullRecord = Struct.new(:class)
+      NullRecordClass = Struct.new(:name)
+      NULL_MODEL = NullModel.new(nil, NullRecord.new(NullRecordClass.new))
+    end
+
+    class AssociationSavedAssertion < AssociationSavedAssertionBase
+      def field_assertion_class; FieldSavedAssertion; end
+    end
+
+    class AssociationNotSavedAssertion < AssociationSavedAssertionBase
+      def field_assertion_class; FieldNotSavedAssertion; end
+    end
+
+    class FieldSavedAssertionBase
+      def initialize(model, field, expected_value)
+        if !model.record.kind_of?(MR::FakeRecord)
+          raise ArgumentError, "model must be using a fake record"
+        end
+        @expected_value = expected_value
+        @field = field.to_s
+        @saved    = model.record.saved_attributes.key?(@field)
+        @saved_as = model.record.saved_attributes[@field]
+      end
+    end
+
+    class FieldSavedAssertion < FieldSavedAssertionBase
+      def run(context)
+        if @saved
+          context.assert_equal @expected_value, @saved_as, saved_as_desc
+        else
+          context.assert_true @saved, saved_desc
+        end
+      end
+
+      private
+
+      def saved_desc
+        "Expected #{@field.inspect} field was saved."
+      end
+
+      def saved_as_desc
+        "Expected #{@field.inspect} field was saved as #{@expected_value.inspect}."
+      end
+    end
+
+    class FieldNotSavedAssertion < FieldSavedAssertionBase
+      def run(context)
+        if @saved
+          context.assert_not_equal @expected_value, @saved_as, saved_as_desc
+        else
+          context.assert_false @saved, saved_desc
+        end
+      end
+
+      private
+
+      def saved_desc
+        "Expected #{@field.inspect} field was not saved."
+      end
+
+      def saved_as_desc
+        "Expected #{@field.inspect} field was not saved as #{@expected_value.inspect}."
+      end
+    end
+
+    class ModelDestroyedAssertionBase
+      def initialize(model)
+        @model = model
+        @destroyed = @model.destroyed?
+      end
+    end
+
+    class ModelDestroyedAssertion < ModelDestroyedAssertionBase
+      def run(context)
+        context.assert_true(@destroyed){ destroyed_desc }
+      end
+
+      private
+
+      def destroyed_desc
+        "Expected #{@model.inspect} was destroyed."
+      end
+    end
+
+    class ModelNotDestroyedAssertion < ModelDestroyedAssertionBase
+      def run(context)
+        context.assert_false(@destroyed){ destroyed_desc }
+      end
+
+      private
+
+      def destroyed_desc
+        "Expected #{@model.inspect} was not destroyed."
+      end
+    end
+
+    class ModelSavedAssertionBase
+      def initialize(model)
+        @model = model
+        fake_record = model.record
+        if !fake_record.kind_of?(MR::FakeRecord)
+          raise ArgumentError, "model must be using a fake record"
+        end
+        @saved = fake_record.save_called
+      end
+    end
+
+    class ModelSavedAssertion < ModelSavedAssertionBase
+      def run(context)
+        context.assert_true(@saved){ saved_desc }
+      end
+
+      private
+
+      def saved_desc
+        "Expected #{@model.inspect} was saved."
+      end
+    end
+
+    class ModelNotSavedAssertion < ModelSavedAssertionBase
+      def run(context)
+        context.assert_false(@saved){ saved_desc }
+      end
+
+      private
+
+      def saved_desc
+        "Expected #{@model.inspect} was not saved."
+      end
+    end
+
+  end
+
+end