yiffspace 0.0.1

data/lib/yiffspace/auth/helper.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require("active_support/concern")
+
+module YiffSpace
+  module Auth
+    module Helper
+      extend(ActiveSupport::Concern)
+
+      module ClassMethods
+        def set_client_name(name) # rubocop:disable Naming/AccessorMethodName
+          before_action do |controller|
+            controller.request.env["yiffspace.auth.client_name"] = name
+            if controller.respond_to?(:yiffspace_client_name=)
+              controller.yiffspace_client_name = name
+            elsif controller.respond_to?(:client_name=)
+              controller.client_name = name
+            elsif controller.respond_to?(:helpers)
+              if controller.helpers.respond_to?(:yiffspace_client_name=)
+                controller.helpers.yiffspace_client_name = name
+              elsif controller.helpers.respond_to?(:client_name=)
+                controller.helpers.client_name = name
+              end
+            end
+          end
+        end
+      end
+
+      def auth_raw
+        session[auth_client_config.auth_session_key]
+      end
+
+      def auth
+        return AuthInfo::Anonymous.instance if auth_raw.blank?
+
+        AuthInfo.from_session(auth_raw)
+      end
+
+      def auth?
+        auth_raw.present? && !auth.anonymous?
+      end
+
+      def auth=(value)
+        value                                        = nil if value.is_a?(AuthInfo::Anonymous)
+        session[auth_client_config.auth_session_key] = value&.to_session
+      end
+
+      def reset_auth!
+        session.delete(auth_client_config.auth_session_key)
+      end
+
+      def user_raw
+        session[auth_client_config.user_session_key]
+      end
+
+      def user
+        return UserInfo::Anonymous.instance if user_raw.blank?
+
+        UserInfo.from_session(user_raw)
+      end
+
+      def user?
+        user_raw.present? && !user.anonymous?
+      end
+
+      def user=(value)
+        value                                        = nil if value.is_a?(UserInfo::Anonymous)
+        session[auth_client_config.user_session_key] = value&.to_session
+      end
+
+      def reset_user!
+        session.delete(auth_client_config.user_session_key)
+      end
+
+      def state
+        session[auth_client_config.state_session_key]
+      end
+
+      def state=(value)
+        session[auth_client_config.state_session_key] = value
+      end
+
+      def reset_state!
+        session.delete(auth_client_config.state_session_key)
+      end
+
+      def generate_state!
+        generator  = auth_client_config.state_generator
+        self.state = generator.call(*(generator.arity.zero? ? [] : [self]))
+      end
+
+      def return_path
+        session[auth_client_config.return_path_session_key]
+      end
+
+      def return_path=(value)
+        return if value && (!value.start_with?("/") || value.start_with?("//"))
+
+        session[auth_client_config.return_path_session_key] = value
+      end
+
+      def reset_return_path!
+        session.delete(auth_client_config.return_path_session_key)
+      end
+
+      def full_reset!
+        reset_state!
+        reset_auth!
+        reset_user!
+        reset_return_path!
+      end
+
+      def require_auth(path)
+        redirect_to(path) unless auth?
+      end
+
+      def has_permission?(name)
+        return false unless auth?
+
+        auth.permissions.has?(name)
+      end
+
+      def url_helpers
+        YiffSpace::Auth::Engine.for(client_name).routes.url_helpers
+      end
+
+      # Returns the Auth::Client for the current request. In auth engine controllers this is
+      # resolved from the routing default set by Engine.for; in host app controllers it falls
+      # back to the default registered client. Override in your controller to choose a specific
+      # client when multiple are registered.
+      def auth_client_config
+        client_name = self.client_name
+        client_name.present? ? YiffSpace::Auth[client_name.to_sym] : YiffSpace::Auth.default
+      end
+
+      def client_name
+        respond_to?(:request, true) && request.env[CLIENT_NAME_ENV]
+      end
+
+      def client_name=(value)
+        request.env[CLIENT_NAME_ENV] = value.to_sym
+      end
+
+      module Scoped
+        extend(ActiveSupport::Concern)
+        include(Helper)
+
+        included do
+          private(*Helper.instance_methods(false))
+          private_class_method(*Helper::ClassMethods.instance_methods(false))
+        end
+
+        Helper.instance_methods(false).each do |name|
+          define_method("yiffspace_#{name}") { |*args, **kwargs, &block| send(name, *args, **kwargs, &block) }
+        end
+
+        module ClassMethods
+          include(Helper::ClassMethods)
+
+          Helper::ClassMethods.instance_methods(false).each do |name|
+            define_method("yiffspace_#{name}") { |*args, **kwargs, &block| send(name, *args, **kwargs, &block) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/auth/permissions.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Auth
+    class Permissions
+      attr_accessor(:values)
+
+      delegate(:each, to: :values)
+
+      include(Enumerable)
+
+      def initialize(perms)
+        @values = perms
+        @tree   = {}
+
+        perms.each do |perm|
+          current = @tree
+          parts   = perm.split(".")
+
+          parts.each do |part|
+            current[part] ||= {}
+            current       = current[part]
+          end
+
+          # mark leaf
+          current[:__leaf__] = true
+        end
+      end
+
+      def has?(perm)
+        current = @tree
+        parts   = perm.split(".")
+
+        parts.each do |part|
+          return false unless current[part]
+
+          current = current[part]
+        end
+
+        current[:__leaf__] == true
+      end
+
+      alias include? has?
+
+      def method_missing(name, *_args)
+        str = name.to_s
+
+        if str.end_with?("?")
+          key = str[0..-2]
+          return @tree[key]&.dig(:__leaf__) == true
+        end
+
+        if @tree.key?(str)
+          self.class.new_from_subtree(@tree[str])
+        else
+          # return empty node instead of raising
+          self.class.new([])
+        end
+      end
+
+      def respond_to_missing?(_name, _include_private = false)
+        true
+      end
+
+      def self.new_from_subtree(tree)
+        obj = allocate
+        obj.instance_variable_set(:@tree, tree)
+        obj.instance_variable_set(:@values, leaves_from_tree(tree))
+        obj
+      end
+
+      def self.leaves_from_tree(node, prefix = "")
+        result = []
+        node.each do |key, subtree|
+          next if key == :__leaf__
+
+          path = prefix.empty? ? key : "#{prefix}.#{key}"
+          result << path if subtree[:__leaf__]
+          result.concat(leaves_from_tree(subtree, path))
+        end
+        result
+      end
+    end
+  end
+end

data/lib/yiffspace/auth/set_client_name.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Auth
+    class SetClientName < Utils::SetEnvConstraint
+      def initialize(value)
+        super(CLIENT_NAME_ENV, value.to_sym)
+      end
+
+      def self.default
+        new(DEFAULT_CLIENT_NAME)
+      end
+    end
+  end
+end

data/lib/yiffspace/auth/user_info/anonymous.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require("singleton")
+
+module YiffSpace
+  module Auth
+    class UserInfo
+      class Anonymous
+        include(::Singleton)
+
+        %i[id user discord avatar].each do |attr|
+          define_method(attr) { |*, **| raise(NotImplementedError, "#{attr} is not present on anonymous user") }
+        end
+
+        def username
+          "anonymous"
+        end
+
+        def display_name
+          "Anonymous"
+        end
+
+        def avatar
+          nil
+        end
+
+        def avatar_url
+          nil
+        end
+
+        def banner
+          nil
+        end
+
+        def banner_url
+          nil
+        end
+
+        def anonymous?
+          true
+        end
+
+        # this feels wrong, but it hopefully shouldn't break anything
+        def present?
+          false
+        end
+
+        def blank?
+          true
+        end
+
+        def serializable_hash(*)
+          nil
+        end
+
+        def to_session
+          serializable_hash
+        end
+
+        def self.from_json(*)
+          Anonymous.new
+        end
+
+        def self.from_session(data)
+          return nil if data.blank?
+
+          from_json(data)
+        end
+      end
+    end
+  end
+end

data/lib/yiffspace/auth/user_info.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module YiffSpace
+  module Auth
+    class UserInfo
+      attr_reader(:id, :user, :discord, :client_id)
+
+      # @param id String
+      # @param user OpenIDConnect::ResponseObject::UserInfo
+      # @param discord Hash
+      # @param client_id String
+      def initialize(id:, user:, discord:, client_id:)
+        raise(ArgumentError, "no id provided") if id.blank?
+        raise(ArgumentError, "no user provided") if user.blank?
+
+        @id        = id
+        @user      = user
+        @discord   = DiscordInfo.from_json(discord)
+        @client_id = client_id
+      end
+
+      def anonymous?
+        false
+      end
+
+      # this feels wrong, but it hopefully shouldn't break anything
+      def present?
+        true
+      end
+
+      def blank?
+        false
+      end
+
+      def avatar(type = nil)
+        type.present? ? Images::Avatar.get_for(id, type) : Images::Avatar.default_for(id)
+      end
+
+      def avatar_url(type = nil)
+        avatar(type).url
+      end
+
+      def banner(type = nil)
+        type.present? ? Images::Banner.get_for(id, type) : Images::Banner.default_for(id)
+      end
+
+      def banner_url(type = nil)
+        banner(type).url
+      end
+
+      delegate(:username, to: :discord)
+
+      def display_name
+        discord.global_name
+      end
+
+      def serializable_hash(_options = {})
+        {
+          "id"      => id,
+          "discord" => discord.serializable_hash,
+          "user"    => ::YiffSpace::Auth.serialize_user(user, client_id: client_id),
+        }
+      end
+
+      def to_session
+        serializable_hash.without("discord").merge(discord: discord.to_session)
+      end
+
+      def self.from_json(data)
+        raise(ArgumentError, "invalid data") if data.blank?
+
+        data = JSON.parse(data) if data.is_a?(String)
+        data = ::YiffSpace::Utils::OpenHash.from(data)
+
+        user_data = ::YiffSpace::Utils::OpenHash.from(data.user)
+        new(
+          id:        data.id,
+          discord:   data.discord,
+          user:      ::YiffSpace::Auth.unserialize_user(user_data),
+          client_id: user_data.client_id,
+        )
+      end
+
+      def self.from_session(data)
+        return nil if data.blank?
+
+        from_json(data)
+      end
+    end
+  end
+end

data/lib/yiffspace/auth.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require("openid_connect")
+
+module YiffSpace
+  module Auth
+    class SerializeError < StandardError; end
+
+    ExchangeResponse    = Struct.new(:auth, :user)
+    CLIENT_NAME_ENV     = "yiffspace.auth.client_name"
+    DEFAULT_CLIENT_NAME = :default
+
+    @clients             = {}
+    @enable_debug_action = false
+
+    module_function
+
+    def register(name, &block)
+      client = Client.new(name)
+      block&.call(client)
+      @clients[name.to_sym] = client
+      client
+    end
+
+    def [](name)
+      @clients[name.to_sym] or raise(KeyError, "unknown auth client: #{name.inspect}")
+    end
+
+    def default
+      @clients[DEFAULT_CLIENT_NAME] || raise("no default client configured")
+    end
+
+    def find_by_client_id(client_id)
+      @clients.values.find { |c| c.oidc_client.identifier == client_id }
+    end
+
+    def serialize_token(token)
+      { attributes: token.raw_attributes.without("client"), client_id: token.client.identifier }
+    end
+
+    def unserialize_token(data)
+      raise(SerializeError, "no token data provided") if data.blank?
+      return data if data.is_a?(OpenIDConnect::AccessToken)
+
+      data = JSON.parse(data) if data.is_a?(String)
+      data = ::YiffSpace::Utils::OpenHash.from(data)
+      raise(SerializeError, "no client id for token, refusing to reconstruct") if data.client_id.nil?
+
+      client_config = find_by_client_id(data.client_id)
+      raise(SerializeError, "unknown client_id #{data.client_id.inspect}") unless client_config
+
+      OpenIDConnect::AccessToken.new(data.attributes.merge(client: client_config.oidc_client))
+    end
+
+    def serialize_user(user, client_id:)
+      { attributes: user.raw_attributes, client_id: client_id }
+    end
+
+    def unserialize_user(data)
+      raise(SerializeError, "no user data provided") if data.blank?
+      return data if data.is_a?(OpenIDConnect::ResponseObject::UserInfo)
+
+      data = JSON.parse(data) if data.is_a?(String)
+      data = ::YiffSpace::Utils::OpenHash.from(data)
+      raise(SerializeError, "no client id for user, refusing to reconstruct") if data.client_id.nil?
+
+      find_by_client_id(data.client_id) or raise(SerializeError, "unknown client_id #{data.client_id.inspect}")
+
+      OpenIDConnect::ResponseObject::UserInfo.new(data.attributes)
+    end
+
+    def enable_debug_action?
+      @enable_debug_action
+    end
+
+    def enable_debug_action!
+      @enable_debug_action = true
+    end
+
+    def disable_debug_action!
+      @enable_debug_action = false
+    end
+  end
+end

data/lib/yiffspace/config_builder.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+# This is intended to only be used externally, it is NOT reusable, do not use it within this project, or attempt to use it multiple times!!
+module YiffSpace
+  class ConfigBuilder
+    include(Singleton)
+
+    cattr_accessor(:list, default: [])
+    cattr_accessor(:env_set, default: {})
+    cattr_accessor(:unset, default: [])
+    cattr_accessor(:required, default: [])
+    cattr_accessor(:reviver_map, default: {})
+    cattr_accessor(:subconfigs, default: Hash.new { |h, k| h[k] = {} })
+    cattr_accessor(:env_name, default: "CONFIG")
+
+    def self.config(name, type = :string, env: true, required: false, blank: false, &block)
+      name = name.to_sym
+      remove_config(name) if list.include?(name)
+      list << name
+      self.required << name if required
+      if block.nil?
+        unset << name
+        block = -> { raise(NotImplementedError, "Config option #{name} is not set") }
+      end
+      define_method(name) do |*args|
+        env_or_value(name, args, blank: blank, &block)
+      end
+      if type == :boolean
+        define_method("#{name}?") do |*args|
+          public_send(name, *args)
+        end
+      end
+      reviver(name, type) if type && type != :string
+      env_set[name] = env
+    end
+
+    def self.remove_config(name, reviver: false)
+      name = name.to_sym
+      list.delete(name)
+      required.delete(name)
+      unset.delete(name)
+      reviver_map.delete(name) if reviver
+      env_set.delete(name)
+      remove_method(name)
+      remove_method("#{name}?") if method_defined?("#{name}?")
+    end
+
+    def env_or_value(name, args, blank: false, &)
+      value = env(name)
+      value = nil if !value.nil? && value.blank? && !blank
+      if value.nil?
+        instance_exec(*args, &)
+      else
+        reviver = reviver_map.fetch(name, proc(&:itself))
+        instance_exec(value, *args, &reviver)
+      end
+    end
+
+    def env(name)
+      ENV.fetch("#{self.class.env_name}_#{name.to_s.upcase}", nil)
+    end
+
+    def self.reviver(name, type = nil, &block)
+      if block
+        reviver_map[name] = block
+        return
+      end
+      method            = case type
+                          when :boolean
+                            ->(v) { !v.match?(/\A(false|f|no|n|off|0)\z/i) }
+                          when :integer
+                            ->(v) { v.to_i }
+                          when :symbol
+                            ->(v) { v.to_sym }
+                          when :array
+                            ->(v) { v.split(/\s*,\s*/) }
+                          else
+                            raise(ArgumentError, "not sure how to revive #{type} for #{method}")
+                          end
+      reviver_map[name] = method
+    end
+
+    def self.subconfig(prefix, parent: [], &block)
+      raise(ArgumentError, "block required") unless block
+
+      prefix = prefix.to_sym
+      path   = parent + [prefix]
+
+      node = subconfigs
+      path.each do |p|
+        node[p] ||= {}
+        node    = node[p]
+      end
+
+      define_method(prefix) { SubconfigProxy.new(self, path) } unless method_defined?(prefix)
+
+      collector = Module.new do
+        def self.collected
+          @collected ||= []
+        end
+
+        def self.config(name, type = :string, env: true, required: false, blank: false, &block)
+          collected << [:config, name, type, env, required, blank, block]
+        end
+
+        def self.reviver(name, type = nil, &block)
+          collected << [:reviver, name, type, block]
+        end
+
+        def self.subconfig(name, &block)
+          collected << [:subconfig, name, block]
+        end
+      end
+
+      collector.module_eval(&block)
+
+      collector.collected.each do |kind, name, *args|
+        case kind
+        when :config
+          full = (path + [name]).join("_").to_sym
+          config(full, args[0], env: args[1], required: args[2], blank: args[3], &args[4])
+        when :reviver
+          full = (path + [name]).join("_").to_sym
+          reviver(full, args[0], &args[1])
+        when :subconfig
+          subconfig(name, parent: path, &args[0])
+        end
+      end
+    end
+
+    def self.ensure_required_set!
+      unset = []
+      required.each do |name|
+        value = begin
+          instance.public_send(name)
+        rescue StandardError
+          nil
+        end
+        unset << name if value.blank?
+      end
+
+      raise("Missing required configuration options: #{unset.join(', ')}") if unset.any?
+    end
+
+    def present?(*names)
+      names.flatten.all? { |name| public_send(name).present? }
+    end
+
+    class SubconfigProxy
+      def initialize(owner, path)
+        @owner = owner
+        @path  = path
+      end
+
+      def method_missing(name, *, &)
+        name      = name.to_sym
+        full_path = @path + [name]
+
+        flat = full_path.join("_").to_sym
+        return @owner.public_send(flat, *, &) if @owner.respond_to?(flat)
+
+        return SubconfigProxy.new(@owner, full_path) if subconfig_path?(full_path)
+
+        super
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        name = name.to_sym
+        flat = (@path + [name]).join("_").to_sym
+
+        @owner.respond_to?(flat, include_private) ||
+          subconfig_path?(@path + [name]) ||
+          super
+      end
+
+      private
+
+      def subconfig_path?(path)
+        node = ConfigBuilder.subconfigs
+        path.each do |p|
+          return false unless node.key?(p)
+
+          node = node[p]
+        end
+        true
+      end
+    end
+  end
+end