Safe Haskell	None
Language	Haskell2010

Foreign.Ruby.Helpers

Synopsis

class FromRuby a where
class ToRuby a where
fromRubyIntegral :: Integral n => RValue -> IO (Either String n)
toRubyIntegral :: Integral n => n -> IO RValue
fromRubyArray :: FromRuby a => RValue -> IO (Either String [a])
embedHaskellValue :: a -> IO RValue
freeHaskellValue :: RValue -> IO ()
extractHaskellValue :: RValue -> IO a
runscript :: String -> IO (Either String ())
defineGlobalClass :: String -> IO RValue
safeMethodCall :: String -> String -> [RValue] -> IO (Either (String, RValue) RValue)
showErrorStack :: IO String
setGC :: Bool -> IO (Either (String, RValue) RValue)
startGC :: IO ()
freezeGC :: IO a -> IO a

Documentation

class FromRuby a where #

The class of things that can be converted from Ruby values. Note that there are a ton of stuff that are Ruby values, hence the Maybe type, as the instances will probably be incomplete.

Minimal complete definition

fromRuby

Methods

fromRuby :: RValue -> IO (Either String a) #

To define more instances, please look at the instances defined in Foreign.Ruby.Helpers.

Instances

FromRuby Double #
Instance details Defined in Foreign.Ruby.Helpers Methods fromRuby :: RValue -> IO (Either String Double) #
FromRuby Int #
Instance details Defined in Foreign.Ruby.Helpers Methods fromRuby :: RValue -> IO (Either String Int) #
FromRuby Integer #
Instance details Defined in Foreign.Ruby.Helpers Methods fromRuby :: RValue -> IO (Either String Integer) #
FromRuby ByteString #
Instance details Defined in Foreign.Ruby.Helpers Methods fromRuby :: RValue -> IO (Either String ByteString) #
FromRuby Text #
Instance details Defined in Foreign.Ruby.Helpers Methods fromRuby :: RValue -> IO (Either String Text) #
FromRuby Value #	This is the most complete instance that is provided in this module. Please note that it is far from being sufficient for even basic requirements. For example, the `Value` type can only encode dictionnaries with keys that can be converted to strings.
Instance details Defined in Foreign.Ruby.Helpers Methods fromRuby :: RValue -> IO (Either String Value) #
FromRuby a => FromRuby [a] #
Instance details Defined in Foreign.Ruby.Helpers Methods fromRuby :: RValue -> IO (Either String [a]) #

class ToRuby a where #

Whenever you use ToRuby, don't forget to use something like freezeGC or you will get random segfaults.

Minimal complete definition

toRuby

Methods

toRuby :: a -> IO RValue #

Instances

ToRuby Double #
Instance details Defined in Foreign.Ruby.Helpers Methods toRuby :: Double -> IO RValue #
ToRuby Int #
Instance details Defined in Foreign.Ruby.Helpers Methods toRuby :: Int -> IO RValue #
ToRuby Integer #
Instance details Defined in Foreign.Ruby.Helpers Methods toRuby :: Integer -> IO RValue #
ToRuby ByteString #
Instance details Defined in Foreign.Ruby.Helpers Methods toRuby :: ByteString -> IO RValue #
ToRuby Scientific #
Instance details Defined in Foreign.Ruby.Helpers Methods toRuby :: Scientific -> IO RValue #
ToRuby Text #
Instance details Defined in Foreign.Ruby.Helpers Methods toRuby :: Text -> IO RValue #
ToRuby Value #
Instance details Defined in Foreign.Ruby.Helpers Methods toRuby :: Value -> IO RValue #
ToRuby a => ToRuby [a] #
Instance details Defined in Foreign.Ruby.Helpers Methods toRuby :: [a] -> IO RValue #

fromRubyIntegral :: Integral n => RValue -> IO (Either String n) #

toRubyIntegral :: Integral n => n -> IO RValue #

fromRubyArray :: FromRuby a => RValue -> IO (Either String [a]) #

embedHaskellValue :: a -> IO RValue #

An unsafe version of the corresponding Foreign.Ruby.Safe function.

freeHaskellValue :: RValue -> IO () #

Frees the Haskell value represented by the corresponding RValue. This is probably extremely unsafe to do, and will most certainly lead to exploitable security bug if you use something modified from Ruby land. You should always free the RValue you generated from embedHaskellValue.

extractHaskellValue :: RValue -> IO a #

This is unsafe as hell, so you'd better be certain this RValue has not been tempered with : GC frozen, bugfree Ruby scripts.

If it has been tempered by an attacker, you are probably looking at a good vector for arbitrary code execution.

runscript :: String -> IO (Either String ()) #

defineGlobalClass :: String -> IO RValue #

safeMethodCall #

Arguments

:: String	Class name.
-> String	Method name.
-> [RValue]	Arguments. Please note that the maximum number of arguments is 16.
-> IO (Either (String, RValue) RValue)	Returns either an error message / value couple, or the value returned by the function.

Runs a Ruby method, capturing errors.

showErrorStack :: IO String #

Gives a (multiline) error friendly string representation of the last error.

setGC #

Arguments

:: Bool	Set to `True` to enable GC, and to `False` to disable it.
-> IO (Either (String, RValue) RValue)

Sets the current GC operation. Please note that this could be modified from Ruby scripts.

startGC :: IO () #

Runs the Ruby garbage collector.

freezeGC :: IO a -> IO a #

Runs a computation with the Ruby GC disabled. Once the computation is over, GC will be re-enabled and the startGC function run.