gluttonberg-core 2.5

data/lib/gluttonberg/content/clean_html.rb

@@ -0,0 +1,74 @@
+module Gluttonberg
+  module Content
+    
+    module CleanHtml
+      
+      def self.setup
+        ::ActiveRecord::Base.send :include, Gluttonberg::Content::CleanHtml
+      end
+      
+      def self.included(klass)
+        klass.class_eval do
+          extend  ClassMethods
+          include InstanceMethods
+          before_validation :clean_all_html_content
+          
+          cattr_accessor :html_columns_list
+        end
+      end
+      
+      module ClassMethods
+        def clean_html(cols)
+          self.html_columns_list = cols 
+        end
+        
+        def clean_tags(str)
+          if !str.blank? && str.instance_of?(String)
+            str = self.removeStyle(str)
+            str = self.removeMetaTag(str)
+            str = removeEmptyTag(str)
+          end  
+          str
+        end
+
+        def removeEmptyTag(str)
+          removeList = [/<blockquote>[\s]*<\/blockquote>/, /<p>[\s]*<\/p>/,/<div>[\s]*<\/div>/,/<span>[\s]*<\/span>/, /<h1>[\s]*<\/h1>/, /<h2>[\s]*<\/h2>/, /<h3>[\s]*<\/h3>/, /<h4>[\s]*<\/h4>/, /<h5>[\s]*<\/h5>/, /<h6>[\s]*<\/h6>/ , /<br[\s]*\/>/ , /<br[\s]*>/]
+          removeList.each do |r|
+            str = str.gsub(r,"")
+          end
+
+          str
+        end
+
+        def removeStyle(str)
+          removeList = [/style=\"[\sA-Za-z0-9.,-;:]*\"/]
+          removeList.each do |r|
+            str = str.gsub(r,"")
+          end
+
+          str
+        end
+
+        def removeMetaTag(str)
+           removeList = [ "<meta charset=\"utf-8\">", "</meta>" ]
+           removeList.each do |r|
+            str = str.gsub(r,"")
+          end
+
+          str
+        end
+      end
+      
+      module InstanceMethods
+        def clean_all_html_content
+          unless self.class.html_columns_list.blank?
+            self.class.html_columns_list.each do |field|
+              write_attribute(field , self.class.clean_tags(read_attribute(field)) )
+            end
+          end  
+        end
+      end
+      
+    end
+  end
+end

data/lib/gluttonberg/content/import_export_csv.rb

@@ -0,0 +1,201 @@
+module Gluttonberg
+  module Content
+    # A mixin which allows for any arbitrary model to have multiple versions. It will
+    # generate the versioning models and add methods for creating, managing and
+    # retrieving different versions of a record.
+    # In reality this is behaving like a wrapper on acts_as_versioned
+    module ImportExportCSV
+
+      def self.setup
+        ::ActiveRecord::Base.send :include, Gluttonberg::Content::ImportExportCSV
+      end
+
+      def self.included(klass)
+        klass.class_eval do
+          extend  ClassMethods
+          include InstanceMethods
+          cattr_accessor :import_export_columns , :wysiwyg_columns
+
+        end
+      end
+
+      module ClassMethods
+
+        def import_export_csv(import_export_columns=nil,wysiwyg_columns=nil)
+          #@@wysiwyg_columns = wysiwyg_columns
+          if import_export_columns.blank?
+            self.import_export_columns = self.new.attributes.keys
+          else
+            self.import_export_columns = import_export_columns
+          end
+        end
+
+
+        # takes complete path to csv file.
+        # if all records are created successfully then return true
+        # otherwise returns array of feedback. each value represents the feedback for respective row in csv
+        # sample feedback array : [true , true , [active_record error array...] , true]
+        def importCSV(file_path , local_options = {})
+          begin
+            if RUBY_VERSION >= "1.9"
+              require 'csv'
+              csv_table = CSV.read(file_path)
+            else
+              csv_table = FasterCSV.read(file_path)
+            end
+          rescue => e
+            return "Please provide a valid CSV file with correct column names."
+          end
+
+          import_column_names = self.import_export_columns
+          if local_options && local_options.has_key?(:import_columns)
+            import_column_names = local_options[:import_columns]
+          end
+
+          wysiwyg_columns_names = self.wysiwyg_columns
+          if local_options && local_options.has_key?(:wysiwyg_columns)
+            wysiwyg_columns_names = local_options[:wysiwyg_columns]
+          end
+
+
+          if import_column_names.blank?
+            raise "Please define import_export_columns property"
+          end
+
+          import_columns = {}
+
+          import_column_names.each do |key|
+            import_columns[key] = self.find_column_position(csv_table , key )
+          end
+
+          feedback = []
+          records = []
+          all_valid = true #assume all records are valid.
+
+          csv_table.each_with_index do |row , index |
+            if index > 0 # ignore first row because its meta data row
+              record_info = {}
+              import_columns.each do |key , val|
+                if !val.blank? && val >= 0
+                  if row[val].blank? || !row[val].kind_of?(String)
+                    record_info[key] = row[val]
+                  else
+                    record_info[key] = row[val].force_encoding("UTF-8")
+                  end
+                end
+              end
+              record = nil
+              if local_options[:unique_key]
+                record = self.where(local_options[:unique_key] => record_info[local_options[:unique_key].to_s]).first
+              end
+              if record.blank?
+                # make object
+                if self.respond_to?(:localized?) && self.localized?
+                  record = self.new_with_localization(record_info)
+                else
+                  record = self.new(record_info)
+                end
+              else
+                record.attributes = record.attributes.merge(record_info)
+              end
+
+              record_info.each do |field,val|
+                record.send("#{field}=",val)
+              end
+
+              records << record
+              if record.valid?
+                feedback << true
+              else
+                feedback << record.errors
+                all_valid = false
+              end
+            end # if csv row index > 0
+
+          end #loop
+
+          if all_valid
+            records.each do |record|
+              unless wysiwyg_columns_names.blank?
+
+                wysiwyg_columns_names.each do |c|
+                  record.send("#{c}=",helper.simple_format(record.send(c)))
+                end
+              end
+              record.save
+            end
+          end
+
+          all_valid ? true : feedback
+        end
+
+        class GlosentryHelper
+            include ActionView::Helpers::TagHelper
+            include ActionView::Helpers::TextHelper
+        end
+
+        def helper
+          @h ||= GlosentryHelper.new
+        end
+
+        # csv_table is two dimentional array
+        # col_name is a string.
+        # if structure is proper and column name found it returns column index from 0 to n-1
+        # otherwise nil
+        def find_column_position(csv_table  , col_name)
+          if csv_table.instance_of?(Array) && csv_table.count > 0 && csv_table.first.count > 0
+            csv_table.first.each_with_index do |table_col , index|
+              return index if table_col.to_s.upcase == col_name.to_s.upcase
+            end
+            nil
+          else
+            nil
+          end
+        end
+
+        def exportCSV(all_records , local_options = {})
+          export_column_names = self.import_export_columns
+          if local_options && local_options.has_key?(:export_columns)
+            export_column_names = local_options[:export_columns]
+          end
+
+          if export_column_names.blank?
+            raise "Please define export_column_names property"
+          end
+
+          export_column_names << "published_at"
+          export_column_names << "updated_at"
+
+          csv_class_name = nil
+          if RUBY_VERSION >= "1.9"
+            require 'csv'
+            csv_class_name = CSV
+          else
+            csv_class_name = FasterCSV
+          end
+
+          csv_string = csv_class_name.generate do |csv|
+              csv << export_column_names
+
+              all_records.each do |record|
+                  row = []
+                  export_column_names.each do |column|
+                    row << record.send(column)
+                  end
+                  csv << row
+              end
+          end
+
+          csv_string
+        end
+
+      end
+
+      module InstanceMethods
+
+      end
+
+    end
+  end
+end
+

data/lib/gluttonberg/content/localization.rb

@@ -0,0 +1,238 @@
+module Gluttonberg
+  module Content
+    # A mixin which allows for any arbitrary model to be localized. It will
+    # generate the localization models and add methods for creating and
+    # retrieving localized versions of a record.
+    module Localization
+      # The included hook is used to create a bunch of class ivars we need to
+      # store various bits of configuration.
+      def self.included(klass)
+        klass.class_eval do
+          extend  Model::ClassMethods
+          include Model::InstanceMethods
+
+          #class << self;
+            cattr_accessor :localized, :localized_model, :localized_model_name, :localized_fields, :locale;
+          #end
+          self.localized = false
+          self.localized_fields = []
+
+        end
+      end
+
+      # This module gets mixed into the class that includes the localization module
+      module Model
+        module ClassMethods
+          def is_localized(&blk)
+
+            # Why yes, this is localized.
+            self.localized = true
+
+            # Create the localization model
+            class_name = self.name + "Localization"
+            table_name = class_name.tableize
+            # Check to see if the localization is inside a constant
+            target = Object
+            if class_name.index("::")
+              modules = class_name.split("::")
+              # Remove the localization class from the end
+              class_name = modules.pop
+              # Get each constant in turn
+              modules.each { |mod| target = target.const_get(mod) }
+            end
+
+            self.localized_model = Class.new(ActiveRecord::Base)
+            target.const_set(class_name, self.localized_model)
+            self.localized_model_name = class_name
+            self.localized_model.table_name = table_name
+
+            # Add the properties declared in the block, and sprinkle in our own mixins
+            self.localized_model.class_eval(&blk)
+            self.localized_model.send(:include, ModelLocalization)
+
+            # For each property on the localization model, create an accessor on
+            # the parent model, without over-writing any of the existing methods.
+            exclusions = [:id, :created_at, :updated_at, :locale_id , :parent_id]
+            localized_properties = self.localized_model.column_names.reject { |p| exclusions.include? p }
+            non_localized_properties = self.column_names.reject { |p| exclusions.include? p }
+
+            localized_properties.each do |prop|
+              self.localized_fields << prop
+              # Create the accessor that points to the localized version
+              unless non_localized_properties.include?(prop)
+                class_eval %{
+                  def #{prop}
+                     current_localization.#{prop}
+                  end
+                  def #{prop}=(val)
+                     current_localization.#{prop} = val
+                  end
+                }
+              end
+            end
+
+            #---------TODO cleaning html code
+            #@localized_model.clean_html([:text])#(@localized_fields.map{|c|c.to_sym})
+
+            # Associate the model and it’s localization
+            has_many  :localizations, :class_name => self.localized_model.name.to_s, :foreign_key => :parent_id, :dependent => :destroy
+            has_one  :default_localization, :class_name => self.localized_model.name.to_s, :foreign_key => :parent_id , :conditions => ["locale_id = ?", Locale.first_default.id]
+            self.localized_model.belongs_to(:parent, :class_name => self.name, :foreign_key => :parent_id)
+
+            # Set up validations for when we update in the presence of a localization
+            after_validation  :validate_current_localization
+            after_save    :save_current_localization
+
+          end
+
+          def localized?
+            self.localized
+          end
+
+          # Returns a new instance of the model, with a localization instance
+          # already assigned to it based on the options passed in.
+          #
+          # The options include the attributes for the both new model and its localization.
+          def new_with_localization(attrs={})
+            new_model = new
+            default_localization = nil
+            # new localization object for all locales.
+            Gluttonberg::Locale.all.each do |locale|
+              loc = self.localized_model.new(:locale_id => locale.id)
+              new_model.instance_variable_set(:@current_localization, loc)
+              new_model.localizations << loc
+              new_model.attributes = attrs #update current object and current localization
+              if locale.default?
+                 default_localization = loc
+              end
+            end
+
+            # make default localization as default
+            default_localization = new_model.localizations.first if default_localization.blank?
+            new_model.instance_variable_set(:@current_localization, default_localization)
+            new_model
+          end
+
+
+          # def all_with_localization(opts)
+          #   fallback = check_for_fallback(opts)
+          #   localization_opts = extract_localization_conditions(opts)
+          #   matches = all(prefix_localized_fields(opts))
+          #   matches.each { |match| match.load_localization(localization_opts, fallback || false) }
+          #   matches
+          # end
+
+          # def first_with_localization(opts)
+          #   fallback = check_for_fallback(opts)
+          #   localization_opts = extract_localization_conditions(opts)
+          #   match = first(prefix_localized_fields(opts))
+          #   if match
+          #     match.load_localization(localization_opts, fallback || false)
+          #     match
+          #   end
+          # end
+
+          private
+
+        end
+
+        module InstanceMethods
+          def localized?
+            self.class.is_localized?
+          end
+
+          # returns current localization if current localization does not exist then init it with default localization
+          def current_localization
+            if @current_localization.blank?
+              @current_localization = self.default_localization
+            end
+            @current_localization
+          end
+
+          def current_localization=(localization)
+            self.instance_variable_set(:@current_localization, localization)
+          end
+
+          # load locaization for given locale (locale id or locale objects both are acceptable)
+          # if localization for given locale does not exist then create localization for it
+          # and if creation of localization failed then return default localization
+          def load_localization(locale, fallback = true)
+            opts = {}
+            opts[:locale_id] = locale.kind_of?(Gluttonberg::Locale) ? locale.id: locale
+            opts[:parent_id] = self.id
+            # Go and find the localization
+            self.current_localization = nil
+            self.current_localization = self.class.localized_model.where(opts).first
+            if @current_localization.blank? && !locale.blank?
+              self.current_localization = self.create_localization(locale)
+            end
+            # Check to see if we missed the load and if we also need the fallback
+            if self.current_localization.blank? && fallback
+              self.current_localization = self.default_localization
+            end
+            self.current_localization
+          end
+
+
+
+          # create localization for given locale (locale id or object both are acceptable) if it does not exist
+          def create_localization(locale)
+            locale_id = locale.kind_of?(Gluttonberg::Locale) ? locale.id: locale
+            unless locale.blank?
+              loc = self.class.localized_model.where(:locale_id => locale_id, :parent_id => self.id).first
+              if loc.blank?
+                tmp_current = self.current_localization
+                tmp_attributes = tmp_current.attributes
+                tmp_attributes[:locale_id] = locale_id
+                loc = self.class.localized_model.new(:locale_id => locale_id)
+                loc.attributes = tmp_attributes
+                if loc.save
+                  loc
+                else
+                  nil
+                end
+              end
+            end
+          end #create_localization
+
+
+
+
+          private
+
+          # Validates the current_localization. If it is invalid, it's errors
+          # are appended to the model's own errors.
+          def validate_current_localization
+            if current_localization
+              unless current_localization.valid?
+                current_localization.errors.each { |name, error| errors.add(name, error) }
+              end
+            end
+          end
+
+          def save_current_localization
+            if current_localization && current_localization.changed?
+              current_localization.save
+            end
+          end
+
+        end
+      end
+
+      # This module is used when dynamically creating the localization class.
+      module ModelLocalization
+        # This included hook is used to declare base properties like the id and
+        # to set up associations to the dialect and locale
+        def self.included(klass)
+          klass.class_eval do
+            belongs_to :locale,   :class_name => "Gluttonberg::Locale"
+          end
+        end
+
+        def locale_name
+          locale.name
+        end
+      end
+    end # Localization
+  end # Content
+end # Gluttonberg

data/lib/gluttonberg/content/publishable.rb

@@ -0,0 +1,90 @@
+module Gluttonberg
+  module Content
+    # A mixin that will add simple publishing functionality to any arbitrary 
+    # model. This includes finders for retrieving published records and 
+    # instance methods for quickly changing the state.
+    module Publishable
+      # Add the class and instance methods, declare the property we store the
+      # published state in.
+      def self.included(klass)
+        klass.class_eval do
+          extend ClassMethods
+          include InstanceMethods
+          scope :published, lambda { where("state = 'published'  AND  published_at <= ?", Time.zone.now) }
+          scope :archived, :conditions => { :state => "archived" }
+          scope :draft, :conditions => { :state => "draft" }
+          scope :non_published, :conditions => "state != 'published'"
+          before_validation :clean_published_date 
+        end
+      end
+
+      module ClassMethods
+        
+         
+        # Returns all matching records that are published for a particular user. May be called 
+        # with additional conditions.
+        def all_unpublished_for_user( user , options = {})
+          if options[:conditions].blank?
+             options[:conditions] = { :state => "published" }
+          else   
+            options[:conditions][:state] = "published"
+          end
+          
+          all(options)
+        end
+        
+      end
+
+      module InstanceMethods
+        # Change the publish state to true and save the record.
+        def publish!
+          update_attributes(:state=>"published")
+        end
+        
+        # Change the publish state to false and save the record.
+        def unpublish!
+          update_attributes(:state=>"draft")
+        end
+
+        # Change the publish state to draft but not save the record
+        def unpublish
+          assign_attributes(:state=>"draft")
+        end
+        
+        # Change the publish state to true and save the record.
+        def archive!
+          update_attributes(:state=>"archived")
+        end
+        
+        # Check to see if this record has been published.
+        def published?
+          self.state == "published" && published_at <= Time.zone.now
+        end
+        
+        # Check to see if this record has been published.
+        def archived?
+          self.state == "archived"
+        end
+        
+        def draft?
+          self.state == "draft" || self.state == "ready" || self.state == "not_ready"
+        end
+        
+        def publishing_status
+          if draft?
+            "Draft"
+          else  
+            self.state.capitalize unless self.state.blank?
+          end  
+        end
+        
+        def clean_published_date
+          if self.state != "published"
+            self.published_at = nil
+          end  
+        end
+        
+      end
+    end # Publishable
+  end # Content
+end # Gluttonberg

data/lib/gluttonberg/content/slug_management.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+module Gluttonberg
+  module Content
+    # This module can be mixed into a class to provide slug management methods
+    module SlugManagement
+
+      # This included hook is used to declare the various properties and class
+      # ivars we need.
+      def self.included(klass)
+        klass.class_eval do
+          extend ClassMethods
+          include InstanceMethods
+          
+          before_validation :slug_management
+          class << self;  attr_accessor :slug_source_field_name end
+          attr_accessor :current_slug
+          
+                    
+        end
+      end
+    
+      module ClassMethods
+        
+      end
+      
+      module InstanceMethods
+        
+        def get_slug_source
+          if self.class.slug_source_field_name.blank?
+            if self.respond_to?(:name)
+              self.class.slug_source_field_name= :name
+            elsif self.respond_to?(:title)
+              self.class.slug_source_field_name= :title
+            else
+              self.class.slug_source_field_name= :id
+            end
+          end
+          self.class.slug_source_field_name
+        end
+        
+        def slug=(new_slug)
+          #if you're changing this regex, make sure to change the one in /javascripts/slug_management.js too
+          # utf-8 special chars are fixed for new ruby 1.9.2
+          unless new_slug.blank?
+            new_slug = new_slug.downcase.gsub(/\s/, '_').gsub(/[\!\*'"″′‟‛„‚”“”˝\(\)\;\:\.\@\&\=\+\$\,\/?\%\#\[\]]/, '')
+            new_slug = new_slug.gsub('__','_') # remove consective underscores
+            new_slug = new_slug.gsub(/_$/,'') # remove trailing underscore
+          end  
+          write_attribute(:slug, new_slug)
+        end
+        
+        protected 
+        # Checks If slug is blank then tries to set slug using following logic
+        # if slug_field_name is set then use its value and make it slug
+        # otherwise checks for name column
+        # otherwise checks for title column
+        # else get id as slug
+          def slug_management
+            if self.slug.blank?
+              if self.class.slug_source_field_name.blank?
+                if self.respond_to?(:name)
+                  self.class.slug_source_field_name= :name
+                  self.slug= self.name
+                elsif self.respond_to?(:title)
+                  self.class.slug_source_field_name= :title
+                  self.slug= self.title
+                else
+                  self.class.slug_source_field_name= :id
+                  self.slug= self.id.to_s
+                end
+              else
+                self.slug= self.send(self.class.slug_source_field_name)
+              end
+            end #slug.blank
+            # check duplication: add id at the end if its duplicated
+            already_exist = self.class.where(:slug => self.slug).all
+            if !already_exist.blank?
+              if already_exist.length > 1 || (already_exist.length == 1 && already_exist.first.id != self.id )
+                self.slug= "#{self.slug}_#{already_exist.length+1}"
+              end  
+            end
+          end
+          
+      end
+      
+    end
+  end
+end