mr 0.35.2

data/lib/mr/fake_record/persistence.rb

@@ -0,0 +1,116 @@
+require 'active_model'
+require 'active_record'
+require 'active_record/validations'
+require 'much-plugin'
+require 'mr/factory'
+require 'mr/fake_record/attributes'
+
+module MR; end
+module MR::FakeRecord
+
+  module Persistence
+    include MuchPlugin
+
+    plugin_included do
+      include MR::FakeRecord::Attributes
+      extend TransactionMethods
+      extend ClassMethods
+      include InstanceMethods
+
+      attribute :id, :primary_key
+    end
+
+    # this is broken into a separate module so `FakeRecord` can extend it and
+    # provide easy access to the `transaction` method (for stubbing, etc)
+    module TransactionMethods
+
+      # ActiveRecord methods
+
+      def transaction
+        begin
+          yield if block_given?
+        rescue ActiveRecord::Rollback
+          # activerecord swallows rollback exceptions, they are only intended as a
+          # mechanism to rollback the transaction
+        end
+      end
+
+    end
+
+    module ClassMethods
+
+      # ActiveRecord methods
+
+      # this is needed to raise ActiveRecord::RecordInvalid
+      def human_attribute_name(attribute, options = {})
+        options[:default] || attribute.to_s.split('.').last
+      end
+
+    end
+
+    module InstanceMethods
+
+      # ActiveRecord methods
+
+      def save!
+        raise ActiveRecord::RecordInvalid.new(self) unless self.valid?
+        self.id ||= MR::Factory.primary_key(self.class)
+        current_time = CurrentTime.new
+        self.created_at ||= current_time if self.respond_to?(:created_at=)
+        if self.respond_to?(:updated_at=) && !self.updated_at_changed?
+          self.updated_at = current_time
+        end
+        self.saved_attributes = self.attributes.dup
+        @save_called = true
+      end
+
+      def destroy
+        @destroyed = true
+      end
+
+      def transaction(&block)
+        self.class.transaction(&block)
+      end
+
+      def new_record?
+        !self.id
+      end
+
+      def destroyed?
+        !!@destroyed
+      end
+
+      def errors
+        @errors ||= ActiveModel::Errors.new(self)
+      end
+
+      def valid?
+        self.errors.empty?
+      end
+
+      # Non-ActiveRecord methods
+
+      def save_called
+        @save_called = false if @save_called.nil?
+        @save_called
+      end
+
+      def reset_save_called
+        @save_called = false
+      end
+
+    end
+
+    module CurrentTime
+      def self.new
+        if ActiveRecord::Base.default_timezone == :utc
+          Time.now.utc
+        else
+          Time.now
+        end
+      end
+    end
+
+  end
+
+end

data/lib/mr/json_field.rb

@@ -0,0 +1,180 @@
+require 'much-plugin'
+
+require 'mr/json_field/fake_record'
+require 'mr/json_field/record'
+
+module MR
+
+  module JsonField
+    include MuchPlugin
+
+    DEFAULT_ENCODER = proc{ |value| ::JSON.dump(value) }
+    DEFAULT_DECODER = proc{ |value| ::JSON.load(value) }
+
+    def self.encoder;             @encoder ||= DEFAULT_ENCODER; end
+    def self.encoder=(new_value); @encoder = new_value;         end
+
+    def self.decoder;             @decoder ||= DEFAULT_DECODER; end
+    def self.decoder=(new_value); @decoder = new_value;         end
+
+    def self.encode(value)
+      self.encoder.call(value)
+    rescue StandardError => exception
+      raise InvalidJSONError, exception.message
+    end
+
+    def self.decode(value)
+      self.decoder.call(value)
+    rescue StandardError => exception
+      raise InvalidJSONError, exception.message
+    end
+
+    # this can be used with `MR::Model` or `MR::ReadModel`, so it doesn't
+    # include either by default
+    plugin_included do
+      extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def json_field(field_name, options = nil)
+        json_field_reader(field_name, options)
+        json_field_writer(field_name, options)
+      end
+
+      def json_field_reader(field_name, options = nil)
+        options ||= {}
+        field_name        = field_name.to_s
+        ivar_name         = "@#{field_name}"
+        source_field_name = (options[:source] || "#{field_name}_json").to_s
+
+        if source_field_name == field_name
+          raise ArgumentError, "the field name and source cannot be the same"
+        end
+
+        define_method(field_name) do
+          if !(cached_value = self.instance_variable_get(ivar_name)).nil?
+            return cached_value
+          else
+            source_value = self.send(source_field_name)
+            return source_value if source_value.nil?
+
+            value = begin
+              MR::JsonField.decode(source_value)
+            rescue InvalidJSONError => exception
+              message = "can't decode `#{field_name}` JSON field (from " \
+                        "`#{source_field_name}`): #{exception.message}"
+              raise exception.class, message, caller
+            end
+
+            # cache the decoded value in the ivar
+            self.instance_variable_set(ivar_name, value)
+
+            value
+          end
+        end
+
+        (self.json_field_readers       << field_name).uniq!
+        (self.json_field_source_fields << source_field_name).uniq!
+      end
+
+      def json_field_writer(field_name, options = nil)
+        options ||= {}
+        field_name        = field_name.to_s.strip
+        ivar_name         = "@#{field_name}"
+        source_field_name = (options[:source] || "#{field_name}_json").to_s.strip
+
+        if source_field_name == field_name
+          raise ArgumentError, "the field name and source cannot be the same"
+        end
+
+        define_method("#{field_name}=") do |new_value|
+          encoded_value = if !new_value.nil?
+            begin
+              MR::JsonField.encode(new_value)
+            rescue InvalidJSONError => exception
+              message = "can't encode value for `#{field_name}` JSON field: " \
+                        "#{exception.message}"
+              raise exception.class, message, caller
+            end
+          else
+            nil
+          end
+          self.send("#{source_field_name}=", encoded_value)
+
+          # reset the ivar so its value will be calculated again when read
+          self.instance_variable_set(ivar_name, nil)
+
+          new_value
+        end
+
+        (self.json_field_writers       << field_name).uniq!
+        (self.json_field_source_fields << source_field_name).uniq!
+      end
+
+      def json_field_readers; @json_field_readers ||= []; end
+      def json_field_writers; @json_field_writers ||= []; end
+
+      def json_field_accessors
+        self.json_field_readers & self.json_field_writers
+      end
+
+      def json_field_source_fields
+        @json_field_source_fields ||= []
+      end
+
+    end
+
+    module TestHelpers
+      include MuchPlugin
+
+      plugin_included do
+        include InstanceMethods
+
+        require 'mr/factory'
+      end
+
+      module InstanceMethods
+
+        def assert_json_field(subject, field_name, options = nil)
+          assert_json_field_reader(subject, field_name, options)
+          assert_json_field_writer(subject, field_name, options)
+        end
+
+        def assert_json_field_reader(subject, field_name, options = nil)
+          options ||= {}
+          source_field_name = options[:source] || "#{field_name}_json"
+
+          # set a value to read if it's `nil`
+          if subject.send(source_field_name).nil?
+            encoded_value = MR::JsonField.encode({
+              MR::Factory.string => MR::Factory.string
+            })
+            subject.send("#{source_field_name}=", encoded_value)
+          end
+
+          assert_respond_to "#{field_name}", subject
+          exp = MR::JsonField.decode(subject.send"#{source_field_name}")
+          assert_equal exp, subject.send("#{field_name}")
+        end
+
+        def assert_json_field_writer(subject, field_name, options = nil)
+          options ||= {}
+          source_field_name = options[:source] || "#{field_name}_json"
+
+          assert_respond_to "#{field_name}=", subject
+          new_value = { MR::Factory.string => MR::Factory.string }
+          subject.send("#{field_name}=", new_value)
+          exp = MR::JsonField.encode(new_value)
+          assert_equal exp, subject.send("#{source_field_name}")
+        end
+
+      end
+
+    end
+
+    InvalidJSONError = Class.new(StandardError)
+
+  end
+
+end

data/lib/mr/json_field/fake_record.rb

@@ -0,0 +1,31 @@
+require 'much-plugin'
+
+require 'mr/fake_record'
+
+module MR; end
+module MR::JsonField
+
+  module FakeRecord
+    include MuchPlugin
+
+    plugin_included do
+      include MR::FakeRecord
+      include InstanceMethods
+    end
+
+    module InstanceMethods
+
+      # this mimics the `JsonField::Record` mixin, doing the same logic to
+      # ensure that the source fields match the json fields
+      def save!
+        self.model.class.json_field_accessors.each do |field_name|
+          self.model.send("#{field_name}=", self.model.send(field_name))
+        end
+        super
+      end
+
+    end
+
+  end
+
+end

data/lib/mr/json_field/record.rb

@@ -0,0 +1,38 @@
+require 'much-plugin'
+
+require 'mr/record'
+
+module MR; end
+module MR::JsonField
+
+  module Record
+    include MuchPlugin
+
+    plugin_included do
+      include MR::Record
+      include InstanceMethods
+
+      before_save :json_field_sync_all_json_fields_on_save
+    end
+
+    module InstanceMethods
+
+      private
+
+      # this makes it so changes that are done to the JSON object are persisted
+      # to the DB without having to re-write the entire field, for example if
+      # the json field is a hash then a change to an individual key's value
+      # needs to get re-encoded and stored in the source field, since the json
+      # field writer wasn't used it won't get encoded, this callback fixes the
+      # issue by ensuring all json fields get synced before we save the record
+      def json_field_sync_all_json_fields_on_save
+        self.model.class.json_field_accessors.each do |field_name|
+          self.model.send("#{field_name}=", self.model.send(field_name))
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/mr/model.rb

@@ -0,0 +1,67 @@
+require 'much-plugin'
+require 'mr/model/associations'
+require 'mr/model/configuration'
+require 'mr/model/fields'
+require 'mr/model/persistence'
+
+module MR
+
+  module Model
+    include MuchPlugin
+
+    plugin_included do
+      include MR::Model::Configuration
+      include MR::Model::Fields
+      include MR::Model::Associations
+      include MR::Model::Persistence
+      extend ClassMethods
+      include InstanceMethods
+    end
+
+    module ClassMethods
+
+      def find(id)
+        self.new(self.record_class.find(id))
+      end
+
+      def all
+        self.record_class.all.map{ |record| self.new(record) }
+      end
+
+    end
+
+    module InstanceMethods
+
+      def initialize(*args)
+        field_values = args.pop if args.last.kind_of?(Hash)
+        set_record(args.first || self.record_class.new)
+        (field_values || {}).each do |name, value|
+          self.send("#{name}=", value)
+        end
+      end
+
+      def ==(other)
+        other.kind_of?(self.class) ? self.record == other.record : super
+      end
+
+      def eql?(other)
+        other.kind_of?(self.class) ? self.record.eql?(other.record) : super
+      end
+
+      def hash
+        record.hash
+      end
+
+      def inspect
+        object_hex = (self.object_id << 1).to_s(16)
+        fields_inspect = self.class.fields.map do |field|
+          "@#{field.name}=#{field.read(record).inspect}"
+        end.sort.join(" ")
+        "#<#{self.class}:0x#{object_hex} #{fields_inspect}>"
+      end
+
+    end
+
+  end
+
+end

data/lib/mr/model/associations.rb

@@ -0,0 +1,161 @@
+require 'much-plugin'
+require 'mr/model/configuration'
+
+module MR; end
+module MR::Model
+
+  module Associations
+    include MuchPlugin
+
+    plugin_included do
+      include MR::Model::Configuration
+      extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def associations
+        @associations ||= MR::Model::AssociationSet.new
+      end
+
+      def belongs_to(*names)
+        names.each do |name|
+          self.associations.add_belongs_to(name, self)
+        end
+      end
+
+      def polymorphic_belongs_to(*names)
+        names.each do |name|
+          self.associations.add_polymorphic_belongs_to(name, self)
+        end
+      end
+
+      def has_one(*names)
+        names.each do |name|
+          self.associations.add_has_one(name, self)
+        end
+      end
+
+      def has_many(*names)
+        names.each do |name|
+          self.associations.add_has_many(name, self)
+        end
+      end
+
+    end
+
+  end
+
+  class AssociationSet
+    attr_reader :belongs_to, :polymorphic_belongs_to
+    attr_reader :has_one, :has_many
+
+    def initialize
+      @belongs_to = []
+      @polymorphic_belongs_to = []
+      @has_one  = []
+      @has_many = []
+    end
+
+    def add_belongs_to(name, model_class)
+      association = BelongsToAssociation.new(name)
+      association.define_accessor_on(model_class)
+      @belongs_to << association
+    end
+
+    def add_polymorphic_belongs_to(name, model_class)
+      association = PolymorphicBelongsToAssociation.new(name)
+      association.define_accessor_on(model_class)
+      @polymorphic_belongs_to << association
+    end
+
+    def add_has_one(name, model_class)
+      association = HasOneAssociation.new(name)
+      association.define_accessor_on(model_class)
+      @has_one << association
+    end
+
+    def add_has_many(name, model_class)
+      association = HasManyAssociation.new(name)
+      association.define_accessor_on(model_class)
+      @has_many << association
+    end
+
+  end
+
+  class Association
+    attr_reader :name
+    attr_reader :reader_method_name, :writer_method_name
+
+    def initialize(name)
+      @name = name.to_s
+      @reader_method_name = @name
+      @writer_method_name = "#{@name}="
+      @association_reader_name = @name
+      @association_writer_name = "#{@name}="
+    end
+
+    def define_accessor_on(model_class)
+      association = self
+      model_class.class_eval do
+
+        define_method(association.reader_method_name) do
+          association.read(record)
+        end
+
+        define_method(association.writer_method_name) do |value|
+          begin
+            association.write(value, self, record){ |m| m.record }
+          rescue BadAssociationValueError => exception
+            raise ArgumentError, exception.message, caller
+          end
+        end
+
+      end
+    end
+  end
+
+  class OneToOneAssociation < Association
+    def read(record)
+      if associated_record = record.send(@association_reader_name)
+        associated_record.model_class.new(associated_record)
+      end
+    end
+
+    def write(value, model, record, &block)
+      raise BadAssociationValueError.new(value) if value && !value.kind_of?(MR::Model)
+      associated_record = model.instance_exec(value, &block) if value
+      record.send(@association_writer_name, associated_record)
+      value
+    end
+  end
+
+  class OneToManyAssociation < Association
+    def read(record)
+      (record.send(@association_reader_name) || []).map do |associated_record|
+        associated_record.model_class.new(associated_record)
+      end
+    end
+
+    def write(values, model, record, &block)
+      associated_records = [*values].compact.map do |value|
+        raise BadAssociationValueError.new(value) if !value.kind_of?(MR::Model)
+        model.instance_exec(value, &block)
+      end
+      record.send(@association_writer_name, associated_records)
+      values
+    end
+  end
+
+  BelongsToAssociation = Class.new(OneToOneAssociation)
+  PolymorphicBelongsToAssociation = Class.new(BelongsToAssociation)
+  HasOneAssociation = Class.new(OneToOneAssociation)
+  HasManyAssociation = Class.new(OneToManyAssociation)
+
+  class BadAssociationValueError < RuntimeError
+    def initialize(value)
+      super "#{value.inspect} is not a kind of MR::Model"
+    end
+  end
+
+end