11db66e · vty · git.iko.soy

git.iko.soy/vty

on master help sign in

correct the cap used for function keys to kfN not key_fN

11db66eCorey O'Connor13 years ago

src/Graphics/Vty/Input.hs+1−2

compare with master

unifiedsplit

@@ -79,8 +79,7 @@ initTermInput escDelay terminal = do

79 ]

80 setTerminalAttributes stdInput attr' Immediately

81 set_term_timing

82− let caps_legacy_table = map_to_legacy_table $ caps_classify_table terminal keys_from_caps_table

82+ let classify_table = classify_table_for_term terminal

83− classify_table = concat $ caps_legacy_table : ansi_classify_table

84 (eventChannel, shutdown_input) <- initInputForFd escDelay classify_table stdInput

83 (eventChannel, shutdown_input) <- initInputForFd escDelay classify_table stdInput

85 let pokeIO = Catch $ do

84 let pokeIO = Catch $ do

86 let e = error "(getsize in input layer)"

85 let e = error "(getsize in input layer)"

src/Graphics/Vty/Input/Data.hs+1−1

@@ -46,7 +46,7 @@ keys_from_caps_table =

46 ] ++ function_key_caps_table

48function_key_caps_table :: [(String, Event)]

49−function_key_caps_table = flip map [0..63] $ \n -> ("key_f" ++ show n, EvKey (KFun n) [])

49+function_key_caps_table = flip map [0..63] $ \n -> ("kf" ++ show n, EvKey (KFun n) [])

51nav_keys_0 :: ClassifyTable

52nav_keys_0 =

src/Graphics/Vty/Input/Terminfo.hs+5

@@ -8,3 +8,8 @@ import System.Console.Terminfo

8caps_classify_table :: Terminal -> [(String,Event)] -> [(String,Event)]

9caps_classify_table terminal table = [(x,y) | (Just x,y) <- map extract_cap table]

10 where extract_cap = first (getCapability terminal . tiGetStr)

11+

12+classify_table_for_term :: Terminal -> ClassifyTable

13+classify_table_for_term term =

14+ let caps_legacy_table = map_to_legacy_table $ caps_classify_table term keys_from_caps_table

15+ in concat $ caps_legacy_table : ansi_classify_table

test/VerifyUsingMockInput.hs+40−7

@@ -32,6 +32,8 @@ import Test.Framework

32import Test.SmallCheck

33import Test.SmallCheck.Series

35+import Text.Printf

36+

35-- processing a block of 16 chars is the largest I can do without taking too long to run the test.

37-- processing a block of 16 chars is the largest I can do without taking too long to run the test.

36max_block_size :: Int

38max_block_size :: Int

37max_block_size = 16

39max_block_size = 16

@@ -58,7 +60,7 @@ synthesize_input input out_handle = forM_ input f >> (void $ fdWrite out_handle

58 f (Delay t) = threadDelay t

60 f (Delay t) = threadDelay t

60min_detectable_delay :: Int

62min_detectable_delay :: Int

61−min_detectable_delay = 1000

63+min_detectable_delay = 4000

63min_timout :: Int

65min_timout :: Int

64min_timout = 4000000

66min_timout = 4000000

@@ -80,6 +82,25 @@ gen_events_using_io_actions max_duration input_action output_action = do

80 Just () <- timeout max_duration' $ takeMVar read_complete

82 Just () <- timeout max_duration' $ takeMVar read_complete

81 return ()

83 return ()

85+compare_events input_spec expected_events out_events = compare_events' expected_events out_events

86+ where

87+ compare_events' [] [] = return True

88+ compare_events' [] out_events' = do

89+ printf "extra events %s\n" (show out_events) :: IO ()

90+ return False

91+ compare_events' expected_events' [] = do

92+ printf "events %s were not produced for input %s\n" (show expected_events') (show input_spec) :: IO ()

93+ printf "expected events %s\n" (show expected_events) :: IO ()

94+ printf "received events %s\n" (show out_events) :: IO ()

95+ return False

96+ compare_events' (e : expected_events') (o : out_events')

97+ | e == o = compare_events' expected_events' out_events'

98+ | otherwise = do

99+ printf "%s expected not %s for input %s\n" (show e) (show o) (show input_spec) :: IO ()

100+ printf "expected events %s\n" (show expected_events) :: IO ()

101+ printf "received events %s\n" (show out_events) :: IO ()

102+ return False

103+

83assert_events_from_syn_input :: ClassifyTable -> InputSpec -> ExpectedSpec -> IO Bool

104assert_events_from_syn_input :: ClassifyTable -> InputSpec -> ExpectedSpec -> IO Bool

84assert_events_from_syn_input table input_spec expected_events = do

105assert_events_from_syn_input table input_spec expected_events = do

85 let max_duration = sum [t | Delay t <- input_spec] + min_detectable_delay

106 let max_duration = sum [t | Delay t <- input_spec] + min_detectable_delay

@@ -103,8 +124,7 @@ assert_events_from_syn_input table input_spec expected_events = do

103 read_loop (n - 1)

124 read_loop (n - 1)

104 gen_events_using_io_actions max_duration write_wait_close read_events

125 gen_events_using_io_actions max_duration write_wait_close read_events

105 out_events <- reverse <$> readIORef events_ref

126 out_events <- reverse <$> readIORef events_ref

106− print (input_spec, expected_events, out_events)

127+ compare_events input_spec expected_events out_events

107− return $ out_events == expected_events

108

128

109assert_events_from_input_block :: ClassifyTable -> InputSpec -> ExpectedSpec -> IO Bool

129assert_events_from_input_block :: ClassifyTable -> InputSpec -> ExpectedSpec -> IO Bool

110assert_events_from_input_block table input_spec expected_events = do

130assert_events_from_input_block table input_spec expected_events = do

@@ -162,7 +182,7 @@ verify_keys_from_caps_table_block_to_event = forAll $ \(InputBlocksUsingTable ge

162 input_seq = gen table

182 input_seq = gen table

163 events = [e | (_,e) <- input_seq]

183 events = [e | (_,e) <- input_seq]

164 keydowns = [Bytes s | (s,_) <- input_seq]

184 keydowns = [Bytes s | (s,_) <- input_seq]

165− input = intersperse (Delay test_key_delay) keydowns

185+ input = intersperse (Delay test_key_delay) keydowns ++ [Delay test_key_delay]

166 assert_events_from_input_block (map_to_legacy_table table) input events

186 assert_events_from_input_block (map_to_legacy_table table) input events

167

187

168verify_simple_syn_input_to_event :: Property IO

188verify_simple_syn_input_to_event :: Property IO

@@ -171,7 +191,7 @@ verify_simple_syn_input_to_event = forAll $ \(InputBlocksUsingTable gen) -> mona

171 input_seq = gen table

191 input_seq = gen table

172 events = [EvKey k ms | (_,(k,ms)) <- input_seq]

192 events = [EvKey k ms | (_,(k,ms)) <- input_seq]

173 keydowns = [Bytes s | (s,_) <- input_seq]

193 keydowns = [Bytes s | (s,_) <- input_seq]

174− input = intersperse (Delay test_key_delay) keydowns

194+ input = intersperse (Delay test_key_delay) keydowns ++ [Delay test_key_delay]

175 assert_events_from_syn_input (concat ansi_classify_table) input events

195 assert_events_from_syn_input (concat ansi_classify_table) input events

176

196

177verify_caps_syn_input_to_event :: Property IO

197verify_caps_syn_input_to_event :: Property IO

@@ -182,7 +202,7 @@ verify_caps_syn_input_to_event = forAll $ \(InputBlocksUsingTable gen) ->

182 input_seq = gen table

202 input_seq = gen table

183 events = [e | (_,e) <- input_seq]

203 events = [e | (_,e) <- input_seq]

184 keydowns = [Bytes s | (s,_) <- input_seq]

204 keydowns = [Bytes s | (s,_) <- input_seq]

185− input = intersperse (Delay test_key_delay) keydowns

205+ input = intersperse (Delay test_key_delay) keydowns ++ [Delay test_key_delay]

186 assert_events_from_syn_input (map_to_legacy_table table) input events

206 assert_events_from_syn_input (map_to_legacy_table table) input events

187

207

188verify_special_syn_input_to_event :: Property IO

208verify_special_syn_input_to_event :: Property IO

@@ -191,9 +211,20 @@ verify_special_syn_input_to_event = forAll $ \(InputBlocksUsingTable gen) -> mon

191 input_seq = gen table

211 input_seq = gen table

192 events = [EvKey k ms | (_,(k,ms)) <- input_seq]

212 events = [EvKey k ms | (_,(k,ms)) <- input_seq]

193 keydowns = [Bytes s | (s,_) <- input_seq]

213 keydowns = [Bytes s | (s,_) <- input_seq]

194− input = intersperse (Delay test_key_delay) keydowns

214+ input = intersperse (Delay test_key_delay) keydowns ++ [Delay test_key_delay]

195 assert_events_from_syn_input (concat ansi_classify_table) input events

215 assert_events_from_syn_input (concat ansi_classify_table) input events

196

216

217+verify_full_syn_input_to_event :: Property IO

218+verify_full_syn_input_to_event = forAll $ \(InputBlocksUsingTable gen) ->

219+ forEachOf terminals_of_interest $ \term_name -> monadic $ do

220+ term <- setupTerm term_name

221+ let table = classify_table_for_term term

222+ input_seq = gen table

223+ events = [EvKey k ms | (_,(k,ms)) <- input_seq]

224+ keydowns = [Bytes s | (s,_) <- input_seq]

225+ input = intersperse (Delay test_key_delay) keydowns ++ [Delay test_key_delay]

226+ assert_events_from_syn_input table input events

227+

197main :: IO ()

228main :: IO ()

198main = defaultMain

229main = defaultMain

199 [ testProperty "basic block generated from a single visible chars to event translation"

230 [ testProperty "basic block generated from a single visible chars to event translation"

@@ -206,5 +237,7 @@ main = defaultMain

206 verify_caps_syn_input_to_event

237 verify_caps_syn_input_to_event

207 , testProperty "synthesized typing from hard coded special keys translates to expected events"

238 , testProperty "synthesized typing from hard coded special keys translates to expected events"

208 verify_special_syn_input_to_event

239 verify_special_syn_input_to_event

240+ , testProperty "synthesized typing from any key in the table translates to expected events"

241+ verify_full_syn_input_to_event

209 ]

242 ]

210

243