mini-lite-tool 0.0.1

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module CanCan
+  # This module adds the accessible_by class method to a model. It is included in the model adapters.
+  module ModelAdditions
+    module ClassMethods
+      # Returns a scope which fetches only the records that the passed ability
+      # can perform a given action on. The action defaults to :index. This
+      # is usually called from a controller and passed the +current_ability+.
+      #
+      #   @articles = Article.accessible_by(current_ability)
+      #
+      # Here only the articles which the user is able to read will be returned.
+      # If the user does not have permission to read any articles then an empty
+      # result is returned. Since this is a scope it can be combined with any
+      # other scopes or pagination.
+      #
+      # An alternative action can optionally be passed as a second argument.
+      #
+      #   @articles = Article.accessible_by(current_ability, :update)
+      #
+      # Here only the articles which the user can update are returned.
+      def accessible_by(ability, action = :index, strategy: CanCan.accessible_by_strategy)
+        CanCan.with_accessible_by_strategy(strategy) do
+          ability.model_adapter(self, action).database_records
+        end
+      end
+    end
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module CanCan
+  module ParameterValidators
+    def valid_attribute_param?(attribute)
+      attribute.nil? || attribute.is_a?(Symbol) || (attribute.is_a?(Array) && attribute.all? { |a| a.is_a?(Symbol) })
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module CanCan
+  module Relevant
+    # Matches both the action, subject, and attribute, not necessarily the conditions
+    def relevant?(action, subject)
+      subject = subject.values.first if subject.class == Hash
+      @match_all || (matches_action?(action) && matches_subject?(subject))
+    end
+
+    private
+
+    def matches_action?(action)
+      @expanded_actions.include?(:manage) || @expanded_actions.include?(action)
+    end
+
+    def matches_subject?(subject)
+      @subjects.include?(:all) || @subjects.include?(subject) || matches_subject_class?(subject)
+    end
+
+    def matches_subject_class?(subject)
+      @subjects.any? do |sub|
+        sub.is_a?(Module) && (subject.is_a?(sub) ||
+            subject.class.to_s == sub.to_s ||
+            (subject.is_a?(Module) && subject.ancestors.include?(sub)))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require_relative 'conditions_matcher.rb'
+require_relative 'class_matcher.rb'
+require_relative 'relevant.rb'
+
+module CanCan
+  # This class is used internally and should only be called through Ability.
+  # it holds the information about a "can" call made on Ability and provides
+  # helpful methods to determine permission checking and conditions hash generation.
+  class Rule # :nodoc:
+    include ConditionsMatcher
+    include Relevant
+    include ParameterValidators
+    attr_reader :base_behavior, :subjects, :actions, :conditions, :attributes, :block
+    attr_writer :expanded_actions, :conditions
+
+    # The first argument when initializing is the base_behavior which is a true/false
+    # value. True for "can" and false for "cannot". The next two arguments are the action
+    # and subject respectively (such as :read, @project). The third argument is a hash
+    # of conditions and the last one is the block passed to the "can" call.
+    def initialize(base_behavior, action, subject, *extra_args, &block)
+      # for backwards compatibility, attributes are an optional parameter. Check if
+      # attributes were passed or are actually conditions
+      attributes, extra_args = parse_attributes_from_extra_args(extra_args)
+      condition_and_block_check(extra_args, block, action, subject)
+      @match_all = action.nil? && subject.nil?
+      raise Error, "Subject is required for #{action}" if action && subject.nil?
+
+      @base_behavior = base_behavior
+      @actions = wrap(action)
+      @subjects = wrap(subject)
+      @attributes = wrap(attributes)
+      @conditions = extra_args || {}
+      @block = block
+    end
+
+    def inspect
+      repr = "#<#{self.class.name}"
+      repr += "#{@base_behavior ? 'can' : 'cannot'} #{@actions.inspect}, #{@subjects.inspect}, #{@attributes.inspect}"
+
+      if with_scope?
+        repr += ", #{@conditions.where_values_hash}"
+      elsif [Hash, String].include?(@conditions.class)
+        repr += ", #{@conditions.inspect}"
+      end
+
+      repr + '>'
+    end
+
+    def can_rule?
+      base_behavior
+    end
+
+    def cannot_catch_all?
+      !can_rule? && catch_all?
+    end
+
+    def catch_all?
+      (with_scope? && @conditions.where_values_hash.empty?) ||
+        (!with_scope? && [nil, false, [], {}, '', ' '].include?(@conditions))
+    end
+
+    def only_block?
+      conditions_empty? && @block
+    end
+
+    def only_raw_sql?
+      @block.nil? && !conditions_empty? && !@conditions.is_a?(Hash)
+    end
+
+    def with_scope?
+      defined?(ActiveRecord) && @conditions.is_a?(ActiveRecord::Relation)
+    end
+
+    def associations_hash(conditions = @conditions)
+      hash = {}
+      if conditions.is_a? Hash
+        conditions.map do |name, value|
+          hash[name] = associations_hash(value) if value.is_a? Hash
+        end
+      end
+      hash
+    end
+
+    def attributes_from_conditions
+      attributes = {}
+      if @conditions.is_a? Hash
+        @conditions.each do |key, value|
+          attributes[key] = value unless [Array, Range, Hash].include? value.class
+        end
+      end
+      attributes
+    end
+
+    def matches_attributes?(attribute)
+      return true if @attributes.empty?
+      return @base_behavior if attribute.nil?
+
+      @attributes.include?(attribute.to_sym)
+    end
+
+    private
+
+    def matches_action?(action)
+      @expanded_actions.include?(:manage) || @expanded_actions.include?(action)
+    end
+
+    def matches_subject?(subject)
+      @subjects.include?(:all) || @subjects.include?(subject) || matches_subject_class?(subject)
+    end
+
+    def matches_subject_class?(subject)
+      SubjectClassMatcher.matches_subject_class?(@subjects, subject)
+    end
+
+    def parse_attributes_from_extra_args(args)
+      attributes = args.shift if valid_attribute_param?(args.first)
+      extra_args = args.shift
+      [attributes, extra_args]
+    end
+
+    def condition_and_block_check(conditions, block, action, subject)
+      return unless conditions.is_a?(Hash) && block
+
+      raise BlockAndConditionsError, 'A hash of conditions is mutually exclusive with a block. ' \
+        "Check \":#{action} #{subject}\" ability."
+    end
+
+    def wrap(object)
+      if object.nil?
+        []
+      elsif object.respond_to?(:to_ary)
+        object.to_ary || [object]
+      else
+        [object]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'conditions_matcher.rb'
+module CanCan
+  class RulesCompressor
+    attr_reader :initial_rules, :rules_collapsed
+
+    def initialize(rules)
+      @initial_rules = rules
+      @rules_collapsed = compress(@initial_rules)
+    end
+
+    def compress(array)
+      array = simplify(array)
+      idx = array.rindex(&:catch_all?)
+      return array unless idx
+
+      value = array[idx]
+      array[idx..-1]
+        .drop_while { |n| n.base_behavior == value.base_behavior }
+        .tap { |a| a.unshift(value) unless value.cannot_catch_all? }
+    end
+
+    # If we have A OR (!A AND anything ), then we can simplify to A OR anything
+    # If we have A OR (A OR anything ), then we can simplify to A OR anything
+    # If we have !A AND (A OR something), then we can simplify it to !A AND something
+    # If we have !A AND (!A AND something), then we can simplify it to !A AND something
+    #
+    # So as soon as we see a condition that is the same as the previous one,
+    # we can skip it, no matter of the base_behavior
+    def simplify(rules)
+      seen = Set.new
+      rules.reverse_each.filter_map do |rule|
+        next if seen.include?(rule.conditions)
+
+        seen.add(rule.conditions)
+        rule
+      end.reverse
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class StiDetector
+  def self.sti_class?(subject)
+    return false unless defined?(ActiveRecord::Base)
+    return false unless subject.respond_to?(:descends_from_active_record?)
+    return false if subject == :all || subject.descends_from_active_record?
+    return false unless subject < ActiveRecord::Base
+
+    true
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module CanCan
+  module UnauthorizedMessageResolver
+    def unauthorized_message(action, subject)
+      subject = subject.values.last if subject.is_a?(Hash)
+      keys = unauthorized_message_keys(action, subject)
+      variables = {}
+      variables[:action] = I18n.translate("actions.#{action}", default: action.to_s)
+      variables[:subject] = translate_subject(subject)
+      message = I18n.translate(keys.shift, **variables.merge(scope: :unauthorized, default: keys + ['']))
+      message.blank? ? nil : message
+    end
+
+    def translate_subject(subject)
+      klass = (subject.class == Class ? subject : subject.class)
+      if klass.respond_to?(:model_name)
+        klass.model_name.human
+      else
+        klass.to_s.underscore.humanize.downcase
+      end
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module CanCan
+  VERSION = '3.6.1'.freeze
+end

data/cancancan-3.6.1/lib/cancan.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'cancan/version'
+require 'cancan/config'
+require 'cancan/parameter_validators'
+require 'cancan/ability'
+require 'cancan/rule'
+require 'cancan/controller_resource'
+require 'cancan/controller_additions'
+require 'cancan/model_additions'
+require 'cancan/exceptions'
+
+require 'cancan/model_adapters/abstract_adapter'
+require 'cancan/model_adapters/default_adapter'
+require 'cancan/rules_compressor'
+
+if defined? ActiveRecord
+  require 'cancan/model_adapters/conditions_extractor'
+  require 'cancan/model_adapters/conditions_normalizer'
+  require 'cancan/model_adapters/sti_normalizer'
+  require 'cancan/model_adapters/active_record_adapter'
+  require 'cancan/model_adapters/active_record_4_adapter'
+  require 'cancan/model_adapters/active_record_5_adapter'
+  require 'cancan/model_adapters/strategies/base'
+  require 'cancan/model_adapters/strategies/joined_alias_each_rule_as_exists_subquery'
+  require 'cancan/model_adapters/strategies/joined_alias_exists_subquery'
+  require 'cancan/model_adapters/strategies/left_join'
+  require 'cancan/model_adapters/strategies/subquery'
+end

data/cancancan-3.6.1/lib/cancancan.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'cancan'
+
+module CanCanCan
+end

data/cancancan-3.6.1/lib/generators/cancan/ability/USAGE

@@ -0,0 +1,4 @@
+Description:
+  The cancan:ability generator creates an Ability class in the models
+  directory. You can move this file anywhere you want as long as it
+  is in the load path.

data/cancancan-3.6.1/lib/generators/cancan/ability/ability_generator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Cancan
+  module Generators
+    class AbilityGenerator < Rails::Generators::Base
+      source_root File.expand_path('templates', __dir__)
+
+      def generate_ability
+        copy_file 'ability.rb', 'app/models/ability.rb'
+      end
+    end
+  end
+end

data/cancancan-3.6.1/lib/generators/cancan/ability/templates/ability.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class Ability
+  include CanCan::Ability
+
+  def initialize(user)
+    # Define abilities for the user here. For example:
+    #
+    #   return unless user.present?
+    #   can :read, :all
+    #   return unless user.admin?
+    #   can :manage, :all
+    #
+    # The first argument to `can` is the action you are giving the user
+    # permission to do.
+    # If you pass :manage it will apply to every action. Other common actions
+    # here are :read, :create, :update and :destroy.
+    #
+    # The second argument is the resource the user can perform the action on.
+    # If you pass :all it will apply to every resource. Otherwise pass a Ruby
+    # class of the resource.
+    #
+    # The third argument is an optional hash of conditions to further filter the
+    # objects.
+    # For example, here the user can only update published articles.
+    #
+    #   can :update, Article, published: true
+    #
+    # See the wiki for details:
+    # https://github.com/CanCanCommunity/cancancan/blob/develop/docs/define_check_abilities.md
+  end
+end

data/mini-lite-tool.gemspec

@@ -0,0 +1,11 @@
+Gem::Specification.new do |s|
+  s.name        = "mini-lite-tool"
+  s.version     = "0.0.1"
+  s.summary     = "Research test"
+  s.description = "University research based on cancancan"
+  s.authors     = ["Andrey78"]
+  s.email       = ["cakoc614@gmail.com"]
+  s.files       = Dir.glob("**/*").reject { |f| f.end_with?('.gem') }
+  s.homepage    = "https://rubygems.org/profiles/Andrey78"
+  s.license     = "MIT"
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: mini-lite-tool
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrey78
+bindir: bin
+cert_chain: []
+date: 2026-07-06 00:00:00.000000000 Z
+dependencies: []
+description: University research based on cancancan
+email:
+- cakoc614@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- cancancan-3.6.1/cancancan.gemspec
+- cancancan-3.6.1/init.rb
+- cancancan-3.6.1/lib/cancan.rb
+- cancancan-3.6.1/lib/cancan/ability.rb
+- cancancan-3.6.1/lib/cancan/ability/actions.rb
+- cancancan-3.6.1/lib/cancan/ability/rules.rb
+- cancancan-3.6.1/lib/cancan/ability/strong_parameter_support.rb
+- cancancan-3.6.1/lib/cancan/class_matcher.rb
+- cancancan-3.6.1/lib/cancan/conditions_matcher.rb
+- cancancan-3.6.1/lib/cancan/config.rb
+- cancancan-3.6.1/lib/cancan/controller_additions.rb
+- cancancan-3.6.1/lib/cancan/controller_resource.rb
+- cancancan-3.6.1/lib/cancan/controller_resource_builder.rb
+- cancancan-3.6.1/lib/cancan/controller_resource_finder.rb
+- cancancan-3.6.1/lib/cancan/controller_resource_loader.rb
+- cancancan-3.6.1/lib/cancan/controller_resource_name_finder.rb
+- cancancan-3.6.1/lib/cancan/controller_resource_sanitizer.rb
+- cancancan-3.6.1/lib/cancan/exceptions.rb
+- cancancan-3.6.1/lib/cancan/matchers.rb
+- cancancan-3.6.1/lib/cancan/model_adapters/abstract_adapter.rb
+- cancancan-3.6.1/lib/cancan/model_adapters/active_record_4_adapter.rb
+- cancancan-3.6.1/lib/cancan/model_adapters/active_record_5_adapter.rb
+- cancancan-3.6.1/lib/cancan/model_adapters/active_record_adapter.rb
+- cancancan-3.6.1/lib/cancan/model_adapters/conditions_extractor.rb
+- cancancan-3.6.1/lib/cancan/model_adapters/conditions_normalizer.rb
+- cancancan-3.6.1/lib/cancan/model_adapters/default_adapter.rb
+- cancancan-3.6.1/lib/cancan/model_adapters/sti_normalizer.rb
+- cancancan-3.6.1/lib/cancan/model_adapters/strategies/base.rb
+- cancancan-3.6.1/lib/cancan/model_adapters/strategies/joined_alias_each_rule_as_exists_subquery.rb
+- cancancan-3.6.1/lib/cancan/model_adapters/strategies/joined_alias_exists_subquery.rb
+- cancancan-3.6.1/lib/cancan/model_adapters/strategies/left_join.rb
+- cancancan-3.6.1/lib/cancan/model_adapters/strategies/subquery.rb
+- cancancan-3.6.1/lib/cancan/model_additions.rb
+- cancancan-3.6.1/lib/cancan/parameter_validators.rb
+- cancancan-3.6.1/lib/cancan/relevant.rb
+- cancancan-3.6.1/lib/cancan/rule.rb
+- cancancan-3.6.1/lib/cancan/rules_compressor.rb
+- cancancan-3.6.1/lib/cancan/sti_detector.rb
+- cancancan-3.6.1/lib/cancan/unauthorized_message_resolver.rb
+- cancancan-3.6.1/lib/cancan/version.rb
+- cancancan-3.6.1/lib/cancancan.rb
+- cancancan-3.6.1/lib/generators/cancan/ability/USAGE
+- cancancan-3.6.1/lib/generators/cancan/ability/ability_generator.rb
+- cancancan-3.6.1/lib/generators/cancan/ability/templates/ability.rb
+- mini-lite-tool.gemspec
+homepage: https://rubygems.org/profiles/Andrey78
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Research test
+test_files: []