best_in_place 2.1.0 → 3.0.0.rc1

data/lib/assets/javascripts/best_in_place.purr.js

@@ -1,10 +1,20 @@
-//= require jquery.purr
+/*
+ * BestInPlace 3.0.0.alpha (2014)
+ *
+ * Depends:
+ *	best_in_place.js
+ *	jquery.purr.js
+ */
+/*global BestInPlaceEditor */
 
-jQuery(document).on('best_in_place:error', function(event, request, error) {
+BestInPlaceEditor.defaults.purrErrorContainer =  "<span class='bip-flash-error'></span>";
+
+jQuery(document).on('best_in_place:error', function (event, request, error) {
+    'use strict';
     // Display all error messages from server side validation
-    jQuery.each(jQuery.parseJSON(request.responseText), function(index, value) {
-      if( typeof(value) == "object") {value = index + " " + value.toString(); }
-      var container = jQuery("<span class='flash-error'></span>").html(value);
-      container.purr();
+    jQuery.each(jQuery.parseJSON(request.responseText), function (index, value) {
+        if (typeof value === "object") {value = index + " " + value.toString(); }
+        var container = jQuery(BestInPlaceEditor.defaults.purrErrorContainer).html(value);
+        container.purr();
     });
 });

data/lib/best_in_place.rb

@@ -1,12 +1,32 @@
-require "best_in_place/check_version"
-require "best_in_place/utils"
-require "best_in_place/helper"
-require "best_in_place/engine"
-require "best_in_place/railtie"
-require "best_in_place/controller_extensions"
-require "best_in_place/display_methods"
-require "action_view"
+require 'rails/railtie'
+require 'action_view/railtie'
+require 'action_controller/railtie'
 
 module BestInPlace
-  autoload :TestHelpers, "best_in_place/test_helpers"
+  def self.configure
+    @configuration ||= Configuration.new
+    yield @configuration if block_given?
+  end
+
+  def self.method_missing(method_name, *args, &block)
+    @configuration.respond_to?(method_name) ?
+        @configuration.send(method_name, *args, &block) : super
+  end
+
+  class Configuration
+    attr_accessor :container
+
+    def initialize
+      @container = :span
+    end
+  end
+
+  configure
 end
+
+require 'best_in_place/engine'
+require 'best_in_place/utils'
+require 'best_in_place/helper'
+require 'best_in_place/railtie'
+require 'best_in_place/controller_extensions'
+require 'best_in_place/display_methods'

data/lib/best_in_place/controller_extensions.rb

@@ -1,28 +1,25 @@
 module BestInPlace
   module ControllerExtensions
-    def respond_with_bip(obj)
-      obj.changed? ? respond_bip_error(obj) : respond_bip_ok(obj)
+    def respond_with_bip(obj, options = {})
+      obj.errors.any? ? respond_bip_error(obj) : respond_bip_ok(obj, options)
     end
 
-  private
-    def respond_bip_ok(obj)
-      if obj.respond_to?(:id)
-        klass = "#{obj.class}_#{obj.id}"
-      else
-        klass = obj.class.to_s
-      end
-      param_key = BestInPlace::Utils.object_to_key(obj)
+    private
+
+    def respond_bip_ok(obj, options = {})
+      param_key = options[:param] ||= BestInPlace::Utils.object_to_key(obj)
+
       updating_attr = params[param_key].keys.first
 
-      if renderer = BestInPlace::DisplayMethods.lookup(klass, updating_attr)
-        render :json => renderer.render_json(obj)
+      if renderer = BestInPlace::DisplayMethods.lookup(obj.class, updating_attr)
+        render json: renderer.render_json(obj)
       else
         head :no_content
       end
     end
 
     def respond_bip_error(obj)
-      render :json => obj.errors.full_messages, :status => :unprocessable_entity
+      render json: obj.errors.full_messages, status: :unprocessable_entity
     end
   end
 end

data/lib/best_in_place/display_methods.rb

@@ -1,44 +1,49 @@
 module BestInPlace
-  module DisplayMethods
-    extend self
+  module DisplayMethods  #:nodoc:
+    module_function
 
     class Renderer < Struct.new(:opts)
       def render_json(object)
         case opts[:type]
-        when :model
-          {:display_as => object.send(opts[:method])}.to_json
-        when :helper
-          value = if opts[:helper_options]
-                    BestInPlace::ViewHelpers.send(opts[:method], object.send(opts[:attr]), opts[:helper_options])
-                  else
-                    BestInPlace::ViewHelpers.send(opts[:method], object.send(opts[:attr]))
-                  end
-          {:display_as => value}.to_json
-        when :proc
-          {:display_as => opts[:proc].call(object.send(opts[:attr]))}.to_json
-        else
-          {}.to_json
+          when :model
+            { display_as: object.send(opts[:method]) }.to_json
+          when :helper
+            value = if opts[:helper_options]
+                      BestInPlace::ViewHelpers.send(opts[:method], object.send(opts[:attr]), opts[:helper_options])
+                    else
+                      BestInPlace::ViewHelpers.send(opts[:method], object.send(opts[:attr]))
+                    end
+            { display_as: value }.to_json
+          when :proc
+            { display_as: opts[:proc].call(object.send(opts[:attr])) }.to_json
+          else
+            '{}'
         end
       end
     end
 
-    @@table = Hash.new { |h,k| h[k] = Hash.new(&h.default_proc) }
+    @@table = Hash.new { |h, k| h[k] = Hash.new(&h.default_proc) }
 
     def lookup(klass, attr)
-      foo = @@table[klass.to_s][attr.to_s]
+      foo = model_attributes(klass)[attr.to_s]
       foo == {} ? nil : foo
     end
 
     def add_model_method(klass, attr, display_as)
-      @@table[klass.to_s][attr.to_s] = Renderer.new :method => display_as.to_sym, :type => :model
+      model_attributes(klass)[attr.to_s] = Renderer.new method: display_as.to_sym, type: :model
     end
 
     def add_helper_method(klass, attr, helper_method, helper_options = nil)
-      @@table[klass.to_s][attr.to_s] = Renderer.new :method => helper_method.to_sym, :type => :helper, :attr => attr, :helper_options => helper_options
+      model_attributes(klass)[attr.to_s] = Renderer.new method: helper_method.to_sym, type: :helper, attr: attr, helper_options: helper_options
     end
-    
+
     def add_helper_proc(klass, attr, helper_proc)
-      @@table[klass.to_s][attr.to_s] = Renderer.new :type => :proc, :attr => attr, :proc => helper_proc
+      model_attributes(klass)[attr.to_s] = Renderer.new type: :proc, attr: attr, proc: helper_proc
+    end
+
+    def model_attributes(klass)
+      key = Utils.object_to_key(klass)
+      @@table[key]
     end
   end
 end

data/lib/best_in_place/engine.rb

@@ -1,7 +1,7 @@
 module BestInPlace
   class Engine < Rails::Engine
-    initializer "setup for rails" do
-      ActionView::Base.send(:include, BestInPlace::BestInPlaceHelpers)
+    initializer 'best_in_place' do
+      ActionView::Base.send(:include, BestInPlace::Helper)
       ActionController::Base.send(:include, BestInPlace::ControllerExtensions)
     end
   end

data/lib/best_in_place/helper.rb

@@ -1,99 +1,90 @@
 module BestInPlace
-  module BestInPlaceHelpers
-
+  module Helper
     def best_in_place(object, field, opts = {})
-      if opts[:display_as] && opts[:display_with]
-        raise ArgumentError, "Can't use both 'display_as' and 'display_with' options at the same time"
-      end
+      best_in_place_assert_arguments(opts)
+      type = opts[:as] || :input
+      field = field.to_s
 
-      if opts[:display_with] && !opts[:display_with].is_a?(Proc) && !ViewHelpers.respond_to?(opts[:display_with])
-        raise ArgumentError, "Can't find helper #{opts[:display_with]}"
+      options = {}
+      options[:data] = HashWithIndifferentAccess.new(opts[:data])
+      options[:data]['bip-type'] = type
+      options[:data]['bip-attribute'] = field
+
+      real_object = best_in_place_real_object_for object
+
+      display_value = best_in_place_build_value_for(real_object, field, opts)
+
+      value = real_object.send(field)
+
+      if opts[:collection] or type == :checkbox
+        collection = opts[:collection]
+        case type
+          when :checkbox
+            value = value.to_s
+            if collection.blank?
+              collection = best_in_place_default_collection
+            else
+              collection = best_in_place_collection_builder(collection)
+            end
+            display_value = collection[value]
+            collection = collection.to_json
+          else # :select
+            value = value.to_s
+            collection = best_in_place_collection_builder(collection)
+            display_value = collection[value]
+            collection = collection.to_json
+        end
+        options[:data]['bip-collection'] = html_escape(collection)
       end
 
-      real_object = real_object_for object
-      opts[:type] ||= :input
-      opts[:collection] ||= []
-      field = field.to_s
+      options[:class] = ['best_in_place'] + Array(opts[:class] || opts[:classes])
+      options[:id] = opts[:id] || BestInPlace::Utils.build_best_in_place_id(real_object, field)
 
-      display_value = build_value_for(real_object, field, opts)
+      options[:data]['bip-activator'] = opts[:activator].presence
 
-      collection = nil
-      value = nil
-      if opts[:type] == :select && !opts[:collection].blank?
-        value = real_object.send(field)
-        display_value = Hash[opts[:collection]].stringify_keys[value.to_s]
-        collection = opts[:collection].to_json
-      end
-      if opts[:type] == :checkbox
-        value = !!real_object.send(field)
-        if opts[:collection].blank? || opts[:collection].size != 2
-          opts[:collection] = ["No", "Yes"]
-        end
-        display_value = value ? opts[:collection][1] : opts[:collection][0]
-        collection = opts[:collection].to_json
-      end
-      classes = ["best_in_place"]
-      unless opts[:classes].nil?
-        # the next three lines enable this opt to handle both a stings and a arrays
-        classes << opts[:classes]
-        classes.flatten!
-      end
+      options[:data]['bip-html-attrs'] = opts[:html_attrs].to_json unless opts[:html_attrs].blank?
+      options[:data]['bip-inner-class'] = opts[:inner_class].presence
 
-      out = "<span class='#{classes.join(" ")}'"
-      out << " id='#{BestInPlace::Utils.build_best_in_place_id(real_object, field)}'"
-      out << " data-url='#{opts[:path].blank? ? url_for(object) : url_for(opts[:path])}'"
-      out << " data-object='#{opts[:object_name] || BestInPlace::Utils.object_to_key(real_object)}'"
-      out << " data-collection='#{attribute_escape(collection)}'" unless collection.blank?
-      out << " data-attribute='#{field}'"
-      out << " data-activator='#{opts[:activator]}'" unless opts[:activator].blank?
-      out << " data-ok-button='#{opts[:ok_button]}'" unless opts[:ok_button].blank?
-      out << " data-ok-button-class='#{opts[:ok_button_class]}'" unless opts[:ok_button_class].blank?
-      out << " data-cancel-button='#{opts[:cancel_button]}'" unless opts[:cancel_button].blank?
-      out << " data-cancel-button-class='#{opts[:cancel_button_class]}'" unless opts[:cancel_button_class].blank?
-      out << " data-nil='#{attribute_escape(opts[:nil])}'" unless opts[:nil].blank?
-      out << " data-use-confirm='#{opts[:use_confirm]}'" unless opts[:use_confirm].nil?
-      out << " data-type='#{opts[:type]}'"
-      out << " data-inner-class='#{opts[:inner_class]}'" if opts[:inner_class]
-      out << " data-html-attrs='#{opts[:html_attrs].to_json}'" unless opts[:html_attrs].blank?
-      out << " data-original-content='#{attribute_escape(real_object.send(field))}'" if opts[:display_as] || opts[:display_with]
-      out << " data-value='#{attribute_escape(value)}'" if value
-
-      if opts[:data] && opts[:data].is_a?(Hash)
-        opts[:data].each do |k, v|
-          if !v.is_a?(String) && !v.is_a?(Symbol)
-            v = v.to_json
-          end
-          out << %( data-#{k.to_s.dasherize}="#{v}")
-        end
-      end
-      if !opts[:sanitize].nil? && !opts[:sanitize]
-        out << " data-sanitize='false'>"
-        out << display_value.to_s
-      else
-        out << ">#{h(display_value.to_s)}"
+      options[:data]['bip-placeholder'] = html_escape(opts[:place_holder]).presence
+
+      options[:data]['bip-object'] = opts[:param] || BestInPlace::Utils.object_to_key(real_object)
+      options[:data]['bip-ok-button'] = opts[:ok_button].presence
+      options[:data]['bip-ok-button-class'] = opts[:ok_button_class].presence
+      options[:data]['bip-cancel-button'] = opts[:cancel_button].presence
+      options[:data]['bip-cancel-button-class'] = opts[:cancel_button_class].presence
+      options[:data]['bip-original-content'] = html_escape(opts[:value] || value).presence
+
+      options[:data]['bip-url'] = url_for(opts[:url] || object)
+
+      options[:data]['bip-confirm'] = opts[:confirm].presence
+      options[:data]['bip-value'] = html_escape(value).presence
+
+      if opts[:raw]
+        options[:data]['bip-raw'] = 'true'
       end
-      out << "</span>"
-      raw out
+
+      # delete nil keys only
+      options[:data].delete_if { |_, v| v.nil? }
+      container = opts[:container] || BestInPlace.container
+      content_tag(container, display_value, options, opts[:raw].blank?)
     end
 
-    def best_in_place_if(condition, object, field, opts={})
+    def best_in_place_if(condition, object, field, opts = {})
       if condition
         best_in_place(object, field, opts)
       else
-        build_value_for real_object_for(object), field, opts
+        best_in_place_build_value_for best_in_place_real_object_for(object), field, opts
       end
     end
 
-  private
-    def build_value_for(object, field, opts)
-      return "" if object.send(field).blank?
+    def best_in_place_unless(condition, object, field, opts = {})
+      best_in_place_if(!condition, object, field, opts)
+    end
 
-      klass = if object.respond_to?(:id)
-        "#{object.class}_#{object.id}"
-      else
-        object.class.to_s
-      end
+    private
 
+    def best_in_place_build_value_for(object, field, opts)
+      klass = object.class
       if opts[:display_as]
         BestInPlace::DisplayMethods.add_model_method(klass, field, opts[:display_as])
         object.send(opts[:display_as]).to_s
@@ -107,7 +98,15 @@ module BestInPlace
         if opts[:helper_options]
           BestInPlace::ViewHelpers.send(opts[:display_with], object.send(field), opts[:helper_options])
         else
-          BestInPlace::ViewHelpers.send(opts[:display_with], object.send(field))
+          field_value = object.send(field)
+
+          if field_value.blank?
+            ''
+          else
+
+
+            BestInPlace::ViewHelpers.send(opts[:display_with], field_value)
+          end
         end
 
       else
@@ -115,18 +114,77 @@ module BestInPlace
       end
     end
 
-    def attribute_escape(data)
-      return unless data
+    def best_in_place_real_object_for(object)
+      (object.is_a?(Array) && object.last.class.respond_to?(:model_name)) ? object.last : object
+    end
 
-      data.to_s.
-        gsub("&", "&amp;").
-        gsub("'", "&apos;").
-        gsub(/\r?\n/, "&#10;")
+    def best_in_place_assert_arguments(args)
+      args.assert_valid_keys(:id, :type, :nil, :classes, :collection, :data,
+                             :activator, :cancel_button, :cancel_button_class, :html_attrs, :inner_class, :nil,
+                             :object_name, :ok_button, :ok_button_class, :display_as, :display_with, :path, :value,
+                             :use_confirm, :confirm, :sanitize, :raw, :helper_options, :url, :place_holder, :class,
+                             :as, :param, :container)
+
+      best_in_place_deprecated_options(args)
+
+      if args[:display_as] && args[:display_with]
+        fail ArgumentError, 'Can`t use both `display_as`` and `display_with` options at the same time'
+      end
+
+      if args[:display_with] && !args[:display_with].is_a?(Proc) && !ViewHelpers.respond_to?(args[:display_with])
+        fail ArgumentError, "Can't find helper #{args[:display_with]}"
+      end
     end
 
-    def real_object_for(object)
-      (object.is_a?(Array) && object.last.class.respond_to?(:model_name)) ? object.last : object
+    def best_in_place_deprecated_options(args)
+      if deprecated_option = args.delete(:path)
+        args[:url] = deprecated_option
+        ActiveSupport::Deprecation.warn('[Best_in_place] :path is deprecated in favor of :url ')
+      end
+
+      if deprecated_option = args.delete(:object_name)
+        args[:param] = deprecated_option
+        ActiveSupport::Deprecation.warn('[Best_in_place] :object_name is deprecated in favor of :param ')
+      end
+
+      if deprecated_option = args.delete(:type)
+        args[:as] = deprecated_option
+        ActiveSupport::Deprecation.warn('[Best_in_place] :type is deprecated in favor of :as ')
+      end
+
+      if deprecated_option = args.delete(:classes)
+        args[:class] = deprecated_option
+        ActiveSupport::Deprecation.warn('[Best_in_place] :classes is deprecated in favor of :class ')
+      end
+
+      if deprecated_option = args.delete(:nil)
+        args[:place_holder] = deprecated_option
+        ActiveSupport::Deprecation.warn('[Best_in_place] :nil is deprecated in favor of :place_holder ')
+      end
+
+      if deprecated_option = args.delete(:use_confirm)
+        args[:confirm] = deprecated_option
+        ActiveSupport::Deprecation.warn('[Best_in_place] :use_confirm is deprecated in favor of :confirm ')
+      end
+
+      if deprecated_option = args.delete(:sanitize)
+        args[:raw] = !deprecated_option
+        ActiveSupport::Deprecation.warn('[Best_in_place] :sanitize is deprecated in favor of :raw ')
+      end
+    end
+
+    def best_in_place_collection_builder(collection)
+      case collection
+        when Array
+          Hash[collection.map { |x| [x.to_s, x.to_s] }]
+        else
+          collection.stringify_keys
+      end
+    end
+
+    def best_in_place_default_collection
+      {'true' => t(:'best_in_place.yes', default: 'Yes'),
+       'false' => t(:'best_in_place.no', default: 'No')}
     end
   end
 end
-