Regexdispatcher

.travis.yml

@@ -214,7 +214,7 @@ before_script:
   - |
     if [[ $HASKELL == ON ]]; then
       bindings="haskell"
-      plugins="resolver_fm_hpu_b;dump;dini;list;spec;haskell;typechecker;ini;sync;error;base64"
+      plugins="resolver_fm_hpu_b;dump;dini;list;spec;haskell;typechecker;ini;sync;error;base64;regexdispatcher"
       tools="kdb"
     fi
   - |

cmake/Modules/LibAddHaskellPlugin.cmake

@@ -30,10 +30,13 @@ macro (add_haskell_plugin target)
 
 	set (PLUGIN_NAME ${target})
 	set (PLUGIN_NAME_CAPITALIZED ${target})
-	string (SUBSTRING ${PLUGIN_NAME} 0 1 FIRST_LETTER)
-	string (TOUPPER ${FIRST_LETTER} FIRST_LETTER)
-	string (REGEX REPLACE "^.(.*)" "${FIRST_LETTER}\\1" PLUGIN_NAME_CAPITALIZED "${PLUGIN_NAME}")
-	string (TOUPPER ${PLUGIN_NAME} PLUGIN_NAME_UPPERCASE)
+	if (ARG_MODULE)
+		set (PLUGIN_NAME_CAPITALIZED ${ARG_MODULE})
+	else (ARG_MODULE)
+		string (SUBSTRING ${PLUGIN_NAME} 0 1 FIRST_LETTER)
+		string (TOUPPER ${FIRST_LETTER} FIRST_LETTER)
+		string (REGEX REPLACE "^.(.*)" "${FIRST_LETTER}\\1" PLUGIN_NAME_CAPITALIZED "${PLUGIN_NAME}")
+	endif (ARG_MODULE)
 
 	if (DEPENDENCY_PHASE)
 		find_package (Haskell)
@@ -180,9 +183,16 @@ macro (add_haskell_plugin target)
 										# our custom libs are all to be processed by cmake before we
 										# can add them, so enforce that, the build is more stable
 										# this way
-											add_subdirectory (
-												"${CMAKE_SOURCE_DIR}/${SANDBOX_ADD_SOURCE}"
-												"${CMAKE_BINARY_DIR}/${SANDBOX_ADD_SOURCE}")
+											if (NOT
+											    IS_DIRECTORY
+											    "${CMAKE_BINARY_DIR}/${SANDBOX_ADD_SOURCE}")
+												add_subdirectory (
+													"${CMAKE_SOURCE_DIR}/${SANDBOX_ADD_SOURCE}"
+													"${CMAKE_BINARY_DIR}/${SANDBOX_ADD_SOURCE}"
+													)
+											endif (NOT
+											       IS_DIRECTORY
+											       "${CMAKE_BINARY_DIR}/${SANDBOX_ADD_SOURCE}")
 											execute_process (
 												COMMAND
 													${CABAL_EXECUTABLE} sandbox

doc/METADATA.ini

@@ -526,7 +526,7 @@ description= defines the max value type of the integer value
 
 [check/range]
 status= implemented
-usedby/plugin= range
+usedby/plugin= range regexdispatcher
 usedby/tool = web
 description= range checks, from-to, multiple ranges are separated by a comma
 example= 1-10 or -1-4,6-10
@@ -596,21 +596,21 @@ description= type of match, to toggle REG_EXTENDED
 
 [check/enum]
 status=deprecated
-usedby/plugin=enum
+usedby/plugin= enum
 description= List of apostrophe enclosed values separated by
 	commas to check against.
 	Please use check/enum/# instead.
 
 [check/enum/#]
 status= implemented
-usedby/plugin=enum
+usedby/plugin= enum regexdispatcher
 usedby/tool = web
 description= An array with different enum values to be used
 	instead of check/enum
 
 [check/enum/multi]
 status= implemented
-usedby/plugin=enum
+usedby/plugin= enum regexdispatcher
 type= char
 description= Specifies if multiple, but different, strings are allowed
 	within an value. The character given within this metavalue
@@ -905,3 +905,13 @@ default = dec
 usedby/plugins = hexnumber
 description = used to specify the base of an integer value. Currently only the hexnumber plugin supports this metadata. It converts any value marked as "hex" from
     hexadecimal into decimal when the configuration is read, and back when it is written. The hexnumber plugin also ensures that a value marked as "hex" starts with "0x" or "0X".
+
+[elektra/spec/regex/check/enum]
+type = string
+usedby/plugins = regexdispatcher
+description = the generated regex representing the type of check/enum/# and check/enum/multi metakeys
+
+[elektra/spec/regex/check/range]
+type = string
+usedby/plugins = regexdispatcher
+description = the generated regex representing the type of check/range metakeys

doc/news/_preparation_next_release.md

@@ -59,7 +59,7 @@ set of type definitions for commonly used metakeys such as `check/range`,
 `check/long`, `fallback` or `override`.
 
 For more details see the
-[typechecker readme](https://github.com/ElektraInitiative/libelektra/tree/master/src/plugins/typechecker/README.md)
+[typechecker readme](https://www.libelektra.org/plugins/typechecker)
 
 Thanks to Armin Wurzinger.
 
@@ -87,16 +87,17 @@ We added even more functionality, which could not make it to the highlights:
 - The build system no longer installs haskell dependencies from hackage by itself, instead
   this has to be done beforehand like it is the case with all other dependencies. The main
   reason is that the build servers shouldn't compile the dependencies over and over again,
-  only if something changes. See the [readme](https://github.com/ElektraInitiative/libelektra/blob/master/src/bindings/haskell/README.md). *(Armin Wurzinger)*
-- <<TODO>>
-- <<TODO>>
+  only if something changes. See the [readme](https://www.libelektra.org/bindings/haskell). *(Armin Wurzinger)*
 - The new tool `kdb find` lists keys of the database matching a certain regular expression. *(Markus Raab)*
+- <<TODO>>
 
 ## New Plugins
 
 - The plugin [hexnumber](https://www.libelektra.org/plugins/hexnumber) has been added. It can be used
   to convert hexadecimal values into decimal when read, and back to hexadecimal when written. *(Klemens Böswirth)*
-- <<TODO>>
+- The plugin [regexdispatcher](https://www.libelektra.org/plugins/regexdispatcher) has been added. It calculates regex representations for commonly used specification
+  keywords to be used with the [typechecker](https://www.libelektra.org/plugins/typechecker). Currently the
+  keywords `check/range`, `check/enum` and `check/validation` are supported. *(Armin Wurzinger)*
 - <<TODO>>
 
 

src/bindings/haskell/CMakeLists.txt

@@ -44,6 +44,7 @@ if (HASKELL_FOUND)
 			     "${CMAKE_CURRENT_SOURCE_DIR}/src/Elektra/Plugin.chs"
 			     "${CMAKE_CURRENT_SOURCE_DIR}/src/Elektra/KDB.chs"
 			     "${CMAKE_CURRENT_SOURCE_DIR}/src/Elektra/Ease.chs"
+			     "${CMAKE_CURRENT_SOURCE_DIR}/src/Elektra/Invoke.chs"
 			     "${CMAKE_CURRENT_SOURCE_DIR}/test/Elektra.hs"
 			     "${CMAKE_CURRENT_SOURCE_DIR}/test/ElektraRealWorld.hs"
 			     "${CMAKE_CURRENT_SOURCE_DIR}/src/c/hskdberrors.c"

src/bindings/haskell/libelektra-haskell.cabal.in

@@ -21,12 +21,16 @@ library
                    , Elektra.Plugin
                    , Elektra.Ease
                    , Elektra.Errors
+                   , Elektra.Invoke
+                   , Elektra.PluginProcess
   build-depends:     base >= 4.9 && < 4.12
   includes:          kdb.h
                    , kdbplugin.h
                    , kdbease.h
+                   , kdbinvoke.h
                    , kdberrors.h
                    , hskdberrors.h
+                   , kdbpluginprocess.h
   include-dirs:      @CABAL_INCLUDE_DIRS@
                    , "@CMAKE_CURRENT_SOURCE_DIR@/src/include"
   c-sources:         "@CMAKE_CURRENT_BINARY_DIR@/src/c/hskdberrors.c"

src/bindings/haskell/src/Elektra/Invoke.chs

@@ -0,0 +1,62 @@
+--
+-- @file
+--
+-- @brief Haskell bindings for libelektra-invoke
+--
+-- @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
+-- 
+module Elektra.Invoke (
+  InvokeFunction,
+  elektraInvokeOpen, elektraInvokeGetFunction, 
+  elektraInvokeGetPluginConfig, elektraInvokeGetPluginName, elektraInvokeGetPluginData, elektraInvokeGetModules,
+  elektraInvokeGetExports, elektraInvoke2Args, elektraInvokeClose,
+  ifHandle
+) where
+
+{#import Elektra.Key #}
+{#import Elektra.KeySet #}
+{#import Elektra.Plugin #}
+
+import Data.Maybe (maybe)
+import Foreign.Ptr (Ptr, castPtr, nullPtr)
+import Foreign.ForeignPtr (withForeignPtr, newForeignPtr_)
+
+#include <kdbinvoke.h>
+
+{#pointer *ElektraInvokeHandle newtype #}
+type InvokeFunction = Ptr ()
+
+-- Handles are already pointers, so just cast them from/to void pointers
+instance PluginData ElektraInvokeHandle where
+  store a (ElektraInvokeHandle p) = a $ castPtr p
+  retrieve p = if p == nullPtr then Nothing else (Just . ElektraInvokeHandle $ castPtr p)
+
+ifHandle :: IO a -> (ElektraInvokeHandle -> IO a) -> ElektraInvokeHandle -> IO a
+ifHandle f t h@(ElektraInvokeHandle p) = if p == nullPtr then f else t h
+
+-- ***
+-- Invoke METHODS
+-- ***
+
+elektraInvokeOpen :: String -> Maybe KeySet -> Maybe Key -> IO ElektraInvokeHandle
+elektraInvokeOpen elektraPluginName config errorKey = do
+  c <- maybe (ksNew 0) return config
+  e <- maybe (keyNew "") return errorKey
+  elektraInvokeOpenRaw elektraPluginName c e
+{#fun unsafe elektraInvokeOpen as elektraInvokeOpenRaw {`String', `KeySet', `Key'} -> `ElektraInvokeHandle' #}
+
+{#fun unsafe elektraInvokeGetFunction {`ElektraInvokeHandle', `String'} -> `InvokeFunction' return* #}
+{#fun unsafe elektraInvokeGetPluginConfig {`ElektraInvokeHandle'} -> `KeySet' #}
+{#fun unsafe elektraInvokeGetPluginName {`ElektraInvokeHandle'} -> `String' #}
+elektraInvokeGetPluginData :: PluginData d => ElektraInvokeHandle -> IO (Maybe d)
+elektraInvokeGetPluginData h = retrieve <$> elektraInvokeGetPluginDataRaw h
+{#fun unsafe elektraInvokeGetPluginData as elektraInvokeGetPluginDataRaw {`ElektraInvokeHandle'} -> `Ptr ()' return* #}
+{#fun unsafe elektraInvokeGetModules {`ElektraInvokeHandle'} -> `KeySet' #}
+{#fun unsafe elektraInvokeGetExports {`ElektraInvokeHandle'} -> `KeySet' #}
+{#fun unsafe elektraInvoke2Args {`ElektraInvokeHandle', `String', `KeySet', `Key'} -> `Int' #}
+
+elektraInvokeClose :: ElektraInvokeHandle -> Maybe Key -> IO ()
+elektraInvokeClose handle errorKey = do
+  e <- maybe (keyNew "") return errorKey
+  elektraInvokeCloseRaw handle e
+{#fun unsafe elektraInvokeClose as elektraInvokeCloseRaw {`ElektraInvokeHandle',`Key'} -> `()' #}

src/bindings/haskell/src/Elektra/Key.chs

@@ -21,7 +21,7 @@ module Elektra.Key (
   keyCmp, keyNeedSync, 
   keyIsBelow, keyIsDirectBelow, 
   keyRel, keyIsInactive, keyIsBinary, keyIsString, keyPtrNull, 
-  ifKey, withKey,
+  ifKey, withKey, whenKey,
   tmpRef
 ) where
 
@@ -32,7 +32,7 @@ import Foreign.ForeignPtr (FinalizerPtr (..), withForeignPtr, addForeignPtrFinal
 import System.IO.Unsafe (unsafePerformIO)
 import Data.Maybe (isJust, fromJust)
 import Control.Monad (liftM)
-import Debug.Trace
+import Data.Bool (bool)
 
 {#context lib="libelektra" #}
 
@@ -190,14 +190,14 @@ instance Eq Key where
 -- ADDITIONAL HELPERS USEFUL IN HASKELL
 -- ***
 
---Key (C2HSImp.ForeignPtr (Key))
 addFinalizer :: Key -> IO Key
 addFinalizer (Key a) = addForeignPtrFinalizer keyDel a >> return (Key a)
 
-ifKey :: IO Key -> (Key -> IO a) -> IO a -> IO a
-ifKey k t f = do
-  null <- k >>= keyPtrNull
-  if null then f else k >>= t
+ifKey :: IO a -> (Key -> IO a) -> Key -> IO a
+ifKey f t k = keyPtrNull k >>= bool (t k) f 
+
+whenKey :: (Key -> IO ()) -> Key -> IO ()
+whenKey w k = ifKey (return ()) w k
 
 -- Temporarily increases the reference counter so e.g. a keyset will not take ownership so
 -- Haskell's finalizer can run successfully afterwards

src/bindings/haskell/src/Elektra/Plugin.chs

@@ -6,7 +6,7 @@
 -- @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
 -- 
 module Elektra.Plugin (
-  Plugin, PluginStatus (..),
+  Plugin, withPlugin, PluginStatus (..), PluginData (..),
   elektraPluginGetConfig, 
   elektraPluginSetData, elektraPluginGetData,
   elektraPluginOpenWith, elektraPluginCloseWith, 
@@ -16,6 +16,7 @@ module Elektra.Plugin (
 
 {#import Elektra.Key#}
 {#import Elektra.KeySet#}
+
 import Foreign.Ptr (Ptr)
 import Foreign.ForeignPtr (newForeignPtr_)
 import Control.Monad (join, liftM, liftM2, liftM3)
@@ -44,9 +45,21 @@ instance Enum PluginStatus where
 -- ***
 
 {#fun unsafe elektraPluginGetConfig {`Plugin'} -> `KeySet' #}
--- You have to cast it using Foreign.Ptr.castPtr to the data structure you use manually
-{#fun unsafe elektraPluginSetData {`Plugin', `Ptr ()'} -> `()' #}
-{#fun unsafe elektraPluginGetData {`Plugin'} -> `Ptr ()' #}
+
+-- This is already implemented for invoke handles
+-- If you want to use other data structures you have to provide an instance of PluginData yourself
+-- This way we can hide the ugly casting to c's void pointer
+class PluginData d where
+  store :: (Ptr () -> IO ()) -> d -> IO ()
+  retrieve :: Ptr () -> Maybe d
+
+elektraPluginSetData :: PluginData d => Plugin -> d -> IO ()
+elektraPluginSetData p = store (elektraPluginSetDataRaw p)
+{#fun unsafe elektraPluginSetData as elektraPluginSetDataRaw {`Plugin', `Ptr ()'} -> `()' #}
+
+elektraPluginGetData :: PluginData d => Plugin -> IO (Maybe d)
+elektraPluginGetData p = retrieve <$> elektraPluginGetDataRaw p
+{#fun unsafe elektraPluginGetData as elektraPluginGetDataRaw {`Plugin'} -> `Ptr ()' #}
 
 -- ***
 -- PLUGIN STUB METHODS

src/bindings/haskell/src/Elektra/PluginProcess.chs

@@ -0,0 +1,30 @@
+--
+-- @file
+--
+-- @brief PluginProcess Haskell bindings
+--
+-- @copyright BSD License (see LICENSE.md or https://www.libelektra.org)
+-- 
+module Elektra.PluginProcess (
+  elektraPluginProcessGetData,
+  elektraPluginProcessSetData
+) where
+
+{#import Elektra.Plugin#}
+{#import Elektra.Invoke#}
+
+import Foreign.Ptr (Ptr)
+
+#include <kdbpluginprocess.h>
+
+-- ***
+-- PLUGINPROCESS METHODS
+-- ***
+
+elektraPluginProcessSetData :: PluginData d => Plugin -> d -> IO ()
+elektraPluginProcessSetData p = store (elektraPluginProcessSetDataRaw p)
+{#fun unsafe elektraPluginProcessSetData as elektraPluginProcessSetDataRaw {`Plugin', `Ptr ()'} -> `()' #}
+
+elektraPluginProcessGetData :: PluginData d => Plugin -> IO (Maybe d)
+elektraPluginProcessGetData p = retrieve <$> elektraPluginProcessGetDataRaw p
+{#fun unsafe elektraPluginProcessGetData as elektraPluginProcessGetDataRaw {`Plugin'} -> `Ptr ()' #}

src/include/kdbpluginprocess.h

@@ -40,6 +40,9 @@ int elektraPluginProcessSend (const ElektraPluginProcess *, pluginprocess_t, Key
 
 int elektraPluginProcessClose (ElektraPluginProcess *, Key *);
 
+void elektraPluginProcessSetData (Plugin * handle, void * data);
+void * elektraPluginProcessGetData (Plugin * handle);
+
 #ifdef __cplusplus
 }
 }

src/libs/pluginprocess/pluginprocess.c

@@ -31,6 +31,7 @@ struct _ElektraPluginProcess
 	int pid;
 	int counter;
 	ElektraInvokeHandle * dump;
+	void * pluginData;
 };
 
 static void cleanupPluginData (ElektraPluginProcess * pp, Key * errorKey)
@@ -333,6 +334,7 @@ ElektraPluginProcess * elektraPluginProcessInit (Key * errorKey)
 	pp->resultPipe = getPipename (pp->pipeDirectory, "/result");
 	pp->dump = elektraInvokeOpen ("dump", 0, errorKey);
 	pp->counter = 0;
+	pp->pluginData = NULL;
 
 	if (pp->pipeDirectory && pp->commandPipe && pp->resultPipe && pp->dump)
 	{
@@ -401,3 +403,34 @@ int elektraPluginProcessClose (ElektraPluginProcess * pp, Key * errorKey)
 	if (done) cleanupPluginData (pp, errorKey);
 	return done;
 }
+
+/** Store a pointer to any plugin related data that is being executed inside an own process.
+ *
+ * @param plugin a pointer to the plugin
+ * @param data the pointer to the data
+ */
+void elektraPluginProcessSetData (Plugin * handle, void * data)
+{
+	ElektraPluginProcess * pp = elektraPluginGetData (handle);
+	if (pp)
+	{
+		pp->pluginData = data;
+	}
+}
+
+/** Get a pointer to any plugin related data stored before.
+ *
+ * If elektraPluginProcessSetData was not called earlier, NULL will be returned.
+ *
+ * @param plugin a pointer to the plugin
+ * @retval a pointer to the data
+ */
+void * elektraPluginProcessGetData (Plugin * handle)
+{
+	ElektraPluginProcess * pp = elektraPluginGetData (handle);
+	if (pp)
+	{
+		return pp->pluginData;
+	}
+	return NULL;
+}