friendly_extensions 0.0.8

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 29c0b1955597b587688ee28aa4ed2db4aa362e21
+  data.tar.gz: e8877f694cd2e9f205cd0f5791ebcec25f0187d6
+SHA512:
+  metadata.gz: 14e5181cd8bf96edb76e90108ffaf724f62037f91098cc03ed23119e13d63f07e0ca41320f7e05e513e64887516208ebaea074fba7941d13d6d0febdd6fe1d40
+  data.tar.gz: b10b32aa9e92e6737ff0c4635270547ecbc903b180d84896f15349c7fa4c4c68913065b62df48c0e95ca19decfb9f44a5f0e4cb84e430f827f721a0c59d68508

data/app/helpers/friends_forms_helper.rb

@@ -0,0 +1,27 @@
+module FriendsFormsHelper
+  
+  def fieldset(title, options = {}, &block)
+    if options[:if].nil? || options[:if] == true
+      data_string = " "
+      if options[:data]
+        options[:data].each {|d,v| data_string << "#{d}='v' "}
+      end  
+      concat raw("<fieldset id='#{options[:id]}' #{data_string} class='shadow #{options[:mainclass]}' #{("style='height: %spx'" % options[:height]) if options[:height]} style='#{options[:mainstyle]}'>")
+      concat raw("<legend class='#{options[:class]}' style='#{options[:style]}'>#{title}</legend><div class='fieldset-content'>")
+        yield
+      concat raw("</div></fieldset>")
+    end  
+  end  
+    
+  def tooltip_box(tooltip)
+    "<span class='label-tooltip' title='#{tooltip}'>&nbsp;</span>".html_safe
+  end
+  
+  def tooltip_content_box(name, options = {}, &block)
+    options[:default_class] ||= "icon-clue"
+    html = "<div class='tooltip-box'><div class='tooltip-box-label #{options[:default_class]}'>"
+    html << "#{name}<div class='tooltip-box-content #{options[:css]} box rounded shadow'>#{capture(&block)}</div></div></div>"
+    concat(html.html_safe)
+  end    
+  
+end  

data/app/helpers/friends_labeled_form_helper.rb

@@ -0,0 +1,124 @@
+# -*- encoding : utf-8 -*-
+module FriendsLabeledFormHelper
+
+  def self.included(arg)
+    ActionView::Helpers::FormBuilder.send(:include, FriendsLabeledFormBuilder)
+  end
+
+  def label_tag_for(object_name, method, options = {})
+    label_name = (options[:label].blank? ? method.to_label : options[:label])
+    
+    label_name += options[:append] unless options[:append].nil?
+    
+    label_text = "<span class='label-text'>#{label_name}</span>"
+
+    if options[:errors]
+      label_text << tooltip_box(options[:errors].to_text)
+    elsif ((options[:label].blank? && options[:tooltip].blank?) || !options[:tooltip].blank?) && options[:tooltip] != false
+      tooltip = (options[:tooltip] || method.to_label(:show_tooltip => true))
+      if !tooltip.blank? && options[:hide_tooltip] != true
+        # Setting Tooltip format for display in Browsertooltip
+        # line breaks in unicode
+        tooltip = tooltip.gsub(/\n|\<br(\ )?(\/)?\>/, "&#xA;")
+        # single to double quotes 
+        tooltip = tooltip.gsub("'", '"')
+        label_text << tooltip_box(tooltip)
+      end  
+    end    
+      
+    
+    label_options = {}
+    label_options.merge!(:class => options[:class]) unless options[:class].blank?
+    label_options.merge!(:for => options[:for]) unless options[:for].blank?
+    label_options.merge!(:id => options[:id]) unless options[:id].blank?
+
+    return label(object_name, method, label_text.html_safe, label_options).html_safe
+  end
+
+  def labeled_text_field(object_name, method, options={})
+    
+    if options[:id]
+      label_options = options.merge(:id => "label-#{options[:id]}")
+    else
+      label_options = options
+    end    
+    
+    html = label_tag_for(object_name, method, label_options)
+    if options[:password] && options.delete(:password)
+      html += password_field(object_name, method, options)
+    else  
+      html += text_field(object_name, method, options)
+    end  
+    return html.html_safe
+  end
+
+  def labeled_check_box(object_name, method, options={}, checked_value=1, unchecked_value=0)
+    method = method.to_s.to_sym
+    box_id = object_name.to_s+"_"+method.to_s
+    
+    html = "<div class='cf labeled-check-box'>"
+    html += "<div class='checkbox-container'>#{check_box(object_name, method, options.merge!(:id => box_id), checked_value, unchecked_value)}</div>"
+    html += "<div class='checkbox-label-container'>#{label_tag_for(object_name, method, :label => options[:label], :tooltip => options[:tooltip], :class => "checkbox-label", :for => box_id, :errors => options[:errors])}</div>"
+    html += "</div>"
+
+    return html.html_safe
+  end
+
+
+
+  def labeled_radio_button(object_name, method, value, options = {})
+    options[:id] ||= "radio-#{method.to_s}-#{value.inspect}"
+    options[:label] ||= method.to_label
+    html = "<div class='cf labeled-radio-button'>"
+    html << radio_button(object_name, method, value, options.except(:label, :errors))
+    html << "&nbsp;"
+    html << label_tag_for(object_name, method, {:label => options[:label], :for => options[:id]})
+    html << "</div>"
+    return raw(html)
+  end    
+
+end
+
+module FriendsLabeledFormBuilder
+  
+  def label_tag_for(method, options = {})
+    @template.label_tag_for(@object_name, method, options)
+  end  
+  
+
+  def labeled_radio_button(method, value, options ={})
+    options[:checked] = (object.send(method) == value) if options[:checked].nil?
+
+    options[:class] ||= ""
+    options[:class] << " error" if ((!object.errors[method.to_sym].empty? && !object.new_record?) rescue false  )
+    options[:errors] = ((object.errors[method.to_sym].empty? ? nil : object.errors[method.to_sym]) rescue false )
+
+    @template.labeled_radio_button(@object_name, method, value, options)
+  end
+
+
+  def labeled_check_box(method, options = {}, checked_value=1, unchecked_value=0)
+
+    options[:class] ||= ""
+    options[:class] << " error" if ((!object.errors[method.to_sym].empty? && !object.new_record?) rescue false  )
+    options[:errors] = ((object.errors[method.to_sym].empty? ? nil : object.errors[method.to_sym]) rescue false )
+
+    options[:checked] ||= ((object.send(method) rescue false) || options[:checked])
+    @template.labeled_check_box(@object_name, method, options, checked_value, unchecked_value)
+  end    
+
+
+  def labeled_text_field(method, options = {})
+
+    options[:value] ||= (object.send(method) rescue nil )
+    options[:class] ||= ""
+    options[:class] << " error" if ((!object.errors[method.to_sym].empty? && !object.new_record?) rescue false )
+
+    options[:errors] = ((object.errors[method.to_sym].empty? ? nil : object.errors[method.to_sym]) rescue false )
+
+    @template.labeled_text_field(@object_name, method, options)
+  end  
+
+end  
+
+

data/app/models/friends_label.rb

@@ -0,0 +1,22 @@
+# -*- encoding : utf-8 -*-
+class FriendsLabel < ActiveRecord::Base
+  
+  validates_uniqueness_of :attribute_name
+  
+  
+
+  labels = {}
+
+  if self.table_exists?
+    concept_labels = FriendsLabel.all
+    concept_labels.each {|l| labels.merge!(l.attribute_name => {:label => l.label, :tooltip => l.tooltip, :docu_tooltip => l.tooltip_docu})}
+  end
+  
+  LABELS = labels
+  
+  
+  def is_unset?
+    return (!(self.attribute_name == self.label)).to_s
+  end  
+
+end

data/config/initializers/values.rb

@@ -0,0 +1,24 @@
+states = [
+  "Baden-Württemberg"     ,
+  "Bayern"                ,
+  "Berlin "               ,
+  "Brandenburg"           ,
+  "Bremen "               ,
+  "Hamburg "              ,
+  "Hessen"                ,
+  "Mecklenburg-Vorpommern",
+  "Niedersachsen"         ,
+  "Nordrhein-Westfalen"   ,
+  "Rheinland-Pfalz"       ,
+  "Saarland"              ,
+  "Sachsen"               ,
+  "Sachsen-Anhalt"        ,
+  "Schleswig-Holstein"    ,
+  "Thüringen"             
+]
+
+GERMAN_STATES = states.map {|s| [s, states.index(s)+1]}
+german_states_hash = {}
+GERMAN_STATES.each {|s| german_states_hash.merge!(s[1] => s[0])}
+
+GERMAN_STATES_HASH = german_states_hash

data/db/migrate/20140326005600_create_labels.rb

@@ -0,0 +1,13 @@
+class CreateLabels < ActiveRecord::Migration
+  
+  def change
+    create_table "friends_labels", :force => true do |t|
+      t.string "attribute_name"
+      t.string "label"
+      t.text   "tooltip"
+      t.text   "tooltip_docu"
+      t.text   "search_tags"
+    end
+  end  
+  
+end  

data/lib/alphanumeric.rb

@@ -0,0 +1,76 @@
+# -*- encoding : utf-8 -*-
+module Alphanumeric
+  
+  # Give every year a letter
+  # TODO: should be automatically computed
+  LETTERS = "abcdefghijklmnopqrstuvwxyz".upcase.split('')
+  
+  START_YEAR = 1960
+  
+  YEAR_LETTERS = {
+    2009 => "A",
+    2010 => "B",
+    2011 => "C",
+    2012 => "D",
+    2013 => "E",
+    2014 => "F",
+    2015 => "G",
+    2016 => "H",
+    2017 => "I",
+    2018 => "J",
+    2019 => "K",
+    2020 => "L",
+    2021 => "M",
+    2022 => "N",
+    2023 => "O",
+    2024 => "P",
+    2025 => "Q",
+    2026 => "R",
+    2027 => "S",
+    2028 => "T",
+    2029 => "U",
+    2030 => "V",
+    2031 => "W",
+    2032 => "X",
+    2033 => "Y",
+    2034 => "Z",
+    2035 => "AA",
+    2036 => "BA",
+    2037 => "CA",
+    2038 => "DA",
+    2039 => "EA",
+    2040 => "FA",
+    2041 => "GA",
+    2042 => "HA",
+    2043 => "IA",
+    2044 => "JA",
+    2045 => "KA",
+    2046 => "LA",
+    2047 => "MA",
+    2048 => "NA",
+    2049 => "OA",
+    2050 => "PA",
+  }
+  
+  def self.year_letter(year=Time.now.year, letters = LETTERS)
+    
+    steps = []
+    
+    d = (year - START_YEAR)
+    n = d.fdiv(letters.size).ceil
+    string = ""
+    
+    n.times do |i| 
+      # First 
+      if i == 0
+        string << letters[d%letters.size]
+      else
+        x = d.fdiv(letters.size*(i+1)).round
+        string << letters[x]
+      end    
+    end  
+    
+    return string
+  end  
+
+end  

data/lib/array.rb

@@ -0,0 +1,280 @@
+# -*- encoding : utf-8 -*-
+# Add the methods to the Array Class
+module ArrayExt
+  Array.class_eval do
+  
+    # Use sum from Activesupport
+    # Sum is not a default in Ruby
+    def sum(identity = 0, &block)
+      if block_given?
+        map(&block).sum(identity)
+      else
+        inject { |sum, element| sum + element } || identity
+      end
+    end
+  
+    # Get avg. value from, either from numeric values or from
+    # values from a object included in array
+    def avg(attribute = nil)
+      value = self
+      if attribute.nil?
+        value.delete(nil)
+        value = self.map {|r| r.to_f }
+      else
+        value = self
+        # Bei fehlerhaften attribute wird nil gespeichert
+        value = value.map {|r| r.send(attribute.to_sym).to_f rescue nil}
+        # Leere Werte löschen
+        value.delete(nil)
+      end
+      # Divide by zero ausschließen
+      value.size == 0 ? size = 1 : size = value.size
+      value.sum / size
+    end
+  
+  
+  
+    # Generate a hash with the given array elements as keys and 'init_value' as value
+    def array_to_hash(init_val = 0)
+      h = {}
+      self.each {|x| h.merge!(x => init_val) unless x.nil? }
+      return h
+    end
+  
+  
+    def to_structured_hash(attribute, options = {})
+      data = {}
+
+      self.each do |item|
+        if attribute.is_a?(Symbol) && options[:load_from_hash] != true
+          key = item.send(attribute) rescue ""
+        elsif attribute.is_a?(Symbol) && options[:load_from_hash] == true  
+          key = item[attribute] rescue ""
+        elsif attribute.is_a?(String)
+          attribute_methods = attribute.split(".")  
+          key = item.send(attribute_methods[0])
+          attribute_methods[1..-1].each do |x|
+            key = key.send(x) rescue ""
+          end
+        end
+
+        if data[key].nil?
+          data.merge!(key => [item])
+        else
+          data[key] << item
+        end      
+      end
+
+      return data  
+    end    
+
+  
+    # Sum up an array of objects with given attirbute
+    # Attributes can be given as symbol (:my_value will return obj.my_value)
+    # or as string ("user.my_value" will return my_value from user object which belongs to object in array)
+    # also, options could be passed, which could be *args or options hash
+    def sum_with_attribute(arg, opt =nil)
+      if arg.nil?
+        return self.compact.sum
+      else
+        values = []
+        if arg.is_a?(Symbol)
+          self.map {|i| ((opt.nil? ? i.send(arg) : i.send(arg, opt)) rescue 0) }.sum 
+        elsif arg.is_a?(String)
+          self.each do |v|
+            tag_methods = arg.split(".")  
+            tagx = v.send(tag_methods[0])
+            tag_methods[1..-1].each do |x|
+              # Use options if last method in chain called
+              if tag_methods[1..-1].last == x && !opt.nil?
+                tagx = tagx.send(x,opt)
+              else  
+                tagx = tagx.send(x)
+              end  
+            end
+            values << tagx  
+          end
+          return values.compact.sum
+        end
+      end
+    end
+  
+
+    # check the number of items included in the array
+    def count_for(item)
+      count = 0
+      self.each {|x| count += 1 if x == item}
+      return count
+    end
+  
+  
+    # return the item after the given val in array
+    # returns val if no item found or val is not included
+    # toggle :cycle => true to continue search at beginn of array if end is reached
+    def next(val, options = {})
+      i = self.index(val)
+      return val if i.nil?
+      
+      i == self.size-1 ?
+        (options[:cycle] == true ? self.first : val) : self[i+1] 
+    end  
+  
+  
+    # Schnittmenge / Intersection zwischen 2 Arrays
+    def isec(b)
+      raise ArgumentError, "#{b.inspect} is not an array" if !b.is_a?(Array)
+      (self- (self-b))
+    end  
+  
+    # like except for hash
+    def except(*args)
+      excluded = *args
+      return self - excluded
+    end  
+  
+    # break array into n arrays
+    def seperate(n = 8)
+      f = n
+      aks_size  = self.size
+      rest      = aks_size % f
+
+      stack = ((aks_size - rest) / f)
+
+      arrays = (1..f).to_a
+
+      arrays.map! {|i| self.first(stack*i).last(stack) }
+      arrays[-1] += self.last(rest) if rest != 0
+      #arrays.last.pop if (arrays.last.last.empty? || arrays.last.last.blank?)
+      return arrays
+    end
+  
+    # [1,2,3,5,6,7].stack(2)
+    #  will return [[1, 2], [3, 5], [6, 7]]
+    def stack(n = 4)
+      arr = []
+      i = (self.size.to_f/n).ceil
+      i.times do |x|
+        arr << self[x*n..(((x+1)*n)-1)]
+      end    
+      return arr
+    end  
+  
+
+    # Prepare array for use with mysql IN operator
+    def to_sql
+      return "(NULL)" if self.empty?
+      if self.first.is_a?(Numeric)
+        return "(#{self.compact.join(',')})"
+      else
+        return "(#{self.map{|i| "'#{i.to_s}'"}.join(',')})"
+      end    
+    end 
+  
+    #== Untested / deprecated functions below, should be moved somewhere else!
+    # Ignore these functions, there are neither tested nor documented, use them for fun if you like but dont ask me ;-)
+  
+    def fill_with_sth(sth, size)
+      ary_length = self.size
+      diff = size - ary_length
+      if diff > 0
+        pop = Array.new(diff){|i| sth}
+        new_ary = pop.push(self).flatten!
+        return new_ary
+      else
+        return self
+      end
+    end
+
+
+    # Generiert einen JSON-String aus einem Array mit Werten
+    def json_labels
+      json = "["
+      self.each_with_index {|l,i| json << '{"id": "%s", "text": "%s"}' % [i, l] ; json << "," unless i+1 == self.size}
+      json << "]"
+    end
+
+    def to_text(sep = "<br />")
+      if Rails.env == "development"
+        raise "#REMOVED - use .join() - (17.12.2013, 15:18, Florian Eck)"
+      else  
+        self.join(sep)
+      end  
+    end 
+    
+    
+    def interpolate(filtered_value = nil, options = {})
+      begin
+      
+        int_start_value = nil
+        int_end_value   = nil
+        int_from        = 0
+        int_to          = 0 
+        int_steps       = 0 
+      
+        array_with_interpolation = []
+      
+        self.each_with_index do |x,i| 
+          if i > 0
+            if x != filtered_value
+              # Wenn der letze ein fehler war ist die strecke zuende
+              if self[i-1] == filtered_value
+              
+                if i-1 == 0
+                  # Berechnung anstieg der linearfunktion zwischen Start-und Endpunkt
+                  # 
+                  m = (self[i+1]-x)
+                
+                  array_with_interpolation[0] = x-m
+                  array_with_interpolation << x
+                
+                else  
+                  int_end_value = x
+                  int_to        = i
+                
+                  # Berechnung anstieg der linearfunktion zwischen Start-und Endpunkt
+                  m = (int_end_value-int_start_value).fdiv((int_to-int_from))
+              
+                  # Fülle fehlende werte mit werten (y = mx + b)
+                  int_steps.times {|mi| array_with_interpolation << (int_start_value+((mi+1)*m)) }
+                  array_with_interpolation << int_end_value
+              
+                  # Reset all values
+                  int_start_value = int_end_value
+                  int_end_value   = nil
+                  int_from        = 0
+                  int_to          = 0 
+                  int_steps       = 0  
+                  puts array_with_interpolation.inspect
+                end  
+              else  
+                int_start_value = x
+                array_with_interpolation << x
+              end
+            # Wenn letzer wert fehlerhaft  
+            elsif i == self.size-1 && x == filtered_value
+              # Berechnung anstieg der linearfunktion zwischen Start-und Endpunkt
+              # Berechnung über gesamtes array
+              m = (array_with_interpolation.last-array_with_interpolation.first).fdiv(array_with_interpolation.size-1)
+              array_with_interpolation << (array_with_interpolation.last+m)
+            else  
+              int_steps += 1
+              int_from = i-int_steps
+            end    
+      
+          else
+            int_start_value = x
+            array_with_interpolation << x
+          end    
+        
+        end  
+      
+        return array_with_interpolation
+      rescue
+        puts "WARNING: Interpolation not possible!".red
+        return self
+      end    
+      
+    end   
+
+  end  
+end

data/lib/boolean.rb

@@ -0,0 +1,32 @@
+# -*- encoding : utf-8 -*-
+
+# Functions for True/FalseClass
+module Boolean
+  [TrueClass, FalseClass].each do |bclass|
+  
+    bclass.class_eval do
+      
+      # return string if true/false
+      def to_real(t = "ja", f = "nein")
+        case self
+        when TrueClass
+          return t
+        else
+          return f
+        end    
+      end  
+    
+      # return integer if true/false
+      def to_i
+        case self
+        when TrueClass
+          return 1
+        else
+          return 0
+        end    
+      end
+    
+    end  
+
+  end  
+end