mini-lite-tool 0.0.1

data/cancancan-3.6.1/lib/cancan/controller_resource.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require_relative 'controller_resource_loader.rb'
+module CanCan
+  # Handle the load and authorization controller logic
+  # so we don't clutter up all controllers with non-interface methods.
+  # This class is used internally, so you do not need to call methods directly on it.
+  class ControllerResource # :nodoc:
+    include ControllerResourceLoader
+
+    def self.add_before_action(controller_class, method, *args)
+      options = args.extract_options!
+      resource_name = args.first
+      before_action_method = before_callback_name(options)
+      controller_class.send(before_action_method, options.slice(:only, :except, :if, :unless)) do |controller|
+        controller.class.cancan_resource_class
+                  .new(controller, resource_name, options.except(:only, :except, :if, :unless)).send(method)
+      end
+    end
+
+    def self.before_callback_name(options)
+      options.delete(:prepend) ? :prepend_before_action : :before_action
+    end
+
+    def initialize(controller, *args)
+      @controller = controller
+      @params = controller.params
+      @options = args.extract_options!
+      @name = args.first
+    end
+
+    def load_and_authorize_resource
+      load_resource
+      authorize_resource
+    end
+
+    def authorize_resource
+      return if skip?(:authorize)
+
+      @controller.authorize!(authorization_action, resource_instance || resource_class_with_parent)
+    end
+
+    def parent?
+      @options.key?(:parent) ? @options[:parent] : @name && @name != name_from_controller.to_sym
+    end
+
+    def skip?(behavior)
+      return false unless (options = @controller.class.cancan_skipper[behavior][@name])
+
+      options == {} ||
+        options[:except] && !action_exists_in?(options[:except]) ||
+        action_exists_in?(options[:only])
+    end
+
+    protected
+
+    # Returns the class used for this resource. This can be overridden by the :class option.
+    # If +false+ is passed in it will use the resource name as a symbol in which case it should
+    # only be used for authorization, not loading since there's no class to load through.
+    def resource_class
+      case @options[:class]
+      when false
+        name.to_sym
+      when nil
+        namespaced_name.to_s.camelize.constantize
+      when String
+        @options[:class].constantize
+      else
+        @options[:class]
+      end
+    end
+
+    def load_instance?
+      parent? || member_action?
+    end
+
+    def load_collection?
+      resource_base.respond_to?(:accessible_by) && !current_ability.has_block?(authorization_action, resource_class)
+    end
+
+    def member_action?
+      new_actions.include?(@params[:action].to_sym) || @options[:singleton] ||
+        ((@params[:id] || @params[@options[:id_param]]) &&
+          !collection_actions.include?(@params[:action].to_sym))
+    end
+
+    def resource_class_with_parent
+      parent_resource ? { parent_resource => resource_class } : resource_class
+    end
+
+    def resource_instance=(instance)
+      @controller.instance_variable_set("@#{instance_name}", instance)
+    end
+
+    def resource_instance
+      return unless load_instance? && @controller.instance_variable_defined?("@#{instance_name}")
+
+      @controller.instance_variable_get("@#{instance_name}")
+    end
+
+    def collection_instance=(instance)
+      @controller.instance_variable_set("@#{instance_name.to_s.pluralize}", instance)
+    end
+
+    def collection_instance
+      return unless @controller.instance_variable_defined?("@#{instance_name.to_s.pluralize}")
+
+      @controller.instance_variable_get("@#{instance_name.to_s.pluralize}")
+    end
+
+    def parameters_require_sanitizing?
+      save_actions.include?(@params[:action].to_sym) || resource_params_by_namespaced_name.present?
+    end
+
+    def instance_name
+      @options[:instance_name] || name
+    end
+
+    def collection_actions
+      [:index] + Array(@options[:collection])
+    end
+
+    def save_actions
+      %i[create update]
+    end
+
+    private
+
+    def action_exists_in?(options)
+      Array(options).include?(@params[:action].to_sym)
+    end
+
+    def adapter
+      ModelAdapters::AbstractAdapter.adapter_class(resource_class)
+    end
+
+    def current_ability
+      @controller.send(:current_ability)
+    end
+  end
+end

data/cancancan-3.6.1/lib/cancan/controller_resource_builder.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module CanCan
+  module ControllerResourceBuilder
+    protected
+
+    def build_resource
+      resource = resource_base.new(resource_params || {})
+      assign_attributes(resource)
+    end
+
+    def assign_attributes(resource)
+      resource.send("#{parent_name}=", parent_resource) if @options[:singleton] && parent_resource
+      initial_attributes.each do |attr_name, value|
+        resource.send("#{attr_name}=", value)
+      end
+      resource
+    end
+
+    def initial_attributes
+      current_ability.attributes_for(@params[:action].to_sym, resource_class).delete_if do |key, _value|
+        resource_params && resource_params.include?(key)
+      end
+    end
+  end
+end

data/cancancan-3.6.1/lib/cancan/controller_resource_finder.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module CanCan
+  module ControllerResourceFinder
+    protected
+
+    def find_resource
+      if @options[:singleton] && parent_resource.respond_to?(name)
+        parent_resource.send(name)
+      elsif @options[:find_by]
+        find_resource_using_find_by
+      else
+        adapter.find(resource_base, id_param)
+      end
+    end
+
+    def find_resource_using_find_by
+      find_by_dynamic_finder || find_by_find_by_finder || resource_base.send(@options[:find_by], id_param)
+    end
+
+    def find_by_dynamic_finder
+      method_name = "find_by_#{@options[:find_by]}!"
+      resource_base.send(method_name, id_param) if resource_base.respond_to? method_name
+    end
+
+    def find_by_find_by_finder
+      resource_base.find_by(@options[:find_by].to_sym => id_param) if resource_base.respond_to? :find_by
+    end
+
+    def id_param
+      @params[id_param_key].to_s if @params[id_param_key].present?
+    end
+
+    def id_param_key
+      if @options[:id_param]
+        @options[:id_param]
+      else
+        parent? ? :"#{name}_id" : :id
+      end
+    end
+  end
+end

data/cancancan-3.6.1/lib/cancan/controller_resource_loader.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require_relative 'controller_resource_finder.rb'
+require_relative 'controller_resource_name_finder.rb'
+require_relative 'controller_resource_builder.rb'
+require_relative 'controller_resource_sanitizer.rb'
+module CanCan
+  module ControllerResourceLoader
+    include CanCan::ControllerResourceNameFinder
+    include CanCan::ControllerResourceFinder
+    include CanCan::ControllerResourceBuilder
+    include CanCan::ControllerResourceSanitizer
+
+    def load_resource
+      return if skip?(:load)
+
+      if load_instance?
+        self.resource_instance ||= load_resource_instance
+      elsif load_collection?
+        self.collection_instance ||= load_collection
+      end
+    end
+
+    protected
+
+    def new_actions
+      %i[new create] + Array(@options[:new])
+    end
+
+    def resource_params_by_key(key)
+      return unless @options[key] && @params.key?(extract_key(@options[key]))
+
+      @params[extract_key(@options[key])]
+    end
+
+    def resource_params_by_namespaced_name
+      resource_params_by_key(:instance_name) || resource_params_by_key(:class) || (
+      params = @params[extract_key(namespaced_name)]
+      params.respond_to?(:to_h) ? params : nil)
+    end
+
+    def resource_params
+      if parameters_require_sanitizing? && params_method.present?
+        sanitize_parameters
+      else
+        resource_params_by_namespaced_name
+      end
+    end
+
+    def fetch_parent(name)
+      if @controller.instance_variable_defined? "@#{name}"
+        @controller.instance_variable_get("@#{name}")
+      elsif @controller.respond_to?(name, true)
+        @controller.send(name)
+      end
+    end
+
+    # The object to load this resource through.
+    def parent_resource
+      parent_name && fetch_parent(parent_name)
+    end
+
+    def parent_name
+      @options[:through] && [@options[:through]].flatten.detect { |i| fetch_parent(i) }
+    end
+
+    def resource_base_through_parent_resource
+      if @options[:singleton]
+        resource_class
+      else
+        parent_resource.send(@options[:through_association] || name.to_s.pluralize)
+      end
+    end
+
+    def resource_base_through
+      if parent_resource
+        resource_base_through_parent_resource
+      elsif @options[:shallow]
+        resource_class
+      else
+        # maybe this should be a record not found error instead?
+        raise AccessDenied.new(nil, authorization_action, resource_class)
+      end
+    end
+
+    # The object that methods (such as "find", "new" or "build") are called on.
+    # If the :through option is passed it will go through an association on that instance.
+    # If the :shallow option is passed it will use the resource_class if there's no parent
+    # If the :singleton option is passed it won't use the association because it needs to be handled later.
+    def resource_base
+      @options[:through] ? resource_base_through : resource_class
+    end
+
+    def parent_authorization_action
+      @options[:parent_action] || :show
+    end
+
+    def authorization_action
+      parent? ? parent_authorization_action : @params[:action].to_sym
+    end
+
+    def load_collection
+      resource_base.accessible_by(current_ability, authorization_action)
+    end
+
+    def load_resource_instance
+      if !parent? && new_actions.include?(@params[:action].to_sym)
+        build_resource
+      elsif id_param || @options[:singleton]
+        find_resource
+      end
+    end
+
+    private
+
+    def extract_key(value)
+      value.to_s.underscore.tr('/', '_')
+    end
+  end
+end

data/cancancan-3.6.1/lib/cancan/controller_resource_name_finder.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module CanCan
+  module ControllerResourceNameFinder
+    protected
+
+    def name_from_controller
+      @params[:controller].split('/').last.singularize
+    end
+
+    def namespaced_name
+      [namespace, name].join('/').singularize.camelize.safe_constantize || name
+    end
+
+    def name
+      @name || name_from_controller
+    end
+
+    def namespace
+      @params[:controller].split('/')[0..-2]
+    end
+  end
+end

data/cancancan-3.6.1/lib/cancan/controller_resource_sanitizer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module CanCan
+  module ControllerResourceSanitizer
+    protected
+
+    def sanitize_parameters
+      case params_method
+      when Symbol
+        @controller.send(params_method)
+      when String
+        @controller.instance_eval(params_method)
+      when Proc
+        params_method.call(@controller)
+      end
+    end
+
+    def params_methods
+      methods = ["#{@params[:action]}_params".to_sym, "#{name}_params".to_sym, :resource_params]
+      methods.unshift(@options[:param_method]) if @options[:param_method].present?
+      methods
+    end
+
+    def params_method
+      params_methods.each do |method|
+        return method if (method.is_a?(Symbol) && @controller.respond_to?(method, true)) ||
+                         method.is_a?(String) || method.is_a?(Proc)
+      end
+      nil
+    end
+  end
+end

data/cancancan-3.6.1/lib/cancan/exceptions.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module CanCan
+  # A general CanCan exception
+  class Error < StandardError; end
+
+  # Raised when behavior is not implemented, usually used in an abstract class.
+  class NotImplemented < Error; end
+
+  # Raised when removed code is called, an alternative solution is provided in message.
+  class ImplementationRemoved < Error; end
+
+  # Raised when using check_authorization without calling authorize!
+  class AuthorizationNotPerformed < Error; end
+
+  # Raised when a rule is created with both a block and a hash of conditions
+  class BlockAndConditionsError < Error; end
+
+  # Raised when an unexpected argument is passed as an attribute
+  class AttributeArgumentError < Error; end
+
+  # Raised when using a wrong association name
+  class WrongAssociationName < Error; end
+
+  # This error is raised when a user isn't allowed to access a given controller action.
+  # This usually happens within a call to ControllerAdditions#authorize! but can be
+  # raised manually.
+  #
+  #   raise CanCan::AccessDenied.new("Not authorized!", :read, Article)
+  #
+  # The passed message, action, and subject are optional and can later be retrieved when
+  # rescuing from the exception.
+  #
+  #   exception.message # => "Not authorized!"
+  #   exception.action # => :read
+  #   exception.subject # => Article
+  #
+  # If the message is not specified (or is nil) it will default to "You are not authorized
+  # to access this page." This default can be overridden by setting default_message.
+  #
+  #   exception.default_message = "Default error message"
+  #   exception.message # => "Default error message"
+  #
+  # See ControllerAdditions#authorize! for more information on rescuing from this exception
+  # and customizing the message using I18n.
+  class AccessDenied < Error
+    attr_reader :action, :subject, :conditions
+    attr_writer :default_message
+
+    def initialize(message = nil, action = nil, subject = nil, conditions = nil)
+      @message = message
+      @action = action
+      @subject = subject
+      @conditions = conditions
+      @default_message = I18n.t(:"unauthorized.default", default: 'You are not authorized to access this page.')
+    end
+
+    def to_s
+      @message || @default_message
+    end
+
+    def inspect
+      details = %i[action subject conditions message].map do |attribute|
+        value = instance_variable_get "@#{attribute}"
+        "#{attribute}: #{value.inspect}" if value.present?
+      end.compact.join(', ')
+      "#<#{self.class.name} #{details}>"
+    end
+  end
+end

data/cancancan-3.6.1/lib/cancan/matchers.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+rspec_module = defined?(RSpec::Core) ? 'RSpec' : 'Spec' # RSpec 1 compatability
+
+if rspec_module == 'RSpec'
+  require 'rspec/core'
+  require 'rspec/expectations'
+else
+  ActiveSupport::Deprecation.warn('RSpec < 3 will not be supported in the CanCanCan >= 2.0.0')
+end
+
+Kernel.const_get(rspec_module)::Matchers.define :be_able_to do |*args|
+  match do |ability|
+    actions = args.first
+    if actions.is_a? Array
+      if actions.empty?
+        false
+      else
+        actions.all? { |action| ability.can?(action, *args[1..-1]) }
+      end
+    else
+      ability.can?(*args)
+    end
+  end
+
+  # Check that RSpec is < 2.99
+  if !respond_to?(:failure_message) && respond_to?(:failure_message_for_should)
+    alias_method :failure_message, :failure_message_for_should
+  end
+
+  if !respond_to?(:failure_message_when_negated) && respond_to?(:failure_message_for_should_not)
+    alias_method :failure_message_when_negated, :failure_message_for_should_not
+  end
+
+  failure_message do
+    resource = args[1]
+    if resource.instance_of?(Class)
+      "expected to be able to #{args.map(&:to_s).join(' ')}"
+    else
+      "expected to be able to #{args.map(&:inspect).join(' ')}"
+    end
+  end
+
+  failure_message_when_negated do
+    resource = args[1]
+    if resource.instance_of?(Class)
+      "expected not to be able to #{args.map(&:to_s).join(' ')}"
+    else
+      "expected not to be able to #{args.map(&:inspect).join(' ')}"
+    end
+  end
+
+  description do
+    "be able to #{args.map(&:to_s).join(' ')}"
+  end
+end

data/cancancan-3.6.1/lib/cancan/model_adapters/abstract_adapter.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module CanCan
+  module ModelAdapters
+    class AbstractAdapter
+      attr_reader :model_class
+
+      def self.inherited(subclass)
+        @subclasses ||= []
+        @subclasses.insert(0, subclass)
+      end
+
+      def self.adapter_class(model_class)
+        @subclasses.detect { |subclass| subclass.for_class?(model_class) } || DefaultAdapter
+      end
+
+      # Used to determine if the given adapter should be used for the passed in class.
+      def self.for_class?(_member_class)
+        false # override in subclass
+      end
+
+      # Override if you need custom find behavior
+      def self.find(model_class, id)
+        model_class.find(id)
+      end
+
+      # Used to determine if this model adapter will override the matching behavior for a hash of conditions.
+      # If this returns true then matches_conditions_hash? will be called. See Rule#matches_conditions_hash
+      def self.override_conditions_hash_matching?(_subject, _conditions)
+        false
+      end
+
+      # Override if override_conditions_hash_matching? returns true
+      def self.matches_conditions_hash?(_subject, _conditions)
+        raise NotImplemented, 'This model adapter does not support matching on a conditions hash.'
+      end
+
+      # Override if parent condition could be under a different key in conditions
+      def self.parent_condition_name(parent, _child)
+        parent.class.name.downcase.to_sym
+      end
+
+      # Used above override_conditions_hash_matching to determine if this model adapter will override the
+      # matching behavior for nested subject.
+      # If this returns true then nested_subject_matches_conditions? will be called.
+      def self.override_nested_subject_conditions_matching?(_parent, _child, _all_conditions)
+        false
+      end
+
+      # Override if override_nested_subject_conditions_matching? returns true
+      def self.nested_subject_matches_conditions?(_parent, _child, _all_conditions)
+        raise NotImplemented, 'This model adapter does not support matching on a nested subject.'
+      end
+
+      # Used to determine if this model adapter will override the matching behavior for a specific condition.
+      # If this returns true then matches_condition? will be called. See Rule#matches_conditions_hash
+      def self.override_condition_matching?(_subject, _name, _value)
+        false
+      end
+
+      # Override if override_condition_matching? returns true
+      def self.matches_condition?(_subject, _name, _value)
+        raise NotImplemented, 'This model adapter does not support matching on a specific condition.'
+      end
+
+      def initialize(model_class, rules)
+        @model_class = model_class
+        @rules = rules
+      end
+
+      def database_records
+        # This should be overridden in a subclass to return records which match @rules
+        raise NotImplemented, 'This model adapter does not support fetching records from the database.'
+      end
+    end
+  end
+end

data/cancancan-3.6.1/lib/cancan/model_adapters/active_record_4_adapter.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module CanCan
+  module ModelAdapters
+    class ActiveRecord4Adapter < ActiveRecordAdapter
+      AbstractAdapter.inherited(self)
+
+      class << self
+        def for_class?(model_class)
+          version_lower?('5.0.0') && model_class <= ActiveRecord::Base
+        end
+
+        def override_condition_matching?(subject, name, _value)
+          subject.class.defined_enums.include?(name.to_s)
+        end
+
+        def matches_condition?(subject, name, value)
+          # Get the mapping from enum strings to values.
+          enum = subject.class.send(name.to_s.pluralize)
+          # Get the value of the attribute as an integer.
+          attribute = enum[subject.send(name)]
+          # Check to see if the value matches the condition.
+          if value.is_a?(Enumerable)
+            value.include? attribute
+          else
+            attribute == value
+          end
+        end
+      end
+
+      private
+
+      # As of rails 4, `includes()` no longer causes active record to
+      # look inside the where clause to decide to outer join tables
+      # you're using in the where. Instead, `references()` is required
+      # in addition to `includes()` to force the outer join.
+      def build_joins_relation(relation, *_where_conditions)
+        relation.includes(joins).references(joins)
+      end
+
+      # Rails 4.2 deprecates `sanitize_sql_hash_for_conditions`
+      def sanitize_sql(conditions)
+        if self.class.version_greater_or_equal?('4.2.0') && conditions.is_a?(Hash)
+          sanitize_sql_activerecord4(conditions)
+        else
+          @model_class.send(:sanitize_sql, conditions)
+        end
+      end
+
+      def sanitize_sql_activerecord4(conditions)
+        table = Arel::Table.new(@model_class.send(:table_name))
+
+        conditions = ActiveRecord::PredicateBuilder.resolve_column_aliases @model_class, conditions
+        conditions = @model_class.send(:expand_hash_conditions_for_aggregates, conditions)
+
+        ActiveRecord::PredicateBuilder.build_from_hash(@model_class, conditions, table).map do |b|
+          @model_class.send(:connection).visitor.compile b
+        end.join(' AND ')
+      end
+    end
+  end
+end