can_be 0.2.1 → 0.3.0

data/lib/can_be/builder/can_be_detail.rb

@@ -1,20 +1,78 @@
+require 'can_be/config'
+
 module CanBe
   module Builder
     class CanBeDetail
-      def self.build(klass, can_be_model)
-        new(klass, can_be_model).define_association
+      def self.build(klass, can_be_model, options = {})
+        new(klass, can_be_model, options).define_functionality
       end
 
-      def initialize(klass, can_be_model)
+      def initialize(klass, can_be_model, options)
         @klass = klass
         @can_be_model = can_be_model
+        @options = parse_options(options)
+      end
+
+      def define_functionality
+        define_association
+        define_history
       end
 
       def define_association
         can_be_model = @can_be_model
+        details_name = @options[:details_name]
 
         @klass.class_eval do
-          has_one can_be_model, as: :details, dependent: :destroy
+          has_one can_be_model, as: details_name.to_sym, dependent: :destroy
+        end
+      end
+
+      def define_history
+        return unless keeps_history?
+
+        history_model = @options[:history_model]
+        details_name = @options[:details_name]
+        can_be_model = @can_be_model
+
+        @klass.instance_eval do
+          define_method can_be_model do |*params|
+            begin
+              details = association(details_name).reader(false)
+              return details
+            rescue NoMethodError
+              # this should be for the missing 'association_class' method because the association is broken
+              # so we just want to move on and find the record manually
+            end
+
+            history_model_class = history_model.to_s.camelize.constantize
+            history = history_model_class.where({
+              can_be_details_id: self.id,
+              can_be_details_type: self.class.name.underscore
+            }).first
+
+            can_be_model_class = can_be_model.to_s.camelize.constantize
+            can_be_model_class.find(history.can_be_model_id)
+          end
+        end
+      end
+
+      private
+      def keeps_history?
+        !@options[:history_model].nil?
+      end
+
+      def parse_options(options)
+        default_options = {
+          details_name: Config::DEFAULT_DETAILS_NAME,
+          history_model: nil
+        }
+
+        if options.is_a? Symbol
+          # this is defining the details name
+          default_options.merge details_name: options
+        else
+          # the options must be a hash
+          default_options.merge options
         end
       end
     end

data/lib/can_be/config.rb

@@ -1,19 +1,36 @@
 module CanBe
   class Config
     DEFAULT_CAN_BE_FIELD = :can_be_type
+    DEFAULT_DETAILS_NAME = :details
 
-    attr_reader :types
+    attr_reader :types, :history_model
 
-    def field_name
-      @field_name || CanBe::Config::DEFAULT_CAN_BE_FIELD
+    def field_name(name = nil)
+      if name.nil?
+        @field_name || CanBe::Config::DEFAULT_CAN_BE_FIELD
+      else
+        @field_name = name
+      end
+    end
+
+    def details_name(name = nil)
+      if name.nil?
+        @details_name || CanBe::Config::DEFAULT_DETAILS_NAME
+      else
+        @details_name = name
+      end
     end
 
     def types=(types)
       @types = types.map(&:to_s)
     end
 
-    def default_type
-      @default_type || @types.first
+    def default_type(type = nil)
+      if type.nil?
+        @default_type || @types.first
+      else
+        @default_type = type
+      end
     end
 
     def parse_options(options = {})
@@ -28,5 +45,13 @@ module CanBe
     def add_details_model(can_be_type, model_symbol)
       self.details[can_be_type] = model_symbol
     end
+
+    def keep_history_in(history_model)
+      @history_model = history_model
+    end
+
+    def keeps_history?
+      !@history_model.nil?
+    end
   end
 end

data/lib/can_be/model_extensions.rb

@@ -18,13 +18,13 @@ module CanBe
         can_be_config.types = types
         can_be_config.parse_options options if options
 
-        can_be_config.instance_eval(&block)if block_given?
+        can_be_config.instance_eval(&block) if block_given?
 
         CanBe::Builder::CanBe.build(self)
       end
 
-      def can_be_detail(can_be_model)
-        CanBe::Builder::CanBeDetail.build(self, can_be_model)
+      def can_be_detail(can_be_model, options = {})
+        CanBe::Builder::CanBeDetail.build(self, can_be_model, options)
       end
     end
   end

data/lib/can_be/processor/instance.rb

@@ -5,20 +5,32 @@ module CanBe
         @model = model
         @config = model.class.can_be_config
         @field_name = @config.field_name
+        @details_name = @config.details_name.to_sym
+        @details_id = "#{@details_name}_id".to_sym
+        @details_type = "#{@details_name}_type".to_sym
+        set_cleaning_defaults
       end
 
       def boolean_eval(t)
-        field_value == t
+        field_value.to_s == t.to_s
       end
 
-      def update_field(t, save = false)
+      def update_field(t, options = {})
+        @original_details = @model.send(@details_name)
+        @force_history_removal = options[:force_history_removal] if options.has_key?(:force_history_removal)
+
+        save = options.has_key?(:save) ? options[:save] : false
+
         if save
-          original_details = @model.details
           @model.update_attributes(@field_name => t)
-          original_details.destroy unless original_details.class == @model.details.class
         else
           self.field_value = t
         end
+
+        if block_given?
+          yield(@model.send(@details_name))
+          @model.send(@details_name).save if save
+        end
       end
 
       def field_value=(t)
@@ -35,26 +47,109 @@ module CanBe
       end
 
       def initialize_details
-        set_details(field_value.to_sym) if has_details? && !@model.details_id
+        set_details(field_value.to_sym) if has_details? && !@model.send(@details_id)
+      end
+
+      def clean_details
+        if @original_details && @original_details.class != @model.send(@details_name).class
+          if @config.keeps_history?
+            if @force_history_removal
+              @original_details.destroy
+              destroy_history(@original_details.class.name.underscore)
+            end
+          else
+            @original_details.destroy
+          end
+        end
+
+        set_cleaning_defaults
+      end
+
+      def set_cleaning_defaults
+        @original_details = nil
+        @force_history_removal = false
+      end
+
+      def save_history
+        history_model_class.create({
+          can_be_model_id: @model.id,
+          can_be_type: field_value,
+          can_be_details_id: @model.send(@details_name).id,
+          can_be_details_type: details_class_name(field_value)
+        }) unless history_model_for(field_value)
+      end
+
+      def destroy_histories
+        histories = history_model_class.where(can_be_model_id: @model.id)
+
+        destroy_details_history(histories)
+        histories.destroy_all
+      end
+
+      def destroy_history(details_type)
+        history_model_class.where(can_be_model_id: @model.id, can_be_details_type: details_type).destroy_all
       end
 
       private
       def has_details?
-        @model.respond_to?(:details) && @model.respond_to?(:details_id) && @model.respond_to?(:details_type)
+        @model.respond_to?(@details_name) && @model.respond_to?(@details_id) && @model.respond_to?(@details_type)
       end
 
       def set_details(t)
         return unless has_details?
 
-        classname = @config.details[t.to_sym]
+        if details_class_name(t)
+          if @config.keeps_history?
+            set_history_details_for(t)
+          else
+            @model.send("#{@details_name}=", details_for(t))
+          end
+        else
+          @model.send("#{@details_id}=", nil)
+          @model.send("#{@details_type}=", nil)
+        end
+      end
+
+      def destroy_details_history(histories)
+        histories.each do |h|
+          details_record = details_class(h.can_be_type).where(id: h.can_be_details_id).first
+          details_record.destroy if details_record
+        end
+      end
+
+      def set_history_details_for(t)
+        history_model = history_model_for(t)
+
+        if history_model
+          @model.send("#{@details_name}=", details_for(t, history_model.can_be_details_id))
+        else
+          @model.send("#{@details_name}=", details_for(t))
+        end
+      end
 
-        if classname
-          @model.details = classname.to_s.camelize.constantize.new
+      def details_for(t, details_id = nil)
+        if details_id.nil?
+          details_class(t).new
         else
-          @model.details_id = nil
-          @model.details_type = nil
+          details_class(t).find(details_id)
         end
       end
+
+      def history_model_for(t)
+        history_model_class.where(can_be_model_id: @model.id, can_be_type: t).first
+      end
+
+      def details_class_name(t)
+        @config.details[t.to_sym]
+      end
+
+      def details_class(t)
+        details_class_name(t).to_s.camelize.constantize if details_class_name(t)
+      end
+
+      def history_model_class
+        @config.history_model.to_s.camelize.constantize
+      end
     end
   end
 end

data/lib/can_be/rspec/matchers.rb

@@ -0,0 +1,9 @@
+require 'can_be/rspec/matchers/can_be_detail_matcher'
+require 'can_be/rspec/matchers/can_be_matcher'
+
+module CanBe
+  module RSpec
+    module Matchers
+    end
+  end
+end

data/lib/can_be/rspec/matchers/can_be_detail_matcher.rb

@@ -0,0 +1,26 @@
+RSpec::Matchers.define :implement_can_be_detail do |can_be_type, details_name|
+  match do |actual|
+    reflections = actual.reflect_on_all_associations(:has_one)
+    details_name_to_match = details_name || CanBe::Config::DEFAULT_DETAILS_NAME
+
+    matched = false
+
+    reflections.each do |reflection|
+      as_matches = reflection.options[:as] == details_name_to_match
+
+      if reflection.name == can_be_type.to_sym && as_matches
+        matched = true
+        break
+      end
+    end
+
+    matched
+  end
+
+  failure_message_for_should do |actual|
+    failure_message = "expected that #{actual.name} would implement can_be_detail with a can_be_type of #{can_be_type.to_sym}"
+    failure_message += " and a details_name of #{details_name.to_sym}" if details_name
+    failure_message += "."
+    failure_message
+  end
+end

data/lib/can_be/rspec/matchers/can_be_matcher.rb

@@ -0,0 +1,76 @@
+RSpec::Matchers.define :implement_can_be do |*expected_types|
+  match do |actual|
+    @config = actual.can_be_config
+
+    types_match?(expected_types || []) &&
+      default_type_matches? &&
+      field_name_matches? &&
+      details_name_matches? &&
+      details_matches?
+  end
+
+  failure_message_for_should do |actual|
+    failure_message = "expected that #{actual.name} would implement can_be with the following types: #{expected_types.map(&:to_sym).join(", ")}."
+    failure_message += "  With the default type of #{@expected_default_type.to_sym}." if @expected_default_type
+    failure_message += "  With the field name of #{@expected_field_name.to_sym}." if @expected_field_name
+    failure_message += "  With the details name of #{@expected_details_name.to_sym}." if @expected_details_name
+
+    @expected_details.each do |can_be_type, model|
+      failure_message += "  With the details of can_be_type: #{can_be_type.to_sym} & model: #{model.to_sym}."
+    end if @expected_details
+
+    failure_message
+  end
+
+  chain :with_default_type do |default_type|
+    @expected_default_type = default_type
+  end
+
+  chain :with_field_name do |field_name|
+    @expected_field_name = field_name
+  end
+
+  chain :with_details_name do |details_name|
+    @expected_details_name = details_name
+  end
+
+  chain :and_has_details do |can_be_type, model|
+    @expected_details = {} unless @expected_details
+    @expected_details[can_be_type.to_sym] = model.to_sym
+  end
+
+  def types_match?(expected_types)
+    return true unless expected_types
+    config_types = @config.types || []
+    expected_types.map(&:to_s).sort == config_types.sort
+  end
+
+  def default_type_matches?
+    return true unless @expected_default_type
+    @config.default_type.to_s == @expected_default_type.to_s
+  end
+
+  def field_name_matches?
+    return true unless @expected_field_name
+    @config.field_name.to_s == @expected_field_name.to_s
+  end
+
+  def details_name_matches?
+    return true unless @expected_details_name
+    @config.details_name.to_sym == @expected_details_name.to_sym
+  end
+
+  def details_matches?
+    return true unless @expected_details
+
+    @config.details.each do |can_be_type, model|
+      return false unless @expected_details[can_be_type] == model
+    end
+
+    @expected_details.each do |can_be_type, model|
+      return false unless @config.details[can_be_type] == model
+    end
+
+    return true
+  end
+end

data/lib/can_be/version.rb

@@ -1,3 +1,3 @@
 module CanBe
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/spec/can_be/config_spec.rb

@@ -5,6 +5,12 @@ describe CanBe::Config do
     it "defines a default field name" do
       subject.field_name.should == :can_be_type
     end
+
+    it "sets the field name" do
+      field_name = :custom_field_name
+      subject.field_name field_name
+      subject.field_name.should == field_name
+    end
   end
 
   context "#types" do
@@ -22,6 +28,24 @@ describe CanBe::Config do
     it "returns the first type by default" do
       subject.default_type.should == "a"
     end
+
+    it "sets the default type" do
+      default_type = :custom_default_type
+      subject.default_type default_type
+      subject.default_type.should == default_type
+    end
+  end
+
+  context "#details_name" do
+    it "defines a default details name" do
+      subject.details_name.should == :details
+    end
+
+    it "sets the details name" do
+      details_name = :custom_details_name
+      subject.details_name details_name
+      subject.details_name.should == details_name
+    end
   end
 
   context "#parse_options" do
@@ -58,5 +82,23 @@ describe CanBe::Config do
       subject.details[:type1].should == :config_spec_model2
     end
   end
+
+  context "#keep_history_in" do
+    it "keeps the history model name" do
+      subject.keep_history_in :history_model
+      subject.history_model.should == :history_model
+    end
+  end
+
+  context "#keeps_history?" do
+    it "keeps history when history_model is specified" do
+      subject.keep_history_in :history_model
+      subject.keeps_history?.should be_true
+    end
+
+    it "doesn't keep history when history_model isn't specified" do
+      subject.keeps_history?.should be_false
+    end
+  end
 end