your_platform 0.0.1 → 0.0.2

data/app/models/active_record_associations_patches.rb

@@ -0,0 +1,26 @@
+module ActiveRecordAssociationsPatches
+  extend ActiveSupport::Concern
+  
+  # This fixes a bug in ActiveRecord Association Callbacks.
+  # https://github.com/rails/rails/issues/7618
+  #
+  # For example `group.members.destroy(user)` would not call the `before_destroy` callbacks
+  # on the memberships (i.e. the through_records of the HasManyThrough association).
+  #
+  # But we need the cache deletion to be called. Therefore, we trigger them here manually.
+  #
+  def destroy(*records)
+    if self.class.name == "ActiveRecord::Associations::HasManyThroughAssociation"
+      through_association.load_target
+      records.each do |record|
+        through_records_for(record).each do |through_record|
+          through_record.delete_cache if through_record.respond_to? :delete_cache
+        end
+      end
+    end
+    super(*records)
+  end
+  
+end
+
+ActiveRecord::Associations::CollectionAssociation.send(:prepend, ActiveRecordAssociationsPatches)

data/app/models/active_record_cache_extension.rb

@@ -0,0 +1,152 @@
+#
+# To understand our caching conventions, have a look at our wiki page:
+# https://github.com/fiedl/wingolfsplattform/wiki/Caching
+# 
+module ActiveRecordCacheExtension
+  extend ActiveSupport::Concern
+  
+  # Case 1: Use it to call a cached method result.
+  # 
+  #     user.cached(:name)
+  #
+  # Case 2: Use it to call a cached method with arguments.
+  # Use this with care, since there is a cache for each argument!
+  #
+  #     user.cached(:membership_in, group)
+  #
+  # Case 3: Use it with a block within a method definition.
+  # This moves the responsibility to cache into the model itself.
+  # 
+  #     class User
+  #       def name
+  #         cached { "#{first_name} #{last_name}" }
+  #       end
+  #     end
+  #     
+  #     user.name  # already uses the cache!
+  #
+  def cached(method_name = nil, arguments = nil, &block)
+    if method_name
+      cached_method(method_name, arguments)
+    else
+      cached_block(&block)
+    end
+  end
+  
+  def cached_method(method_name, arguments = nil)
+    cached_block(method_name: method_name, arguments: arguments) do
+      arguments ? send(method_name, *arguments) : send(method_name)
+    end
+  end
+  private :cached_method
+  
+  # options: 
+  #   method_name
+  #   arguments
+  #
+  def cached_block(options = {}, &block)
+    # This gives the method name that called the #cached method.
+    # See: http://www.ruby-doc.org/core-2.1.2/Kernel.html
+    #
+    if options[:method_name] && options[:arguments]
+      key = [options[:method_name], options[:arguments]]
+    elsif options[:method_name]
+      key = options[:method_name]
+    else
+      caller_method_name = caller_locations(2,1)[0].label
+      key = caller_method_name
+    end
+    rescue_from_too_big_to_marshal(block) do
+      Rails.cache.fetch([self, key], expires_in: 1.week) do
+        process_result_for_caching(yield)
+      end
+    end
+  end
+  private :cached_block
+  
+  def process_result_for_caching(result)
+    # Not all ActiveRecord::Relation objects can be stored in cache.
+    # Convert them to Arrays. Otherwise, this might raise an 'cannot dump' error.
+    result = result.to_a if result.kind_of? ActiveRecord::Relation
+    
+    # This circumvents a bug: https://github.com/mperham/dalli/issues/250
+    Marshal.dump(result)
+    
+    # Store the result in cache.
+    return result
+  end
+  private :process_result_for_caching
+  
+  def rescue_from_too_big_to_marshal(block_without_caching, &block_with_caching)
+    begin
+      yield
+    rescue ArgumentError, NameError => exc
+      if exc.message.include? 'year too big to marshal'
+        block_without_caching.call
+      else
+        raise exc
+      end
+    end
+  end
+  private :rescue_from_too_big_to_marshal
+  
+  
+  def invalidate_cache
+    # Be careful in specs. This takes one second to count as invalid.
+    self.touch
+  end
+  
+  def delete_cached(method_name)
+    # p "DEBUG DELETE CACHED #{self} #{method_name}"
+    Rails.cache.delete [self, method_name]
+    Rails.cache.delete_matched "#{self.cache_key}/#{method_name}/*"
+  end
+  
+  def bulk_delete_cached(method_name, objects)
+    ids = objects.map &:id
+    regex = /.*\/(#{ids.join('|')})(-.*|)\/#{method_name}.*/
+    # p "DEBUG BULK DELETE CACHE #{regex}"
+    Rails.cache.delete_regex regex
+  end
+  
+  def delete_cache
+    # p "DEBUG DELETE CACHE #{self}"
+    Rails.cache.delete_matched "#{self.cache_key}/*"
+  end
+  
+  def cache_created_at(method_name, arguments = nil)
+    CacheAdditions
+    Rails.cache.created_at [self, method_name, arguments]
+  end
+  
+  # This method ensures that no app cache is used to produce the result.
+  # If you call
+  #
+  #    user.uncached :title
+  #
+  # this calls `user.title` but makes sure, no app cache is used at all.
+  # Note: This does not prevent the sql cache to be used.
+  #
+  # You could use this in specs:
+  #
+  #     user.cached(:title).should == user.uncached(:title)
+  #
+  # ## What about user.title?
+  #
+  # Usually, user.title returns the uncached version; but if cached methods
+  # are used in the implementation of `User#title` then `user.title` does use these
+  # caches. If you call `user.uncached(:title)`, all app caches are ignored.
+  #
+  def uncached(method_name, args = nil)
+    Rails.cache.uncached do
+      if args
+        self.send method_name, *args
+      else
+        self.send method_name
+      end
+    end
+  end
+  
+  module ClassMethods
+  end
+end

data/app/models/active_record_find_by_extension.rb

@@ -0,0 +1,20 @@
+module ActiveRecordFindByExtension
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+
+    # A Rails 4 alias for `where`.
+    # See: https://github.com/rails/rails/blob/master/activerecord/lib/active_record/relation/finder_methods.rb
+    #
+    # It will return the first matching object and return the object, not an ActiveRecord::Relation.
+    # If an ActiveRecord::Relation, which is chainable, is needed, use where().
+    #
+    def find_by( args )
+      where( args ).limit( 1 ).first
+    end
+
+  end
+
+end
+
+ActiveRecord::Base.send( :include, ActiveRecordFindByExtension ) if Rails.version < "4.0"

data/app/models/active_record_json_url_extension.rb

@@ -0,0 +1,51 @@
+module ActiveRecordJsonUrlExtension
+  extend ActiveSupport::Concern
+
+  def serializable_hash( options = {} )
+    options[ :methods ] = [ :url ] if not options[ :methods ]
+    options[ :methods ] = [ options[ :methods ] ] if options[ :methods ].kind_of? Symbol
+    options[ :methods ] << :url if options[ :methods ]
+    raise 'options[ :methods ] should be an array' unless options[ :methods ].kind_of? Array
+    super options
+  end
+
+  def url
+    UrlHelper.new( self ).url
+  end
+  
+  # The following class generates a scope that prevents the url helpers
+  # from being included directly into ActiveRecordJsonUrlExtension and therefore
+  # into ActiveRecord::Base. 
+  #
+  #   class MyModel < ActiveRecord::Base
+  #   end
+  #
+  #   my_instance = MyModel.create()
+  #
+  # You may call <tt>my_instance.url()</tt> to get the same result as for
+  # <tt>url_for(my_instance)</tt>.
+  # But you should not be able to call, for example, 
+  # <tt>my_instance.my_model_path( ... )</tt>.
+  #
+  class UrlHelper
+
+    include Rails.application.routes.url_helpers
+    include ActionDispatch::Routing::UrlFor
+
+    def initialize( obj )
+      @obj = obj
+    end
+    
+    def url_options
+      Rails.application.config.action_mailer.default_url_options
+    end
+
+    def url
+      url_for @obj
+    end
+
+  end
+  
+end
+
+ActiveRecord::Base.send( :include, ActiveRecordJsonUrlExtension )

data/app/models/active_record_metric_events_extension.rb

@@ -0,0 +1,22 @@
+module ActiveRecordMetricEventsExtension
+#   extend ActiveSupport::Concern
+# 
+#   # This triggers a event for the metric logger service.
+#   #
+#   # Example:
+#   # 
+#   # class PagesController
+#   #   def show
+#   #     # ...
+#   #     @page.log_metric_event(:show)
+#   #   end
+#   # end
+#   #
+#   def log_metric_event(type)
+#     type = "#{type}_#{self.class.name.underscore}"  # e.g. show_page
+#     MetricLogger.log_event(self.attributes, type: type)
+#   end
+#   
+end
+
+# ActiveRecord::Base.send( :include, ActiveRecordMetricEventsExtension )

data/app/models/active_record_read_only_extension.rb

@@ -0,0 +1,35 @@
+module ActiveRecordReadOnlyExtension
+  extend ActiveSupport::Concern
+  
+  def destroy
+    raise 'Read-Only Mode' if readonly?
+    super
+  end
+  
+  module ClassMethods
+    def read_only_mode?
+      # Read only mode only applies to the web server, not the console or rake tasks,
+      # since they are used for maintenance during read-only mode.
+      #
+      @@read_only_mode = (read_only_trigger? and not console? and not rake_task?) if not defined?(@@read_only_mode)
+      @@read_only_mode
+    end
+    def read_only_trigger?
+      File.exist?(File.join(Rails.root, 'tmp/read_only_mode'))
+    end
+    def console?
+      defined?(Rails::Console)
+    end
+    def rake_task?
+      File.basename($0) == 'rake'
+    end
+  end
+end
+
+module ActiveRecord
+  class Base
+    def readonly?
+      ActiveRecord::Base.read_only_mode?
+    end
+  end
+end

data/app/models/active_record_update_attributes_bip_extension.rb

@@ -0,0 +1,24 @@
+# This module overrides the regular `update_attributes` method in order to
+# fix some issues with best_in_place. For unknown reasons, best_in_place keeps
+# sending post requests with empty strings — without pattern we could recognize,
+# so far. Therefore, this hack is a quick fix to avoid accidental data loss 
+# until we have fixed the real issue, which is on the view/js side, really.
+#
+module ActiveRecordUpdateAttributesBipExtension
+  extend ActiveSupport::Concern
+
+  # Definition of the original method:
+  # http://apidock.com/rails/v3.2.13/ActiveRecord/Persistence/update_attributes
+  # 
+  def update_attributes(attributes, options = {})
+    # We allow `nil`, but we do not allow "" (empty string).
+    non_empty_attributes = attributes.select { |key, value| value != "" }
+    super(non_empty_attributes, options)
+  end
+
+  module ClassMethods
+  end
+
+end
+
+ActiveRecord::Base.send(:include, ActiveRecordUpdateAttributesBipExtension)

data/app/models/address_label.rb

@@ -0,0 +1,50 @@
+class AddressLabel
+  attr_accessor :name
+  attr_accessor :company
+  attr_accessor :postal_address, :postal_code, :country_code, :country, :city
+  attr_accessor :text_above_name, :text_below_name, :name_prefix, :name_suffix
+  attr_accessor :personal_title
+  
+  def initialize(name, address_field, name_surrounding_field, personal_title = '', company = '')
+    self.name = name
+    self.company = company
+    self.postal_address = address_field.try(:value)
+    self.postal_code = address_field.try(:postal_code)
+    self.country_code = address_field.try(:country_code)
+    self.country = address_field.try(:geo_location).try(:country)
+    self.city = address_field.try(:geo_location).try(:city)
+    self.text_above_name = name_surrounding_field.try(:text_above_name).try(:strip)
+    self.text_below_name = name_surrounding_field.try(:text_below_name).try(:strip)
+    self.name_prefix = name_surrounding_field.try(:name_prefix).try(:strip)
+    self.name_suffix = name_surrounding_field.try(:name_suffix).try(:strip)
+    self.personal_title = personal_title
+  end
+  
+  def to_s
+    postal_address_with_name_surrounding
+  end
+  
+  def postal_address_with_name_surrounding
+    # text_before_the_name = name_prefix || ""
+    # text_before_the_name += " #{personal_title}" if name_prefix != personal_title
+    # ("#{text_above_name}\n" + 
+    #   "#{text_before_the_name} #{name} #{name_suffix}\n" + 
+    #   "#{text_below_name}\n" +
+    #   (postal_address || "")
+    # )
+    (
+      "#{text_above_name}\n" +
+      "#{name_prefix} #{name} #{name_suffix}\n" +
+      "#{text_below_name}\n" +
+      "#{company}\n" + 
+      (postal_address || "")
+    )
+    .gsub('  ', ' ')
+    .gsub("\n\n\n", "\n")
+    .gsub("\n\n", "\n")
+    .gsub(" \n", "\n")
+    .gsub("\n ", "\n")
+    .strip
+  end
+  
+end

data/app/models/app_version.rb

@@ -0,0 +1,49 @@
+class AppVersion
+  
+  def self.last_tag
+    `git describe --abbrev=0 --tags`.strip
+  end
+  
+  def self.version
+    last_tag.gsub("v", "")
+  end
+  
+  def self.commit_id
+    `git rev-parse HEAD`.strip
+  end
+  
+  def self.short_commit_id
+    `git rev-parse --short HEAD`.strip
+  end
+  
+  # Returns something like:
+  # `git@github.com:fiedl/wingolfsplattform.git`
+  def self.git_remote_url
+    `git config --get remote.origin.url`.strip
+  end
+  
+  def self.github_repo_url
+    git_remote_url.gsub(":", "/").gsub("git@", "https://").gsub(/.git$/, "")
+  end
+
+  def self.github_commit_url
+    "#{github_repo_url}/commit/#{commit_id}"
+  end
+  
+  def self.changelog_url
+    "#{github_repo_url}/commits/#{branch}"
+  end
+  
+  def self.releases_url
+    "#{github_repo_url}/releases"
+  end
+  
+  def self.branch
+    `git rev-parse --abbrev-ref HEAD`.strip
+  end
+  
+  def self.app_name
+    Setting.app_name || Rails.application.class.parent_name
+  end
+
+end

data/app/models/array.rb

@@ -0,0 +1,15 @@
+# This patches the basic Array object.
+#
+class Array
+  
+  # Pass the `reload` to all objects in the array
+  # if they respond to `reload`.
+  #
+  # This is used in model caching.
+  # See, for exmaple, `app/models/cache_store_extension.rb`.
+  #
+  def reload
+    collect { |element| element.reload if element.respond_to?(:reload) }
+  end
+  
+end