worth_saving 0.0.9

data/lib/worth_saving/form/base.rb

@@ -0,0 +1,21 @@
+module WorthSaving
+  module Form
+    class Base
+      include WorthSaving::Form::Rendering
+      include WorthSaving::Form::Record
+
+      def initialize(template, record, options, &proc)
+        @template = template
+        @record = record
+        @proc = proc
+        @interval = options.delete(:save_interval) || WorthSaving::Engine.config.default_save_interval
+        @options = options.merge builder: WorthSaving::FormBuilder
+      end
+
+      def render
+        options[:worth_saving_recovery] = recovery?
+        render_form
+      end
+    end
+  end
+end

data/lib/worth_saving/form/record.rb

@@ -0,0 +1,53 @@
+module WorthSaving
+  module Form
+    module Record
+      def self.included(base)
+        base.send :include, InstanceMethods
+      end
+
+      module InstanceMethods
+        private
+
+        def record
+          @record
+        end
+
+        def draft
+          @draft ||= object.worth_saving_draft
+        end
+
+        def options
+          @options
+        end
+
+        def object
+          @object ||= record.is_a?(Array) ? record.last : record
+        end
+
+        def recovery?
+          return @recovery if @recovery == true || @recovery == false
+          if draft.nil?
+            return @recovery = false
+          elsif draft.reconstituted_record.attributes == object.attributes
+            draft.destroy
+            return @recovery = false
+          end
+          @recovery = true
+        end
+
+        def rescued_object
+          @rescued_object ||= draft && draft.reconstituted_record
+        end
+
+        def rescued_record
+          if record.is_a? Array
+            rescued_record = record.dup
+            rescued_record.last = rescued_object
+          else
+            rescued_record = rescued_object
+          end
+        end
+      end
+    end
+  end
+end

data/lib/worth_saving/form/rendering.rb

@@ -0,0 +1,100 @@
+module WorthSaving
+  module Form
+    module Rendering
+      def self.included(base)
+        base.send :include, InstanceMethods
+      end
+
+      module InstanceMethods
+        def render_form
+          recovery? ? recovery_forms : standard_form
+        end
+
+        private
+
+        def recovery_forms
+          form_container 'recovery', recovery_header, main_form_container, recovery_form_container
+        end
+
+        def standard_form
+          form_container 'standard', main_form_container, draft_status_footer, draft_form_container
+        end
+
+        def form_container(type, *elements)
+          content = elements.join("\n").html_safe
+          @template.content_tag :div, content, class: "worth-saving-#{type}-form-container"
+        end
+
+        def main_form_container
+          @template.content_tag :div, main_form, form_container_attributes('saved')
+        end
+
+        def recovery_form_container
+          @template.content_tag :div, recovery_form, form_container_attributes('recovered')
+        end
+
+        def draft_form_container
+          @template.content_tag :div, draft_form, style: 'display: none'
+        end
+
+        def draft_form
+          draft_object = draft || object.build_worth_saving_draft
+          @template.form_for(draft_object, draft_form_options) do |f|
+            WorthSaving::Form::WORTH_SAVING_DRAFT_FORM_BLOCK.call f
+          end
+        end
+
+        def draft_form_options
+          url = @template.worth_saving.drafts_path
+          { url: url, html: { data: { worth_saving_draft_form_id: form_id } } }
+        end
+
+        def main_form
+          @template.form_for record, main_form_options, &@proc
+        end
+
+        def main_form_options
+          return options if recovery?
+          user_data = options.delete(:data) || {}
+          options.deep_merge(
+            html: {
+              data: user_data.merge(
+                worth_saving_form_id: form_id,
+                worth_saving_interval: @interval,
+              )
+            }
+          )
+        end
+
+        def recovery_form
+          @template.form_for rescued_record, options.merge(namespace: 'recovered'), &@proc
+        end
+
+        def form_container_attributes(form_type)
+          {
+            id: "worth-saving-#{form_type}-form-container-#{form_id}",
+            class: "worth-saving-form-container"
+          }
+        end
+
+        def recovery_header
+          @template.content_tag(:div, recovery_message, class: 'worth-saving-header-message')
+        end
+
+        def recovery_message
+          options.delete(:recovery_message) || WorthSaving::Engine.config.default_recovery_message
+        end
+
+        def draft_status_footer
+          @template.content_tag(:div, '',
+            class: 'worth-saving-form-message', id: "worth-saving-form-message-#{form_id}"
+          )
+        end
+
+        def form_id
+          @form_id ||= WorthSaving::FormBuilder.next_form_id
+        end
+      end
+    end
+  end
+end

data/lib/worth_saving/form_builder.rb

@@ -0,0 +1,57 @@
+module WorthSaving
+  class FormBuilder < ActionView::Base.default_form_builder
+    def text_field(method, options = {})
+      process_options! method, options
+      super
+    end
+
+    def radio_button(method, tag_value, options = {})
+      process_options! method, options
+      super
+    end
+
+    def check_box(method, options = {}, checked_value = "1", unchecked_value = "0")
+      process_options! method, options
+      super
+    end
+
+    def text_area(method, options = {})
+      process_options! method, options
+      super
+    end
+
+    def select(method, choices, options = {}, html_options = {})
+      process_options! method, html_options
+      super
+    end
+
+    def hidden_field(method, options = {})
+      process_options! method, options
+      super
+    end
+
+    def fields_for(record_name, options = {}, &bloc)
+      options[:builder] = options[:builder].superclass unless object.worth_saving? record_name
+      super
+    end
+
+    def submit(value = nil, options = {})
+      value = 'Choose this copy' if self.options[:worth_saving_recovery]
+      super
+    end
+
+    def self.next_form_id
+      @@worth_saving_form_id ||= 0
+      @@worth_saving_form_id += 1
+    end
+
+    private
+
+    def process_options!(method, options)
+      if object.worth_saving? method
+        options[:data] ||= options.delete('data') || {}
+        options[:data].reverse_merge! worth_saving: true
+      end
+    end
+  end
+end

data/lib/worth_saving/info.rb

@@ -0,0 +1,102 @@
+module WorthSaving
+  class Info
+    attr_reader :scope
+
+    def initialize(klass, opts)
+      register_class klass
+      set_up_options opts
+    end
+
+    def self.class_with_name(name)
+      classes.find{ |klass| klass.name == name.camelcase }
+    end
+
+    def self.attribute_whitelisting_required?
+      puts "Rails version: #{Rails.version}"
+      puts "Defined?(ProtectedAttributes): #{defined?(ProtectedAttributes) == 'constant'}"
+      result = Rails.version.match(/^3/).present? || defined?(ProtectedAttributes) == 'constant'
+      puts "Returning: #{result}"
+      result
+    end
+
+    def saves_field?(field)
+      !@excluded_fields.include? field
+    end
+
+    private
+
+    def self.classes
+      @@classes ||= []
+    end
+
+    def register_class(klass)
+      @klass = klass
+      self.class.classes << klass
+    end
+
+    def set_up_options(opts)
+      opts.reverse_merge! except: nil, scope: nil
+      @excluded_fields = [opts[:except]].flatten.compact
+      @excluded_fields.concat Rails.application.config.filter_parameters
+      set_up_scoped_draft opts[:scope]
+    end
+
+    def set_up_scoped_draft(scope)
+      unless @scope = scope
+        @klass.class_eval do
+          def worth_saving_draft
+            return super if persisted?
+            @worth_saving_draft ||= WorthSaving::Draft.where(recordable_id: nil, recordable_type: self.class.name).first
+          end
+        end
+        return
+      end
+      @scope_class = scope.to_s.camelcase.constantize
+
+      @klass.class_eval do
+        def build_worth_saving_draft(opts = {})
+          return super if persisted?
+          self.class.worth_saving_info.build_worth_saving_draft_by_scopeable self, opts
+        end
+
+        def worth_saving_draft
+          return super if persisted?
+          self.class.worth_saving_info.draft_by_scopeable self
+        end
+      end
+
+      class_eval do
+        def build_worth_saving_draft_by_scopeable(recordable, opts)
+          opts.merge! recordable_type: @klass.name, scopeable: scopeable(recordable)
+          WorthSaving::Draft.new opts
+        end
+
+        def draft_by_scopeable(recordable)
+          WorthSaving::Draft.where(
+            scopeable_id: scopeable_id(recordable),
+            scopeable_type: scope_class,
+            recordable_type: recordable.class.name
+          ).first
+        end
+
+        private
+
+        def scope_class
+          @scope_class
+        end
+
+        def scopeable_id(recordable)
+          recordable.send scopeable_foreign_key
+        end
+
+        def scopeable(recordable)
+          scope_class.find_by_id scopeable_id recordable
+        end
+
+        def scopeable_foreign_key
+          @scopeable_foreign_key ||= "#{@scope}_id"
+        end
+      end
+    end
+  end
+end

data/lib/worth_saving/version.rb

@@ -0,0 +1,3 @@
+module WorthSaving
+  VERSION = "0.0.9"
+end

data/spec/app/controllers/drafts_controller_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe WorthSaving::DraftsController do
+  describe '#update' do
+    pending '' do
+      # raise Dummy::Application.inspect
+    end
+  end
+
+  describe '#create' do
+    pending
+  end
+end

data/spec/app/models/worth_saving/draft_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+describe WorthSaving::Draft do
+  with_model :Record do
+    table do |t|
+      t.string    :name
+      t.integer   :age
+    end
+
+    model do
+      if Rails.version.match /^3/
+        attr_accessible :name, :age
+      end
+    end
+  end
+
+  before do
+    class WorthSaving::Info; end
+  end
+
+  subject { WorthSaving::Draft.table_name }
+
+  it { should eq 'worth_saving_drafts' }
+
+  describe 'associations' do
+    describe ':recordable' do
+      subject { WorthSaving::Draft.reflect_on_association :recordable }
+
+      its(:macro) { should eq :belongs_to }
+      its(:options) { should include :polymorphic }
+    end
+
+    describe ':scopeable' do
+      subject { WorthSaving::Draft.reflect_on_association :scopeable }
+
+      its(:macro) { should eq :belongs_to }
+      its(:options) { should include :polymorphic }
+    end
+  end
+
+  describe 'validations' do
+    let(:record_class_worth_saving_info) { double Object }
+
+    context 'unscoped recordable class' do
+      context 'missing recordable_type' do
+        let(:draft) { stub_model WorthSaving::Draft }
+
+        it 'expects recordable_type' do
+          draft.should_not be_valid
+          draft.errors[:recordable_type].should eq ["can't be blank"]
+        end
+      end
+
+      context 'valid draft' do
+        before do
+          WorthSaving::Info.should_receive(:class_with_name).with('Record').and_return Record
+          record_class_worth_saving_info.should_receive(:scope).and_return nil
+          Record.should_receive(:worth_saving_info).and_return record_class_worth_saving_info
+        end
+
+        subject { stub_model WorthSaving::Draft, recordable_type: 'Record' }
+        it { should be_valid }
+      end
+    end
+
+    context 'scoped recordable class' do
+      subject { draft }
+      let(:draft) { stub_model WorthSaving::Draft, recordable_type: 'Record' }
+
+      before do
+        WorthSaving::Info.should_receive(:class_with_name).with('Record').and_return Record
+        record_class_worth_saving_info.stub(:scope).and_return :user
+        Record.stub(:worth_saving_info).and_return record_class_worth_saving_info
+      end
+
+      context 'valid draft' do
+        before do
+          draft.stub(:scopeable).and_return double(Object)
+        end
+
+        it { should be_valid }
+      end
+
+      context 'missing scopeable' do
+        before do
+          draft.stub(:scopeable).and_return nil
+          draft.valid?
+        end
+
+        it { should_not be_valid }
+        its('errors.full_messages') { should eq ["Cannot save draft for new record without scopeable record.\nBe sure to build draft from Record with a non-nil user.\n"] }
+      end
+    end
+  end # validation
+
+  describe 'attr_accessible' do
+    subject { WorthSaving::Draft.attr_accessible[:default].to_a.reject(&:empty?) }
+
+    context 'whitelisting attributes is not required' do
+      before do
+        WorthSaving.send :remove_const, :Draft
+        WorthSaving::Info.should_receive(:attribute_whitelisting_required?).and_return false
+        load WorthSaving::Engine.root + 'app/models/worth_saving/draft.rb'
+      end
+
+      it { should be_empty }
+    end
+
+    context 'whitelisting attributes is required' do
+      before do
+        WorthSaving.send :remove_const, :Draft
+        WorthSaving::Info.should_receive(:attribute_whitelisting_required?).and_return true
+        load WorthSaving::Engine.root + 'app/models/worth_saving/draft.rb'
+      end
+
+      it { should include 'scopeable' }
+      it { should include 'recordable_id' }
+      it { should include 'recordable_type' }
+      it { should include 'scopeable_id' }
+      it { should include 'scopeable_type' }
+      it { should include 'form_data' }
+    end
+  end
+
+  describe '#reconstituted_record' do
+    subject { draft.reconstituted_record }
+
+    context 'recordable_type is missing' do
+      let(:draft) { stub_model WorthSaving::Draft, recordable_type: 'Record' }
+
+      before do
+        WorthSaving::Info.should_receive(:class_with_name).with('Record').and_return nil
+      end
+
+      it { should be_nil }
+    end
+
+    context 'recordable_type is present and name of a class' do
+      let(:draft) { stub_model WorthSaving::Draft, recordable_id: record.id, recordable_type: 'Record', form_data: form_data }
+      let(:record) { Record.create name: 'John Smith', age: nil }
+      let(:form_data) { 'record%5Bname%5D=John%20N%20Smith&record%5Bage%5D=42' }
+
+      before do
+        WorthSaving::Info.should_receive(:class_with_name).with('Record').and_return Record
+      end
+
+      its(:id) { should eq record.id }
+      its(:name) { should eq 'John N Smith' }
+      its(:age) { should eq 42 }
+    end
+  end
+
+  after :all do
+    load WorthSaving::Engine.root + 'app/models/worth_saving/draft.rb'
+  end
+end