in_place_edit_with_datepicker 0.0.1

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

@@ -0,0 +1,20 @@
+/*
+ * BestInPlace 3.0.0.alpha (2014)
+ *
+ * Depends:
+ *	best_in_place.js
+ *	jquery.purr.js
+ */
+/*global BestInPlaceEditor */
+
+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(BestInPlaceEditor.defaults.purrErrorContainer).html(value);
+        container.purr();
+    });
+});

data/lib/assets/javascripts/best_in_place_datetime.js

@@ -0,0 +1,52 @@
+(function() {
+  var datetime;
+
+  datetime = {
+    "datetime": {
+      activateForm: function() {
+        var input_elt, options, output, overrideOptions, that, _defaults;
+        that = this;
+        _defaults = {
+          dateFormat: "yy-mm-dd",
+          timeFormat: "HH:mm:ss",
+          parse: 'loose',
+          onClose: function() {
+            return that.update();
+          }
+        };
+        overrideOptions = $(this.element[0]).data('datetimepicker-options');
+        options = $.extend({}, _defaults, overrideOptions);
+        output = jQuery(document.createElement('form')).addClass('form_in_place').attr('action', 'javascript:void(0);').attr('style', 'display:inline');
+        input_elt = jQuery(document.createElement('input')).attr('type', 'text').attr('name', this.attributeName).attr('value', this.sanitizeValue(this.display_value));
+        if (this.inner_class !== null) {
+          input_elt.addClass(this.inner_class);
+        }
+        output.append(input_elt);
+        this.element.html(output);
+        this.setHtmlAttributes();
+        this.element.find('input')[0].select();
+        this.element.find("form").bind('submit', {
+          editor: this
+        }, BestInPlaceEditor.forms.input.submitHandler);
+        this.element.find("input").bind('keyup', {
+          editor: this
+        }, BestInPlaceEditor.forms.input.keyupHandler);
+        return this.element.find('input').datetimepicker(options).datepicker('show');
+      },
+      getValue: function() {
+        return this.sanitizeValue(this.element.find("input").val());
+      },
+      submitHandler: function(event) {
+        return event.data.editor.update();
+      },
+      keyupHandler: function(event) {
+        if (event.keyCode === 27) {
+          return event.data.editor.abort();
+        }
+      }
+    }
+  };
+
+  $.extend(BestInPlaceEditor.forms, datetime);
+
+}).call(this);

data/lib/assets/javascripts/best_in_place_datetime.js.coffee

@@ -0,0 +1,56 @@
+#= require best_in_place
+#= require jquery-ui
+#= require jquery-ui-timepicker-addon
+
+datetime =
+  "datetime" :
+    activateForm: ->
+      that      = this
+
+      _defaults =
+          dateFormat: "yy-mm-dd"
+          timeFormat: "HH:mm:ss"
+          parse: 'loose'
+          onClose: ->
+            that.update()
+      overrideOptions = jQuery(this.element[0]).data('datetimepicker-options')
+      options = $.extend {}, _defaults, overrideOptions
+
+      output    = jQuery(document.createElement('form'))
+                  .addClass('form_in_place')
+                  .attr('action', 'javascript:void(0);')
+                  .attr('style', 'display:inline')
+      input_elt = jQuery(document.createElement('input'))
+                  .attr('type', 'text')
+                  .attr('name', this.attributeName)
+                  .attr('value', this.sanitizeValue(this.display_value))
+
+      if (this.inner_class != null)
+        input_elt.addClass(this.inner_class)
+
+      output.append(input_elt)
+
+      this.element.html(output)
+      this.setHtmlAttributes()
+      this.element.find('input')[0].select()
+      this.element.find("form").bind('submit', {editor: this}, BestInPlaceEditor.forms.input.submitHandler)
+      this.element.find("input").bind('keyup', {editor: this}, BestInPlaceEditor.forms.input.keyupHandler)
+
+      this.element.find('input')
+        .datetimepicker(options)
+        .datepicker('show')
+    ,
+
+    getValue: ->
+      this.sanitizeValue(this.element.find("input").val())
+    ,
+
+    submitHandler : (event)  ->
+      event.data.editor.update()
+    ,
+
+    keyupHandler : (event) ->
+      if (event.keyCode == 27)
+        event.data.editor.abort()
+
+$.extend BestInPlaceEditor.forms, datetime

data/lib/best_in_place.rb

@@ -0,0 +1,33 @@
+require 'rails/railtie'
+require 'action_view/railtie'
+require 'action_controller/railtie'
+
+module BestInPlace
+  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, :skip_blur
+
+    def initialize
+      @container = :span
+      @skip_blur = false
+    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

@@ -0,0 +1,25 @@
+module BestInPlace
+  module ControllerExtensions
+    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, options = {})
+      param_key = options[:param] ||= BestInPlace::Utils.object_to_key(obj)
+
+      updating_attr = params[param_key].keys.first
+
+      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
+    end
+  end
+end

data/lib/best_in_place/display_methods.rb

@@ -0,0 +1,49 @@
+module BestInPlace
+  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
+            '{}'
+        end
+      end
+    end
+
+    @@table = Hash.new { |h, k| h[k] = Hash.new(&h.default_proc) }
+
+    def lookup(klass, attr)
+      foo = model_attributes(klass)[attr.to_s]
+      foo == {} ? nil : foo
+    end
+
+    def add_model_method(klass, attr, display_as)
+      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)
+      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)
+      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

@@ -0,0 +1,8 @@
+module BestInPlace
+  class Engine < Rails::Engine
+    initializer 'best_in_place' do
+      ActionView::Base.send(:include, BestInPlace::Helper)
+      ActionController::Base.send(:include, BestInPlace::ControllerExtensions)
+    end
+  end
+end

data/lib/best_in_place/helper.rb

@@ -0,0 +1,204 @@
+module BestInPlace
+  module Helper
+    def best_in_place(object, field, opts = {})
+
+      best_in_place_assert_arguments(opts)
+      type = opts[:as] || :input
+      field = field.to_s
+
+      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]
+        value = value.to_s
+        collection = best_in_place_default_collection if collection.blank?
+        collection = best_in_place_collection_builder(type, collection)
+        display_value = collection.flat_map{|a| a[0].to_s == value ? a[1] : nil }.compact[0]
+        collection = collection.to_json
+        options[:data]['bip-collection'] = html_escape(collection)
+      end
+
+      options[:class] = ['best_in_place'] + Array(opts[:class] || opts[:classes])
+      options[:id] = opts[:id] || BestInPlace::Utils.build_best_in_place_id(real_object, field)
+
+      pass_through_html_options(opts, options)
+
+      options[:data]['bip-activator'] = opts[:activator].presence
+
+      options[:data]['bip-html-attrs'] = opts[:html_attrs].to_json unless opts[:html_attrs].blank?
+      options[:data]['bip-inner-class'] = opts[:inner_class].presence
+
+      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-skip-blur'] = opts.has_key?(:skip_blur) ? opts[:skip_blur].presence : BestInPlace.skip_blur
+
+      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
+
+      # 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 = {})
+      if condition
+        best_in_place(object, field, opts)
+      else
+        best_in_place_build_value_for best_in_place_real_object_for(object), field, opts
+      end
+    end
+
+    def best_in_place_unless(condition, object, field, opts = {})
+      best_in_place_if(!condition, object, field, opts)
+    end
+
+    private
+
+    def pass_through_html_options(opts, options)
+      known_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]
+      uknown_keys = opts.keys - known_keys
+      uknown_keys.each { |key| options[key] = opts[key] }
+    end
+
+    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
+
+      elsif opts[:display_with].try(:is_a?, Proc)
+        BestInPlace::DisplayMethods.add_helper_proc(klass, field, opts[:display_with])
+        opts[:display_with].call(object.send(field))
+
+      elsif opts[:display_with]
+        BestInPlace::DisplayMethods.add_helper_method(klass, field, opts[:display_with], opts[:helper_options])
+        if opts[:helper_options]
+          BestInPlace::ViewHelpers.send(opts[:display_with], object.send(field), opts[:helper_options])
+        else
+          field_value = object.send(field)
+
+          if field_value.blank?
+            ''
+          else
+            BestInPlace::ViewHelpers.send(opts[:display_with], field_value)
+          end
+        end
+
+      else
+        object.send(field).to_s
+      end
+    end
+
+    def best_in_place_real_object_for(object)
+      (object.is_a?(Array) && object.last.class.respond_to?(:model_name)) ? object.last : object
+    end
+
+    def best_in_place_assert_arguments(args)
+      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 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(type, collection)
+      collection = case collection
+        when Array
+          if type == :checkbox
+            if collection.length == 2
+              [['false', collection[0]], ['true', collection[1]]]
+            else
+              fail ArgumentError, '[Best_in_place] :collection array should have 2 values'
+            end
+          else # :select
+            case collection[0]
+              when Array
+                collection
+              else
+                if collection[0].length == 2
+                  collection.to_a
+                else
+                  collection.each_with_index.map{|a,i| [i+1,a]}
+                end
+            end
+          end
+        else
+          collection.to_a
+      end
+      collection
+    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