mr 0.35.2

data/lib/mr/read_model.rb

@@ -0,0 +1,83 @@
+require 'much-plugin'
+require 'mr/read_model/data'
+require 'mr/read_model/fields'
+require 'mr/read_model/querying'
+
+module MR
+
+  module ReadModel
+    include MuchPlugin
+
+    plugin_included do
+      include MR::ReadModelStruct
+      include MR::ReadModel::Querying
+      extend ClassMethods
+    end
+
+    def self.add_select_for_field(read_model_class, name, column_sql = nil, &column_sql_block)
+      if column_sql
+        read_model_class.select("#{column_sql} AS #{name}")
+      elsif column_sql_block
+        read_model_class.select do |params|
+          "#{column_sql_block.call(params)} AS #{name}"
+        end
+      end
+    end
+
+    module ClassMethods
+
+      def field(name, type, column_sql = nil, &column_sql_block)
+        super(name, type)
+        MR::ReadModel.add_select_for_field(self, name, column_sql, &column_sql_block)
+      end
+
+      def json_struct_list(name, struct_class, column_sql = nil, &column_sql_block)
+        super(name, struct_class)
+        MR::ReadModel.add_select_for_field(self, name, column_sql, &column_sql_block)
+      end
+
+      def json_struct_obj(name, struct_class, column_sql = nil, &column_sql_block)
+        super(name, struct_class)
+        MR::ReadModel.add_select_for_field(self, name, column_sql, &column_sql_block)
+      end
+
+    end
+
+  end
+
+  module ReadModelStruct
+    include MuchPlugin
+
+    plugin_included do
+      include MR::ReadModel::Data
+      include MR::ReadModel::Fields
+      include InstanceMethods
+    end
+
+    module InstanceMethods
+
+      def initialize(data = nil)
+        set_read_model_data(data || {})
+      end
+
+      def ==(other)
+        if other.kind_of?(self.class)
+          self.fields == other.fields
+        else
+          super
+        end
+      end
+
+      def inspect
+        object_hex     = (self.object_id << 1).to_s(16)
+        fields_inspect = self.class.fields.map do |field|
+          "#{field.ivar_name}=#{field.read(self.read_model_data).inspect}"
+        end.sort.join(" ")
+        "#<#{self.class}:0x#{object_hex} #{fields_inspect}>"
+      end
+
+    end
+
+  end
+
+end

data/lib/mr/read_model/data.rb

@@ -0,0 +1,38 @@
+module MR; end
+module MR::ReadModel
+
+  module Data
+
+    # `MR::ReadModel::Data` is a mixin that provides helpers for setting and
+    # accessing the "data" for a read model. These methods provide a strict
+    # interface to avoid confusing errors and ensure that the data for a
+    # read model should, as much as possible, work.
+    #
+    # * Use the `read_model_data` protected method to access the data object.
+    # * Use the `set_read_model_data` private method to write a data object.
+
+    protected
+
+    def read_model_data
+      @read_model_data || raise(NoDataError.new(caller))
+    end
+
+    private
+
+    def set_read_model_data(data)
+      raise InvalidDataError unless data.respond_to?(:[])
+      @read_model_data = data
+    end
+
+  end
+
+  InvalidDataError = Class.new(ArgumentError)
+
+  class NoDataError < RuntimeError
+    def initialize(called_from = nil)
+      super "the read model's data hasn't been set"
+      set_backtrace(called_from) if called_from
+    end
+  end
+
+end

data/lib/mr/read_model/fields.rb

@@ -0,0 +1,218 @@
+require 'much-plugin'
+require 'mr/json_field'
+require 'mr/read_model/data'
+require 'mr/type_converter'
+
+module MR; end
+module MR::ReadModel
+
+  module Fields
+    include MuchPlugin
+
+    plugin_included do
+      include MR::ReadModel::Data
+      extend ClassMethods
+      include InstanceMethods
+    end
+
+    module ClassMethods
+
+      def fields
+        @fields ||= MR::ReadModel::FieldSet.new
+      end
+
+      def field(name, type)
+        fields.add(name, type, self)
+      rescue InvalidFieldTypeError => exception
+        raise ArgumentError, exception.message, caller
+      end
+
+      def json_struct_list(name, struct_class)
+        field     = JsonStructListField.new(self, name.to_s, struct_class)
+        ivar_name = "@#{name}"
+
+        define_method(name) do
+          begin
+            instance_variable_get(ivar_name) ||
+            instance_variable_set(ivar_name, field.reader(self.read_model_data))
+          rescue StandardError => exception
+            exception.set_backtrace(caller)
+            raise exception
+          end
+        end
+
+        (self.json_struct_lists << field).uniq!
+      end
+
+      def json_struct_lists
+        @json_struct_lists ||= []
+      end
+
+      def json_struct_obj(name, struct_class)
+        field     = JsonStructObjField.new(self, name.to_s, struct_class)
+        ivar_name = "@#{name}"
+
+        define_method(name) do
+          begin
+            instance_variable_get(ivar_name) ||
+            instance_variable_set(ivar_name, field.reader(self.read_model_data))
+          rescue StandardError => exception
+            exception.set_backtrace(caller)
+            raise exception
+          end
+        end
+
+        (self.json_struct_objs << field).uniq!
+      end
+
+      def json_struct_objs
+        @json_struct_objs ||= []
+      end
+
+    end
+
+    module InstanceMethods
+
+      def fields
+        @fields ||= begin
+          fields = self.class.fields.read_all(self.read_model_data)
+          ( self.class.json_struct_lists +
+            self.class.json_struct_objs
+          ).inject(fields) do |h, field|
+            h.merge!(field.name => self.send(field.name))
+          end
+        end
+      end
+
+    end
+
+  end
+
+  class FieldSet
+    include Enumerable
+
+    def initialize
+      @fields = []
+    end
+
+    def find(name)
+      @fields.detect{ |f| f.name == name.to_s }
+    end
+
+    def read_all(data)
+      inject({}) do |h, field|
+        h.merge(field.name => field.read(data))
+      end
+    end
+
+    def add(name, type, model_class = nil)
+      @fields << Field.new(name, type).tap do |field|
+        field.define_on(model_class) if model_class
+      end
+    end
+
+    def each(&block)
+      @fields.each(&block)
+    end
+
+  end
+
+  class Field
+    attr_reader :name, :type, :value
+    attr_reader :method_name, :ivar_name
+
+    def initialize(name, type)
+      @name = name.to_s
+      @type = type.to_sym
+      unless MR::TypeConverter.valid?(@type)
+        raise InvalidFieldTypeError, "`#{@type}` is not a valid field type"
+      end
+
+      @method_name    = @name
+      @ivar_name      = "@#{@name}"
+      @attribute_name = @name
+      @converter      = nil
+    end
+
+    def read(data)
+      @converter ||= MR::TypeConverter.new(determine_ar_column_class(data))
+      @converter.send(@type, data[@attribute_name])
+    end
+
+    def define_on(model_class)
+      field = self
+      model_class.class_eval do
+
+        define_method(field.method_name) do
+          instance_variable_get(field.ivar_name) ||
+          instance_variable_set(field.ivar_name, field.read(self.read_model_data))
+        end
+
+      end
+    end
+
+    private
+
+    def determine_ar_column_class(data)
+      data.class.columns.first.class if data.class.respond_to?(:columns)
+    end
+
+  end
+
+  class JsonStructField < Struct.new(:read_model_class, :name, :struct_class_name)
+
+    def struct_class
+      @struct_class ||= if self.struct_class_name.kind_of?(String)
+        names     = self.struct_class_name.to_s.split('::').reject{ |name| name.empty? }
+        namespace = self.struct_class_name =~ /^::/ ? Object : self.read_model_class
+        names.inject(namespace){ |o, name| o.const_get(name) }
+      else
+        self.struct_class_name
+      end
+    end
+
+    def reader(read_model_data)
+      json_value = read_model_data[self.name]
+      return json_value if json_value.nil?
+
+      if json_value.kind_of?(String)
+        begin
+          return MR::JsonField.decode(json_value)
+        rescue MR::JsonField::InvalidJSONError => exception
+          message = "can't decode `#{self.name}` JSON: #{exception.message}"
+          raise exception.class, message, exception.backtrace
+        end
+      else
+        return json_value
+      end
+    end
+
+  end
+
+  class JsonStructListField < JsonStructField
+
+    def reader(read_model_data)
+      if !(json_datas = super(read_model_data)).nil?
+        json_datas.map{ |data| self.struct_class.new(data) }
+      else
+        nil
+      end
+    end
+
+  end
+
+  class JsonStructObjField < JsonStructField
+
+    def reader(read_model_data)
+      if !(json_data = super(read_model_data)).nil?
+        self.struct_class.new(json_data)
+      else
+        nil
+      end
+    end
+
+  end
+
+  InvalidFieldTypeError = Class.new(RuntimeError)
+
+end

data/lib/mr/read_model/query_expression.rb

@@ -0,0 +1,188 @@
+require 'mr/read_model/subquery'
+
+module MR::ReadModel
+
+  module QueryExpression
+    def self.new(type, *args, &block)
+      if !args.empty?
+        StaticQueryExpression.new(type, *args)
+      elsif block
+        DynamicQueryExpression.new(type, &block)
+      else
+        raise InvalidQueryExpressionError, "must be passed args or a block"
+      end
+    end
+  end
+
+  class StaticQueryExpression
+    attr_reader :type, :args
+
+    def initialize(type, *args)
+      @type = type
+      @args = args
+    end
+
+    # `apply_to` has to take params that it ignores, so it has the same
+    # interface as `DynamicQueryExpression` (which actually uses the params)
+    def apply_to(relation, params = nil)
+      relation.send(@type, *@args)
+    end
+  end
+
+  class DynamicQueryExpression
+    attr_reader :type, :block
+
+    def initialize(type, &block)
+      @type  = type
+      @block = block
+    end
+
+    def apply_to(relation, params)
+      relation.send(@type, relation.instance_exec(params, &@block))
+    end
+  end
+
+  class MergeQueryExpression
+    attr_accessor :type, :query_expression
+
+    def initialize(type, *args, &block)
+      @type = type
+      @query_expression = QueryExpression.new(:merge, *args, &block)
+    end
+
+    def apply_to(relation, params = nil)
+      @query_expression.apply_to(relation, params)
+    end
+  end
+
+  class SubqueryExpression
+    TYPES = {
+      :joins => JoinSubquery
+    }.freeze
+
+    attr_reader :subquery_type, :subquery_args, :subquery_block
+    alias :type :subquery_type
+
+    def initialize(type, *args, &block)
+      raise ArgumentError, "a block must be provided" unless block
+      @subquery_type  = type
+      @subquery_args  = args
+      @subquery_block = block
+    end
+
+    def subquery
+      @subquery ||= TYPES[self.subquery_type].new(
+        *self.subquery_args,
+        &self.subquery_block
+      )
+    end
+
+    def apply_to(relation, params = nil)
+      relation.send(self.type, self.subquery.build_sql(params))
+    end
+  end
+
+  class FromExpression
+    attr_reader :record_class
+
+    def initialize(record_class)
+      raise ArgumentError, "must be passed a MR::Record" unless record_class < MR::Record
+      @record_class = record_class
+    end
+
+    def default_find_attr
+      @default_find_attr ||= [
+        self.record_class.table_name,
+        self.record_class.primary_key
+      ].join('.')
+    end
+
+    def ar_relation(params = nil)
+      self.record_class.scoped
+    end
+  end
+
+  class FromSubqueryExpression
+    attr_reader :subquery_block
+
+    def initialize(&block)
+      raise ArgumentError, "a block must be provided" unless block
+      @subquery_block = block
+    end
+
+    # lazy-build `FromSubquery` so its block is not evaluated until the read
+    # model `query` method is called, cache it so it doesn't have to be rebuilt
+    # for every `query` call
+    def from_subquery
+      @from_subquery ||= FromSubquery.new(&self.subquery_block)
+    end
+
+    def record_class
+      self.from_subquery.record_class
+    end
+
+    def default_find_attr
+      raise NoFindAttrError, "a `find_attr` has to be specified " \
+                             "when using a from subquery"
+    end
+
+    def ar_relation(params = nil)
+      self.record_class.scoped.from(self.from_subquery.build_sql(params))
+    end
+  end
+
+  class NullFromExpression
+    def record_class;              raise NoFromExpressionError; end
+    def default_find_attr;         raise NoFromExpressionError; end
+    def ar_relation(params = nil); raise NoFromExpressionError; end
+  end
+
+  class SetExpression
+    OPERATOR_SQL = {
+      :union         => 'UNION'.freeze,
+      :union_all     => 'UNION ALL'.freeze,
+      :intersect     => 'INTERSECT'.freeze,
+      :intersect_all => 'INTERSECT ALL'.freeze,
+      :except        => 'EXCEPT'.freeze,
+      :except_all    => 'EXCEPT ALL'.freeze
+    }.freeze
+
+    attr_reader :operator_sql, :read_model_block
+
+    def initialize(operator, &block)
+      raise ArgumentError, "a block must be provided" unless block
+      @operator_sql     = OPERATOR_SQL[operator]
+      @read_model_block = block
+    end
+
+    def read_model_class
+      @read_model_class ||= begin
+        c = 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
+        c.class_eval(&self.read_model_block)
+        c
+      end
+    end
+
+    def combine_sql(sql, params = nil)
+      "#{sql} #{self.operator_sql} #{self.read_model_class.build_sql(params)}"
+    end
+  end
+
+  InvalidQueryExpressionError = Class.new(RuntimeError)
+
+  NoFindAttrError = Class.new(RuntimeError)
+
+  class NoFromExpressionError < RuntimeError
+    def initialize
+      super "a from expression hasn't been set - " \
+            "set one using `from` or `from_subquery`"
+    end
+  end
+
+end