mr 0.35.2

data/lib/mr/fake_query.rb

@@ -0,0 +1,53 @@
+require 'mr/query'
+
+module MR
+
+  class FakeQuery
+
+    attr_reader :results, :count
+    alias :results! :results
+    alias :count! :count
+
+    def initialize(results)
+      @results = results || []
+      @count   = @results.size
+    end
+
+    def first
+      @results.first
+    end
+    alias :first! :first
+
+    def paged(page_num = nil, page_size = nil)
+      FakePagedQuery.new(self, page_num, page_size)
+    end
+
+  end
+
+  class FakePagedQuery < FakeQuery
+
+    attr_reader :page_num, :page_size, :page_offset, :total_count
+    alias :total_count! :total_count
+
+    def initialize(query, page_num, page_size)
+      @page_num        = MR::PagedQuery::PageNumber.new(page_num)
+      @page_size       = MR::PagedQuery::PageSize.new(page_size)
+      @page_offset     = MR::PagedQuery::PageOffset.new(@page_num, @page_size)
+      @unpaged_results = query.results.dup
+      @total_count     = @unpaged_results.size
+      @has_next_page   = (@page_offset + @page_size) < @total_count
+
+      super(@unpaged_results.dup[@page_offset, @page_size])
+    end
+
+    def has_next_page?
+      @has_next_page
+    end
+
+    def is_last_page?
+      !self.has_next_page?
+    end
+
+  end
+
+end

data/lib/mr/fake_record.rb

@@ -0,0 +1,58 @@
+require 'much-plugin'
+require 'mr/fake_record/associations'
+require 'mr/fake_record/attributes'
+require 'mr/fake_record/persistence'
+require 'mr/record'
+
+module MR
+
+  module FakeRecord
+    include MuchPlugin
+    extend MR::FakeRecord::Persistence::TransactionMethods
+
+    plugin_included do
+      include MR::Record
+      include MR::FakeRecord::Associations
+      include MR::FakeRecord::Attributes
+      include MR::FakeRecord::Persistence
+      extend ClassMethods
+      include InstanceMethods
+    end
+
+    module ClassMethods
+
+      def model_class(value = nil)
+        @model_class = value if value
+        @model_class
+      end
+
+    end
+
+    module InstanceMethods
+
+      def initialize(attrs = nil)
+        self.attributes = attrs || {}
+      end
+
+      def ==(other)
+        other.kind_of?(self.class) ? self.id == other.id : super
+      end
+      alias :eql? :==
+
+      def hash
+        self.id.hash
+      end
+
+      def inspect
+        object_hex = (self.object_id << 1).to_s(16)
+        attributes_inspect = self.class.attributes.map do |attribute|
+          "@#{attribute.name}=#{attribute.read(self).inspect}"
+        end.sort.join(" ")
+        "#<#{self.class}:0x#{object_hex} #{attributes_inspect}>"
+      end
+
+    end
+
+  end
+
+end

data/lib/mr/fake_record/associations.rb

@@ -0,0 +1,257 @@
+require 'much-plugin'
+require 'active_support/core_ext'
+require 'mr/fake_record/attributes'
+
+module MR; end
+module MR::FakeRecord
+
+  module Associations
+    include MuchPlugin
+
+    plugin_included do
+      include MR::FakeRecord::Attributes
+      extend ClassMethods
+      include InstanceMethods
+    end
+
+    module ClassMethods
+
+      def reflections
+        @reflections ||= MR::FakeRecord::ReflectionSet.new
+      end
+
+      def belongs_to(name, options = nil)
+        self.reflections.add_belongs_to(self, name, options)
+      end
+
+      def has_one(name, options = nil)
+        self.reflections.add_has_one(self, name, options)
+      end
+
+      def has_many(name, options = nil)
+        self.reflections.add_has_many(self, name, options)
+      end
+
+      # ActiveRecord methods
+
+      def reflect_on_association(name)
+        self.reflections.find(name)
+      end
+
+      def reflect_on_all_associations(type = nil)
+        self.reflections.all(type)
+      end
+
+    end
+
+    module InstanceMethods
+
+      # ActiveRecord methods
+
+      def association(name)
+        @association_cache ||= {}
+        @association_cache[name.to_sym] ||= begin
+          reflection = self.class.reflections.find(name)
+          reflection.association_class.new(self, reflection)
+        end
+      end
+
+    end
+
+  end
+
+  class ReflectionSet
+    def initialize
+      @belongs_to = {}
+      @has_one  = {}
+      @has_many = {}
+    end
+
+    def belongs_to
+      @belongs_to.values.sort
+    end
+
+    def has_one
+      @has_one.values.sort
+    end
+
+    def has_many
+      @has_many.values.sort
+    end
+
+    def find(name)
+      @belongs_to[name.to_s] || @has_one[name.to_s] || @has_many[name.to_s]
+    end
+
+    def all(type = nil)
+      case type
+      when :belongs_to, :has_one, :has_many
+        self.send(type)
+      else
+        self.belongs_to + self.has_one + self.has_many
+      end
+    end
+
+    def add_belongs_to(fake_record_class, name, options = nil)
+      options ||= {}
+      options[:foreign_key] ||= "#{name}_id"
+      if options[:polymorphic]
+        options[:foreign_type] ||= "#{name}_type"
+      end
+      reflection = Reflection.new(:belongs_to, name, options)
+      reflection.define_accessor_on(fake_record_class)
+      @belongs_to[name.to_s] = reflection
+    end
+
+    def add_has_one(fake_record_class, name, options = nil)
+      reflection = Reflection.new(:has_one, name, options)
+      reflection.define_accessor_on(fake_record_class)
+      @has_one[name.to_s] = reflection
+    end
+
+    def add_has_many(fake_record_class, name, options = nil)
+      reflection = Reflection.new(:has_many, name, options)
+      reflection.define_accessor_on(fake_record_class)
+      @has_many[name.to_s] = reflection
+    end
+  end
+
+  class Reflection
+    attr_reader :reader_method_name, :writer_method_name
+
+    # ActiveRecord methods
+    attr_reader :name, :macro, :options
+    attr_reader :foreign_key, :foreign_type
+    attr_reader :association_class
+
+    BELONGS_TO_ASSOC_PROC = proc do |r|
+      r.options[:polymorphic] ? PolymorphicBelongsToAssociation : BelongsToAssociation
+    end
+    ASSOCIATION_CLASS = {
+      :belongs_to => BELONGS_TO_ASSOC_PROC,
+      :has_one    => proc{ HasOneAssociation },
+      :has_many   => proc{ HasManyAssociation }
+    }.freeze
+
+    def initialize(macro, name, options = nil)
+      @macro   = macro.to_sym
+      @name    = name
+      @options = options || {}
+
+      @class_name   = @options[:class_name]
+      @foreign_key  = @options[:foreign_key]
+      @foreign_type = @options[:foreign_type]
+
+      @reader_method_name = name.to_s
+      @writer_method_name = "#{@reader_method_name}="
+      @association_class  = ASSOCIATION_CLASS[@macro].call(self)
+    end
+
+    # ActiveRecord method
+    def klass
+      @klass ||= (@class_name.to_s.constantize if @class_name)
+    end
+
+    def define_accessor_on(fake_record_class)
+      reflection = self
+      fake_record_class.class_eval do
+
+        define_method(reflection.reader_method_name) do
+          self.association(reflection.name).read
+        end
+        define_method(reflection.writer_method_name) do |value|
+          self.association(reflection.name).write(value)
+        end
+
+      end
+    end
+
+    def <=>(other)
+      if other.kind_of?(self.class)
+        [ self.macro,  self.options[:polymorphic],  self.name ].map(&:to_s) <=>
+        [ other.macro, other.options[:polymorphic], other.name ].map(&:to_s)
+      else
+        super
+      end
+    end
+  end
+
+  class Association
+    # ActiveRecord method
+    attr_reader :owner, :reflection
+
+    def initialize(owner, reflection)
+      @owner = owner
+      @reflection = reflection
+      @ivar_name = "@#{@reflection.name}"
+    end
+
+    def read;         raise NotImplementedError; end
+    def write(value); raise NotImplementedError; end
+
+    # ActiveRecord method
+    def klass
+      self.reflection.klass
+    end
+
+    def <=>(other)
+      other.kind_of?(Association) ? self.reflection <=> other.reflection : super
+    end
+  end
+
+  class OneToOneAssociation < Association
+    def read
+      @owner.instance_variable_get(@ivar_name)
+    end
+
+    def write(value)
+      @owner.instance_variable_set(@ivar_name, value)
+      write_attributes(value || NULL_RECORD)
+      value
+    end
+
+    private
+
+    def write_attributes(associated_fake_record); end
+
+    NullRecord  = Struct.new(:id, :class)
+    NullClass   = Struct.new(:name)
+    NULL_RECORD = NullRecord.new(nil, NullClass.new)
+  end
+
+  class OneToManyAssociation < Association
+    def read
+      @owner.instance_variable_get(@ivar_name) ||
+      @owner.instance_variable_set(@ivar_name, [])
+    end
+
+    def write(value)
+      @owner.instance_variable_set(@ivar_name, [*value].compact)
+    end
+  end
+
+  class BelongsToAssociation < OneToOneAssociation
+    def write_attributes(associated_fake_record)
+      super
+      associated_id = associated_fake_record.id
+      @owner.send("#{self.reflection.foreign_key}=", associated_id)
+    end
+  end
+
+  class PolymorphicBelongsToAssociation < BelongsToAssociation
+    def write_attributes(associated_fake_record)
+      super
+      associated_type = associated_fake_record.class.name
+      @owner.send("#{self.reflection.foreign_type}=", associated_type)
+    end
+
+    def klass
+      class_name = @owner.send(self.reflection.foreign_type)
+      class_name.constantize if class_name
+    end
+  end
+
+  HasOneAssociation  = OneToOneAssociation
+  HasManyAssociation = OneToManyAssociation
+
+end

data/lib/mr/fake_record/attributes.rb

@@ -0,0 +1,168 @@
+require 'much-plugin'
+
+module MR; end
+module MR::FakeRecord
+
+  module Attributes
+    include MuchPlugin
+
+    plugin_included do
+      extend ClassMethods
+      include InstanceMethods
+    end
+
+    module ClassMethods
+
+      def attributes
+        @attributes ||= MR::FakeRecord::AttributeSet.new
+      end
+
+      def attribute(name, type, options = nil)
+        self.attributes.add(self, name, type, options)
+      end
+
+      # ActiveRecord methods
+
+      def columns
+        self.attributes.to_a
+      end
+
+    end
+
+    module InstanceMethods
+
+      attr_writer :saved_attributes
+
+      def saved_attributes
+        @saved_attributes ||= {}
+      end
+
+      # ActiveRecord methods
+
+      def attributes
+        self.class.attributes.read_all(self)
+      end
+
+      def attributes=(new_attributes)
+        return unless new_attributes.is_a?(Hash)
+        self.class.attributes.batch_write(new_attributes, self)
+      end
+
+      def column_for_attribute(name)
+        self.class.attributes.find(name)
+      rescue NoAttributeError
+        return nil
+      end
+
+    end
+
+  end
+
+  class AttributeSet
+    include Enumerable
+
+    def initialize
+      @attributes = {}
+    end
+
+    def find(name)
+      @attributes[name.to_s] || raise(NoAttributeError.new(name))
+    end
+
+    def each(&block)
+      @attributes.values.each(&block)
+    end
+
+    def read_all(record)
+      @attributes.values.inject({}) do |h, attribute|
+        h.merge(attribute.name => attribute.read(record))
+      end
+    end
+
+    def batch_write(new_attributes, record)
+      new_attributes.each{ |name, value| find(name).write(value, record) }
+    end
+
+    def to_a
+      @attributes.values.sort
+    end
+
+    def add(record_class, name, type, options = nil)
+      attribute = Attribute.new(name, type, options)
+      attribute.define_on(record_class)
+      @attributes[name.to_s] = attribute
+    end
+
+  end
+
+  class Attribute
+    attr_reader :name, :type
+    attr_reader :reader_method_name, :writer_method_name
+    attr_reader :was_method_name, :changed_method_name
+
+    # ActiveRecord methods
+    attr_reader :primary, :null
+
+    def initialize(name, type, options = nil)
+      options ||= {}
+      @name = name.to_s
+      @type = type.to_sym
+      @primary = (@type == :primary_key)
+      @null = options.key?(:null) ? !!options[:null] : true
+
+      @reader_method_name  = @name
+      @writer_method_name  = "#{@reader_method_name}="
+      @was_method_name     = "#{@reader_method_name}_was"
+      @changed_method_name = "#{@reader_method_name}_changed?"
+    end
+
+    def read(record)
+      record.send(@reader_method_name)
+    end
+
+    def write(value, record)
+      record.send(@writer_method_name, value)
+    end
+
+    def was(record)
+      record.saved_attributes[@name]
+    end
+
+    def changed?(record)
+      read(record) != was(record)
+    end
+
+    def ==(other)
+      self.name == other.name &&
+      self.type == other.type &&
+      self.null == other.null
+    end
+
+    def <=>(other)
+      self.name <=> other.name
+    end
+
+    def define_on(record_class)
+      attribute = self
+      record_class.class_eval do
+
+        attr_accessor attribute.reader_method_name
+        define_method(attribute.was_method_name) do
+          attribute.was(self)
+        end
+        define_method(attribute.changed_method_name) do
+          attribute.changed?(self)
+        end
+
+      end
+    end
+
+  end
+
+  class NoAttributeError < RuntimeError
+    def initialize(attr_name)
+      super "the '#{attr_name}' attribute doesn't exist"
+    end
+  end
+
+end