kantox-roles 1.2.1

data/lib/kantox/roles/helpers.rb

@@ -0,0 +1,138 @@
+module Kantox
+  module Helpers
+    # Fakes hash values
+    # @param [Hash] hash to fake
+    # @return [Hash] faked hash
+    def fake_data hash_or_array_or_json, deep = true
+      (hash_or_array_or_json.is_a?(String) ? JSON.parse(hash_or_array_or_json) : hash_or_array_or_json).each_with_index.map do |kv, index|
+        case kv
+        when Array # we iterate hash
+          [ kv.first.respond_to?(:to_sym) ? kv.first.to_sym : kv.first,
+            deep ?  case kv.last
+                    when Array then fake_data(kv.last).values
+                    when Hash then fake_hash kv.last
+                    else Kantox::LOCK_EMOJI
+                    end
+                 : Kantox::LOCK_EMOJI
+          ]
+        else [index, Kantox::LOCK_EMOJI]
+        end
+      end.to_h
+    end
+    def fake_hash hash_or_array_or_json, deep = true
+      fake_data(hash_or_array_or_json, deep).merge({ Kantox::LOCK_EMOJI => true })
+    end
+    def fake_array array
+      array.zip(fake_data(array, false).values).to_h
+    end
+    module_function :fake_data, :fake_hash, :fake_array
+    private :fake_data
+
+    # Returns class, method and parameters as s string.
+    # @return [Hash|nil]
+    def get_instance_method name
+      k, m = name.split('#')
+
+      unless Kernel.const_defined? k
+        Kantox::Helpers.debug "Bad handler: «#{k}##{m}» not found. Error message: “#{e}”.\nUsually it’s OK meaning that the respective class is not yet initialized."
+        return nil
+      end
+
+      klazz = Kernel.const_get(k)
+
+      meth = (
+        klazz.private_method_defined?(m) ||
+        klazz.protected_method_defined?(m) ||
+        klazz.public_method_defined?(m)
+      ) && klazz.instance_method(m)
+
+      unless meth
+        Kantox::Helpers.err "Class [#{klazz}] has no instance method [#{m}]."
+        return nil
+      end
+
+      params_arr = meth.parameters
+      params_str = [
+        params_arr.select { |tv| tv.first == :req }.map(&:last).map(&:to_s),
+        params_arr.select { |tv| tv.first == :rest }.map(&:last).map { |m| "*#{m}"},
+        params_arr.select { |tv| tv.first == :block }.map(&:last).map { |m| "&#{m}"}
+      ].flatten.join(', ')
+
+      Hashie::Mash.new(
+        class: klazz,
+        method: { name: m, instance: meth },
+        params: { string: params_str }
+      )
+    end
+
+    # @param mash [Hash|Hashie::Mash|NilClass] hash to merge `hos` into
+    # @param hos [Hash|Hashie::Mash|String] the new values taken from hash,
+    #   mash or string (when string, should be either valid YAML file name or
+    #   string with valid YAML)
+    def merge_hash_or_string mash, hos
+      case mash
+      when Hashie::Mash then mash
+      when Hash then Hashie::Mash.new(mash)
+      when NilClass then Hashie::Mash.new
+      else
+        fail ArgumentError.new "#{__callee__} expects [Hash|Hashie::Mash|NilClass] as first parameter"
+      end.deep_merge  case hos
+                      when NilClass then {} # aka skip
+                      when Hash then hos
+                      when String
+                        begin
+                          File.exists?(hos) ? Hashie::Mash.load(hos) : Hashie::Mash.new(YAML.load(hos))
+                        rescue ArgumentError => ae
+                          fail ArgumentError.new "#{__callee__} expects valid YAML configuration file. [#{hos}] contains invalid syntax."
+                        rescue Psych::SyntaxError => pse
+                          fail ArgumentError.new "#{__callee__} expects valid YAML configuration string. Got:\n#{hos}"
+                        end
+                      else
+                        Kantox::Helpers.warn 'Kantox::Roles#configure accepts either String or Hash as parameter.'
+                      end
+    end
+
+    # @return [Method|nil]
+    def get_runner_strategy name
+      im = get_instance_method(name)
+      im.nil? ? im : im[:method][:instance].bind(im[:class])
+    end
+
+    # @return [Method|nil]
+    def get_simple_strategy name
+      get_runner_strategy("Kantox::Strategies##{name}")
+    end
+
+    # @return [Proc]
+    def get_lambda_strategy lmbd
+      begin
+        eval(lmbd)
+      rescue LocalJumpError => lje
+        Kantox::Helpers.err "Lambda strategy failed: «return» is not allowed from this lambda.\n#{lmbd}\nOriginal error: #{lje}"
+      rescue NameError => ne
+        Kantox::Helpers.err "Lambda strategy failed: syntax error in lambda.\n#{lmbd}\nOriginal error: #{ne}"
+      rescue SyntaxError => se
+        Kantox::Helpers.err "Lambda strategy failed: syntax error in lambda.\n#{lmbd}\nOriginal error: #{se}"
+      rescue RuntimeError => re
+        Kantox::Helpers.err "Lambda strategy failed: undetermined error in lambda.\n#{lmbd}\nOriginal error: #{re}"
+      end
+    end
+
+    # @return [Object]
+    def get_object_strategy name, mash
+      klazz = name.split('_').map { |n| n.capitalize }.join('::')
+      return nil unless Module.const_defined?(klazz)
+      klazz = Module.const_get(klazz)
+      return nil unless klazz.is_a?(Class) && klazz.instance_methods(false).include?(:to_proc)
+      klazz.new(mash)
+    end
+
+    module_function :get_instance_method, :merge_hash_or_string
+
+    Helpers.instance_methods.select do |m|
+      m.to_s =~ /\Aget_(.*)_strategy\z/
+    end.each do |m|
+      module_function m
+    end
+  end
+end

data/lib/kantox/roles/logger.rb

@@ -0,0 +1,102 @@
+require 'logger'
+require 'json'
+
+module Kantox
+  module Helpers
+    BACKTRACE_LENGTH = 12
+    SEV_COLORS = {
+      'INFO'    => ['01;38;05;21', '00;38;05;152'],
+      'WARN'    => ['01;38;05;226', '00;38;05;222'],
+      'ERROR'   => ['01;38;05;196', '01;38;05;174'],
+      'DEBUG'   => ['01;38;05;242', '00;38;05;246'],
+      'ANY'     => ['01;38;05;222;48;05;238', '01;38;05;253;48;05;238']
+    }
+    SEV_SYMBOLS = {
+      'INFO'    => '✔',
+      'WARN'    => '✗',
+      'ERROR'   => '✘',
+      'DEBUG'   => '✓',
+      'ANY'     => '▶'
+    }
+
+    @stopwords = []
+    def logger_stopwords file
+      if File.exist?(file)
+        @stopwords += File.read(file).split($/).map { |l| Regexp.new l }
+      else
+        Kantox::Helpers.warn "Bad stopwords file: [#{file}]."
+      end
+    end
+    module_function :logger_stopwords
+
+    def self.clrz txt, clr
+      return txt unless @tty
+
+      "\e[#{clr}m#{txt.gsub(/«(.*?)»/, "\e[01;38;05;51m\\1\e[#{clr}m")}\e[0m"
+    end
+
+    def logger
+      unless @logger
+        @logger, @logdevice = if Kernel.const_defined? 'Rails'
+                                [
+                                  ::Rails.logger,
+                                  ::Rails.logger
+                                         .instance_variable_get(:@logger)
+                                         .instance_variable_get(:@log)
+                                ]
+                              else
+                                l = Logger.new($stdout)
+                                [l, l]
+                              end
+        @tty = @logdevice.instance_variable_get(:@logdev).instance_variable_get(:@dev).tty? ||
+               Kernel.const_defined?('Rails') && ::Rails.env.development?
+
+        unless Kernel.const_defined?('Rails') && ::Rails.env.production? || ENV['RAILS_PRETTY_LOG'] != '42'
+          @logdevice.formatter = proc { |severity, datetime, progname, message|
+            message = message.join($/) if message[0] == '[' && message[-1] == ']' && (arr_msg = JSON.parse(message)).is_a?(Array) rescue message
+
+            message.strip!                       # strip
+            message.gsub! "\n", "\n⮩#{' ' * 29}" # align
+            if message.empty? || @stopwords.any? { |sw| sw =~ message }
+              nil
+            else
+            '' << clrz("#{SEV_SYMBOLS[severity]} ", SEV_COLORS[severity].first)\
+               << clrz(severity[0..2], SEV_COLORS[severity].first)             \
+               << ' | '                                                        \
+               << clrz(datetime.strftime('%Y%m%d-%H%M%S.%3N'), '01;38;05;238') \
+               << ' | '                                                        \
+               << clrz(message, SEV_COLORS[severity].last)                     \
+               << "\n"
+            end
+          }
+        end
+      end
+      @logger
+    end
+    module_function :logger
+    def log message
+      logger.unknown { message }
+      nil
+    end
+
+    def catched message, e
+      bt = e.backtrace.is_a?(Array) ? e.backtrace : caller(1)
+      msg = "#{message}\nOriginal exception «#{e.class}»: #{e.message}\n" \
+           "Stacktrace: #{bt.take(BACKTRACE_LENGTH).join($/)}\n" \
+           "[...#{bt.length - BACKTRACE_LENGTH} more]"
+      warn msg
+    end
+    module_function :log, :catched
+    %i(warn info error debug).each do |m|
+      class_eval "
+        def #{m} message
+          logger.#{m}(message)
+          nil
+        end
+        module_function :#{m}
+      "
+    end
+    alias_method :err, :error
+    module_function :err
+  end
+end

data/lib/kantox/roles/strategies/aspect.rb

@@ -0,0 +1,13 @@
+require_relative 'strategy_error'
+
+module Kantox
+  module Strategies
+    class AspectError < Kantox::Strategies::StrategyError ; end
+    def aspect context, im, *args
+      # fail AspectError.new(context, im)
+      Kantox::Helpers.info "Aspect strategy applyed to #{context}"
+      Kantox::Helpers.warn 'Aspect strategy does not expect block passed.' if block_given?
+    end
+    module_function :aspect
+  end
+end

data/lib/kantox/roles/strategies/cancancan.rb

@@ -0,0 +1,48 @@
+require_relative 'strategy_error'
+
+module Kantox
+  module Strategies
+    class CanCanCanError < Kantox::Strategies::StrategyError
+      attr_reader :ability
+      def initialize context, im, policy = nil
+        super(context, im)
+        @policy = policy
+      end
+    end
+
+    # Ability factory for cancancan.
+    module AbilityFactory
+      def lookup klz, mth
+        meth = mth.capitalize.gsub(/_./) { |m|
+          m[-1].capitalize
+        }
+        klazz = "#{klz.capitalize}#{meth}Ability"
+        if Kantox::Abilities.const_defined? klazz
+          Kantox::Abilities.const_get klazz
+        else
+          Kantox::Helpers.error "Missing ability for «#{self.class.name}##{m}». You should define it explicitly."
+        end
+      end
+      module_function :lookup
+    end
+
+    def cancancan context, im, *args
+      Kantox::Helpers.debug "CanCanCaning object: [#{context}], «#{im}»"
+      begin # Whoever does not reply on classify would be punished :)
+        model = const_defined?('Rails') ?
+          context.instance_eval('controller_path.classify.singularize') :
+          context.class.name
+        ability = AbilityFactory.lookup model.split('::').last, im.split('#').last
+        user = Kernel.const_defined?('User') && User.respond_to?(:current) ?
+          User.current :
+          (context.respond_to?(:current_user) ? context.current_user : '@fixme')
+        fail CanCanCanError.new(context, im, ability) unless ability.new(user, '@todo').can *im.split('#')
+      rescue NameError => e
+        Kantox::Helpers.err "Error cancancaning «#{context}». Will reject request.\nOriginal error: #{e}"
+        throw CanCanCanError.new(context, im)
+      end
+      Kantox::Helpers.warn "CanCanCan strategy does not expect block passed.\nFailed: «#{ability}»" if block_given?
+    end
+    module_function :cancancan
+  end
+end

data/lib/kantox/roles/strategies/pundit.rb

@@ -0,0 +1,70 @@
+require_relative 'strategy_error'
+
+module Kantox
+  module Strategies
+    class PunditError < Kantox::Strategies::StrategyError
+      attr_reader :policy, :user
+      def initialize context, im, policy = nil, user = nil
+        super(context, im)
+        @policy = policy
+        @user = user
+      end
+
+      def to_s
+        ctx = @context ? ", context: #{@context}" : ''
+        usr = @user ? ", user: #{@user.login rescue nil} #{@user.class}" : ''
+        "(strategy: «pundit»#{usr}, policy: #{@policy}#{ctx})"
+      end
+    end
+
+    # Policy factory for pundit.
+    module PolicyFactory
+      def lookup name
+        klazz = "#{name}Policy"
+        if Kantox::Policies.const_defined? klazz
+          Kantox::Policies.const_get klazz
+        else
+          c = Kantox::Policies.const_set(klazz, Class.new(ApplicationPolicy) {
+            def method_missing m, *args, &cb
+              if m.to_s[-1] == '?'
+                Kantox::Helpers.error "Missing policy for «#{self.class.name}##{m}». You should define it explicitly."
+                nil
+              else
+                super
+              end
+            end
+          })
+          c.const_set('Scope', Class.new(ApplicationPolicy::Scope) {
+            def resolve
+              scope
+            end
+          })
+          c
+        end
+      end
+      module_function :lookup
+    end
+
+    def pundit context, im, *args
+      context_as_string = "#{context}"
+      context_as_string = "#{context_as_string[0..58]} [...]" if context_as_string.length > 65
+      Kantox::Helpers.debug "Punditing object: [#{context_as_string}], «#{im}»"
+      begin # Whoever does not reply on classify would be punished :)
+        model = const_defined?('Rails') && context.respond_to?(:controller_path) ?
+          context.instance_eval('controller_path.classify.singularize') :
+          context.class.name
+        model << 's' if model[-5..-1] == 'Statu' # Fucking Rails
+        policy = PolicyFactory.lookup model.split('::')[2..-1].join('::')
+        user = Kernel.const_defined?('User') && User.respond_to?(:current) ?
+          User.current :
+          (context.respond_to?(:current_user) ? context.current_user : nil)
+        fail PunditError.new(context, im, policy, user) unless policy.new(user, context).send "#{im.split('#').last}?"
+      rescue NameError => e
+        Kantox::Helpers.err "Error punditing «#{context.class}». Will reject request.\nOriginal error: #{e}"
+        throw PunditError.new(context, im)
+      end
+      Kantox::Helpers.warn "Pundit strategy does not expect block passed.\nFailed: «#{policy}»" if block_given?
+    end
+    module_function :pundit
+  end
+end

data/lib/kantox/roles/strategies/strategy_error.rb

@@ -0,0 +1,12 @@
+module Kantox
+  module Strategies
+    class StrategyError < RuntimeError
+      def initialize context, im
+        # FIXME Patch the stacktrace
+        # failed = caller(4).first[/`(\w+)'/, 1]
+        meth = Kantox::Helpers.get_instance_method(im.sub('#', '#∃'))[:method][:instance]
+        super("StrategyError @ #{meth.source_location.join(':')}:in: `#{im}'\n     ==> induced by #{self.to_s}")
+      end
+    end
+  end
+end

data/lib/kantox/roles/strategies/wrapper.rb

@@ -0,0 +1,15 @@
+require_relative 'strategy_error'
+
+module Kantox
+  module Strategies
+    module Wrapper
+      def wrap context, *params
+        Kantox::Helpers.info "Wrapped. Context: #{context}. Params: #{params.inspect}"
+#          Kantox::Helpers.debug "Caller: #{caller(0)[0..5]}"
+        # fail Kantox::Strategies::StrategyError, "@ #{context}"
+        yield *params if block_given?
+      end
+      module_function :wrap
+    end
+  end
+end

data/lib/kantox/roles/version.rb

@@ -0,0 +1,5 @@
+module Kantox
+  module Roles
+    VERSION = "1.2.1"
+  end
+end

data/lib/rails/generators/kantox/policy_spec_helper.rb.tmpl

@@ -0,0 +1,35 @@
+ENV['RAILS_ENV'] ||= 'test'
+
+require 'pundit/rspec'
+
+RSpec.configure do |c|
+  c.treat_symbols_as_metadata_keys_with_true_values = true
+end
+
+UserTypes = ApplicationPolicy::UserTypes.call
+
+def examples_for_policy klazz
+  describe klazz do
+    extend Pundit::RSpec::DSL
+    subject { klazz }
+    [:read, :write].each do |access|
+      klazz::METHODS[access].each do |meth|
+        permissions(meth) do
+          it "denies access if user is not allowed", :roles do
+            extend Pundit::RSpec::Matchers
+            (UserTypes - klazz::ALLOWED[access]).each do |user|
+              expect(subject).not_to permit(user.send(:new), controller)
+            end
+          end
+
+          it "grants access if user is allowed", :roles do
+            extend Pundit::RSpec::Matchers
+            klazz::ALLOWED[access].each do |user|
+              expect(subject).to permit(user.send(:new), controller)
+            end
+          end
+        end
+      end
+    end
+  end
+end