goldencobra 1.1.0 → 1.2.0

data/README.markdown

@@ -48,6 +48,18 @@ rails generate goldencobra:install
 rake db:migrate db:test:prepare
 ```
 
+#If you want to use goldencobra in a subdirectory (http://www.domain.de/subdir/), please modify your config/routes.rb
+#and setup your domains in "Settings > Domains" in the backendinterface
+```ruby
+Goldencobra::Domain.pluck(:url_prefix).each do |url_prefix|
+    scope url_prefix do
+        ActiveAdmin.routes(self)
+        devise_for :users, ActiveAdmin::Devise.config
+        mount Goldencobra::Engine => "/"
+    end
+end
+```
+
 #Setup Goldencobra
 
 If you want to use Batch Actions in Goldencobra (set a batch of articles offline), you need to uncomment the line `# config.batch_actions = true` in config/initializers/active_admin.rb
@@ -131,7 +143,6 @@ navigation_menu(menue_id, option={})
 # default = 0
 ```
 
-
 **example:**
 
 ```ruby
@@ -149,6 +160,35 @@ navigation_menu(menue_id, option={})
 # renders menue starting with first Menuitem including title 'MainNavigation' and all children as a nested list
 ```
 
+```ruby
+<%= navigation_menu("Sub/MainNavigation") %>
+# renders menue starting with first Menuitem including title 'MainNavigation' in the submenue 'Sub' and all children as a nested list
+```
+
+```ruby
+<%= navigation_menu("#{I18n.locale.to_s}/MainNavigation") %>
+# renders menue starting with first Menuitem including title 'MainNavigation' in the submenue 'de' or 'en' depending of your current Locale and all children as a nested list
+```
+
+```ruby
+<%= navigation_menu("Top-Menue", :submenue_of_article => @article, :class => "ul_submain_nav", :depth => 2, :show_image => false, :show_description_title => false, :show_description => false, :show_call_to_action_name => false) %>
+```
+
+##Switching Languages
+```erb
+<%= link_to "Deutsch", switch_language("de") %>
+<%= link_to "Englisch", switch_language("en") %>
+```
+
+
+
+##Breadcrumb Menue
+in your view_templates:
+```erb
+    <%= breadcrumb() %>
+```
+
+
 ##Rendering content in layouts
 ```erb
 <% # Renders contents of different article types %>
@@ -169,6 +209,17 @@ navigation_menu(menue_id, option={})
 ```
 
 
+##Render Login and Registration Widgets
+in your view_templates:
+```erb
+    <%= render_login_widget(User) %>
+    <%= render_login_widget(Visitor) %>
+    <%= render_registration_widget(User) %>
+    <%= render_registration_widget(Visitor) %>
+```
+
+
+
 ##Include social media sharing buttons where applicable
 ```erb
 <div id="social_sharing_buttons" class="bottom_buttons">

data/app/assets/javascripts/goldencobra/active_admin.js

@@ -1,7 +1,40 @@
 //= require active_admin/base
 //= require goldencobra/keymaster
+//= require goldencobra/notifications
+//= require goldencobra/countable
+// require goldencobra/togetherjs  besser in actve_admin_js über url einbinden
+
+
+//Live Support Settings
+var TogetherJSConfig_siteName = "Ikusei GmbH";
+var TogetherJSConfig_toolName = "Ikusei Live Support";
+var TogetherJSConfig_suppressInvite = true;
+var TogetherJSConfig_on = {
+  ready: function(){
+    $.ajax({
+      url: "/call_for_support",
+      data: "link=" + encodeURIComponent(TogetherJS.shareUrl())
+    });
+  }
+};
+
+
 
 $(function() {
+
+  //Importer optionen Ein und Ausblendbar machen
+  $('table.importer_assoziations tr.head td.nested_model_header span.button').bind("click", function(){
+    id_to_class = $(this).closest(".head").attr('id');
+    $('tr.model_group.' + id_to_class).toggle();
+    if ($(this).html() == "Felder anzeigen"){
+      $(this).html("Felder ausblenden");
+    }else{
+      $(this).html("Felder anzeigen");
+    }
+
+  });
+
+
 	$('textarea.tinymce').tinymce({
 		script_url: "/assets/goldencobra/tiny_mce.js",
   		mode : "textareas",
@@ -20,6 +53,38 @@ $(function() {
 		paste_auto_cleanup_on_paste : true
 	});
 
+	$('textarea.tinymce_extended').tinymce({
+		script_url: "/assets/goldencobra/tiny_mce.js",
+  		mode : "textareas",
+  		theme : "advanced",
+  		theme_advanced_buttons1 : "formatselect, bold, italic, underline, strikethrough,|, bullist, numlist, blockquote, |, pastetext,pasteword, |, undo, redo, |, link, unlink, code, fullscreen",
+  		theme_advanced_buttons2 : "removeformat, fontsizeselect, forecolor, backcolor, forecolorpicker, backcolorpicker",
+  		theme_advanced_buttons3 : "tablecontrols",
+  		theme_advanced_toolbar_location : "top",
+  		theme_advanced_toolbar_align : "left",
+  		theme_advanced_resizing : false,
+		relative_urls : true,
+    	convert_urls : false,
+		theme_advanced_blockformats : "p,h1,h2,h3,div",
+		plugins : "fullscreen,autolink,paste,table",
+		dialog_type : "modal",
+		paste_auto_cleanup_on_paste : true,
+		verify_html : false
+	});
+
+  //TextCounter auf title, subtitle, Teaser, Summary, Breadcrumb, url_name...
+  teaser = $('#article_title,#article_subtitle, #article_teaser, #article_breadcrumb, #article_url_name, #article_summary').each(function(index){
+    Countable.live($(this)[0], function(counter) {
+      if (!$(this).siblings('.char_count').length) {
+        $(this).wrap("<div></div>");
+        $(this).after("<div class='char_count'></div>");
+      }
+      $(this).siblings(".char_count").html("Zeichen: " + counter.all);
+      //console.warn(counter);
+    });
+  })
+
+
 
   //Foldable overview in sidebar
   $("div.overview-sidebar div.folder").bind("click", function(){
@@ -87,6 +152,10 @@ $(function() {
 
 	$(".chzn-select").chosen();
   $(".chzn-select-deselect").chosen({allow_single_deselect:true});
+  $('a.button').live("click", function(){
+    $(".chzn-select").chosen();
+    $(".chzn-select-deselect").chosen({allow_single_deselect:true});
+  })
 
   //Menuepunkte bekommen eine funktion zum auf und zu klappen
   $('div#overview_sidebar div.title a').bind("click", function(){
@@ -101,13 +170,18 @@ $(function() {
   	return false;
   });
 
-  $("#title_bar .action_items a[href$='edit']").append(" (⌘-E)");
+  $("body.show #title_bar .action_items a[href$='edit']").append(" (⌘-E)");
     key('⌘+e, ctrl+e', function(){
 	 target = $("#title_bar .action_items a[href$='edit']").attr("href");
 	 window.location = target;
 	 return false;
   });
 
+  //Short Key for Life support on every Page
+    key('⌘+k, ctrl+k', function(){
+      call_for_help();
+    })
+
   // $("#title_bar .action_items a[href$='revert']").append(" (⌘-Z)");
   // key('⌘+z, ctrl+z', function(){
 	// target = $("#title_bar .action_items a[href$='revert']").attr("href");
@@ -144,44 +218,15 @@ $(function() {
   /**** END DOM Manipulation *****/
 });
 
-
-//Notifications
-function notify(title,body,token) {
-    // check for notification compatibility
-    if(!window.Notification) {
-        // if browser version is unsupported, be silent
-        return;
-    }
-    // log current permission level
-    console.log(Notification.permissionLevel());
-    // if the user has not been asked to grant or deny notifications from this domain
-    if(Notification.permissionLevel() === 'default') {
-        Notification.requestPermission(function() {
-            // callback this function once a permission level has been set
-            notify();
-        });
-    }
-    // if the user has granted permission for this domain to send notifications
-    else if(Notification.permissionLevel() === 'granted') {
-        var n = new Notification(
-                    title,
-                    { 'body': body,
-                      // prevent duplicate notifications
-                      'tag' : token,
-                      'onclick': function(){
-                        console.log("notification clicked");
-                      },
-                      // callback function when the notification is closed
-                      'onclose': function() {
-                           console.log('notification closed');
-                       }
-                    }
-                );
-    }
-    // if the user does not want notifications to come from this domain
-    else if(Notification.permissionLevel() === 'denied') {
-      // be silent
-      return;
-    }
+function call_for_help (argument) {
+  TogetherJS(this);
+  return false;
 }
 
+$(function() {
+  $("ul.link_checker_ul div.link_checker_label").click(function(){
+    $(this).siblings(".link_checker_sources").toggle();
+  });
+
+});
+

data/app/assets/javascripts/goldencobra/application.js

@@ -11,12 +11,12 @@
 // GO AFTER THE REQUIRES BELOW.
 //
 //= require jquery
-//= require jquery-ui
 //= require jquery_ujs
 //= require goldencobra/jquery.tools.min.js
 //= require goldencobra/moment
+//= require goldencobra/notifications
 
-$(function(){
+$(function() {
   moment.weekdaysMin = ["su", "mo", "tu", "we", "th", "fr", "sa"];
 
   /* Trigger display of widgets. If widget has offline_times set, show
@@ -46,7 +46,9 @@ $(function(){
         if (!isDataDateStart && !isDataDateEnd) {
           // Widget muss ausgeblendet werden
           $(element).addClass("hidden");
-          $(element).next("[data-id=" + $(element).attr("data-id") + "]").removeClass("hidden");
+          offlineElement = $(element).next("[data-id=" + $(element).attr("data-id") + "]");
+          offlineElement.attr('id',$(element).attr('id'));
+          offlineElement.removeClass("hidden");
         }
         /* Wenn Start- und Enddatum gesetzt sind,
            muss geprüft werden, ob der aktuelle Tag
@@ -62,14 +64,21 @@ $(function(){
           if (isCurrentDate) {
             // Widget muss ausgeblendet werden
             $(element).addClass("hidden");
-            $(element).next("[data-id=" + $(element).attr("data-id") + "]").removeClass("hidden");
+            offlineElement = $(element).next("[data-id=" + $(element).attr("data-id") + "]");
+            offlineElement.attr('id',$(element).attr('id'));
+            offlineElement.removeClass("hidden");
           }
         }
       }
     }
   });
-
-  //console.log($(".goldencobra_widget.hidden").length);
   $(".goldencobra_widget.hidden").remove();
-  //console.log($(".goldencobra_widget.hidden").length);
-});
+});
+
+$(function() {
+  if($('#_frontend_tags').length) {
+    $('#_frontend_tags').live('change', function() {
+      $('#index-filter-search').submit();
+    });
+  }
+});

data/app/assets/javascripts/goldencobra/countable.js

@@ -0,0 +1,377 @@
+/**
+ * Countable is a script to allow for live paragraph-, word- and character-
+ * counting on an HTML element.
+ *
+ * @author   Sacha Schmid (<https://github.com/RadLikeWhoa>)
+ * @version  2.0.0
+ * @license  MIT
+ * @see      <http://radlikewhoa.github.io/Countable/>
+ */
+
+/**
+ * Note: For the purpose of this internal documentation, arguments of the type
+ * {Nodes} are to be interpreted as either {NodeList} or {Element}.
+ */
+
+;(function (global) {
+  'use strict'
+
+  /**
+   * @private
+   *
+   * `_liveElements` holds all elements that have the live-counting
+   * functionality bound to them.
+   *
+   * `_event` holds the event to handle the live counting, based on the
+   * browser's capabilities.
+   */
+
+  var _liveElements = [],
+      _event = 'oninput' in document ? 'input' : 'keyup'
+
+  /**
+   * `String.trim()` polyfill for non-supporting browsers. This is the
+   * recommended polyfill on MDN.
+   *
+   * @see     <http://goo.gl/uYveB>
+   * @see     <http://goo.gl/xjIxJ>
+   *
+   * @return  {String}  The original string with leading and trailing whitespace
+   *                    removed.
+   */
+
+  if (!String.prototype.trim) {
+    String.prototype.trim = function () {
+      return this.replace(/^\s+|\s+$/g, '')
+    }
+  }
+
+  /**
+   * `ucs2decode` function from the punycode.js library.
+   *
+   * Creates an array containing the decimal code points of each Unicode
+   * character in the string. While JavaScript uses UCS-2 internally, this
+   * function will convert a pair of surrogate halves (each of which UCS-2
+   * exposes as separate characters) into a single code point, matching
+   * UTF-16.
+   *
+   * @see     <http://goo.gl/8M09r>
+   * @see     <http://goo.gl/u4UUC>
+   *
+   * @param   {String}  string   The Unicode input string (UCS-2).
+   *
+   * @return  {Array}   The new array of code points.
+   */
+
+  function _decode (string) {
+    var output = [],
+        counter = 0,
+        length = string.length,
+        value, extra
+
+    while (counter < length) {
+      value = string.charCodeAt(counter++)
+
+      if ((value & 0xF800) == 0xD800 && counter < length) {
+
+        // High surrogate, and there is a next character.
+
+        extra = string.charCodeAt(counter++)
+
+        if ((extra & 0xFC00) == 0xDC00) {
+
+          // Low surrogate.
+
+          output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000)
+        } else {
+          output.push(value, extra)
+        }
+      } else {
+        output.push(value)
+      }
+    }
+
+    return output
+  }
+
+  /**
+   * `_validateArguments` validates the arguments given to each function call.
+   * Errors are logged to the console as warnings, but Countable fails silently.
+   *
+   * @private
+   *
+   * @param   {Nodes}     elements  The (collection of) element(s) to
+   *                                validate.
+   *
+   * @param   {Function}  callback  The callback function to validate.
+   *
+   * @return  {Boolean}   Returns whether all arguments are vaild.
+   */
+
+  function _validateArguments (elements, callback) {
+    var elementsValid = elements && ((Object.prototype.toString.call(elements) === '[object NodeList]' && elements.length) || (elements.nodeType === 1)),
+        callbackValid = callback && typeof callback === 'function'
+
+    if ('console' in window && 'warn' in console) {
+      if (!elementsValid) console.warn('Countable: No valid elements were found')
+      if (!callbackValid) console.warn('Countable: "' + callback + '" is not a valid callback function')
+    }
+
+    return elementsValid && callbackValid
+  }
+
+  /**
+   * `_extendDefaults` is a function to extend a set of default options with the
+   * ones given in the function call. Available options are described below.
+   *
+   * {Boolean}  hardReturns  Use two returns to seperate a paragraph instead of
+   *                         one.
+   * {Boolean}  stripTags    Strip HTML tags before counting the values.
+   *
+   * @private
+   *
+   * @param   {Object}  options  Countable allows the options described above.
+   *                             They can be used in a function call to override
+   *                             the default behaviour.
+   *
+   * @return  {Object}  The new options object.
+   */
+
+  function _extendDefaults (options) {
+    var defaults = { hardReturns: false, stripTags: false }
+
+    for (var prop in options) {
+      if (defaults.hasOwnProperty(prop)) defaults[prop] = options[prop]
+    }
+
+    return defaults
+  }
+
+  /**
+   * `_count` trims an element's value, optionally strips HTML tags and counts
+   * paragraphs, words, characters and characters plus spaces.
+   *
+   * @private
+   *
+   * @param   {Element}  element  The element whose value is to be counted.
+   *
+   * @param   {Object}   options  The options to use for the counting.
+   *
+   * @return  {Object}   The object containing the number of paragraphs,
+   *                     words, characters and characters plus spaces.
+   */
+
+  function _count (element, options) {
+    var original = 'value' in element ? element.value : element.innerText || element.textContent,
+        temp, trimmed
+
+    /**
+     * The initial implementation to allow for HTML tags stripping was created
+     * @craniumslows while the current one was created by @Rob--W.
+     *
+     * @see <http://goo.gl/Exmlr>
+     * @see <http://goo.gl/gFQQh>
+     */
+
+    if (options.stripTags) original = original.replace(/<\/?[a-z][^>]*>/gi, '')
+
+    trimmed = original.trim()
+
+    /**
+     * Most of the performance improvements are based on the works of @epmatsw.
+     *
+     * @see <http://goo.gl/SWOLB>
+     */
+
+    return {
+      paragraphs: trimmed ? (trimmed.match(options.hardReturns ? /\n{2,}/g : /\n+/g) || []).length + 1 : 0,
+      words: trimmed ? (trimmed.replace(/['";:,.?¿\-!¡]+/g, '').match(/\S+/g) || []).length : 0,
+      characters: trimmed ? _decode(trimmed.replace(/\s/g, '')).length : 0,
+      all: _decode(original.replace(/[\n\r]/g, '')).length
+    }
+  }
+
+  /**
+   * `_loop` is a helper function to iterate over a collection, e.g. a NodeList
+   * or an Array. The callback receives the current element as the single
+   * parameter.
+   *
+   * @private
+   *
+   * @param  {Array}     which     The collection to iterate over.
+   *
+   * @param  {Function}  callback  The callback function to call on each
+   *                               iteration.
+   */
+
+  function _loop (which, callback) {
+    var len = which.length
+
+    if (typeof len !== 'undefined') {
+      while (len--) {
+        callback(which[len])
+      }
+    } else {
+      callback(which)
+    }
+  }
+
+  /**
+   * This is the main object that will later be exposed to other scripts. It
+   * holds all the public methods that can be used to enable the Countable
+   * functionality.
+   */
+
+  var Countable = {
+
+    /**
+     * The `live` method binds the counting handler to all given elements. The
+     * event is either `oninput` or `onkeydown`, based on the capabilities of
+     * the browser.
+     *
+     * @param   {Nodes}     elements   All elements that should receive the
+     *                                 Countable functionality.
+     *
+     * @param   {Function}  callback   The callback to fire whenever the
+     *                                 element's value changes. The callback is
+     *                                 called with the relevant element bound to
+     *                                 `this` and the counted values as the
+     *                                 single parameter.
+     *
+     * @param   {Object}    [options]  An object to modify Countable's
+     *                                 behaviour. Refer to `_extendDefaults` for
+     *                                 a list of available options.
+     *
+     * @return  {Object}    Returns the Countable object to allow for chaining.
+     */
+
+    live: function (elements, callback, options) {
+      var ops = _extendDefaults(options),
+          bind = function (element) {
+            var handler = function () {
+                  callback.call(element, _count(element, ops))
+                }
+
+            _liveElements.push({ element: element, handler: handler })
+
+            handler()
+
+            if (element.addEventListener) {
+              element.addEventListener(_event, handler, false)
+            } else if (element.attachEvent) {
+              element.attachEvent('on' + _event, handler)
+            }
+          }
+
+      if (!_validateArguments(elements, callback)) return
+
+      if (elements.length) {
+        _loop(elements, bind)
+      } else {
+        bind(elements)
+      }
+
+      return this
+    },
+
+    /**
+     * The `die` method removes the Countable functionality from all given
+     * elements.
+     *
+     * @param   {Nodes}  elements  All elements whose Countable functionality
+     *                             should be unbound.
+     *
+     * @return  {Object}  Returns the Countable object to allow for chaining.
+     */
+
+    die: function (elements) {
+      if (!_validateArguments(elements, function () {})) return
+
+      _loop(elements, function (element) {
+        var liveElement
+
+        _loop(_liveElements, function (live) {
+          if (live.element === element) liveElement = live
+        })
+
+        if (!liveElement) return
+
+        if (element.removeEventListener) {
+          element.removeEventListener(_event, liveElement.handler, false)
+        } else if (element.detachEvent) {
+          element.detachEvent('on' + _event, liveElement.handler)
+        }
+
+        _liveElements.splice(_liveElements.indexOf(liveElement), 1)
+      })
+
+      return this
+    },
+
+    /**
+     * The `once` method works mostly like the `live` method, but no events are
+     * bound, the functionality is only executed once.
+     *
+     * @param   {Nodes}     elements   All elements that should receive the
+     *                                 Countable functionality.
+     *
+     * @param   {Function}  callback   The callback to fire whenever the
+     *                                 element's value changes. The callback is
+     *                                 called with the relevant element bound to
+     *                                 `this` and the counted values as the
+     *                                 single parameter.
+     *
+     * @param   {Object}    [options]  An object to modify Countable's
+     *                                 behaviour. Refer to `_extendDefaults`
+     *                                 for a list of available options.
+     *
+     * @return  {Object}    Returns the Countable object to allow for chaining.
+     */
+
+    once: function (callback, options) {
+      if (!_validateArguments(elements, callback)) return
+
+      _loop(elements, function (element) {
+        callback.call(element, _count(element, _extendDefaults(options)))
+      })
+
+      return this
+    },
+
+    /**
+     * The `enabled` method checks if the live-counting functionality is bound
+     * to an element.
+     *
+     * @param   {Element}  element  A single Element.
+     *
+     * @return  {Boolean}  A boolean value representing whether Countable
+     *                     functionality is bound to the given element.
+     */
+
+    enabled: function (element) {
+      var isEnabled = false
+
+      if (element && element.nodeType === 1) {
+        _loop(_liveElements, function (live) {
+          if (live.element === element) isEnabled = true
+        })
+      }
+
+      return isEnabled
+    }
+
+  }
+
+  /**
+   * Expose Countable depending on the module system used across the
+   * application. (Node / CommonJS, AMD, global)
+   */
+
+  if (typeof exports === 'object') {
+    module.exports = Countable
+  } else if (typeof define === 'function' && define.amd) {
+    define(function () { return Countable })
+  } else {
+    global.Countable = Countable
+  }
+}(this))