freeberry 0.2.5

data/lib/freeberry/models/comment.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+module Freeberry
+  module Models
+    module Comment
+      def self.included(base)
+        base.send :include, InstanceMethods
+        base.send :extend,  ClassMethods
+      end
+      
+      module ClassMethods
+        def self.extended(base)
+          base.class_eval do
+            belongs_to :commentable, :polymorphic => true, :counter_cache => :comments_count
+            belongs_to :author, :polymorphic => true
+            
+            validates :user_name, :presence => true, :length => { :maximum => 100 }, 
+                      :format => { :with => /\A[^[:cntrl:]\\<>\/&]*\z/ }
+            validates :user_email, :presence => true, :length => { :within => 6..100 }, 
+                      :format => { :with => /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i }
+            validates :content, :presence => true, :length => { :maximum => 500 }
+            validates :commentable_type, :presence => true, :inclusion => { :in => %w( Post Broadcast ) }
+            
+            validates :author_type, :inclusion => { :in => %w( User Client ) }, :allow_blank => true
+            
+            before_validation :make_author
+            
+            scope :follows, where(:is_follow => true)
+          end
+        end
+      end
+      
+      module InstanceMethods
+        def comments_count
+          @comments_count ||= self.class.count(:conditions=>["commentable_id = ? AND commentable_type = ?", self.commentable_id, self.commentable_type])
+          @comments_count
+        end
+    
+        protected
+    
+          def make_author
+          	unless self.author.nil?
+            	self.user_email = self.author.email
+            	self.user_name = self.author.name
+          	end
+          end
+      end
+    end
+  end
+end

data/lib/freeberry/models/header.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+module Freeberry
+  module Models
+    module Header
+      def self.included(base)
+        base.send :include, InstanceMethods
+        base.send :extend,  ClassMethods
+      end
+      
+      module ClassMethods
+        def self.extended(base)
+          base.class_eval do
+            validates_presence_of :headerable_type, :headerable_id
+    
+            belongs_to :headerable, :polymorphic => true
+          end
+        end
+      end
+      
+      module InstanceMethods
+      end
+    end
+  end
+end

data/lib/freeberry/models/page.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+module Freeberry
+  module Models
+    module Page
+      def self.included(base)
+        base.send :include, InstanceMethods
+        base.send :extend,  ClassMethods
+      end
+      
+      module ClassMethods
+        def self.extended(base)
+          base.class_eval do
+            belongs_to :structure
+            validates_presence_of :title, :content
+          end
+        end
+      end
+      
+      module InstanceMethods
+        def content_without_html
+          return nil if self.content.blank?
+          self.content.no_html
+        end
+      end
+    end
+  end
+end

data/lib/freeberry/models/position_type.rb

@@ -0,0 +1,14 @@
+module Freeberry
+  module Models
+    class PositionType
+      def initialize(code)
+        @code = code.to_sym
+      end
+      attr_reader :code
+      
+      def title
+        I18n.t(@code, :scope => [:manage, :structure, :position])
+      end  
+    end
+  end
+end

data/lib/freeberry/models/post.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+module Freeberry
+  module Models
+    module Post
+      def self.included(base)
+        base.send :include, InstanceMethods
+        base.send :extend,  ClassMethods
+      end
+      
+      module ClassMethods
+        def self.extended(base)
+          base.send(:include, HeaderTools)
+          base.class_eval do
+            belongs_to :structure
+            has_many :comments, :as => :commentable, :dependent => :delete_all
+            has_slug
+            
+            validates_presence_of :title, :content
+	
+	          before_save :make_date
+          end
+        end
+      end
+      
+      module InstanceMethods
+      
+        def content_without_html
+          return nil if self.content.blank?
+          self.content.no_html
+        end
+        
+        protected
+    
+          def make_date
+            self.published_at ||= Time.now
+      
+            self.year  = self.published_at.year  if respond_to?(:year)
+            self.month = self.published_at.month if respond_to?(:month)
+            self.day   = self.published_at.day   if respond_to?(:day)
+          end
+      end
+    end
+  end
+end

data/lib/freeberry/models/role.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+module Freeberry
+  module Models
+    module Role
+      def self.included(base)
+        base.send :include, InstanceMethods
+        base.send :extend,  ClassMethods
+      end
+      
+      module ClassMethods
+        def self.extended(base)
+          base.class_eval do
+            belongs_to :user
+        
+            enumerated_attribute :role_type, :id_attribute => :role_type
+            attr_accessible :role_type
+          end
+        end
+      end
+      
+      module InstanceMethods
+        def to_sym
+          role_type.code
+        end
+      end
+    end
+  end
+end

data/lib/freeberry/models/role_type.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Freeberry
+  module Models
+    class RoleType
+      def initialize(code)
+        @code = code.to_sym
+      end
+      attr_reader :code
+      
+      def title
+        I18n.t(@code, :scope => [:manage, :role, :kind])
+      end  
+    end
+  end
+end

data/lib/freeberry/models/structure.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Freeberry
+  module Models
+    module Structure
+      def self.included(base)
+        base.send :include, InstanceMethods
+        base.send :extend,  ClassMethods
+      end
+      
+      module ClassMethods
+        def self.extended(base)
+          base.send(:include, HeaderTools)
+          base.class_eval do
+            enumerated_attribute :structure_type, :id_attribute => :kind
+            enumerated_attribute :position_type, :id_attribute => :position
+            
+            validates_presence_of :title
+            validates_numericality_of :position, :only_integer => true
+            
+            has_one :page, :dependent => :destroy
+            has_many :posts, :dependent => :destroy
+            
+            scope :visible, where(:is_visible => true)
+            scope :with_kind, proc {|structure_type| where(:kind => structure_type.id) }
+            scope :with_depth, proc {|level| where(:depth => level.to_i) }
+            scope :with_position, proc {|position_type| where(:position => position_type.id) }
+          end
+        end
+      end
+      
+      module InstanceMethods
+        def moveable?
+          return true if new_record?
+          !root?
+        end
+      end
+    end
+  end
+end

data/lib/freeberry/models/structure_type.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Freeberry
+  module Models
+    class StructureType
+      def initialize(value)
+        @kind = value
+      end
+      attr_reader :kind
+      
+      def title
+        I18n.t(@kind, :scope => [:manage, :structure, :kind])
+      end
+    end
+  end
+end

data/lib/freeberry/models/user.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+module Freeberry
+  module Models
+    module User
+      def self.included(base)
+        base.send :include, InstanceMethods
+        base.send :extend,  ClassMethods
+      end
+      
+      module ClassMethods
+        def self.extended(base)
+          base.class_eval do
+            before_validation :make_login
+        
+            has_many :roles, :dependent => :delete_all
+            has_one :avatar, :as => :assetable, :dependent => :destroy, :autosave => true
+            
+            scope :admins, joins(:roles).where(["`roles`.role_type = ?", ::RoleType.admin.id])
+            scope :with_role, proc {|role| joins(:roles).where(["`roles`.role_type = ?", role.id]) }
+          end
+        end
+      end
+      
+      module InstanceMethods
+        def manager?
+	        has_role?(:manager)
+	      end
+	
+	      def admin?
+	        has_role?(:admin)
+	      end
+	
+	      def has_role?(role_name)
+	        role_symbols.include?(role_name.to_sym)
+	      end
+	
+	      def roles_attributes=(value)
+          options = value || {}
+          options.each do |k, v|
+            r = self.roles.detect { |r| r.role_type.id == k.to_i }
+            if v.to_i == 0
+              self.roles.delete(r) unless r.nil?
+            else
+              r ||= self.roles.build(:role_type => ::RoleType.find(k.to_i))
+            end
+          end
+        end
+	
+	      def role_symbols
+          (roles || []).map {|r| r.to_sym}
+        end
+        
+        def state
+          return 'active' if active?
+          return 'register' unless confirmed?
+          return 'suspend' if access_locked?
+          'pending'
+        end
+        
+        def events_for_current_state
+          events = []
+          events << 'activate' if state == 'register'
+          events
+        end
+        
+        protected
+    
+          def make_login
+	          return if self.email.blank?
+	          
+          	if self.login.blank?
+          		tmp_login = self.email.split('@').first
+          		tmp_login ||= ActiveSupport::SecureRandom.hex(7)
+          		tmp_login = tmp_login.parameterize.downcase.gsub('.', '_')
+          		tmp_login = [tmp_login, ActiveSupport::SecureRandom.hex(4)].join('_') unless self.class.find_by_login(tmp_login).nil?
+          		self.login = tmp_login
+          	end
+          end
+      end
+    end
+  end
+end

data/lib/freeberry/mysql_utils.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+module Freeberry
+  module MysqlUtils
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      
+      def values(column = 'id')
+        query = scoped.select(column)
+        connection.select_values(query.to_sql).map(&:to_i).uniq
+      end
+      
+      # Check if database exists
+		  def database_exists?
+			  _options = configurations[Rails.env].dup
+			  _options.symbolize_keys!
+
+		    begin
+		      connection
+		      return true
+		    rescue Exception => e
+		      return false
+		    end
+		  end
+		
+		  # Deletes all rows in table very fast, but without calling +destroy+ method
+      # nor any hooks.
+		  def truncate_table
+			  transaction { connection.execute("TRUNCATE TABLE #{quoted_table_name};") }
+		  end
+		
+      # Disables key updates for model table
+      def disable_keys
+        connection.execute("ALTER TABLE #{quoted_table_name} DISABLE KEYS")
+      end
+      
+      # Enables key updates for model table
+      def enable_keys
+        connection.execute("ALTER TABLE #{quoted_table_name} ENABLE KEYS")
+      end
+
+      # Disables keys, yields block, enables keys.
+      def with_keys_disabled
+        disable_keys
+        yield
+        enable_keys
+      end
+      
+      # Loads data from file(s) using MySQL native LOAD DATA INFILE query, disabling
+      # key updates for even faster import speed
+      #
+      # ==== Parameters
+      # * +files+ file(s) to import
+      # * +options+ (see <tt>load_data_infile</tt>)
+      def fast_import(files, options = {})
+        files = [files] unless files.is_a? Array
+        with_keys_disabled do
+          load_data_infile_multiple(files, options)
+        end
+      end
+
+      # Loads data from multiple files using MySQL native LOAD DATA INFILE query
+      def load_data_infile_multiple(files, options = {})
+        files.each do |file|
+          load_data_infile(file, options)
+        end
+      end
+
+      # Loads data from file using MySQL native LOAD DATA INFILE query
+      #
+      # ==== Parameters
+      # * +file+ the file to import
+      # * +options+
+      def load_data_infile(file, options = {})
+        sql = "LOAD DATA LOCAL INFILE '#{file}' "
+        sql << "#{options[:insert_method]} " if options[:insert_method]
+        sql << "INTO TABLE #{quoted_table_name} "
+        sql << "CHARACTER SET #{options[:charset_name]} " if options[:charset_name]
+        
+        fields = ""
+        fields << "TERMINATED BY '#{options[:fields_terminated_by]}' " if options[:fields_terminated_by]
+        fields << "OPTIONALLY ENCLOSED BY '#{options[:fields_optionally_enclosed_by]}' " if options[:fields_optionally_enclosed_by]
+        fields << "ESCAPED BY '#{options[:fields_escaped_by]}' " if options[:fields_escaped_by]
+
+        sql << "FIELDS #{fields} " unless fields.empty?
+        sql << "LINES TERMINATED BY '#{options[:lines_terminated_by]}' " if options[:lines_terminated_by]
+        sql << "IGNORE #{options[:ignore_lines]} LINES " if options[:ignore_lines]
+        sql << "(" + options[:columns].join(', ') + ") " if options[:columns]
+        if options[:mapping]
+          mappings = []
+          options[:mapping].each_pair do |column, mapping|
+            mappings << "#{column} = #{mapping}"
+          end
+          sql << "SET #{mappings.join(', ')} " if mappings.size > 0
+        end
+        sql << ";"
+        connection.execute(sql)
+      end
+    end
+  end
+end