sunrise-cms 1.0.3 → 1.1.1

data/lib/sunrise/models/structure.rb

@@ -1,70 +1,69 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 require 'enum_field'
 
 module Sunrise
   module Models
     module Structure
       extend ActiveSupport::Concern
-      
+
       included do
         extend EnumField::EnumeratedAttribute
 
         enumerated_attribute :structure_type
         enumerated_attribute :position_type
-        
+
         validates_presence_of :title
         validates_numericality_of :position_type_id, only_integer: true
         validates_numericality_of :structure_type_id, only_integer: true
-        
+
         acts_as_nested_set
 
         before_validation :generate_slug, if: :should_generate_new_slug?
-        
-        scope :visible, lambda { where(is_visible: true) }
-        scope :with_type, lambda {|structure_type| where(structure_type_id: structure_type.id) }
-        scope :with_depth, lambda {|level| where(depth: level.to_i) }
-        scope :with_position, lambda {|position_type| where(position_type_id: position_type.id) }
+
+        scope :visible, -> { where(is_visible: true) }
+        scope :with_type, ->(structure_type) { where(structure_type_id: structure_type.id) }
+        scope :with_depth, ->(level) { where(depth: level.to_i) }
+        scope :with_position, ->(position_type) { where(position_type_id: position_type.id) }
       end
-      
+
       module ClassMethods
         def nested_set_options(mover = nil)
           result = []
-          
+
           roots.each do |root|
             result += root.self_and_descendants.map do |i|
-              if mover.nil? || mover.new_record? || mover.move_possible?(i)
-                [yield(i), i.id]
-              end
+              [yield(i), i.id] if mover.nil? || mover.new_record? || mover.move_possible?(i)
             end.compact
           end
           result
         end
       end
-      
+
       def moveable?
         new_record? || !root?
       end
-      
+
       def descendants_count
         (right - left - 1) / 2
       end
 
       protected
 
-        def generate_slug
-          self.slug = Sunrise::Utils.normalize_friendly_id(title)
-        end
+      def generate_slug
+        self.slug = Sunrise::Utils.normalize_friendly_id(title)
+      end
 
-        def should_generate_new_slug?
-          base = self.title
-          slug_value = self.slug
+      def should_generate_new_slug?
+        base = title
+        slug_value = slug
 
-          # If the slug base is nil, and the slug field is nil, then we're going to leave the slug column NULL.
-          return false if base.nil? && slug_value.nil?
-          
-          # Otherwise, if this is a new record, we're definitely going to try to create a new slug.
-          slug_value.blank?
-        end
+        # If the slug base is nil, and the slug field is nil, then we're going to leave the slug column NULL.
+        return false if base.nil? && slug_value.nil?
+
+        # Otherwise, if this is a new record, we're definitely going to try to create a new slug.
+        slug_value.blank?
+      end
     end
   end
 end

data/lib/sunrise/models/structure_type.rb

@@ -1,17 +1,18 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Sunrise
-  module Models  
+  module Models
     class StructureType
       include EnumField::DefineEnum
-      
+
       attr_reader :kind
-      
+
       def initialize(value)
         @kind = value.to_sym
       end
-      
+
       def title
-        I18n.t(@kind, :scope => [:manage, :structure, :kind])
+        I18n.t(@kind, scope: [:manage, :structure, :kind])
       end
     end
   end

data/lib/sunrise/models/user.rb

@@ -1,40 +1,41 @@
-# encoding: utf-8
-require "csv"
-require "enum_field"
+# frozen_string_literal: true
+
+require 'csv'
+require 'enum_field'
 
 module Sunrise
   module Models
     module User
       extend ActiveSupport::Concern
-      
+
       included do
         extend EnumField::EnumeratedAttribute
-        
+
         enumerated_attribute :role_type
-        
-        has_one :avatar, :as => :assetable, :dependent => :destroy, :autosave => true
-        
+
+        has_one :avatar, as: :assetable, dependent: :destroy, autosave: true
+
         after_initialize :set_default_role
-        
-        validates :name, :presence => true
+
+        validates :name, presence: true
         validate :check_role
-        
-        scope :with_email, lambda {|email| where(:email => email) }
-        scope :with_name, lambda {|name| where(:name => name) }
-        scope :with_role, lambda {|role_type| where(:role_type_id => role_type.id) }
-        scope :defaults, lambda { with_role(::RoleType.default) }
-        scope :moderators, lambda { with_role(::RoleType.moderator) }
-        scope :admins, lambda { with_role(::RoleType.admin) }
+
+        scope :with_email, ->(email) { where(email: email) }
+        scope :with_name, ->(name) { where(name: name) }
+        scope :with_role, ->(role_type) { where(role_type_id: role_type.id) }
+        scope :defaults, -> { with_role(::RoleType.default) }
+        scope :moderators, -> { with_role(::RoleType.moderator) }
+        scope :admins, -> { with_role(::RoleType.admin) }
       end
-      
-      module ClassMethods    
+
+      module ClassMethods
         def to_csv(options = {})
-          options = { :columns => [:id, :email, :name, :current_sign_in_ip] }.merge(options)
+          options = { columns: [:id, :email, :name, :current_sign_in_ip] }.merge(options)
           query = unscoped.order([:id, :desc]).select(options[:columns])
 
           ::CSV.generate do |csv|
             csv << options[:columns]
-            
+
             query.find_each do |user|
               csv << options[:columns].inject([]) do |items, attr_name|
                 items << user.send(attr_name)
@@ -43,11 +44,11 @@ module Sunrise
           end
         end
       end
-      
+
       def default?
         has_role?(:default)
       end
-      
+
       def moderator?
         has_role?(:moderator)
       end
@@ -59,35 +60,36 @@ module Sunrise
       def has_role?(role_name)
         role_symbols.include?(role_name.to_sym)
       end
-      
+
       def role_empty?
-        self.role_type_id.nil?
+        role_type_id.nil?
       end
-      	
+
       def role_symbols
         [role_type.try(:code)]
       end
-      
+
       def role_symbol
         role_symbols.first
       end
-      
+
       def state
         return 'active'   if active_for_authentication?
         return 'confirm'  unless confirmed?
         return 'suspend'  if access_locked?
-        return 'pending'
+
+        'pending'
       end
-      
+
       protected
-        
-        def set_default_role
-          self.role_type ||= ::RoleType.default
-        end
 
-        def check_role
-          errors.add(:role_type_id, :invalid) unless ::RoleType.legal?(role_type_id)
-        end
+      def set_default_role
+        self.role_type ||= ::RoleType.default
+      end
+
+      def check_role
+        errors.add(:role_type_id, :invalid) unless ::RoleType.legal?(role_type_id)
+      end
     end
   end
 end

data/lib/sunrise/utils.rb

@@ -1,40 +1,39 @@
+# frozen_string_literal: true
+
 module Sunrise
   module Utils
     autoload :Transliteration, 'sunrise/utils/transliteration'
     autoload :EvalHelpers, 'sunrise/utils/eval_helpers'
     autoload :CsvDocument, 'sunrise/utils/csv_document'
     autoload :SearchWrapper, 'sunrise/utils/search_wrapper'
-    
-    IMAGE_TYPES = ['image/jpeg', 'image/png', 'image/gif', 'image/jpg', 'image/pjpeg', 'image/tiff', 'image/x-png']
-    
+
+    IMAGE_TYPES = ['image/jpeg', 'image/png', 'image/gif', 'image/jpg',
+                   'image/pjpeg', 'image/tiff', 'image/x-png'].freeze
+
     def self.get_model(model_name, *args)
-      klass = lookup(["Sunrise", model_name.to_s.classify].join, Sunrise::AbstractModel)
+      klass = lookup(['Sunrise', model_name.to_s.classify].join, Sunrise::AbstractModel)
       klass ? klass.new(*args) : nil
     end
-  
+
     # Given a string +model_name+, finds the corresponding model class
-    def self.lookup(model_name, klass = nil)
+    def self.lookup(model_name, _klass = nil)
       model = model_name.constantize
 
-      if model && model.is_a?(Class)
-        model
-      else
-        nil
-      end
+      model if model&.is_a?(Class)
     rescue LoadError, NameError
       Rails.logger.error "Error while loading '#{model_name}': #{$!}"
       nil
     end
-    
+
     def self.superclasses(klass)
       superclasses = []
       while klass
-        superclasses << klass.superclass if klass && klass.superclass
+        superclasses << klass.superclass if klass&.superclass
         klass = klass.superclass
       end
       superclasses
     end
-    
+
     # Convert sort string to hash
     # "create_at_desc" to { :column => "created_at", :mode => "desc" }
     #
@@ -42,14 +41,14 @@ module Sunrise
       items = value.split('_')
       mode = items.pop
       column = items.join('_')
-      
-      {:column => column, :mode => mode}
+
+      { column: column, mode: mode }
     end
 
     # Convert input to friendly slug using babosa gem
     #
     def self.normalize_friendly_id(input)
-      input.to_s.to_slug.normalize(:transliterations => Sunrise::Config.transliteration).to_s
+      input.to_s.to_slug.normalize(transliterations: Sunrise::Config.transliteration).to_s
     end
   end
 end

data/lib/sunrise/utils/csv_document.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'csv'
 
 module Sunrise
@@ -8,37 +10,36 @@ module Sunrise
         @options = options
         @klass = (@options.delete(:klass) || extract_klass)
       end
-      
+
       def columns_names
         @columns_names ||= (@options[:columns] || @klass.column_names)
       end
-      
+
       def human_columns_names
         @human_columns_names ||= columns_names.map { |column| @klass.human_attribute_name(column.to_s) }
       end
-      
+
       def filename
-        @filename ||= [(@options[:filename] || @klass.model_name.plural || "document"), ".csv"].join
+        @filename ||= [(@options[:filename] || @klass.model_name.plural || 'document'), '.csv'].join
       end
-      
+
       def render
         csv_string = ::CSV.generate do |csv|
           csv << human_columns_names
-          
-          each_with_index do |record, index|
-            row = columns_names.inject([]) do |result, column|
+
+          each_with_index do |record, _index|
+            row = columns_names.each_with_object([]) do |column, result|
               result << record.send(column)
-              result
             end
-            
+
             csv << row
           end
         end
       end
-      
+
       def each_with_index
         count = 0
-        
+
         if @source.respond_to?(:find_each)
           @source.find_each do |item|
             yield item, count
@@ -51,19 +52,18 @@ module Sunrise
           end
         end
       end
-      
+
       protected
-      
-        def extract_klass
-          if @source.respond_to?(:klass)
-            @source.klass 
-          elsif @source.is_a?(Array)
-            @source.first.try(:class)
-          else
-            @source.class
-          end
+
+      def extract_klass
+        if @source.respond_to?(:klass)
+          @source.klass
+        elsif @source.is_a?(Array)
+          @source.first.try(:class)
+        else
+          @source.class
         end
-      
+      end
     end
   end
 end

data/lib/sunrise/utils/eval_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sunrise
   module Utils
     # Provides a set of helper methods for evaluating methods within the context
@@ -8,79 +10,79 @@ module Sunrise
       # * Symbol
       # * Method / Proc
       # * String
-      # 
+      #
       # == Examples
-      # 
+      #
       # Below are examples of the various ways that a method can be evaluated
       # on an object:
-      # 
+      #
       #   class Person
       #     def initialize(name)
       #       @name = name
       #     end
-      #     
+      #
       #     def name
       #       @name
       #     end
       #   end
-      #   
+      #
       #   class PersonCallback
       #     def self.run(person)
       #       person.name
       #     end
       #   end
-      # 
+      #
       #   person = Person.new('John Smith')
-      #   
+      #
       #   evaluate_method(person, :name)                            # => "John Smith"
       #   evaluate_method(person, PersonCallback.method(:run))      # => "John Smith"
       #   evaluate_method(person, Proc.new {|person| person.name})  # => "John Smith"
       #   evaluate_method(person, lambda {|person| person.name})    # => "John Smith"
       #   evaluate_method(person, '@name')                          # => "John Smith"
-      # 
+      #
       # == Additional arguments
-      # 
+      #
       # Additional arguments can be passed to the methods being evaluated.  If
       # the method defines additional arguments other than the object context,
       # then all arguments are required.
-      # 
+      #
       # For example,
-      # 
+      #
       #   person = Person.new('John Smith')
-      #   
+      #
       #   evaluate_method(person, lambda {|person| person.name}, 21)                              # => "John Smith"
       #   evaluate_method(person, lambda {|person, age| "#{person.name} is #{age}"}, 21)          # => "John Smith is 21"
       #   evaluate_method(person, lambda {|person, age| "#{person.name} is #{age}"}, 21, 'male')  # => ArgumentError: wrong number of arguments (3 for 2)
       def evaluate_method(object, method, *args, &block)
         case method
-          when Symbol
-            object.method(method).arity == 0 ? object.send(method, &block) : object.send(method, *args, &block)
-          when Proc, Method
-            args.unshift(object)
-            arity = method.arity
-            limit = [0, 1].include?(arity) ? arity : args.length
-            
-            # Procs don't support blocks in < Ruby 1.8.6, so it's tacked on as an
-            # argument for consistency across versions of Ruby (even though 1.9
-            # supports yielding within blocks)
-            if block_given? && Proc === method && arity != 0
-              if [1, 2].include?(arity)
-                # Force the block to be either the only argument or the 2nd one
-                # after the object (may mean additional arguments get discarded)
-                limit = arity
-                args.insert(limit - 1, block)
-              else
-                # Tack the block to the end of the args
-                limit += 1 unless limit < 0
-                args.push(block)
-              end
+        when Symbol
+          object.method(method).arity == 0 ? object.send(method, &block) : object.send(method, *args, &block)
+        when Proc, Method
+          args.unshift(object)
+          arity = method.arity
+          limit = [0, 1].include?(arity) ? arity : args.length
+
+          # Procs don't support blocks in < Ruby 1.8.6, so it's tacked on as an
+          # argument for consistency across versions of Ruby (even though 1.9
+          # supports yielding within blocks)
+          if block_given? && Proc === method && arity != 0
+            if [1, 2].include?(arity)
+              # Force the block to be either the only argument or the 2nd one
+              # after the object (may mean additional arguments get discarded)
+              limit = arity
+              args.insert(limit - 1, block)
+            else
+              # Tack the block to the end of the args
+              limit += 1 unless limit < 0
+              args.push(block)
             end
-            
-            method.call(*args[0, limit], &block)
-          when String
-            eval(method, object.instance_eval {binding}, &block)
-          else
-            raise ArgumentError, 'Methods must be a symbol denoting the method to call, a block to be invoked, or a string to be evaluated'
+          end
+
+          method.call(*args[0, limit], &block)
+        when String
+          eval(method, object.instance_eval { binding }, &block)
+        else
+          raise ArgumentError, 'Methods must be a symbol denoting the method to call, a block to be invoked, or a string to be evaluated'
           end
       end
     end