gluttonberg-core 2.5

data/app/helpers/gluttonberg/asset_library.rb

@@ -0,0 +1,258 @@
+module Gluttonberg
+    module AssetLibrary
+
+       #  nice and clean public url of assets
+       def asset_url(asset , opts = {})
+         url = ""
+         if Rails.env=="development"
+           url = "http://#{request.host}:#{request.port}/user_asset/#{asset.asset_hash[0..3]}/#{asset.id}"
+         else
+           url = "http://#{request.host}/user_asset/#{asset.asset_hash[0..3]}/#{asset.id}"
+         end
+
+         if opts[:thumb_name]
+           url << "/#{opts[:thumb_name]}"
+         end
+
+         url
+       end
+
+
+       # Returns a link for sorting assets in the library
+       def sorter_link(name, param, url)
+         opts = {}
+         route_opts = { :order => param , :order_type => "asc" }
+         if param == params[:order] || (!params[:order] && param == 'date-added')
+           opts[:class] = "current"
+           unless params[:order_type].blank?
+             route_opts[:order_type] = (params[:order_type] == "asc" ? "desc" : "asc" )
+           else
+             route_opts[:order_type] = "desc"
+           end
+           opts[:class] << (route_opts[:order_type] == "asc" ? " desc" : " asc" )
+         end
+
+         link_to(name, url + "?" + route_opts.to_param , opts)
+       end
+
+       # Generates a link which launches the asset browser
+       # This method operates in bound or unbound mode.
+       #
+       #
+       # In unbound mode this method accepts name of the tag and an options hash.
+       #
+       # The options hash accepts the following parameters:
+       #
+       #   The following are required in unbound mode, not used in bound mode:
+       #     :id = This is the id to use for the generated hidden field to store the selected assets id.
+       #     :asset_id = The id of the currently selected asset.
+       #     :filter = Its optional. If valid filter is provided then it only brings assets of belonging to select filter type. (image,audio video)
+       #     :button_class => Html class for button
+       #     :button_text => Its a label for button. If its not provided then "Browse"
+       #   The following are optional in either mode:
+       #     < any option accepted by hidden_field() method >
+       #
+       #
+       # For Finding image assets
+       #   asset_browser_tag( name_of_tag ,  opts = { :button_class => "" , :button_text => "Select" ,  :filter => "" ,  :id => "html_id", :asset_id => content.asset_id } )
+
+       def asset_browser_tag( field_id , opts = {} )
+          _asset_browser_tag( field_id , opts  )
+       end
+
+       def _asset_browser_tag( field_id , opts = {} )
+           asset_id = nil
+           asset_id = opts[:asset_id]
+           filter = opts[:filter].blank? ? "all" : opts[:filter]
+
+           if opts[:id].blank?
+             rel = field_id.to_s + "_" + id.to_s
+             opts[:id] = rel
+           end
+           html_id = opts[:id]
+
+
+          asset_info = ""
+          asset_name = "Nothing selected"
+          unless asset_id.blank?
+            asset = Gluttonberg::Asset.find(:first , :conditions => {:id => asset_id})
+            asset_name =  asset.name if asset
+            if asset
+              if asset.category && asset.category.to_s.downcase == "image"
+                asset_info = asset_tag(asset , :small_thumb).html_safe
+              end
+            else
+              asset_name = "Asset missing!"
+            end
+          end
+
+          asset_name = content_tag(:h5, asset_name) if asset_name
+
+
+
+           # Output it all
+           thumbnail_contents = ""
+           thumbnail_contents << asset_info
+
+           thumbnail_caption = ""
+           thumbnail_caption << asset_name unless asset_name.blank?
+          thumbnail_caption << hidden_field_tag("filter_" + field_id.to_s , value=filter , :id => "filter_#{opts[:id]}" )
+          thumbnail_caption << hidden_field_tag(field_id , asset_id , { :id => opts[:id] , :class => "choose_asset_hidden_field" } )
+
+          thumbnail_p = ""
+          thumbnail_p << link_to("Select", admin_asset_browser_url + "?filter=#{filter}" , { :class =>"btn button choose_button #{opts[:button_class]}" , :rel => html_id, :style => "margin-right:5px;" , :data_url => opts[:data_url] })
+          if opts[:remove_button] != false
+            thumbnail_p << clear_asset_tag( field_id , opts )
+          end
+
+          thumbnail_caption << content_tag(:p, thumbnail_p.html_safe)
+
+          thumbnail_contents << content_tag(:div, thumbnail_caption.html_safe, :class => "caption")
+          thumbnail = content_tag(:div, thumbnail_contents.html_safe, :class => "thumbnail asset_selector_wrapper")
+          li_content = content_tag(:li, thumbnail, :class => "span4")
+          content_tag(:ul , li_content , :id => "title_thumb_#{opts[:id]}", :class => "thumbnails")
+      end
+
+      def add_image_to_gallery_tag( button_text , add_url, gallery_id , opts = {})
+          opts[:class] = "" if opts[:class].blank?
+          opts[:class] << " add_image_to_gallery choose_button btn button  #{opts[:button_class]}"
+          link_contents = link_to(button_text, admin_asset_browser_url + "?filter=image" , opts.merge( :data_url => add_url ))
+          content_tag(:span , link_contents , { :class => "assetBrowserLink" } )
+      end
+
+       def clear_asset_tag( field_id , opts = {} )
+         asset_id = nil
+         asset_id = opts[:asset_id]
+         if opts[:id].blank?
+           rel = field_id.to_s + "_" + id.to_s
+           opts[:id] = rel
+         end
+         html_id = opts[:id]
+         link_to("Remove", "Javascript:;" , { :class => "btn btn-danger button remove #{opts[:button_class]}"  , :onclick => "$('##{html_id}').val('');$('#title_thumb_#{opts[:id]} h5').html('');$('#title_thumb_#{opts[:id]} img').remove();" })
+
+
+       end
+
+       def asset_panel(assets, name_or_id , type )
+          render :partial => "gluttonberg/admin/shared/asset_panel.html" , :locals => {:assets => assets , :name_or_id => name_or_id , :type => type}
+       end
+
+
+       def asset_tag(asset , thumbnail_type = nil, options = {} )
+          unless asset.blank?
+            path = thumbnail_type.blank? ? asset.url : asset.url_for(thumbnail_type)
+
+            unless options.has_key?(:alt)
+              options[:alt] = asset.alt.blank? ? asset.name : asset.alt
+            end
+            options[:src] = path
+            tag(:img , ""  , options)
+          end
+       end
+
+       def asset_tag_v2(asset , options = {} , thumbnail_type = nil)
+           unless asset.blank?
+             options[:class] = "" if options[:class].blank?
+             options[:class] << " #{asset.name}"
+             options[:alt] = asset.name
+             options[:title] = asset.name
+             options[:src] = thumbnail_type.blank? ? asset.url : asset.url_for(thumbnail_type)
+             tag(:img , "" , options)
+           end
+       end
+
+       def gallery_images_ul(id , gallery_thumb_image , gallery_large_image ,html_opts_for_ul = {})
+         gallery = Gluttonberg::Gallery.find(id)
+         unless gallery.blank? || gallery.gallery_images.blank?
+           options = ""
+           gallery.gallery_images.each do |g_image|
+             li_html = link_to(asset_tag(g_image.image , gallery_thumb_image).html_safe , asset_url(g_image.image , :thumb_name => gallery_large_image) , :class => "thumb")
+             unless g_image.image.alt.blank?
+               image_desc_html = content_tag(:div , g_image.image.alt  , :class => "image-desc")
+               li_html << content_tag(:div , image_desc_html , :class => "caption")
+             end
+             options << content_tag(:li , li_html , :id => "image_#{g_image.id}").html_safe
+           end
+           content_tag(:ul  , options.html_safe , html_opts_for_ul)
+         end
+       end
+
+
+    end # Assets
+end # Gluttonberg
+
+
+# Luke I need your help to improve this method.
+# Ideally i should be able to call asset_browser_tag( field_id , opts = {} ) method from here.
+module ActionView
+  module Helpers
+    class FormBuilder
+        include ActionView::Helpers
+
+        def asset_browser( field_id , opts = {} )
+          asset_id = self.object.send(field_id.to_s)
+          filter = opts[:filter].blank? ? "all" : opts[:filter]
+
+          opts[:id] = "#{field_id}_#{asset_id}" if opts[:id].blank?
+          html_id = opts[:id]
+
+          # Find the asset so we can get the name
+          asset_info = ""
+          asset_name = "Nothing selected"
+          unless asset_id.blank?
+            asset = Gluttonberg::Asset.find(:first , :conditions => {:id => asset_id})
+            asset_name =  asset.name if asset
+            if asset
+              if asset.category && asset.category.to_s.downcase == "image"
+                asset_info = asset_tag(asset , :small_thumb).html_safe
+              end
+            else
+              asset_name = "Asset missing!"
+            end
+          end
+
+          asset_name = content_tag(:h5, asset_name) if asset_name
+
+          #hack for url
+          admin_asset_browser_url = "/admin/browser"
+
+          thumbnail_contents = ""
+          thumbnail_contents << asset_info
+
+          thumbnail_caption = ""
+          thumbnail_caption << asset_name unless asset_name.blank?
+          thumbnail_caption << hidden_field_tag("filter_#{html_id}"  , value=filter  )
+          thumbnail_caption << self.hidden_field(field_id , { :id => html_id , :class => "choose_asset_hidden_field" } )
+
+          thumbnail_p = ""
+          thumbnail_p << link_to("Select", admin_asset_browser_url + "?filter=#{filter}" , { :class =>"btn button choose_button #{opts[:button_class]}" , :rel => html_id, :style => "margin-right:5px;" })
+          if opts[:remove_button] != false
+            thumbnail_p << self.clear_asset( field_id , opts )
+          end
+
+          thumbnail_caption << content_tag(:p, thumbnail_p.html_safe)
+
+          thumbnail_contents << content_tag(:div, thumbnail_caption.html_safe, :class => "caption")
+          thumbnail = content_tag(:div, thumbnail_contents.html_safe, :class => "thumbnail asset_selector_wrapper")
+          li_content = content_tag(:li, thumbnail, :class => "span4")
+          content_tag(:ul , li_content , :id => "title_thumb_#{opts[:id]}", :class => "thumbnails")
+        end
+
+        def asset_tag(asset , thumbnail_type = nil)
+           unless asset.blank?
+             path = thumbnail_type.blank? ? asset.url : asset.url_for(thumbnail_type)
+             tag(:img , "", :class => asset.name , :alt => asset.name , :src => path)
+           end
+        end
+
+        def clear_asset( field_id , opts = {} )
+          asset_id = self.object.send(field_id.to_s)
+          opts[:id] = "#{field_id}_#{asset_id}" if opts[:id].blank?
+          html_id = opts[:id]
+          button_text = opts[:button_text].blank? ? "Browse" : opts[:button_text]
+          opts[:button_class] = "" if opts[:button_class].blank?
+          link_to("Remove", "Javascript:;" , { :class => "btn btn-danger button remove #{opts[:button_class]}"  , :onclick => "$('##{html_id}').val('');$('#title_thumb_#{opts[:id]} h5').html('');$('#title_thumb_#{opts[:id]} img').remove();" })
+        end
+    end
+  end
+end

data/app/helpers/gluttonberg/content_helpers.rb

@@ -0,0 +1,100 @@
+module Gluttonberg
+    module ContentHelpers
+      # Finds the matching content block and determines the helper it needs
+      # to execute to actually write the contents to page.
+      # TODO: if there is no way to to render the content, freak out and raise
+      # an error
+      def render_content_for(section_name, opts = {})
+        # At present this generates a bunch of queries. Eventually we should
+        # look at caching section names to save some DB hits.
+        content = gb_content_for(section_name)
+        render_method = :"render_#{content.content_type}"
+        if respond_to? render_method
+          send(:"render_#{content.content_type}", content, opts)
+        elsif content.respond_to? :text
+          content.text
+        else
+          # raise Gluttonberg::ContentRenderError, "Don't know how to render this content"
+        end
+      end
+
+      # Returns the content record for the specified section. It will include
+      # the relevant localized version based the current locale/dialect
+      def gb_content_for(section_name, opts = nil)
+        section_name = section_name.to_sym
+        @page.localized_contents.pluck {|c| c.section[:name] == section_name}
+      end
+
+      # Render html content. Actually just looks for the text
+      # property on the content model.
+      def render_html_content(content, opts = nil)
+        if content.current_localization.text
+          content.current_localization.text.html_safe
+        else
+          ""
+        end
+      end
+
+
+      # Renders an image tag with the src set to the associated asset. If the
+      # asset is missing it returns nil.
+      def render_image_content(content, opts = {})
+        if content.asset
+          if opts[:url_for].blank?
+            image_tag(content.asset.url, opts.merge!(:alt => content.asset.name))
+          else
+            image_tag(content.asset.url_for(opts[:url_for].to_sym), opts.merge!(:alt => content.asset.name))
+          end
+        end
+      end
+
+      # Renders an image url, allows the designer to specify who they want to handle the image.
+      def gb_image_url(section_name, opts = {})
+        content = gb_content_for(section_name)
+        if content.asset
+          if opts[:url_for].blank?
+            content.asset.url
+          else
+            content.asset.url_for(opts[:url_for].to_sym)
+          end
+        end
+      end
+
+      def gb_image_alt_text(section_name, opts = {})
+        content = gb_content_for(section_name)
+        if content.asset
+          content.asset.name
+        end
+      end
+
+      # Simple as it gets, it just pulles the text property from the content
+      # record
+      def render_plain_text_content(content, opts = nil)
+        content.current_localization.text
+      end
+
+      # Looks for a matching partial in the templates directory. Failing that,
+      # it falls back to Gluttonberg's view dir — views/content/editors
+      def content_editor(content_class)
+        locals  = {:content => content_class}
+        type    = content_class.content_type
+        render :partial => Gluttonberg::Templates.editor_template_path(type) , :locals => locals
+      end
+
+      # generate javascript code to enable tinymce on it. textArea need to have class = jwysiwyg
+      def enable_jwysiwyg_on_class(html_class)
+        if Gluttonberg::Setting.get_setting("enable_WYSIWYG") == "Yes"
+          content = "enable_jwysiwyg_on('.#{html_class}'); \n"
+          javascript_tag(content)
+        end
+      end
+
+      # generate javascript code to enable tinymce on it. textArea need to have class = jwysiwyg
+      def enable_slug_management_on(html_class)
+        javascript_tag("enable_slug_management_on('#{html_class}')" )
+      end
+
+
+
+    end # Content
+end # Gluttonberg

data/app/helpers/gluttonberg/public.rb

@@ -0,0 +1,297 @@
+# encoding: utf-8
+
+module Gluttonberg
+    # A few simple helpers to be used when rendering page templates.
+    module Public
+      # A simple helper which loops through a heirarchy of pages and produces a
+      # set of nested lists with links to each page.
+      def navigation_tree(pages, opts = {})
+        content = ""
+        pages.each do |page|
+          if page.hide_in_nav.blank? || page.hide_in_nav == false
+            li_opts = {:id => page.slug + "Nav"}
+            li_opts[:class] = "current" if page == @page
+            page.load_localization(@locale)
+            if page.home?
+              li_content = content_tag(:a, page.nav_label, :href => page_url(page , opts)).html_safe
+            else
+              if page.description && page.description.top_level_page?
+                li_content = content_tag(:a, page.nav_label, :href=>"javascript:;", :class => "menu_disabled").html_safe
+              else
+                li_content = content_tag(:a, page.nav_label, :href => page_url(page , opts)).html_safe
+              end
+            end
+            children = page.children.published
+            li_content << navigation_tree(children , opts).html_safe unless children.blank?
+            content << content_tag(:li, li_content.html_safe, li_opts).html_safe
+          end
+        end
+        content_tag(:ul, content.html_safe, opts).html_safe
+      end
+
+      # This is hacked together.
+      # It is working at the moment but needs further work.
+      # - Yuri
+      def page_url(path_or_page , opts = {})
+        if path_or_page.is_a?(String)
+          if Gluttonberg.localized? == true
+            "/#{opts[:slug]}/#{path_or_page}"
+          else
+            "/#{path_or_page}"
+          end
+        else
+          if path_or_page.rewrite_required?
+            url = Rails.application.routes.recognize_path(path_or_page.description.rewrite_route)
+            url[:host] = Rails.configuration.host_name
+            Rails.application.routes.url_for(url)
+          else
+            if Gluttonberg.localized? && !opts[:slug].blank?
+              "/#{opts[:slug]}/#{path_or_page.path}"
+            else
+              "#{path_or_page.public_path}"
+            end
+          end
+        end
+      end
+
+      # Returns the code for google analytics
+      def google_analytics_js_tag
+        code = Gluttonberg::Setting.get_setting("google_analytics")
+        output = ""
+        unless code.blank?
+          output += "<script type='text/javascript'>\n"
+          output += "//<![CDATA[\n"
+          output += "var gaJsHost = ((\"https:\" == document.location.protocol) ? \"https://ssl.\" : \"http://www.\");\n"
+          output += "document.write(unescape(\"%3Cscript src='\" + gaJsHost + \"google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E\"));\n"
+          output += "//]]>\n"
+          output += "</script>\n"
+          output += "<script type='text/javascript'>\n"
+          output += "//<![CDATA[\n"
+          output += "try {\n"
+          output += "var pageTracker = _gat._getTracker(\"#{code}\");\n"
+          output += "pageTracker._trackPageview();\n"
+          output += "} catch(err) {}\n"
+          output += "//]]>\n"
+          output += "</script>\n"
+        end
+        output.html_safe
+      end
+
+      def keywords_meta_tag
+        tag("meta",{:content => Gluttonberg::Setting.get_setting("keywords") , :name => "keywords" } )
+      end
+
+      def description_meta_tag
+        tag("meta",{:content => Gluttonberg::Setting.get_setting("description") , :name => "description" } )
+      end
+
+      def render_match_partial(result)
+        begin
+          klass = result.class.name.demodulize.underscore
+          render :partial => "search/#{klass}", :locals => { :result => result }
+        rescue ActionView::MissingTemplate => e
+          "Missing search template for model #{klass}. Create a search/_#{klass}.html.erb partial in the correct plugin and try again."
+        rescue RuntimeError => e
+          "Unable to find the class name of the following match #{debug result}"
+        end
+      end
+
+      def link_to_inappropriate(obj)
+        if current_user and current_user.flagged?(obj)
+          content_tag(:p, "You have already flagged this item.")
+        else
+          link_to "Inappropriate" , mark_as_flag_path(obj.class.name , obj.id)
+        end
+      end
+
+
+      # Does NOT behave identical to current Rails truncate method
+      # you must pass options as a hash not just values
+      # Sample usage: <%= html_truncate(category.description, :length =>
+      # 120, :omission => "(continued...)" ) -%>...
+
+      def html_truncate(html, truncate_length, options={})
+        text, result = [], []
+        previous_tags = []
+        # get all text (including punctuation) and tags and stick them in a hash
+        html.scan(/<\/?[^>]*>|[A-Za-z0-9.,\/&#;\!\+\(\)\-"'?]+/).each { |t| text << t }
+        #puts text
+        text.each do |str|
+          if truncate_length > 0
+            if str =~ /<\/?[^>]*>/
+              if str[0..1] != "</"
+                previous_tags.push(str)
+              else
+                previous_tags.pop()
+              end
+              result << str
+            else
+              result << str
+              truncate_length -= str.length
+            end
+          else
+            # now stick the next tag with a  that matches the previous
+            # open tag on the end of the result
+            while previous_tags.length > 0
+              previous_tag = previous_tags.pop()
+              unless previous_tag.start_with?("<br") || previous_tag.start_with?("<hr") || previous_tag.start_with?("<input")
+
+                tokens = previous_tag.split(" ")
+                if tokens.length == 1
+                  closing_tag = tokens.first.insert(1 , '/')
+                else
+                  closing_tag = "#{tokens.first.insert(1 , '/')}>"
+                end
+                result << closing_tag
+              end
+            end
+          end
+        end
+
+        return result.join(" ") + options[:omission].to_s
+      end
+
+
+      def db_stylesheet_link_tag
+        if Rails.configuration.cms_based_public_css == true
+           html = ""
+           Gluttonberg::Stylesheet.all.each do |stylesheet|
+             html << "\n"
+             unless stylesheet.css_prefix.blank?
+               html << stylesheet.css_prefix
+               html << "\n"
+             end
+             html << stylesheet_link_tag( stylesheets_path(stylesheet.slug) +".css?#{stylesheet.version}" )
+             unless stylesheet.css_postfix.blank?
+               html << "\n"
+               html << stylesheet.css_postfix
+             end
+           end
+           html << "\n"
+           html.html_safe
+         end
+       end
+
+      def body_class(page)
+         if !@page.blank?
+           "page #{@page.current_localization.slug} #{@page.home? ? 'home' : ''}"
+         elsif !@article.blank?
+           "post #{@article.slug}"
+         elsif !@blog.blank?
+           "blog #{@blog.slug}"
+         elsif !@custom_model_object.blank?
+           "#{@custom_model_object.class.name.downcase} #{@custom_model_object.slug}"
+         end
+      end
+
+      def page_title
+        wt = website_title
+        pt = ""
+        if !@page.blank?
+          pt = @page.current_localization.seo_title if @page.current_localization.respond_to?(:seo_title)
+          pt = @page.title if pt.blank?
+        elsif !@article.blank?
+          pt = @article.current_localization.seo_title if @article.current_localization.respond_to?(:seo_title)
+          pt = @article.current_localization.title if pt.blank?
+        elsif !@blog.blank?
+          pt = @blog.seo_title if @blog.respond_to?(:seo_title)
+          pt = @blog.name if pt.blank?
+        elsif !@custom_model_object.blank?
+          pt = @custom_model_object.seo_title if @custom_model_object.respond_to?(:seo_title)
+          pt = @custom_model_object.title_or_name? if pt.blank?
+        end
+        if pt.blank?
+          wt
+        elsif wt.blank?
+          pt
+        else
+          "#{pt} | #{wt}"
+        end
+      end
+
+      def page_description
+        wd = Gluttonberg::Setting.get_setting("description")
+        pd = ""
+        if !@page.blank?
+          pd = @page.current_localization.seo_description if @page.current_localization.respond_to?(:seo_description)
+        elsif !@article.blank?
+          pd = @article.current_localization.seo_description if @article.current_localization.respond_to?(:seo_description)
+        elsif !@blog.blank?
+          pd = @blog.seo_description if @blog.respond_to?(:seo_description)
+        elsif !@custom_model_object.blank?
+          pd = @custom_model_object.seo_description if @custom_model_object.respond_to?(:seo_description)
+        end
+
+        if !pd.blank?
+          pd
+        else !wd.blank?
+          wd
+        end
+      end
+
+      def page_keywords
+        wk = Gluttonberg::Setting.get_setting("keywords")
+        pk = ""
+        if !@page.blank?
+          pk = @page.current_localization.seo_keywords if @page.current_localization.respond_to?(:seo_keywords)
+        elsif !@article.blank?
+          pk = @article.current_localization.seo_keywords if @article.current_localization.respond_to?(:seo_keywords)
+        elsif !@blog.blank?
+          pk = @blog.seo_keywords if @blog.respond_to?(:seo_keywords)
+        elsif !@custom_model_object.blank?
+          pk = @custom_model_object.seo_keywords if @custom_model_object.respond_to?(:seo_keywords)
+        end
+
+        if !pk.blank?
+          pk
+        elsif !wk.blank?
+          wk
+        end
+      end
+
+      def page_fb_icon_path
+        wk = Gluttonberg::Setting.get_setting("fb_icon")
+        pk = ""
+        if !@page.blank?
+          pk = @page.current_localization.fb_icon if @page.current_localization.respond_to?(:fb_icon)
+        elsif !@article.blank?
+          pk = @article.current_localization.fb_icon if @article.current_localization.respond_to?(:fb_icon)
+        elsif !@blog.blank?
+          pk = @blog.fb_icon if @blog.respond_to?(:fb_icon)
+        elsif !@custom_model_object.blank?
+          pk = @custom_model_object.fb_icon if @custom_model_object.respond_to?(:fb_icon)
+        end
+
+        if !pk.blank?
+          asset = pk
+        else !wk.blank?
+          asset = Asset.find(:first , :conditions => { :id => wk } )
+        end
+        unless asset.blank?
+          path = asset.url
+        end
+      end
+
+      def clean_public_query(string)
+        unless string.blank?
+          string = string.gsub("'", "\\\\'")
+          string = string.gsub("\"", "\\\"")
+          string = string.gsub(/\${2,}/, "$")
+        else
+          string
+        end
+      end
+
+      def clean_public_query_for_sphinx(string)
+        unless string.blank?
+          string = clean_public_query(string)
+          string = string.gsub("$", "")
+          string = string.gsub(/[\!\*'"″′‟‘’‛„‚”“”˝\(\)\;\:\.\@\&\=\+\-\$\,\/?\%\#\[\]]/,'')
+        else
+          string
+        end
+      end
+
+
+    end # Public
+end # Gluttonberg