gluttonberg-core 2.6.4 → 3.0.0

data/lib/gluttonberg/content/default_template_file.rb

@@ -0,0 +1,44 @@
+module Gluttonberg
+  module Content
+    # This mixin provides functionality for generating default template for any page description which needs template file.
+    module DefaultTemplateFile
+      extend ActiveSupport::Concern
+
+      # if page type is not redirection or rewrite.
+      # then create default view files for all localzations of the page.
+      # file will be created in host appliation/app/views/pages/template_name.locale-slug.html.haml
+      def create_default_template_file
+        unless self.description.redirection_required? || self.description.rewrite_required?
+          pages_root = File.join(Rails.root, "app", "views" , "pages")
+          FileUtils.mkdir(pages_root) unless File.exists?(pages_root)
+          self.localizations.each do |page_localization|
+            create_default_template_file_for_localization(page_localization, pages_root)
+          end
+        end
+      end #create_default_template_file
+
+      private
+
+        def create_default_template_file_for_localization(page_localization, pages_root)
+          file_path = File.join(pages_root , "#{self.view}.#{page_localization.locale.slug}.html.haml"  )
+          unless File.exists?(file_path)
+            file = File.new(file_path, "w")
+
+            page_localization.contents.each do |content|
+              write_template_contents(content, file)
+            end
+            file.close
+          end
+        end
+
+        def write_template_contents(content, file)
+          if content.kind_of?(Gluttonberg::TextareaContent) || content.kind_of?(Gluttonberg::HtmlContent) || content.kind_of?(Gluttonberg::TextareaContentLocalization) || content.kind_of?(Gluttonberg::HtmlContentLocalization)
+            file.puts("= shortcode_safe @page.easy_contents(:#{content.section_name})")
+          else
+            file.puts("= @page.easy_contents(:#{content.section_name})")
+          end
+        end
+
+    end #DefaultTemplateFile
+  end
+end

data/lib/gluttonberg/content/despamilator/filter/naughty_words.rb

@@ -25,7 +25,8 @@ module Gluttonberg
           unless gb_blacklist_settings.blank?
             gb_blacklist_settings_words = gb_blacklist_settings.split(",")
             gb_blacklist_settings_words.each do |word|
-              subject.register_match!({:score => 1.0, :filter => self}) if text =~ /\b#{word.strip.downcase}s?\b/
+              position = (text =~ /\b#{word.strip.downcase}s?\b/)
+              subject.register_match!({:score => 1.0, :filter => self}) if !position.blank? && position >= 0
             end
           end
         end
@@ -36,7 +37,8 @@ module Gluttonberg
             text = subject.downcase
 
             naughty_words.each do |word|
-              local_score += 0.1 if text =~ /\b#{word}s?\b/
+              position = (text =~ /\b#{word}s?\b/)
+              local_score += 0.1 if !position.blank? && position >= 0
             end
 
             gb_blacklist_settings = Gluttonberg::Setting.get_setting("comment_blacklist")

data/lib/gluttonberg/content/home_page_info.rb

@@ -0,0 +1,39 @@
+module Gluttonberg
+  module Content
+    # Mixin which provides functionality related to home page for pages
+    module HomePageInfo
+      extend ActiveSupport::Concern
+
+      included do
+        after_save  :check_for_home_update
+      end
+
+      module ClassMethods
+        def home_page
+          self.where(:home => true).first
+        end
+
+        def home_page_name
+          home_temp = self.home_page
+          home_temp.blank? ? "Not Selected" : home_temp.name
+        end
+      end
+
+      def home=(state)
+        write_attribute(:home, state)
+        @home_updated = state
+      end
+
+      private
+
+        # Checks to see if this page has been set as the homepage. If it has, we
+        # then go and
+        def check_for_home_update
+          if @home_updated && @home_updated == true
+            previous_home = Page.where([ "home = ? AND id <> ? " , true ,self.id ] ).first
+            previous_home.update_attributes(:home => false) if previous_home
+          end
+        end
+    end #HomePage
+  end
+end

data/lib/gluttonberg/content/import_export_csv.rb

@@ -1,201 +1,314 @@
 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
+    # A mixin which allows for any arbitrary model to have import/export functionality
+    # import_export_csv(["name"], ["bio"]) import_export_columns,wysiwyg_columns
+    # it adds importCSV(file_path , local_options = {})
+    # and exportCSV(records , local_options = {})
     module ImportExportCSV
-
+      extend ActiveSupport::Concern
       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
+          include ImportExportHelpers          
           if import_export_columns.blank?
             self.import_export_columns = self.new.attributes.keys
+            if self.class.respond_to?(:localized?) && self.localized?
+              self.import_export_columns += self.new_with_localization.current_localization.attributes.keys
+              self.import_export_columns.uniq!
+            end
           else
             self.import_export_columns = import_export_columns
           end
+          self.wysiwyg_columns = (wysiwyg_columns.blank? ? [] : wysiwyg_columns)
         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."
+        module ImportExportHelpers
+          extend ActiveSupport::Concern
+          included do
+            cattr_accessor :import_export_columns , :wysiwyg_columns
           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
+          module ClassMethods
+            # 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]
+            # sample local_options
+            # {
+            #   :import_columns => [:name, :face_id, :handwritting_id], 
+            #   :wysiwyg_columns => [:bio],
+            #   :unique_key => :name,
+            #   :additional_attributes => {}
+            # }
+            def importCSV(file_path , local_options = {})
+              begin
+                require 'csv'
+                csv_table = CSV.read(file_path, "r:UTF-8")
+              rescue => e
+                return "Please provide a valid CSV file with correct column names."
+              end
+              ImportUtils.import(file_path, local_options, self, csv_table)
+            end
 
-          wysiwyg_columns_names = self.wysiwyg_columns
-          if local_options && local_options.has_key?(:wysiwyg_columns)
-            wysiwyg_columns_names = local_options[:wysiwyg_columns]
-          end
+            class GlosentryHelper
+              include ActionView::Helpers::TagHelper
+              include ActionView::Helpers::TextHelper
+            end
 
+            def helper
+              @h ||= GlosentryHelper.new
+            end
 
-          if import_column_names.blank?
-            raise "Please define import_export_columns property"
+            # sample local_options
+            # {
+            #   :import_columns => [:name, :face_id, :handwritting_id], 
+            #   :wysiwyg_columns => [:bio]
+            # }
+            def exportCSV(all_records , local_options = {})
+              ExportUtils.export(all_records, local_options, self)
+            end
           end
+        end
 
-          import_columns = {}
+      end #ClassMethods
 
-          import_column_names.each do |key|
-            import_columns[key] = self.find_column_position(csv_table , key )
-          end
+      class ExportUtils
+        attr_accessor :all_records, :local_options, :klass, :export_column_names, :export_wysiwyg_columns
+        def initialize(all_records, local_options, klass)
+          self.all_records = all_records
+          self.local_options = local_options
+          self.klass = klass
+        end
 
-          feedback = []
-          records = []
-          all_valid = true #assume all records are valid.
+        def self.export(all_records, local_options, klass)
+          export_utils = ExportUtils.new(all_records, local_options, klass)
+          export_utils.prepare_export_column_names
+          require 'csv'
 
-          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
+          csv_string = CSV.generate do |csv|
+            csv << export_utils.all_export_columns
+            export_utils.all_records.each do |record|
+              csv << export_utils.prepare_row(record)
+            end
+          end
+          csv_string
+        end
 
-              record_info.each do |field,val|
-                record.send("#{field}=",val)
-              end
+        def prepare_export_column_names
+          
+          self.export_column_names = _prepare_names(:export_columns, :import_export_columns)
+          self.export_wysiwyg_columns = _prepare_names(:wysiwyg_columns, :wysiwyg_columns)
+          
 
-              records << record
-              if record.valid?
-                feedback << true
-              else
-                feedback << record.errors
-                all_valid = false
-              end
-            end # if csv row index > 0
+          if self.export_column_names.blank?
+            raise "Please define export_column_names property"
+          end
+          self.export_column_names
+        end
 
-          end #loop
+        def _prepare_names(source, default)
+          if self.local_options && self.local_options.has_key?(source)
+            self.local_options[source].dup
+          else
+            klass.send(default).dup
+          end
+        end
 
-          if all_valid
-            records.each do |record|
-              unless wysiwyg_columns_names.blank?
+        def all_export_columns
+          temp_columns = self.export_column_names.blank? ? [] : self.export_column_names.dup
+          temp_columns << self.export_wysiwyg_columns.dup unless self.export_wysiwyg_columns.blank?
+          temp_columns << :published_at
+          temp_columns << :updated_at
+          temp_columns = temp_columns.flatten
+          temp_columns.uniq!
+          temp_columns
+        end
 
-                wysiwyg_columns_names.each do |c|
-                  record.send("#{c}=",helper.simple_format(record.send(c)))
+        def prepare_row(record)
+          row = []
+          self.all_export_columns.each do |column|
+            if self.export_wysiwyg_columns && self.export_wysiwyg_columns.include?(column)
+              if record.send(column).blank?
+                row << ""
+              else
+                val = record.send(column)
+                if val.is_a? String
+                  row << val.html_safe
+                elsif val.is_a? String
+                  row << val.collect{|v| v.is_a? String ? v.html_safe : v}
+                else
+                  row << val
                 end
               end
-              record.save
+            else
+              row << record.send(column)
             end
           end
-
-          all_valid ? true : feedback
+          row.flatten
         end
+      end
 
-        class GlosentryHelper
-            include ActionView::Helpers::TagHelper
-            include ActionView::Helpers::TextHelper
+      class ImportUtils
+        attr_accessor :file_path, :local_options, :klass, :csv_table
+        attr_accessor :import_columns, :wysiwyg_columns , :records, :feedback, :all_valid
+        attr_accessor :import_column_names, :wysiwyg_columns_names
+
+        def initialize(file_path , local_options = {}, klass, csv_table )
+          self.file_path = file_path
+          self.local_options = local_options
+          self.klass = klass
+          self.csv_table = csv_table
+          self.records = []
+          self.feedback = []
+          self.all_valid = true #assume all records are valid.
         end
 
-        def helper
-          @h ||= GlosentryHelper.new
+        def self.import(file_path , local_options = {}, klass, csv_table)
+          import_utils = ImportUtils.new(file_path, local_options, klass, csv_table)
+          import_utils.prepare_import_columns
+
+          csv_table.each_with_index do |row , index |
+            if index > 0 # ignore first row because its meta data row
+              import_utils.import_row(row)
+            end # if csv row index > 0
+
+          end #loop
+          import_utils.assign_wysiwyg_columns
+          import_utils.all_valid ? true : import_utils.feedback
         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)
+        def find_column_position(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
+          nil
         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]
+        def prepare_import_columns
+          _prepare_import_column_names
+          _prepare_wysiwyg_column_names
+
+          self.import_columns = {}
+          self.import_column_names.each do |key|
+            self.import_columns[key] = find_column_position(key)
           end
 
-          if export_column_names.blank?
-            raise "Please define export_column_names property"
+          self.wysiwyg_columns = {} 
+          self.wysiwyg_columns_names.each do |key|
+            self.wysiwyg_columns[key] = find_column_position(key)
+          end
+        end
+
+        def _prepare_import_column_names
+          self.import_column_names = klass.import_export_columns.dup
+          if local_options && local_options.has_key?(:import_columns)
+            self.import_column_names = local_options[:import_columns].dup
+          end
+          if import_column_names.blank?
+            raise "Please define import_export_columns property"
           end
+        end
 
-          export_column_names << "published_at"
-          export_column_names << "updated_at"
+        def _prepare_wysiwyg_column_names
+          self.wysiwyg_columns_names = klass.wysiwyg_columns
+          if local_options && local_options.has_key?(:wysiwyg_columns)
+            self.wysiwyg_columns_names = local_options[:wysiwyg_columns]
+          end
+        end
+
+        def import_row(row)
+          record_info = prepare_record_info(row)
+          record = find_or_initialize_record(record_info)
 
-          csv_class_name = nil
-          if RUBY_VERSION >= "1.9"
-            require 'csv'
-            csv_class_name = CSV
+          self.records << record
+          if record.valid?
+            self.feedback << true
           else
-            csv_class_name = FasterCSV
+            feedback << record.errors
+            self.all_valid = false
           end
+        end
 
-          csv_string = csv_class_name.generate do |csv|
-              csv << export_column_names
+        def all_import_columns
+          temp_columns = self.import_columns.blank? ? {} : self.import_columns.dup
+          temp_columns = temp_columns.merge(self.wysiwyg_columns.dup) unless self.wysiwyg_columns.blank?
+          temp_columns
+        end
 
-              all_records.each do |record|
-                  row = []
-                  export_column_names.each do |column|
-                    row << record.send(column)
-                  end
-                  csv << row
-              end
+        def prepare_record_info(row)
+          record_info = {}
+
+          self.all_import_columns.each do |key , val|
+            if !val.blank? && val >= 0
+              record_info[key] = row[val]
+              record_info[key] = record_info[key].force_encoding("UTF-8") if row[val].kind_of?(String)
+            end
           end
 
-          csv_string
+          unless self.local_options[:additional_attributes].blank?
+            self.local_options[:additional_attributes].each do |key, val|
+              record_info[key] = (val.kind_of?(String) ? val.force_encoding("UTF-8") : val)
+            end
+          end
+
+          record_info
         end
 
-      end
+        def find_or_initialize_record(record_info)
+          record = nil
+          if local_options[:unique_key]
+            val = record_info[local_options[:unique_key].to_s]
+            val = record_info[local_options[:unique_key].to_sym] if val.blank?
+            record = klass.where(local_options[:unique_key] => val).first
+          end
 
-      module InstanceMethods
+          if record.blank?
+            record = new_record(record_info)
+          end
 
-      end
+          record_info.each do |field,val|
+            record.send("#{field}=",val) unless field.to_s == "id"
+          end
+          record
+        end
+
+        def new_record(record_info)
+          if klass.respond_to?(:localized?) && klass.localized?
+            klass.new_with_localization
+          else
+            klass.new
+          end
+        end
+
+        def assign_wysiwyg_columns
+          if self.all_valid
+            records.each do |record|
+              assign_wysiwyg_column(record)
+            end
+          end
+        end
 
-    end
+        def assign_wysiwyg_column(record)
+          unless self.wysiwyg_columns_names.blank?
+            self.wysiwyg_columns_names.each do |c|
+              record.send("#{c}=", klass.helper.simple_format(record.send(c)))
+            end
+          end
+          record.save
+        end
+
+      end #ImportUtils
+
+    end #ImportExportCSV
   end
 end
-