sunrise-core 0.1.0

data/lib/sunrise/models/role.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+module Sunrise
+  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/sunrise/models/role_type.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Sunrise
+  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/sunrise/models/structure.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+module Sunrise
+  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, Utils::Header)
+          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
+        
+        def find_by_permalink(value)
+          value.to_s.is_int? ? find(value) : where(:slug => value.to_s).first
+        end
+      end
+      
+      module InstanceMethods
+        def moveable?
+          return true if new_record?
+          !root?
+        end
+      end
+    end
+  end
+end

data/lib/sunrise/models/structure_type.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Sunrise
+  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/sunrise/models/user.rb

@@ -0,0 +1,124 @@
+# encoding: utf-8
+module Sunrise
+  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        
+            has_many :roles, :dependent => :delete_all
+            has_one :avatar, :as => :assetable, :dependent => :destroy, :autosave => true
+            
+            scope :with_role, lambda {|role| joins(:roles).where(["`roles`.role_type = ?", role.id]) }
+            scope :defaults, with_role(::RoleType.default)
+            scope :moderators, with_role(::RoleType.moderator)
+            scope :admins, with_role(::RoleType.admin)
+            
+            before_validation :generate_login, :if => :has_login?
+            before_create :set_default_role, :if => :roles_empty?
+          end
+        end
+      end
+      
+      module InstanceMethods
+        def default?
+          has_role?(:default)
+        end
+        
+        def moderator?
+	        has_role?(:moderator)
+	      end
+	
+	      def admin?
+	        has_role?(:admin)
+	      end
+	
+	      def has_role?(role_name)
+	        role_symbols.include?(role_name.to_sym)
+	      end
+	      
+	      def roles_empty?
+	        self.roles.empty?
+	      end
+	      
+	      def has_login?
+	        respond_to?(:login)
+	      end
+	      	
+	      def roles_attributes=(value)
+          options = value || {}
+          options.each do |k, v|
+            create_or_destroy_role(k.to_i, v.to_i == 1)
+          end
+        end
+	
+	      def role_symbols
+          (roles || []).map {|r| r.to_sym}
+        end
+        
+        def current_role
+          self.roles.first
+        end
+        
+        def role_type_id
+          if current_role
+            current_role.role_type.id
+          end
+        end
+        
+        def role_type_id=(value)
+          role_id = value.blank? ? nil : value.to_i
+          
+          if ::RoleType.all.map(&:id).include?(role_id)
+            ::RoleType.all.each do |role_type|
+              create_or_destroy_role(role_type.id, role_type.id == role_id)
+            end
+          end
+        end
+        
+        def state
+          return 'active' if active_for_authentication?
+          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 set_default_role
+            unless has_role?(:default)
+              self.roles.build(:role_type => ::RoleType.default)
+            end
+          end
+          
+          def create_or_destroy_role(role_id, need_create = true)
+            role = self.roles.detect { |r| r.role_type.id == role_id }
+            if need_create
+              role ||= self.roles.build(:role_type => ::RoleType.find(role_id))
+            elsif !role.nil?
+              self.roles.delete(role)
+            end
+          end
+          
+          def generate_login
+            self.login ||= begin
+              unless email.blank?
+                tmp_login = email.split('@').first 
+        		    tmp_login.parameterize.downcase.gsub(/[^A-Za-z0-9-]+/, '-').gsub(/-+/, '-')
+        		  end
+            end
+          end
+      end
+    end
+  end
+end

data/lib/sunrise/plugin.rb

@@ -0,0 +1,46 @@
+module Sunrise
+  class Plugin
+    attr_accessor :name, :model, :menu, :version, :klass, :klass_name
+    
+    def initialize(name)
+      @name = name.to_s.downcase
+      @menu = false
+      @klass = nil
+      @klass_name = nil
+      
+      Sunrise::Plugins.registered << self
+    end
+    
+    def module_name
+      @module_name ||= @name.singularize.camelize.to_sym
+    end
+    
+    def klass
+      @klass ||= klass_name.constantize
+    end
+    
+    def klass_name
+      @klass_name ||= @name.singularize.camelize
+    end
+    
+    def title
+      I18n.t(@name, :scope => [:manage, :plugins])
+    end
+    
+    def self.register(name, &block)
+      plugin = self.new(name)
+
+      yield plugin
+
+      raise "A plugin MUST have a name!: #{plugin.inspect}" if plugin.name.blank?
+      
+      plugin.version ||= Sunrise::VERSION.dup
+      
+      if plugin.model
+        model_path = (plugin.model == true ? "sunrise/models/#{plugin.name}" : plugin.model)
+        Sunrise::Models.send(:autoload, plugin.module_name, model_path)
+      end
+    end
+  end
+  
+end

data/lib/sunrise/plugins.rb

@@ -0,0 +1,56 @@
+module Sunrise
+  class Plugins < Array
+
+    def initialize
+      @plugins = []
+    end
+
+    def find_by_name(name)
+      self.detect { |plugin| plugin.name == name.to_s.downcase }
+    end
+    alias :[] :find_by_name
+
+    def find_by_title(title)
+      self.detect { |plugin| plugin.title == title }
+    end
+
+    def menu(value)
+      self.select { |p| p.menu == value.to_s.downcase }
+    end
+
+    def names
+      self.map(&:name)
+    end
+
+    def titles
+      self.map(&:title)
+    end
+
+    class << self
+      def active
+        @active_plugins ||= self.new
+      end
+
+      def registered
+        @registered_plugins ||= self.new
+      end
+
+      def activate(name)
+        active << registered[name] if registered[name] && !active[name]
+      end
+
+      def deactivate(name)
+        active.delete_if {|p| p.name == name}
+      end
+
+      def set_active(names)
+        @active_plugins = self.new
+
+        names.each do |name|
+          activate(name)
+        end
+      end
+    end
+
+  end
+end

data/lib/sunrise/system_settings.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+require 'ostruct'
+
+module Sunrise
+  class SystemSettings < Utils::Settingslogic
+    source Rails.root.join("config", "application.yml")
+    #namespace (Rails.env.to_s || 'development')
+    
+    class << self
+      def ostruct
+        instance.serialize
+      end
+      
+      def update_settings(attributes)
+        instance.update attributes
+        instance.save
+      end
+      
+      def write(hash)
+        begin
+          File.open(source, 'w') do |file|
+            file.write hash.to_yaml
+          end
+        rescue Exception => e
+          return false
+        end
+      end
+      
+      def hashes_to_openstructs(obj, memo={})
+        return obj unless Hash === obj
+        
+        memo[obj.object_id] ||= OpenStruct.new( Hash[
+            *obj.inject( [] ) { |a, (k, v)|
+              a.push k, hashes_to_openstructs( v, memo )
+            }
+          ])
+      end
+    end
+    
+    def save
+      if self.class.namespace
+        hash = YAML.load(ERB.new(File.read(self.class.source)).result).to_hash
+        hash[self.class.namespace] ||= {}
+        hash[self.class.namespace].update self
+      else
+        hash = self
+      end
+        
+      self.class.write(hash)
+      reload
+    end
+    
+    def reload
+      @instance = nil
+      @struct = nil
+      
+      return true
+    end
+    
+    def serialize
+      @struct ||= self.class.hashes_to_openstructs(self)   
+      @struct
+    end
+  end
+end

data/lib/sunrise/utils/accessible_attributes.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+module Sunrise
+  module Utils
+    module AccessibleAttributes
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+        base.send(:include, InstanceMethods)
+      end
+      
+      module ClassMethods
+        def self.extended(base)  
+          base.class_eval do
+            attr_accessible
+            attr_accessor :accessible
+          end
+        end
+      end
+      
+      module InstanceMethods
+        private
+    
+          def mass_assignment_authorizer
+            if accessible == :all
+              self.class.protected_attributes
+            else
+              super + (accessible || [])
+            end
+          end
+      end
+    end
+  end
+end

data/lib/sunrise/utils/header.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+module Sunrise
+  module Utils
+    module Header
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+        base.send(:include, InstanceMethods)
+      end
+      
+      module ClassMethods
+        def self.extended(base)
+          base.class_eval do
+            has_one :header, :as => :headerable, :dependent => :delete
+            
+            attr_accessible :header_attributes
+            
+            accepts_nested_attributes_for :header, :reject_if => :all_blank
+          end
+        end
+      end
+      
+      module InstanceMethods
+        def default_header
+          header || build_header
+        end
+      end
+    end
+  end
+end

data/lib/sunrise/utils/i18n_backend.rb

@@ -0,0 +1,87 @@
+# encoding: utf-8
+module Sunrise
+  module Utils
+  
+    # "Продвинутый" бекэнд для I18n.
+    # 
+    # Наследует Simple бекэнд и полностью с ним совместим. Добаляет поддержку 
+    # для отдельностоящих/контекстных названий дней недели и месяцев.
+    # Также позволяет каждому языку использовать собственные правила плюрализации,
+    # объявленные как Proc (<tt>lambda</tt>).
+    # 
+    #
+    # Advanced I18n backend.
+    #
+    # Extends Simple backend. Allows usage of "standalone" keys
+    # for DateTime localization and usage of user-defined Proc (lambda) pluralization
+    # methods in translation tables.
+    class I18nBackend < ::I18n::Backend::Simple
+      include ::I18n::Backend::Pluralization
+      
+      LOCALIZE_ABBR_MONTH_NAMES_MATCH = /(%d|%e)(.*)(%b)/
+      LOCALIZE_MONTH_NAMES_MATCH = /(%d|%e)(.*)(%B)/
+      LOCALIZE_STANDALONE_ABBR_DAY_NAMES_MATCH = /^%a/
+      LOCALIZE_STANDALONE_DAY_NAMES_MATCH = /^%A/
+      
+      # Acts the same as +strftime+, but returns a localized version of the 
+      # formatted date string. Takes a key from the date/time formats 
+      # translations as a format argument (<em>e.g.</em>, <tt>:short</tt> in <tt>:'date.formats'</tt>).
+      #
+      #
+      # Метод отличается от <tt>localize</tt> в Simple бекэнде поддержкой 
+      # отдельностоящих/контекстных названий дней недели и месяцев.
+      #
+      #
+      # Note that it differs from <tt>localize</tt> in Simple< backend by checking for 
+      # "standalone" month name/day name keys in translation and using them if available.
+      #
+      # <tt>options</tt> parameter added for i18n-0.3 compliance.
+      def localize(locale, object, format = :default, options = nil)
+        raise ArgumentError, "Object must be a Date, DateTime or Time object. #{object.inspect} given." unless object.respond_to?(:strftime)
+        
+        type = object.respond_to?(:sec) ? 'time' : 'date'
+        # TODO only translate these if format is a String?
+        formats = translate(locale, :"#{type}.formats")
+        format = formats[format.to_sym] if formats && formats[format.to_sym]
+        # TODO raise exception unless format found?
+        format = format.to_s.dup
+
+        # TODO only translate these if the format string is actually present
+        # TODO check which format strings are present, then bulk translate then, then replace them
+
+        if lookup(locale, :"date.standalone_abbr_day_names")
+          format.gsub!(LOCALIZE_STANDALONE_ABBR_DAY_NAMES_MATCH, 
+            translate(locale, :"date.standalone_abbr_day_names")[object.wday])
+        end
+        format.gsub!(/%a/, translate(locale, :"date.abbr_day_names")[object.wday])
+        
+        if lookup(locale, :"date.standalone_day_names")
+          format.gsub!(LOCALIZE_STANDALONE_DAY_NAMES_MATCH, 
+            translate(locale, :"date.standalone_day_names")[object.wday])
+        end
+        format.gsub!(/%A/, translate(locale, :"date.day_names")[object.wday])
+
+        if lookup(locale, :"date.standalone_abbr_month_names")
+          format.gsub!(LOCALIZE_ABBR_MONTH_NAMES_MATCH) do
+            $1 + $2 + translate(locale, :"date.abbr_month_names")[object.mon]
+          end
+          format.gsub!(/%b/, translate(locale, :"date.standalone_abbr_month_names")[object.mon])
+        else
+          format.gsub!(/%b/, translate(locale, :"date.abbr_month_names")[object.mon])
+        end
+
+        if lookup(locale, :"date.standalone_month_names")
+          format.gsub!(LOCALIZE_MONTH_NAMES_MATCH) do
+            $1 + $2 + translate(locale, :"date.month_names")[object.mon]
+          end
+          format.gsub!(/%B/, translate(locale, :"date.standalone_month_names")[object.mon])
+        else
+          format.gsub!(/%B/, translate(locale, :"date.month_names")[object.mon])
+        end
+
+        format.gsub!(/%p/, translate(locale, :"time.#{object.hour < 12 ? :am : :pm}")) if object.respond_to? :hour
+        object.strftime(format)
+      end
+    end
+  end
+end

data/lib/sunrise/utils/mysql.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+module Sunrise
+  module Utils
+    module Mysql
+      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
+end