mr 0.35.2

data/lib/mr/model/configuration.rb

@@ -0,0 +1,67 @@
+require 'much-plugin'
+require 'mr/record'
+
+module MR; end
+module MR::Model
+
+  module Configuration
+    include MuchPlugin
+
+    # `MR::Model::Configuration` is a mixin that provides a model's record
+    # handling behavior. This includes reading/writing a model class'
+    # `record_class` and reading/writing a model's `record`. These operations
+    # validate what is being written to avoid confusing errors. The
+    # `Configuration` mixin is a base mixin for all the other model mixins.
+    #
+    # * Use the `record` protected method to access the record instance.
+    # * Use the `set_record` private method to write a record value.
+
+    plugin_included do
+      extend ClassMethods
+      include InstanceMethods
+    end
+
+    module ClassMethods
+
+      def record_class(*args)
+        set_record_class(*args) unless args.empty?
+        @record_class || raise(NoRecordClassError, "a record class hasn't been set", caller)
+      end
+
+      private
+
+      def set_record_class(value)
+        raise ArgumentError, "must be a MR::Record" unless value < MR::Record
+        @record_class = value
+        value.model_class = self
+      end
+
+    end
+
+    module InstanceMethods
+
+      def record_class
+        self.class.record_class
+      end
+
+      def record
+        @record || raise(NoRecordError, "a record hasn't been set", caller)
+      end
+
+      private
+
+      def set_record(record)
+        raise InvalidRecordError unless record.kind_of?(MR::Record)
+        @record       = record
+        @record.model = self
+      end
+
+    end
+
+  end
+
+  InvalidRecordError = Class.new(ArgumentError)
+  NoRecordError      = Class.new(RuntimeError)
+  NoRecordClassError = Class.new(RuntimeError)
+
+end

data/lib/mr/model/fields.rb

@@ -0,0 +1,177 @@
+require 'much-plugin'
+require 'mr/model/configuration'
+
+module MR; end
+module MR::Model
+
+  module Fields
+    include MuchPlugin
+
+    plugin_included do
+      include MR::Model::Configuration
+      extend ClassMethods
+      include InstanceMethods
+    end
+
+    module ClassMethods
+
+      def fields
+        @fields ||= MR::Model::FieldSet.new
+      end
+
+      def field_reader(*names)
+        names.each do |name|
+          self.fields.add_reader(name, self)
+        end
+      end
+
+      def field_writer(*names)
+        names.each do |name|
+          self.fields.add_writer(name, self)
+        end
+      end
+
+      def field_accessor(*names)
+        field_reader(*names)
+        field_writer(*names)
+      end
+
+      def field_names
+        self.fields.names
+      end
+
+    end
+
+    module InstanceMethods
+
+      def fields
+        self.class.fields.read_all(record)
+      end
+
+      def fields=(values)
+        raise(ArgumentError, "must be a hash") unless values.kind_of?(Hash)
+        self.class.fields.batch_write(values, record)
+      rescue NoFieldError => exception
+        exception.set_backtrace(caller)
+        raise exception
+      end
+
+    end
+
+  end
+
+  class FieldSet
+    include Enumerable
+
+    def initialize
+      @fields = {}
+    end
+
+    def names
+      @fields.keys
+    end
+
+    def find(name)
+      @fields[name.to_s] || raise(NoFieldError, "the '#{name}' field doesn't exist")
+    end
+
+    def get(name)
+      @fields[name.to_s] ||= Field.new(name)
+    end
+
+    def each(&block)
+      @fields.values.each(&block)
+    end
+
+    def read_all(record)
+      @fields.values.inject({}) do |h, field|
+        h.merge(field.name => field.read(record))
+      end
+    end
+
+    def batch_write(values, record)
+      values.each{ |name, value| find(name).write(value, record) }
+    end
+
+    def add_reader(name, model_class)
+      get(name).define_reader_on(model_class)
+    end
+
+    def add_writer(name, model_class)
+      get(name).define_writer_on(model_class)
+    end
+
+    private
+
+    def stringify_hash(hash)
+      hash.inject({}){ |h, (k, v)| h.merge(k.to_s => v) }
+    end
+
+  end
+
+  class Field
+    attr_reader :name
+    attr_reader :reader_method_name, :was_method_name, :changed_method_name
+    attr_reader :writer_method_name
+
+    def initialize(name)
+      @name = name.to_s
+      @reader_method_name  = @name
+      @was_method_name     = "#{@name}_was"
+      @changed_method_name = "#{@name}_changed?"
+      @writer_method_name  = "#{@reader_method_name}="
+      @attribute_reader_method_name = @reader_method_name
+      @attribute_writer_method_name = @writer_method_name
+      @attribute_was_method_name = "#{@reader_method_name}_was"
+      @attribute_changed_method_name = "#{@reader_method_name}_changed?"
+    end
+
+    def read(record)
+      record.send(@attribute_reader_method_name)
+    end
+
+    def write(value, record)
+      record.send(@attribute_writer_method_name, value)
+    end
+
+    def was(record)
+      record.send(@attribute_was_method_name)
+    end
+
+    def changed?(record)
+      record.send(@attribute_changed_method_name)
+    end
+
+    def define_reader_on(model_class)
+      field = self
+      model_class.class_eval do
+
+        define_method(field.reader_method_name) do
+          field.read(record)
+        end
+        define_method(field.changed_method_name) do
+          field.changed?(record)
+        end
+        define_method(field.was_method_name) do
+          field.was(record)
+        end
+
+      end
+    end
+
+    def define_writer_on(model_class)
+      field = self
+      model_class.class_eval do
+
+        define_method(field.writer_method_name) do |value|
+          field.write(value, record)
+        end
+
+      end
+    end
+
+  end
+
+  NoFieldError = Class.new(RuntimeError)
+
+end

data/lib/mr/model/persistence.rb

@@ -0,0 +1,79 @@
+require 'active_record'
+require 'active_record/validations'
+require 'much-plugin'
+require 'mr/model/configuration'
+
+module MR; end
+module MR::Model
+
+  module Persistence
+    include MuchPlugin
+
+    plugin_included do
+      include MR::Model::Configuration
+      extend ClassMethods
+      include InstanceMethods
+    end
+
+    module ClassMethods
+
+      def transaction(&block)
+        self.record_class.transaction(&block)
+      end
+
+    end
+
+    module InstanceMethods
+
+      def save
+        self.transaction{ record.save! }
+      rescue ActiveRecord::RecordInvalid => exception
+        # `caller` is not consistent between 1.8 and 2.0, if we stop supporting
+        # older versions, we can switch to using `caller`
+        called_from = exception.backtrace[6..-1]
+        raise InvalidError.new(self, self.errors, called_from)
+      end
+
+      def destroy
+        record.destroy
+      end
+
+      def transaction(&block)
+        record.transaction(&block)
+      end
+
+      def errors
+        record.errors.messages
+      end
+
+      def valid?
+        record.valid?
+      end
+
+      def new?
+        record.new_record?
+      end
+
+      def destroyed?
+        record.destroyed?
+      end
+
+    end
+
+  end
+
+  class InvalidError < RuntimeError
+    attr_reader :errors
+
+    def initialize(model, errors, backtrace = nil)
+      @errors = errors || {}
+      desc = @errors.map do |(attribute, messages)|
+        messages.map{ |message| "#{attribute.inspect} #{message}" }
+      end.sort.join(', ')
+      super "Invalid #{model.class} couldn't be saved: #{desc}"
+      set_backtrace(backtrace) if backtrace
+    end
+
+  end
+
+end

data/lib/mr/query.rb

@@ -0,0 +1,126 @@
+require 'active_record'
+
+module MR
+
+  class Query
+
+    attr_reader :model_class, :relation
+
+    def initialize(model_class, relation)
+      @model_class = model_class
+      @relation    = relation
+    end
+
+    def results
+      @results ||= self.results!
+    end
+
+    def results!
+      @results = self.relation.all.map{ |record| self.model_class.new(record) }
+    end
+
+    def first
+      @first ||= self.first!
+    end
+
+    def first!
+      @first = if (record = self.relation.first)
+        self.model_class.new(record)
+      end
+    end
+
+    def count
+      @count ||= self.count!
+    end
+
+    def count!
+      @count = count_relation.count
+    end
+
+    def paged(page_num = nil, page_size = nil)
+      PagedQuery.new(self, page_num, page_size)
+    end
+
+    private
+
+    def count_relation
+      @count_relation ||= CountRelation.new(self.relation)
+    end
+
+    module CountRelation
+      def self.new(relation)
+        relation = relation.except(:select, :order)
+        if relation.group_values.empty?
+          relation
+        else
+          # use `SELECT 1` to count grouped results, this avoids trying to use
+          # a column which may not work because it's not part of the group by
+          # (Postgres errors if a column is selected that isn't part of the
+          # sql GROUP BY)
+          subquery = relation.select('1').to_sql
+          relation.klass.scoped.from("(#{subquery}) AS grouped_records")
+        end
+      end
+    end
+
+  end
+
+  class PagedQuery < Query
+    attr_reader :page_num, :page_size, :page_offset
+
+    def initialize(query, page_num = nil, page_size = nil)
+      @page_num    = PageNumber.new(page_num)
+      @page_size   = PageSize.new(page_size)
+      @page_offset = PageOffset.new(@page_num, @page_size)
+
+      @unpaged_relation = query.relation.dup
+      relation = query.relation.offset(@page_offset).limit(@page_size)
+      super query.model_class, relation
+    end
+
+    def total_count
+      @total_count ||= total_count!
+    end
+
+    # This isn't done in the `initialize` because it runs a query (which is
+    # expensive) and should only be done when it's needed. If it's never used
+    # then, running it in the `initialize` would be wasteful.
+    def total_count!
+      @total_count = total_count_relation.count
+    end
+
+    def has_next_page?
+      @has_next_page ||= (self.page_offset + self.page_size) < self.total_count
+    end
+
+    def is_last_page?
+      !self.has_next_page?
+    end
+
+    private
+
+    def total_count_relation
+      @total_count_relation ||= CountRelation.new(@unpaged_relation)
+    end
+
+    module PageNumber
+      def self.new(number)
+        number && number.to_i > 0 ? number.to_i : 1
+      end
+    end
+
+    module PageSize
+      def self.new(number)
+        number && number.to_i > 0 ? number.to_i : 25
+      end
+    end
+
+    module PageOffset
+      def self.new(page_number, page_size)
+        (page_number - 1) * page_size
+      end
+    end
+
+  end
+
+end