PEXOE | The permissions editor you won't regret paying $0 for!

clovisd · September 16, 2014, 5:43pm

If I’m not mistaken, Sponge won’t be using YAML anymore.

Current plans are to switch to: “HOCON”

jdf2 · September 16, 2014, 5:47pm

Oh. Well I can always just encode it to HOCON.
Good think I know that before I started to recode the YAML part.

EDIT: Seems there isn’t already a PHP library for HOCON. Guess I’ll just make my own. Do you happen to have a link to some documentation of HOCON

TangentSpy · September 16, 2014, 5:55pm

I would like to test this new web application when its in a working state. Send me a PM when the editor is in a working state and Ill provide feedback on this web application.

clovisd · September 16, 2014, 5:59pm

I’ve taken a look. Not much out there regarding HOCON.

Apart for a Reddit argument about HOCON (and YAML):
http://www.reddit.com/r/programming/comments/n7s3u/hocon_humanoptimized_config_object_notation/

Found some documentation (more like notes) about it on GitHub:

github.com

lightbend/config/blob/master/HOCON.md

<!-- START doctoc generated TOC please keep comment here to allow auto update -->
<!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
**Table of Contents**  *generated with [DocToc](https://github.com/thlorenz/doctoc)*

- [HOCON (Human-Optimized Config Object Notation)](#hocon-human-optimized-config-object-notation)
  - [Goals / Background](#goals--background)
  - [Definitions](#definitions)
  - [Syntax](#syntax)
    - [Unchanged from JSON](#unchanged-from-json)
    - [Comments](#comments)
    - [Omit root braces](#omit-root-braces)
    - [Key-value separator](#key-value-separator)
    - [Commas](#commas)
    - [Whitespace](#whitespace)
    - [Duplicate keys and object merging](#duplicate-keys-and-object-merging)
    - [Unquoted strings](#unquoted-strings)
    - [Multi-line strings](#multi-line-strings)
    - [Value concatenation](#value-concatenation)
      - [String value concatenation](#string-value-concatenation)
      - [Array and object concatenation](#array-and-object-concatenation)

This file has been truncated. show original

Configs using HOCON: http://marcinkubala.wordpress.com/2013/10/09/typesafe-config-hocon/

HOCON stands for: Human-Optimized Config Object Notation

jdf2 · September 16, 2014, 5:59pm

Will do!
Is there any documentation of how Sponge will do permissions? I don’t think there would be since it’s a bit early in development but, might as well ask.

clovisd · September 16, 2014, 6:00pm

I’d think it would be somewhat similar to how Bukkit deals with it. Only so many ways you can do permissions without upsetting the entire community.

Forge and Spout also use the same system as Bukkit did.

You might want to contact ZML over at Pex.

jdf2 · September 16, 2014, 6:03pm

Yeah I figured so I’m just gonna try and develop it to where it will be easy to add new permission file formats.
Which is one of the main reasons I’m recoding it.

Thanks for the HOCON info.

TangentSpy · September 16, 2014, 6:07pm

Going by the sample applications provided. The code looks very very similar to bukkits implementation of YAML.

github.com

lightbend/config/blob/master/examples/java/simple-app/src/main/java/SimpleApp.java

import com.typesafe.config.*;
import simplelib.*;

class SimpleApp {
    public static void main(String[] args) {
        // example of how system properties override; note this
        // must be set before the config lib is used
        System.setProperty("simple-lib.whatever", "This value comes from a system property");

        // Load our own config values from the default location,
        // application.conf
        Config conf = ConfigFactory.load();
        System.out.println("The answer is: " + conf.getString("simple-app.answer"));

        // In this simple app, we're allowing SimpleLibContext() to
        // use the default config in application.conf ; this is exactly
        // the same as passing in ConfigFactory.load() here, so we could
        // also write "new SimpleLibContext(conf)" and it would be the same.
        // (simple-lib is a library in this same examples/ directory).
        // The point is that SimpleLibContext defaults to ConfigFactory.load()

This file has been truncated. show original

github.com

lightbend/config/blob/master/examples/java/complex-app/src/main/java/ComplexApp.java

import com.typesafe.config.*;
import simplelib.*;

class ComplexApp {

    // Simple-lib is a library in this same examples/ directory.
    // This method demos usage of that library with the config
    // provided.
    private static void demoConfigInSimpleLib(Config config) {
        SimpleLibContext context = new SimpleLibContext(config);
        context.printSetting("simple-lib.foo");
        context.printSetting("simple-lib.hello");
        context.printSetting("simple-lib.whatever");
    }

    public static void main(String[] args) {
        // This app is "complex" because we load multiple separate app
        // configs into a single JVM and we have a separately-configurable
        // context for simple lib.

This file has been truncated. show original

Custom Library: https://github.com/typesafehub/config/blob/master/examples/java/simple-lib/src/main/java/simplelib/SimpleLibContext.java

Anyway here is some documentation:

Its based off JSON.

OffLuffy · September 28, 2014, 12:22am

For various plugins, you may need to make quite drastically different editor setups. For instance, I’ve heard talk about ‘transient’ permissions, which may not be bound to an individual group, world, etc, so for those plugins, you may need areas that can list group-transient or world-transient permissions as well as the common setups so far with permission groups, permissions for groups (not permission groups, but rather permissions applied to a group), per-world per-group permissions, and per-world per-user permissions. I wouldn’t be looking forward to doing something with that many alternatives XD But regardless, good luck! Hopefully it doesn’t do what MCMA does and just kinda botches the permissions files if you have it set up before using MCMA. Seeing proper support for various plugin features would be really nice.

Also, instead of having to add a single permission node at a time in various sections, a bulk input would be nice.

OffLuffy · September 28, 2014, 4:08am

To exemplify what I stated above, here’s a link from the Lapis Commons thread in regards to how their permissions system would work (which looks pretty awesome to be honest)

momar · September 30, 2014, 6:10pm

@OffLuffy Aren’t the Lapis permissions just for simplifiying the configuration process, not being a drastically different idea of permissions? As far as I know, if you only want to have the features of e.g. PermissionsEx, you don’t need to use them and have a simple, clean and working permission setup… If I’m wrong, please correct me - I may did not fully understand the potential of those Buckets…

By the way: I’m now working with @jdf2 on this together and some things of the idea have changed drastically:

There will be a community feature: You can just import the most-used configuration from a huge database created by everyone hosting a server.
It will (probably only) work together with a Sponge plugin which acts as a secure REST API for the biggest permission plugins.
It will be centralized on one website with one database and user accounts for every server admin, so everyone can and will share his setup with the community database.
The interface will probably look completely different from what it does in the first version of jdf2’s PEXOE.

I know this may does not sound perfect for an open source-minded community to have a centralized platform to manage permissions, however this offers huge possibilities for features of all kinds instead of being just another PEx GUI.

jdf2 · September 30, 2014, 7:15pm

Yes me and @momar are working together now.
Since we are working together this will be two times better!

OffLuffy · September 30, 2014, 7:32pm

I can’t say with any certainty as I’ve only really used Group manager in the past, but it does seem like Lapis has some pretty extensive permissions API, although I’m thinking they’re not implemented by Lapis themselves, only allows plugins to do so, so I guess it’s up in the air what happens with that setup.

Gramps · September 30, 2014, 8:28pm

I’ve been using PermissionsEx since 1.8 (the first one that came around, lol). Please tell me it will work with Sponge

OffLuffy · September 30, 2014, 8:31pm

As one of the largest supported permission handlers, I suspect the developers or some other developer would be interested in porting it. If not out of interest, then maybe out of necessity.

Although maybe the wrong place to be asking about that as this is thread is for a web-based permission editor, not necessarily Sponge support for permission handlers.

leonissenbaum · October 1, 2014, 8:03am

I want my 0$ back

momar · October 24, 2014, 7:26am

@leonissenbaum You get 14 days money-back guarantee

Just to keep you all up to date:

It will probably be called Mineperms, however the name is not sure yet.
It currently looks like this and like that
You will be able to rollback any changes other people made

thomas15v · October 24, 2014, 8:49am

I don’t understand why people need a “Permissions Editor”. Just use the in-game commands:

No Parse issues
No incorrect syntax crap
99% guaranteed that server doesn’t break after reload! (As long you don’t make parents loops).

doot · October 24, 2014, 1:08pm

I can’t stand using ingame commands…

momar · October 24, 2014, 1:12pm

With this you will get no parse issues, a correct syntax and it does not break the server as you don’t need a reload. You can also argue there’s no need for things like McMyAdmin or SpaceCP and you should just use your vServer’s CLI, but it’s just more convenient to have something that looks good.
With this, you can setup the server permissions for a server with many plugins in under 10 minutes and you will never forget to set the permissions for new plugins - your server will always be safe from griefers