udongo 0.1.0

data/app/models/concerns/emailable.rb

@@ -0,0 +1,7 @@
+module Concerns::Emailable
+  extend ActiveSupport::Concern
+
+  def email_vars
+    @email_vars ||= "Udongo::EmailVars::#{self.class.name}".constantize.new self
+  end
+end

data/app/models/concerns/flexible_content.rb

@@ -0,0 +1,9 @@
+module Concerns
+  module FlexibleContent
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :content_rows, as: :rowable, dependent: :destroy
+    end
+  end
+end

data/app/models/concerns/locale.rb

@@ -0,0 +1,10 @@
+# This concern is applicable when your model has a 'locale' field.
+module Concerns
+  module Locale
+    extend ActiveSupport::Concern
+
+    included do
+      scope :by_locale, ->(l) { where(locale: l) }
+    end
+  end
+end

data/app/models/concerns/loggable.rb

@@ -0,0 +1,13 @@
+module Concerns
+  module Loggable
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :logs, as: :loggable, dependent: :destroy
+    end
+
+    def log(message, category: nil, data: nil)
+      logs.create!(content: message, category: category, data: data)
+    end
+  end
+end

data/app/models/concerns/notable.rb

@@ -0,0 +1,9 @@
+module Concerns
+  module Notable
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :notes, as: :notable, dependent: :destroy
+    end
+  end
+end

data/app/models/concerns/parentable.rb

@@ -0,0 +1,39 @@
+# If you want to use this concern, you need to add an integer field 'parent_id'
+# to the model.
+module Concerns
+  module Parentable
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :children, class_name: self.name, foreign_key: :parent_id, dependent: :destroy
+      belongs_to :parent, class_name: self.name
+    end
+
+    def depth
+      parent.nil? ? 0 : 1 + parent.depth
+    end
+
+    def parentable?
+      true
+    end
+
+    def parents(instance: nil, list: [], include_self: true)
+      instance = self unless instance.present?
+      list << instance if include_self
+      instance.parent ? parents(instance: instance.parent, list: list) : list
+    end
+
+    module ClassMethods
+      def flat_tree(parent_id: nil, list: [])
+        children = name.constantize.where(parent_id: parent_id)
+
+        children.each do |c|
+          list << c
+          list = self.flat_tree(parent_id: c.id, list: list) if c.children.any?
+        end
+
+        list
+      end
+    end
+  end
+end

data/app/models/concerns/person.rb

@@ -0,0 +1,7 @@
+module Concerns
+  module Person
+    def full_name
+      "#{first_name} #{last_name}"
+    end
+  end
+end

data/app/models/concerns/publishable.rb

@@ -0,0 +1,22 @@
+module Concerns
+  module Publishable
+    extend ActiveSupport::Concern
+
+    included do
+      scope :published, ->{ where('published_at < ?', Time.zone.now).order('published_at DESC') }
+      scope :not_published, ->{ where('published_at > ? OR published_at IS NULL OR published_at = ?', Time.zone.now, '') }
+    end
+
+    def publish!(time = Time.zone.now)
+      update_attribute :published_at, time
+    end
+
+    def unpublish!
+      update_attribute :published_at, nil
+    end
+
+    def published?
+      published_at && published_at.past?
+    end
+  end
+end

data/app/models/concerns/seo.rb

@@ -0,0 +1,31 @@
+module Concerns
+  module Seo
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :meta, as: :sluggable, dependent: :destroy
+    end
+
+    module ClassMethods
+      def find_by_slug(slug, locale: I18n.locale)
+        joins(:meta).where(
+          'meta.locale' => locale,
+          'meta.slug' => slug,
+          'meta.sluggable_type' => self.name
+        ).first
+      end
+
+      def find_by_slug!(slug, locale: I18n.locale)
+        find_by_slug(slug, locale: locale) || raise('No such record found')
+      end
+    end
+
+    def seo(locale = I18n.locale)
+      @seo_collections = {} unless @seo_collections
+      return @seo_collections[locale.to_sym] if @seo_collections[locale.to_sym]
+
+      existing_meta = meta.find_by(locale: locale)
+      @seo_collections[locale.to_sym] = existing_meta ? existing_meta : meta.new(locale: locale)
+    end
+  end
+end

data/app/models/concerns/sortable.rb

@@ -0,0 +1,30 @@
+# If you want to use this concern, you need to add an integer field 'position'
+# to the model.
+module Concerns
+  module Sortable
+    extend ActiveSupport::Concern
+
+    included do
+      acts_as_list
+      default_scope ->{ order(:position) }
+    end
+
+    module ClassMethods
+      def sortable(*args)
+        acts_as_list *args
+      end
+    end
+
+    def set_position(new_position, parent_id = nil)
+      if respond_to?(:draggable?) && !draggable? || position == new_position.to_i
+        return false
+      end
+
+      if respond_to?(:parentable?) && parentable?
+        update_attribute :parent_id, parent_id
+      end
+
+      set_list_position new_position
+    end
+  end
+end

data/app/models/concerns/spammable.rb

@@ -0,0 +1,38 @@
+# If you want to use this module, you need to add a boolean field
+# 'marked_as_spam' to the model.
+module Concerns
+  module Spammable
+    extend ActiveSupport::Concern
+
+    included do
+      include Rakismet::Model
+
+      scope :spam, ->{ where(marked_as_spam: true) }
+      scope :not_spam, -> { where('marked_as_spam = 0 OR marked_as_spam IS NULL') }
+
+      after_initialize :spam_defaults
+    end
+
+    module ClassMethods
+      def spammable(*args)
+        rakismet_attrs *args
+      end
+    end
+
+    def mark_as_spam!
+      update_attribute :marked_as_spam, true
+    end
+
+    def unmark_as_spam!
+      update_attribute :marked_as_spam, false
+    end
+
+    private
+
+    def spam_defaults
+      if self.new_record?
+        self.marked_as_spam = false if marked_as_spam.nil?
+      end
+    end
+  end
+end

data/app/models/concerns/storable/collection.rb

@@ -0,0 +1,117 @@
+module Concerns
+  module Storable
+    class Collection
+      def initialize(parent, config)
+        @parent = parent
+        @config = config
+        @stores = {}
+      end
+
+      def method_missing(method_sym, *arguments, &block)
+        ascii_name = method_sym.to_s.gsub('=', '').to_sym
+
+        if @config.fields.keys.include?(ascii_name)
+          if method_sym.to_s.include?('=')
+            write(ascii_name, arguments.first)
+          else
+            read(method_sym)
+          end
+        else
+          super
+        end
+      end
+
+      def read(field)
+        field = field.to_sym
+        init_field(field.to_sym)
+        object = @stores[field]
+
+        unless object.value.nil?
+          return object.value if klasses_match(@config.fields[field][:klass], object.value)
+        end
+
+        object.value = Marshal.load(Marshal.dump(@config.fields[field][:default]))
+        object.value
+      end
+
+      def write(field, value)
+        field = field.to_sym
+        init_field(field)
+        value = transform_value(@config.fields[field][:klass], value)
+
+        @stores[field].value = value
+      end
+
+      def save
+        @stores.map { |field,object| object.save }
+      end
+
+      private
+
+      def init_field(field)
+        unless @stores[field.to_sym]
+          raise "The field '#{field.to_s}' is not allowed." unless @config.allowed?(field)
+
+          @stores[field] = ::Store.find_or_create_by!(
+            storable_type: @parent.class.name,
+            storable_id: @parent.id,
+            klass: @config.fields[field.to_sym][:klass],
+            name: field
+          )
+        end
+      end
+
+      def klasses_match(klass, value)
+        Concerns::Storable::Config::KLASSES[klass].include? value.class
+      end
+
+      def transform_value(klass, value)
+        send("#{klass}_value", value)
+      end
+
+      def string_value(value)
+        value.to_s if value.is_a?(String) || value.is_a?(Symbol)
+      end
+
+      def integer_value(value)
+        value if value.is_a?(Fixnum)
+      end
+
+      def float_value(value)
+        value if value.is_a?(Float)
+      end
+
+      def array_value(value)
+        value if value.is_a?(Array)
+      end
+
+      def boolean_value(value)
+        if value === true || value == '1' || value == 1
+          true
+        elsif value === false || value == '0' || value == 0
+          false
+        end
+      end
+
+      def date_value(value)
+        return value if value.is_a?(Date)
+
+        begin
+          Date.parse(value)
+        rescue
+          nil
+        end
+      end
+
+      def date_time_value(value)
+        return value if value.is_a?(DateTime)
+
+        begin
+          DateTime.parse(value)
+        rescue
+          nil
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/storable/config.rb

@@ -0,0 +1,40 @@
+module Concerns
+  module Storable
+    class Config
+      attr_reader :fields
+
+      KLASSES = {
+        array: [Array],
+        boolean: [TrueClass, FalseClass],
+        date: [Date],
+        date_time: [DateTime],
+        float: [Float],
+        integer: [Fixnum],
+        string: [String]
+      }
+
+      def initialize
+        @fields = {}
+      end
+
+      def add(field, klass, default = nil)
+        raise "#{klass} is not a valid storable config klass" unless valid_klass?(klass)
+
+        @fields[field.to_sym] = {
+          klass: klass.to_sym,
+          default: default
+        }
+      end
+
+      def allowed?(field)
+        @fields.keys.include?(field.to_sym)
+      end
+
+      private
+
+      def valid_klass?(value)
+        KLASSES.keys.include?(value.to_sym)
+      end
+    end
+  end
+end

data/app/models/concerns/storable.rb

@@ -0,0 +1,32 @@
+module Concerns
+  module Storable
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :stores, as: :storable, dependent: :destroy
+      after_save { store.save }
+    end
+
+    def store
+      @store_collection ||= Concerns::Storable::Collection.new(
+        self, self.class.store_config
+      )
+    end
+
+    def storable?
+      true
+    end
+
+    module ClassMethods
+      def storable_field(name, klass, default = nil)
+        delegate name, to: :store
+        delegate "#{name}=", to: :store
+        store_config.add(name, klass, default)
+      end
+
+      def store_config
+        @store_config ||= Concerns::Storable::Config.new
+      end
+    end
+  end
+end

data/app/models/concerns/taggable.rb

@@ -0,0 +1,29 @@
+module Concerns
+  module Taggable
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :tagged_items, as: :taggable
+    end
+
+    def related(locale = I18n.locale)
+      tagged_items = TaggedItem.where(tag_id: tags(locale).map(&:id), taggable_type: self.class.name)
+      tagged_items.to_a.inject([]) do |memo,i|
+        memo << self.class.find(i.taggable_id) unless i.taggable_id == id
+        memo
+      end.uniq
+    end
+
+    def tags(locale = I18n.locale)
+      tagged_items.select { |i| i.tag.locale == locale.to_s }.map(&:tag)
+    end
+
+    def tags_string(locale = I18n.locale)
+      tags(locale).map(&:name).join(',')
+    end
+
+    def taggable?
+      true
+    end
+  end
+end

data/app/models/concerns/translatable/collection.rb

@@ -0,0 +1,60 @@
+module Concerns
+  module Translatable
+    class Collection
+      def initialize(parent, config, locale)
+        @parent = parent
+        @config = config
+        @locale = locale
+        @translations = {}
+      end
+
+      def method_missing(method_sym, *arguments, &block)
+        ascii_name = method_sym.to_s.gsub('=', '').to_sym
+
+        if @config.fields.include?(ascii_name)
+          if method_sym.to_s.include?('=')
+            write(ascii_name, arguments.first)
+          else
+            read(method_sym)
+          end
+        else
+          super
+        end
+      end
+
+      def read(field)
+        init_field(field.to_sym)
+        @translations[field.to_sym].value
+      end
+
+      def write(field, value)
+        init_field(field.to_sym)
+        @translations[field.to_sym].value = value
+      end
+
+      def save
+        @translations.map { |field,object| object.save }
+
+        @parent.update_attribute(
+          :locales,
+          @parent.translations.where.not(value: nil).pluck(:locale).uniq.sort
+        )
+      end
+
+      private
+
+      def init_field(field)
+        unless @translations[field.to_sym]
+          raise "The field '#{field.to_s}' is not allowed." unless @config.allowed?(field)
+
+          @translations[field] = Translation.find_or_create_by!(
+            translatable_type: @parent.class.name,
+            translatable_id: @parent.id,
+            locale: @locale,
+            name: field
+          )
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/translatable/config.rb

@@ -0,0 +1,19 @@
+module Concerns
+  module Translatable
+    class Config
+      attr_reader :fields
+
+      def initialize
+        @fields = []
+      end
+
+      def add(field)
+        @fields << field.to_sym unless @fields.include?(field.to_sym)
+      end
+
+      def allowed?(field)
+        @fields.include?(field.to_sym)
+      end
+    end
+  end
+end

data/app/models/concerns/translatable.rb

@@ -0,0 +1,39 @@
+# To use this module you need to add a text column to your model. This will be
+# used to determine in which locales the translations exist.
+module Concerns
+  module Translatable
+    extend ActiveSupport::Concern
+
+    included do
+      serialize :locales, Array
+      has_many :translations, as: :translatable, dependent: :destroy
+      scope :within_locale, ->(locale) { where('locales LIKE ?', "%#{locale}%")}
+    end
+
+    def translation(locale = I18n.locale)
+      @translation_collections = {} unless @translation_collections
+      @translation_collections[locale.to_sym] ||= Concerns::Translatable::Collection.new(
+        self, self.class.translation_config, locale
+      )
+    end
+
+    def translatable?
+      true
+    end
+
+    module ClassMethods
+      def translatable_field(name)
+        delegate name, to: :translation
+        translation_config.add(name)
+      end
+
+      def translatable_fields(*args)
+        args.each { |name| translatable_field(name) }
+      end
+
+      def translation_config
+        @translation_config ||= Concerns::Translatable::Config.new
+      end
+    end
+  end
+end

data/app/models/concerns/visible.rb

@@ -0,0 +1,24 @@
+# If you want to use this concern, you need to add a boolean field 'visible' to
+# the model.
+module Concerns
+  module Visible
+    extend ActiveSupport::Concern
+
+    included do
+      scope :visible, ->{ where(visible: true) }
+      scope :hidden, ->{ where('visible = 0 OR visible IS NULL') }
+    end
+
+    def hidden?
+      !visible?
+    end
+
+    def hide!
+      update_attribute :visible, false
+    end
+
+    def show!
+      update_attribute :visible, true
+    end
+  end
+end

data/app/models/content_column.rb

@@ -0,0 +1,14 @@
+class ContentColumn < ActiveRecord::Base
+  include Concerns::Sortable
+  sortable(scope: :row_id)
+
+  belongs_to :row, class_name: 'ContentRow', touch: true
+  belongs_to :content, polymorphic: true, dependent: :destroy
+
+  validates :row, presence: true
+  validates :width_xs, :width_sm, :width_md, :width_lg, :width_xl,
+            presence: true,
+            numericality: { greater_than: 0, less_than_or_equal_to: 12,  only_integer: true }
+
+  default_scope -> { order(:position) }
+end

data/app/models/content_image.rb

@@ -0,0 +1,9 @@
+class ContentImage < ActiveRecord::Base
+  include Concerns::ContentType
+
+  mount_uploader :file, ContentImageUploader
+
+  def content_type
+    :image
+  end
+end

data/app/models/content_row.rb

@@ -0,0 +1,11 @@
+class ContentRow < ActiveRecord::Base
+  include Concerns::Locale
+
+  include Concerns::Sortable
+  sortable scope: [:locale, :rowable_type, :rowable_id]
+
+  belongs_to :rowable, polymorphic: true, touch: true
+  has_many :columns, class_name: 'ContentColumn', foreign_key: :row_id, dependent: :destroy
+
+  validates :locale, presence: true
+end

data/app/models/content_text.rb

@@ -0,0 +1,7 @@
+class ContentText < ActiveRecord::Base
+  include Concerns::ContentType
+
+  def content_type
+    :text
+  end
+end

data/app/models/email.rb

@@ -0,0 +1,13 @@
+class Email < ActiveRecord::Base
+  validates :from_name, :to_name, :subject, :plain_content, :html_content,
+            presence: true
+  validates :from_email, :to_email,
+            format: { with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i }
+
+  scope :sent, -> { where('sent_at IS NOT NULL') }
+  scope :not_sent, -> { where('sent_at IS NULL') }
+
+  def mark_as_sent!
+    update_attribute :sent_at, DateTime.now
+  end
+end

data/app/models/email_template.rb

@@ -0,0 +1,10 @@
+class EmailTemplate < ActiveRecord::Base
+  include Concerns::Translatable
+  translatable_fields :subject, :plain_content, :html_content
+
+  include Concerns::Sortable
+
+  validates :description, :from_name, presence: true
+  validates :identifier, presence: true, uniqueness: { case_sensitive: false }
+  validates :from_email, format: { with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i }
+end

data/app/models/form.rb

@@ -0,0 +1,9 @@
+class Form < ActiveRecord::Base
+  include Concerns::Translatable
+  translatable_fields :success_message
+
+  has_many :fields, class_name: 'FormField', dependent: :destroy
+  has_many :submissions, class_name: 'FormSubmission', dependent: :destroy
+
+  validates :identifier, presence: true
+end