{:group-id "threatgrid", :artifact-id "scopula", :version "0.3.1", :analysis {"clj" ({:name scopula.core, :publics ({:name accepted-by-scopes, :file "scopula/core.cljc", :line 169, :arglists ([scopes required]), :doc "`scopes` should be strings.\nif none of the string contains a `/` nor a `:`.\nIt works as is a subset of.\n\n:scopes #{\"foo\" \"bar\"}\nonly people with scopes which are super sets of\n#{\"foo\" \"bar\"}\nwill be allowed to use the route.\n\nscopes are considered as path with read/write access.\nso \"foo/bar/baz:read\" is a sub-scope of \"foo\"\nand of \"foo:read\".\n\nSo the more precise rule of access is.\nAll mandatory scopes must be sub-scopes of at least one user scopes.\n\nAlso mandatory the scopes and required should be normalized", :type :var} {:name access-granted, :file "scopula/core.cljc", :line 192, :arglists ([scopes required]), :doc "Checks that the first parameter contains all the required scopes\ngiven as second parameter.", :type :var} {:name add-scope, :file "scopula/core.cljc", :line 241, :arglists ([scope scopes]), :doc "Add the scope to a set of scopes.\n", :type :var} {:name allowed-chars-no-colon-no-slash, :file "scopula/core.cljc", :line 57, :type :var} {:name allowed-word, :file "scopula/core.cljc", :line 59, :type :var} {:name is-root-scope?, :file "scopula/core.cljc", :line 236, :arglists ([scope]), :type :var} {:name is-scope-alias?, :file "scopula/core.cljc", :line 435, :arglists ([scope]), :type :var} {:name is-scope-aliases-map?, :file "scopula/core.cljc", :line 440, :arglists ([aliases]), :type :var} {:name is-scope-format-valid?, :file "scopula/core.cljc", :line 67, :arglists ([scope]), :type :var} {:name is-sub-list?, :file "scopula/core.cljc", :line 101, :arglists ([lst super-lst]), :doc "Does `super-lst` begin with `lst`?\n", :type :var} {:name is-subscope?, :file "scopula/core.cljc", :line 113, :arglists ([scope-to-check super-scope]), :doc "Returns whether the `scope-to-check` is a subscope of the `super-scope`\n", :type :var} {:name merge-accesses, :file "scopula/core.cljc", :line 127, :arglists ([[path reprs]]), :type :var} {:name normalize-scopes, :file "scopula/core.cljc", :line 160, :arglists ([scopes]), :doc "Given a set of scopes, remove reduntant ones, and merge them by access if possible.\n", :type :var} {:name raw-repr-scope-disj, :file "scopula/core.cljc", :line 296, :arglists ([rscopes rs-to-remove]), :doc "Removes a scope from a set of scopes.\n", :type :var} {:name repr-is-strict-subpath?, :file "scopula/core.cljc", :line 255, :arglists ([r1 r2]), :doc "Return whether the first argument is strictly a sub-path of the second argument.\n", :type :var} {:name repr-is-subscope?, :file "scopula/core.cljc", :line 107, :arglists ([scope-to-check super-scope]), :doc "Returns whether the `scope-to-check` is a subscope of the `super-scope`\n", :type :var} {:name repr-is-subsummed, :file "scopula/core.cljc", :line 132, :arglists ([repr-scope repr-scopes]), :doc "Return whether a scope is contained by all the scopes.\n\nExamples that return true:\n\n(is-subsummed \"foo\" #{\"foo\"})\n(is-subsummed \"foo:read\" #{\"foo\"})\n(is-subsummed \"foo/sub/scope\" #{\"foo\"})\n(is-subsummed \"foo/sub/scope:read\" #{\"foo\"})\n\nExamples that return false:\n\n(is-subsummed \"foo\" #{\"foo:read\" \"bar\"})\n(is-subsummed \"foo:read\" #{\"foo:read\" \"bar\"})\n(is-subsummed \"foo/sub/scope\" #{\"foo:read\"})", :type :var} {:name repr-normalize-scopes, :file "scopula/core.cljc", :line 150, :arglists ([scopes-repr]), :type :var} {:name repr-scope-disj, :file "scopula/core.cljc", :line 301, :arglists ([repr-scopes rs-to-rm]), :doc "Remove a scope for a set of scopes.\nWill throw an exception if the scope to remove is a subscope of some scope in\nthe scopes set.", :type :var} {:name repr-scope-intersection, :file "scopula/core.cljc", :line 341, :arglists ([r1 r2]), :doc "Returns the maximal intersection between two scopes reprs.\n\n`(to-scope-repr \"foo:write\")` and `(to-scope-repr \"foo/bar\")`\n=> `(to-scope-repr \"foo/bar:write\")`\n", :type :var} {:name repr-scope-remove, :file "scopula/core.cljc", :line 264, :arglists ([rs rs-to-remove]), :doc "While inputs should be in repr form,\nremoves the single scope `rs-to-remove` from the single scope `rs`.\n\nReturns `nil` if the two scopes do not intersect.\n\nIf the operation is not possible (for example, remove `foo/bar` from `foo`)\nthis function throw an exception.\n\nIf the two scopes intersect for the path but their access is different that\nmean some access should be remove. As exemple, removing `foo:write` from\n`foo/bar/baz` should endup with `foo/bar/baz:read`.", :type :var} {:name repr-scopes-intersect?, :file "scopula/core.cljc", :line 389, :arglists ([r1 r2]), :doc "Returns whether r1 and r2 intersect.\n\nFor example: `(to-scope-repr foo:write)` and `(to-scope-repr foo/bar)`\nintersect, while neither of those scopes reprs is a subscope of another.", :type :var} {:name repr-scopes-intersecting, :file "scopula/core.cljc", :line 412, :arglists ([rs-1 rs-2]), :doc "Asymmetrical operation; returns the list of first scopes repr that intersect\nwith some scopes repr of the second set of scopes repr.", :type :var} {:name repr-scopes-intersection, :file "scopula/core.cljc", :line 371, :arglists ([sr1 sr2]), :doc "Return the intersection between two set of scopes.\n", :type :var} {:name repr-scopes-missing, :file "scopula/core.cljc", :line 210, :arglists ([scopes-1 scopes-2]), :doc "Return the list of `scopes-1` that is not in `scopes-2`\n", :type :var} {:name root-scope, :file "scopula/core.cljc", :line 228, :arglists ([scope]), :doc "Returns the root of a scope.\n\n>>> (root-scope \"foo/bar:read\")\nfoo", :type :var} {:name safe-scopes-expand, :file "scopula/core.cljc", :line 462, :arglists ([scopes aliases]), :doc "Same as scope expand but return nil instead of throwing and exception if a scope alias is missing\n", :type :var} {:name scope-alias-regex, :file "scopula/core.cljc", :line 432, :type :var} {:name scope-cons, :file "scopula/core.cljc", :line 246, :type :var} {:name scope-difference, :file "scopula/core.cljc", :line 319, :arglists ([scopes scopes-to-remove]), :doc "Very similar to `scopes-missing`, but taking care of throwing an exception if\nsome sub-scope cannot be removed. This would prevent an error when trying to\nreduce a set of scopes.\n\n(scope-difference #{\"foo/bar\"} #{\"foo:write\"})\n=> #{\"foo/bar:read\"}\n\nkeep foo/bar but removed all :write from super-scope foo.", :type :var} {:name scope-disj, :file "scopula/core.cljc", :line 309, :arglists ([scopes scope-to-remove]), :doc "Remove a scope from a set of scopes. Throw an error if trying to remove a\nsubscope of an existing scope.", :type :var} {:name scope-intersection, :file "scopula/core.cljc", :line 361, :arglists ([scope-1 scope-2]), :doc "Returns the maximal intersection between two scopes.\n\n`foo:write` and `foo/bar` => `foo/bar:write` ", :type :var} {:name scope-regex, :file "scopula/core.cljc", :line 61, :type :var} {:name scope-repr-to-str, :file "scopula/core.cljc", :line 119, :arglists ([{:keys [path access]}]), :type :var} {:name scope-root, :file "scopula/core.cljc", :line 92, :arglists ([scope]), :doc "Displays the root of a scope.\n\n>>> (scope-root \"foo/bar:read\")\nfoo\n", :type :var} {:name scope-union, :file "scopula/core.cljc", :line 248, :arglists ([scopes-1 scopes-2]), :doc "Unionize two set of scopes.\n", :type :var} {:name scopes-compress, :file "scopula/core.cljc", :line 487, :arglists ([scopes aliases]), :doc "Given a set of scopes and a dictionary of scopes aliases\nuse a fast heuristic to compress scopes with scope aliases.\n\nIt is more important to have a fast function than an efficient one.\nThe best possible compression is clearly an NP-complete problem.\n\nWhat we do, we first sort aliases by the size of string that would be generated to list all the scopes.\nSo for example:\n\n```\n{\"+foo\" {\"x\" \"y\"}\n\"+bar\" {\"very-long-name-for-a-scope\"}\n}\n```\n\nthe scope alias +bar will be preferred as even if the set contain fewer elements, the sum of the length\nof the scopes in the scopes set is longer.\n", :type :var} {:name scopes-expand, :file "scopula/core.cljc", :line 444, :arglists ([scopes aliases]), :doc "Given a set of scopes containing scope aliases expand them.\n\nScopes aliases will be replaced, so the output of scopes-expand should not contain\nany scope alias.\n\nIf some scope alias is missing in the scope-aliases-map, scope expand will throw an exception.", :type :var} {:name scopes-intersect?, :file "scopula/core.cljc", :line 402, :arglists ([scope-1 scope-2]), :doc "Returns whether scope-1 and scope-2 intersect.\n\nFor example: `foo:write` and `foo/bar` intersect while\nneither of those scope is a subscope of another.", :type :var} {:name scopes-intersecting, :file "scopula/core.cljc", :line 420, :arglists ([scopes-1 scopes-2]), :doc "Asymmetrical operation; returns the list of first scopes that intersect with\nsome scopes of the second set of scopes.", :type :var} {:name scopes-intersection, :file "scopula/core.cljc", :line 380, :arglists ([scopes-1 scopes-2]), :doc "Return the intersection between two set of scopes.\n", :type :var} {:name scopes-length, :file "scopula/core.cljc", :line 482, :arglists ([scopes]), :doc "Return the sum of the length of string in a set of scopes.\n", :type :var} {:name scopes-missing, :file "scopula/core.cljc", :line 219, :arglists ([scopes-1 scopes-2]), :doc "Return the elements of the first set of scopes, removing those in the second set\nof scopes", :type :var} {:name scopes-subset?, :file "scopula/core.cljc", :line 204, :arglists ([required scopes]), :doc "Flipped version of scopes-superset?.\nReturns true if the first set is a subset of the second set of scopes.", :type :var} {:name scopes-superset?, :file "scopula/core.cljc", :line 199, :doc "Returns true if the first set of scopes is a superset of the second set of scopes.\nThis is another name for `access-granted` function", :type :var} {:name to-scope-repr, :file "scopula/core.cljc", :line 71, :arglists ([txt]), :doc "Transforms a textual scope as an internal representation to help\ncheck rules, typically:\n\n> \"foo\"\n{:path [\"foo\"]\n :access #{:read :write}}\n\n> \"foo/bar/baz:write\"\n{:path [\"foo\" \"bar\" \"baz\"]\n :access #{:write}}", :type :var}), :doc "Handles scopes logic.\n\nScopes are case-sensitive strings without any whitespace, that represent\nauthorization access. From OAuth2 RFC (https://tools.ietf.org/html/rfc6749#section-3.3):\n\n> The value of the scope parameter is expressed as a list of space-\n> delimited, case-sensitive strings.  The strings are defined by the\n> authorization server.  If the value contains multiple space-delimited\n> strings, their order does not matter, and each string adds an\n> additional access range to the requested scope.\n>\n>   scope       = scope-token *( SP scope-token )\n>   scope-token = 1*( %x21 / %x23-5B / %x5D-7E )\n\nIn order to manage fine-grained authorizations, this lib uses a convention\nfor scope formats.\nFor example, we often need to distinguish between a full scope that will provides\nfull access to some resource, and read-only access.\nSometimes we also want to limit the access to some sub-resource.\nHere are some examples of our convention:\n\n`users`                      full access to users resource\n`users/profile`              access to users profile only\n`users/profile:read`         access to users profile read-only\n`users/profile/email:write`  access to users profile only email write-only\n\nMainly `:` is only authorized to split between access read/write/rw\n(nothing implies rw).\n\nSub-resources can be separated by `/`.\n\nThis library provides helper functions to check that\na given scope will also grant e.g. `users/profile/email` and `users/profile:read`.\n\nWe also provide helpers to normalize sets of scopes:\n\n>>> (normalize-scopes #{\"users\" \"users/profile/email:read\" \"admin\"})\n#{\"users\" \"admin\"}\n\n...as `users/profile/email:read` is redundant, it is removed.\n\nNote that scopes are meant to be used in an OAuth2 access in mind, and thus\nare generally manipulated as a set of scopes.\n\nscopes that do not have any subpath are called _root scopes_.\n\nThis is important because it is easy to add, union scopes.\nBut it is generally impossible to remove just a sub-scope as it would\nmean we should know all the sub-paths of some root-scope and add the difference.\n\nScope are additive by nature."}), "cljs" ({:name scopula.core, :doc "Handles scopes logic.\n\nScopes are case-sensitive strings without any whitespace, that represent\nauthorization access. From OAuth2 RFC (https://tools.ietf.org/html/rfc6749#section-3.3):\n\n> The value of the scope parameter is expressed as a list of space-\n> delimited, case-sensitive strings.  The strings are defined by the\n> authorization server.  If the value contains multiple space-delimited\n> strings, their order does not matter, and each string adds an\n> additional access range to the requested scope.\n>\n>   scope       = scope-token *( SP scope-token )\n>   scope-token = 1*( %x21 / %x23-5B / %x5D-7E )\n\nIn order to manage fine-grained authorizations, this lib uses a convention\nfor scope formats.\nFor example, we often need to distinguish between a full scope that will provides\nfull access to some resource, and read-only access.\nSometimes we also want to limit the access to some sub-resource.\nHere are some examples of our convention:\n\n`users`                      full access to users resource\n`users/profile`              access to users profile only\n`users/profile:read`         access to users profile read-only\n`users/profile/email:write`  access to users profile only email write-only\n\nMainly `:` is only authorized to split between access read/write/rw\n(nothing implies rw).\n\nSub-resources can be separated by `/`.\n\nThis library provides helper functions to check that\na given scope will also grant e.g. `users/profile/email` and `users/profile:read`.\n\nWe also provide helpers to normalize sets of scopes:\n\n>>> (normalize-scopes #{\"users\" \"users/profile/email:read\" \"admin\"})\n#{\"users\" \"admin\"}\n\n...as `users/profile/email:read` is redundant, it is removed.\n\nNote that scopes are meant to be used in an OAuth2 access in mind, and thus\nare generally manipulated as a set of scopes.\n\nscopes that do not have any subpath are called _root scopes_.\n\nThis is important because it is easy to add, union scopes.\nBut it is generally impossible to remove just a sub-scope as it would\nmean we should know all the sub-paths of some root-scope and add the difference.\n\nScope are additive by nature.", :publics ({:name accepted-by-scopes, :file "scopula/core.cljc", :line 169, :arglists ([scopes required]), :doc "`scopes` should be strings.\nif none of the string contains a `/` nor a `:`.\nIt works as is a subset of.\n\n:scopes #{\"foo\" \"bar\"}\nonly people with scopes which are super sets of\n#{\"foo\" \"bar\"}\nwill be allowed to use the route.\n\nscopes are considered as path with read/write access.\nso \"foo/bar/baz:read\" is a sub-scope of \"foo\"\nand of \"foo:read\".\n\nSo the more precise rule of access is.\nAll mandatory scopes must be sub-scopes of at least one user scopes.\n\nAlso mandatory the scopes and required should be normalized", :type :var} {:name access-granted, :file "scopula/core.cljc", :line 192, :arglists ([scopes required]), :doc "Checks that the first parameter contains all the required scopes\ngiven as second parameter.", :type :var} {:name add-scope, :file "scopula/core.cljc", :line 241, :arglists ([scope scopes]), :doc "Add the scope to a set of scopes.\n", :type :var} {:name allowed-chars-no-colon-no-slash, :file "scopula/core.cljc", :line 57, :type :var} {:name allowed-word, :file "scopula/core.cljc", :line 59, :type :var} {:name is-root-scope?, :file "scopula/core.cljc", :line 236, :arglists ([scope]), :type :var} {:name is-scope-alias?, :file "scopula/core.cljc", :line 435, :arglists ([scope]), :type :var} {:name is-scope-aliases-map?, :file "scopula/core.cljc", :line 440, :arglists ([aliases]), :type :var} {:name is-scope-format-valid?, :file "scopula/core.cljc", :line 67, :arglists ([scope]), :type :var} {:name is-sub-list?, :file "scopula/core.cljc", :line 101, :arglists ([lst super-lst]), :doc "Does `super-lst` begin with `lst`?\n", :type :var} {:name is-subscope?, :file "scopula/core.cljc", :line 113, :arglists ([scope-to-check super-scope]), :doc "Returns whether the `scope-to-check` is a subscope of the `super-scope`\n", :type :var} {:name merge-accesses, :file "scopula/core.cljc", :line 127, :arglists ([[path reprs]]), :type :var} {:name normalize-scopes, :file "scopula/core.cljc", :line 160, :arglists ([scopes]), :doc "Given a set of scopes, remove reduntant ones, and merge them by access if possible.\n", :type :var} {:name raw-repr-scope-disj, :file "scopula/core.cljc", :line 296, :arglists ([rscopes rs-to-remove]), :doc "Removes a scope from a set of scopes.\n", :type :var} {:name repr-is-strict-subpath?, :file "scopula/core.cljc", :line 255, :arglists ([r1 r2]), :doc "Return whether the first argument is strictly a sub-path of the second argument.\n", :type :var} {:name repr-is-subscope?, :file "scopula/core.cljc", :line 107, :arglists ([scope-to-check super-scope]), :doc "Returns whether the `scope-to-check` is a subscope of the `super-scope`\n", :type :var} {:name repr-is-subsummed, :file "scopula/core.cljc", :line 132, :arglists ([repr-scope repr-scopes]), :doc "Return whether a scope is contained by all the scopes.\n\nExamples that return true:\n\n(is-subsummed \"foo\" #{\"foo\"})\n(is-subsummed \"foo:read\" #{\"foo\"})\n(is-subsummed \"foo/sub/scope\" #{\"foo\"})\n(is-subsummed \"foo/sub/scope:read\" #{\"foo\"})\n\nExamples that return false:\n\n(is-subsummed \"foo\" #{\"foo:read\" \"bar\"})\n(is-subsummed \"foo:read\" #{\"foo:read\" \"bar\"})\n(is-subsummed \"foo/sub/scope\" #{\"foo:read\"})", :type :var} {:name repr-normalize-scopes, :file "scopula/core.cljc", :line 150, :arglists ([scopes-repr]), :type :var} {:name repr-scope-disj, :file "scopula/core.cljc", :line 301, :arglists ([repr-scopes rs-to-rm]), :doc "Remove a scope for a set of scopes.\nWill throw an exception if the scope to remove is a subscope of some scope in\nthe scopes set.", :type :var} {:name repr-scope-intersection, :file "scopula/core.cljc", :line 341, :arglists ([r1 r2]), :doc "Returns the maximal intersection between two scopes reprs.\n\n`(to-scope-repr \"foo:write\")` and `(to-scope-repr \"foo/bar\")`\n=> `(to-scope-repr \"foo/bar:write\")`\n", :type :var} {:name repr-scope-remove, :file "scopula/core.cljc", :line 264, :arglists ([rs rs-to-remove]), :doc "While inputs should be in repr form,\nremoves the single scope `rs-to-remove` from the single scope `rs`.\n\nReturns `nil` if the two scopes do not intersect.\n\nIf the operation is not possible (for example, remove `foo/bar` from `foo`)\nthis function throw an exception.\n\nIf the two scopes intersect for the path but their access is different that\nmean some access should be remove. As exemple, removing `foo:write` from\n`foo/bar/baz` should endup with `foo/bar/baz:read`.", :type :var} {:name repr-scopes-intersect?, :file "scopula/core.cljc", :line 389, :arglists ([r1 r2]), :doc "Returns whether r1 and r2 intersect.\n\nFor example: `(to-scope-repr foo:write)` and `(to-scope-repr foo/bar)`\nintersect, while neither of those scopes reprs is a subscope of another.", :type :var} {:name repr-scopes-intersecting, :file "scopula/core.cljc", :line 412, :arglists ([rs-1 rs-2]), :doc "Asymmetrical operation; returns the list of first scopes repr that intersect\nwith some scopes repr of the second set of scopes repr.", :type :var} {:name repr-scopes-intersection, :file "scopula/core.cljc", :line 371, :arglists ([sr1 sr2]), :doc "Return the intersection between two set of scopes.\n", :type :var} {:name repr-scopes-missing, :file "scopula/core.cljc", :line 210, :arglists ([scopes-1 scopes-2]), :doc "Return the list of `scopes-1` that is not in `scopes-2`\n", :type :var} {:name root-scope, :file "scopula/core.cljc", :line 228, :arglists ([scope]), :doc "Returns the root of a scope.\n\n>>> (root-scope \"foo/bar:read\")\nfoo", :type :var} {:name safe-scopes-expand, :file "scopula/core.cljc", :line 462, :arglists ([scopes aliases]), :doc "Same as scope expand but return nil instead of throwing and exception if a scope alias is missing\n", :type :var} {:name scope-alias-regex, :file "scopula/core.cljc", :line 432, :type :var} {:name scope-cons, :file "scopula/core.cljc", :line 246, :type :var} {:name scope-difference, :file "scopula/core.cljc", :line 319, :arglists ([scopes scopes-to-remove]), :doc "Very similar to `scopes-missing`, but taking care of throwing an exception if\nsome sub-scope cannot be removed. This would prevent an error when trying to\nreduce a set of scopes.\n\n(scope-difference #{\"foo/bar\"} #{\"foo:write\"})\n=> #{\"foo/bar:read\"}\n\nkeep foo/bar but removed all :write from super-scope foo.", :type :var} {:name scope-disj, :file "scopula/core.cljc", :line 309, :arglists ([scopes scope-to-remove]), :doc "Remove a scope from a set of scopes. Throw an error if trying to remove a\nsubscope of an existing scope.", :type :var} {:name scope-intersection, :file "scopula/core.cljc", :line 361, :arglists ([scope-1 scope-2]), :doc "Returns the maximal intersection between two scopes.\n\n`foo:write` and `foo/bar` => `foo/bar:write` ", :type :var} {:name scope-regex, :file "scopula/core.cljc", :line 61, :type :var} {:name scope-repr-to-str, :file "scopula/core.cljc", :line 119, :arglists ([{:keys [path access]}]), :type :var} {:name scope-root, :file "scopula/core.cljc", :line 92, :arglists ([scope]), :doc "Displays the root of a scope.\n\n>>> (scope-root \"foo/bar:read\")\nfoo\n", :type :var} {:name scope-union, :file "scopula/core.cljc", :line 248, :arglists ([scopes-1 scopes-2]), :doc "Unionize two set of scopes.\n", :type :var} {:name scopes-compress, :file "scopula/core.cljc", :line 487, :arglists ([scopes aliases]), :doc "Given a set of scopes and a dictionary of scopes aliases\nuse a fast heuristic to compress scopes with scope aliases.\n\nIt is more important to have a fast function than an efficient one.\nThe best possible compression is clearly an NP-complete problem.\n\nWhat we do, we first sort aliases by the size of string that would be generated to list all the scopes.\nSo for example:\n\n```\n{\"+foo\" {\"x\" \"y\"}\n\"+bar\" {\"very-long-name-for-a-scope\"}\n}\n```\n\nthe scope alias +bar will be preferred as even if the set contain fewer elements, the sum of the length\nof the scopes in the scopes set is longer.\n", :type :var} {:name scopes-expand, :file "scopula/core.cljc", :line 444, :arglists ([scopes aliases]), :doc "Given a set of scopes containing scope aliases expand them.\n\nScopes aliases will be replaced, so the output of scopes-expand should not contain\nany scope alias.\n\nIf some scope alias is missing in the scope-aliases-map, scope expand will throw an exception.", :type :var} {:name scopes-intersect?, :file "scopula/core.cljc", :line 402, :arglists ([scope-1 scope-2]), :doc "Returns whether scope-1 and scope-2 intersect.\n\nFor example: `foo:write` and `foo/bar` intersect while\nneither of those scope is a subscope of another.", :type :var} {:name scopes-intersecting, :file "scopula/core.cljc", :line 420, :arglists ([scopes-1 scopes-2]), :doc "Asymmetrical operation; returns the list of first scopes that intersect with\nsome scopes of the second set of scopes.", :type :var} {:name scopes-intersection, :file "scopula/core.cljc", :line 380, :arglists ([scopes-1 scopes-2]), :doc "Return the intersection between two set of scopes.\n", :type :var} {:name scopes-length, :file "scopula/core.cljc", :line 482, :arglists ([scopes]), :doc "Return the sum of the length of string in a set of scopes.\n", :type :var} {:name scopes-missing, :file "scopula/core.cljc", :line 219, :arglists ([scopes-1 scopes-2]), :doc "Return the elements of the first set of scopes, removing those in the second set\nof scopes", :type :var} {:name scopes-subset?, :file "scopula/core.cljc", :line 204, :arglists ([required scopes]), :doc "Flipped version of scopes-superset?.\nReturns true if the first set is a subset of the second set of scopes.", :type :var} {:name scopes-superset?, :file "scopula/core.cljc", :line 199, :doc "Returns true if the first set of scopes is a superset of the second set of scopes.\nThis is another name for `access-granted` function", :type :var} {:name to-scope-repr, :file "scopula/core.cljc", :line 71, :arglists ([txt]), :doc "Transforms a textual scope as an internal representation to help\ncheck rules, typically:\n\n> \"foo\"\n{:path [\"foo\"]\n :access #{:read :write}}\n\n> \"foo/bar/baz:write\"\n{:path [\"foo\" \"bar\" \"baz\"]\n :access #{:write}}", :type :var})})}, :pom-str "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<project xmlns=\"http://maven.apache.org/POM/4.0.0\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xsi:schemaLocation=\"http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd\">\n  <modelVersion>4.0.0</modelVersion>\n  <groupId>threatgrid</groupId>\n  <artifactId>scopula</artifactId>\n  <packaging>jar</packaging>\n  <version>0.3.1</version>\n  <name>scopula</name>\n  <description>Offers a scope convention mechanism to enhance control access.</description>\n  <url>https://github.com/threatgrid/scopula</url>\n  <licenses>\n    <license>\n      <name>EPL-2.0 OR GPL-2.0-or-later WITH Classpath-exception-2.0</name>\n      <url>https://www.eclipse.org/legal/epl-2.0/</url>\n      <distribution>repo</distribution>\n    </license>\n  </licenses>\n  <scm>\n    <url>https://github.com/threatgrid/scopula</url>\n    <connection>scm:git:git://github.com/threatgrid/scopula.git</connection>\n    <developerConnection>scm:git:ssh://git@github.com/threatgrid/scopula.git</developerConnection>\n    <tag>a0ca6313eb4c1faab4a0a6e8b56457f8a44e2f46</tag>\n  </scm>\n  <build>\n    <sourceDirectory>src</sourceDirectory>\n    <testSourceDirectory>test</testSourceDirectory>\n    <resources>\n      <resource>\n        <directory>resources</directory>\n      </resource>\n    </resources>\n    <testResources>\n      <testResource>\n        <directory>resources</directory>\n      </testResource>\n    </testResources>\n    <directory>target</directory>\n    <outputDirectory>target/classes</outputDirectory>\n    <plugins/>\n  </build>\n  <repositories>\n    <repository>\n      <id>central</id>\n      <url>https://repo1.maven.org/maven2/</url>\n      <snapshots>\n        <enabled>false</enabled>\n      </snapshots>\n      <releases>\n        <enabled>true</enabled>\n      </releases>\n    </repository>\n    <repository>\n      <id>clojars</id>\n      <url>https://repo.clojars.org/</url>\n      <snapshots>\n        <enabled>true</enabled>\n      </snapshots>\n      <releases>\n        <enabled>true</enabled>\n      </releases>\n    </repository>\n  </repositories>\n  <dependencyManagement>\n    <dependencies/>\n  </dependencyManagement>\n  <dependencies>\n    <dependency>\n      <groupId>org.clojure</groupId>\n      <artifactId>clojure</artifactId>\n      <version>1.11.1</version>\n    </dependency>\n    <dependency>\n      <groupId>org.clojure</groupId>\n      <artifactId>clojurescript</artifactId>\n      <version>1.11.132</version>\n    </dependency>\n  </dependencies>\n</project>\n\n<!-- This file was autogenerated by Leiningen.\n  Please do not edit it directly; instead edit project.clj and regenerate it.\n  It should not be considered canonical data. For more information see\n  https://github.com/technomancy/leiningen -->\n"}