← Back to branch summary

~ufleisch/python-mode/improve-completion

« back to all changes in this revision

Viewing changes to python-components-kill-forms.el

  • Committer: Andreas Röhler
  • Date: 2015-12-25 18:45:27 UTC
  • Revision ID: speck@sprache.kasten-20151225184527-00e6j20xm6gkkq35
`py-kill-indent', new command

Edit-commands will reach beginning-of-line if reasonable
Edit-commands suffixed "-bol" dropped 


Show diffs side-by-side

added added

removed removed

Lines of Context:
python-components-kill-forms.el
29
29
;;; Code:
30
30
 
31
31
 
 
32
(defun py-kill-line ()
 
33
  "Delete `line' at point.
 
34
 
 
35
Stores data in kill ring"
 
36
  (interactive "*")
 
37
  (let ((erg (py--mark-base "line")))
 
38
    (kill-region (car erg) (cdr erg))))
 
39
 
 
40
(defun py-kill-paragraph ()
 
41
  "Delete `paragraph' at point.
 
42
 
 
43
Stores data in kill ring"
 
44
  (interactive "*")
 
45
  (let ((erg (py--mark-base "paragraph")))
 
46
    (kill-region (car erg) (cdr erg))))
 
47
 
 
48
(defun py-kill-expression ()
 
49
  "Delete `expression' at point.
 
50
 
 
51
Stores data in kill ring"
 
52
  (interactive "*")
 
53
  (let ((erg (py--mark-base "expression")))
 
54
    (kill-region (car erg) (cdr erg))))
 
55
 
 
56
(defun py-kill-partial-expression ()
 
57
  "Delete `partial-expression' at point.
 
58
 
 
59
Stores data in kill ring"
 
60
  (interactive "*")
 
61
  (let ((erg (py--mark-base "partial-expression")))
 
62
    (kill-region (car erg) (cdr erg))))
 
63
 
 
64
(defun py-kill-top-level ()
 
65
  "Delete `top-level' at point.
 
66
 
 
67
Stores data in kill ring"
 
68
  (interactive "*")
 
69
  (let ((erg (py--mark-base "top-level")))
 
70
    (kill-region (car erg) (cdr erg))))
 
71
 
32
72
(defun py-kill-block ()
33
 
  "Delete `block' at point.
 
73
  "Delete block at point.
34
74
 
35
 
Stores data in kill ring"
 
75
Stores data in kill ring. Might be yanked back using `C-y'. "
36
76
  (interactive "*")
37
 
  (let ((erg (py--mark-base "block")))
 
77
  (let ((erg (py--mark-base-bol "block")))
38
78
    (kill-region (car erg) (cdr erg))))
39
79
 
40
80
(defun py-kill-block-or-clause ()
41
 
  "Delete `block-or-clause' at point.
 
81
  "Delete block-or-clause at point.
42
82
 
43
 
Stores data in kill ring"
 
83
Stores data in kill ring. Might be yanked back using `C-y'. "
44
84
  (interactive "*")
45
 
  (let ((erg (py--mark-base "block-or-clause")))
 
85
  (let ((erg (py--mark-base-bol "block-or-clause")))
46
86
    (kill-region (car erg) (cdr erg))))
47
87
 
48
88
(defun py-kill-class ()
49
 
  "Delete `class' at point.
 
89
  "Delete class at point.
50
90
 
51
 
Stores data in kill ring"
 
91
Stores data in kill ring. Might be yanked back using `C-y'. "
52
92
  (interactive "*")
53
 
  (let ((erg (py--mark-base "class")))
 
93
  (let ((erg (py--mark-base-bol "class")))
54
94
    (kill-region (car erg) (cdr erg))))
55
95
 
56
96
(defun py-kill-clause ()
57
 
  "Delete `clause' at point.
 
97
  "Delete clause at point.
58
98
 
59
 
Stores data in kill ring"
 
99
Stores data in kill ring. Might be yanked back using `C-y'. "
60
100
  (interactive "*")
61
 
  (let ((erg (py--mark-base "clause")))
 
101
  (let ((erg (py--mark-base-bol "clause")))
62
102
    (kill-region (car erg) (cdr erg))))
63
103
 
64
104
(defun py-kill-def ()
65
 
  "Delete `def' at point.
 
105
  "Delete def at point.
66
106
 
67
 
Stores data in kill ring"
 
107
Stores data in kill ring. Might be yanked back using `C-y'. "
68
108
  (interactive "*")
69
 
  (let ((erg (py--mark-base "def")))
 
109
  (let ((erg (py--mark-base-bol "def")))
70
110
    (kill-region (car erg) (cdr erg))))
71
111
 
72
112
(defun py-kill-def-or-class ()
73
 
  "Delete `def-or-class' at point.
 
113
  "Delete def-or-class at point.
74
114
 
75
 
Stores data in kill ring"
 
115
Stores data in kill ring. Might be yanked back using `C-y'. "
76
116
  (interactive "*")
77
 
  (let ((erg (py--mark-base "def-or-class")))
 
117
  (let ((erg (py--mark-base-bol "def-or-class")))
78
118
    (kill-region (car erg) (cdr erg))))
79
119
 
80
120
(defun py-kill-elif-block ()
81
 
  "Delete `elif-block' at point.
 
121
  "Delete elif-block at point.
82
122
 
83
 
Stores data in kill ring"
 
123
Stores data in kill ring. Might be yanked back using `C-y'. "
84
124
  (interactive "*")
85
 
  (let ((erg (py--mark-base "elif-block")))
 
125
  (let ((erg (py--mark-base-bol "elif-block")))
86
126
    (kill-region (car erg) (cdr erg))))
87
127
 
88
128
(defun py-kill-else-block ()
89
 
  "Delete `else-block' at point.
 
129
  "Delete else-block at point.
90
130
 
91
 
Stores data in kill ring"
 
131
Stores data in kill ring. Might be yanked back using `C-y'. "
92
132
  (interactive "*")
93
 
  (let ((erg (py--mark-base "else-block")))
 
133
  (let ((erg (py--mark-base-bol "else-block")))
94
134
    (kill-region (car erg) (cdr erg))))
95
135
 
96
136
(defun py-kill-except-block ()
97
 
  "Delete `except-block' at point.
 
137
  "Delete except-block at point.
98
138
 
99
 
Stores data in kill ring"
 
139
Stores data in kill ring. Might be yanked back using `C-y'. "
100
140
  (interactive "*")
101
 
  (let ((erg (py--mark-base "except-block")))
 
141
  (let ((erg (py--mark-base-bol "except-block")))
102
142
    (kill-region (car erg) (cdr erg))))
103
143
 
104
144
(defun py-kill-expression ()
105
 
  "Delete `expression' at point.
 
145
  "Delete expression at point.
106
146
 
107
 
Stores data in kill ring"
 
147
Stores data in kill ring. Might be yanked back using `C-y'. "
108
148
  (interactive "*")
109
 
  (let ((erg (py--mark-base "expression")))
 
149
  (let ((erg (py--mark-base-bol "expression")))
110
150
    (kill-region (car erg) (cdr erg))))
111
151
 
112
152
(defun py-kill-for-block ()
113
 
  "Delete `for-block' at point.
 
153
  "Delete for-block at point.
114
154
 
115
 
Stores data in kill ring"
 
155
Stores data in kill ring. Might be yanked back using `C-y'. "
116
156
  (interactive "*")
117
 
  (let ((erg (py--mark-base "for-block")))
 
157
  (let ((erg (py--mark-base-bol "for-block")))
118
158
    (kill-region (car erg) (cdr erg))))
119
159
 
120
160
(defun py-kill-if-block ()
121
 
  "Delete `if-block' at point.
122
 
 
123
 
Stores data in kill ring"
124
 
  (interactive "*")
125
 
  (let ((erg (py--mark-base "if-block")))
 
161
  "Delete if-block at point.
 
162
 
 
163
Stores data in kill ring. Might be yanked back using `C-y'. "
 
164
  (interactive "*")
 
165
  (let ((erg (py--mark-base-bol "if-block")))
 
166
    (kill-region (car erg) (cdr erg))))
 
167
 
 
168
(defun py-kill-indent ()
 
169
  "Delete indent at point.
 
170
 
 
171
Stores data in kill ring. Might be yanked back using `C-y'. "
 
172
  (interactive "*")
 
173
  (let ((erg (py--mark-base-bol "indent")))
126
174
    (kill-region (car erg) (cdr erg))))
127
175
 
128
176
(defun py-kill-minor-block ()
129
 
  "Delete `minor-block' at point.
130
 
 
131
 
Stores data in kill ring"
132
 
  (interactive "*")
133
 
  (let ((erg (py--mark-base "minor-block")))
134
 
    (kill-region (car erg) (cdr erg))))
135
 
 
136
 
(defun py-kill-partial-expression ()
137
 
  "Delete `partial-expression' at point.
138
 
 
139
 
Stores data in kill ring"
140
 
  (interactive "*")
141
 
  (let ((erg (py--mark-base "partial-expression")))
142
 
    (kill-region (car erg) (cdr erg))))
143
 
 
144
 
(defun py-kill-section ()
145
 
  "Delete `section' at point.
146
 
 
147
 
Stores data in kill ring"
148
 
  (interactive "*")
149
 
  (let ((erg (py--mark-base "section")))
 
177
  "Delete minor-block at point.
 
178
 
 
179
Stores data in kill ring. Might be yanked back using `C-y'. "
 
180
  (interactive "*")
 
181
  (let ((erg (py--mark-base-bol "minor-block")))
150
182
    (kill-region (car erg) (cdr erg))))
151
183
 
152
184
(defun py-kill-statement ()
153
 
  "Delete `statement' at point.
 
185
  "Delete statement at point.
154
186
 
155
 
Stores data in kill ring"
 
187
Stores data in kill ring. Might be yanked back using `C-y'. "
156
188
  (interactive "*")
157
 
  (let ((erg (py--mark-base "statement")))
 
189
  (let ((erg (py--mark-base-bol "statement")))
158
190
    (kill-region (car erg) (cdr erg))))
159
191
 
160
192
(defun py-kill-top-level ()
161
 
  "Delete `top-level' at point.
 
193
  "Delete top-level at point.
162
194
 
163
 
Stores data in kill ring"
 
195
Stores data in kill ring. Might be yanked back using `C-y'. "
164
196
  (interactive "*")
165
 
  (let ((erg (py--mark-base "top-level")))
 
197
  (let ((erg (py--mark-base-bol "top-level")))
166
198
    (kill-region (car erg) (cdr erg))))
167
199
 
168
200
(defun py-kill-try-block ()
169
 
  "Delete `try-block' at point.
170
 
 
171
 
Stores data in kill ring"
172
 
  (interactive "*")
173
 
  (let ((erg (py--mark-base "try-block")))
174
 
    (kill-region (car erg) (cdr erg))))
175
 
 
176
 
(defun py-kill-block-bol ()
177
 
  "Delete block bol at point.
178
 
 
179
 
Stores data in kill ring. Might be yanked back using `C-y'. "
180
 
  (interactive "*")
181
 
  (let ((erg (py--mark-base-bol "block")))
182
 
    (kill-region (car erg) (cdr erg))))
183
 
 
184
 
(defun py-kill-clause-bol ()
185
 
  "Delete clause bol at point.
186
 
 
187
 
Stores data in kill ring. Might be yanked back using `C-y'. "
188
 
  (interactive "*")
189
 
  (let ((erg (py--mark-base-bol "block")))
190
 
    (kill-region (car erg) (cdr erg))))
191
 
 
192
 
(defun py-kill-block-or-clause-bol ()
193
 
  "Delete block-or-clause bol at point.
194
 
 
195
 
Stores data in kill ring. Might be yanked back using `C-y'. "
196
 
  (interactive "*")
197
 
  (let ((erg (py--mark-base-bol "block")))
198
 
    (kill-region (car erg) (cdr erg))))
199
 
 
200
 
(defun py-kill-def-bol ()
201
 
  "Delete def bol at point.
202
 
 
203
 
Stores data in kill ring. Might be yanked back using `C-y'. "
204
 
  (interactive "*")
205
 
  (let ((erg (py--mark-base-bol "block")))
206
 
    (kill-region (car erg) (cdr erg))))
207
 
 
208
 
(defun py-kill-class-bol ()
209
 
  "Delete class bol at point.
210
 
 
211
 
Stores data in kill ring. Might be yanked back using `C-y'. "
212
 
  (interactive "*")
213
 
  (let ((erg (py--mark-base-bol "block")))
214
 
    (kill-region (car erg) (cdr erg))))
215
 
 
216
 
(defun py-kill-def-or-class-bol ()
217
 
  "Delete def-or-class bol at point.
218
 
 
219
 
Stores data in kill ring. Might be yanked back using `C-y'. "
220
 
  (interactive "*")
221
 
  (let ((erg (py--mark-base-bol "block")))
222
 
    (kill-region (car erg) (cdr erg))))
223
 
 
224
 
(defun py-kill-if-block-bol ()
225
 
  "Delete if-block bol at point.
226
 
 
227
 
Stores data in kill ring. Might be yanked back using `C-y'. "
228
 
  (interactive "*")
229
 
  (let ((erg (py--mark-base-bol "block")))
230
 
    (kill-region (car erg) (cdr erg))))
231
 
 
232
 
(defun py-kill-try-block-bol ()
233
 
  "Delete try-block bol at point.
234
 
 
235
 
Stores data in kill ring. Might be yanked back using `C-y'. "
236
 
  (interactive "*")
237
 
  (let ((erg (py--mark-base-bol "block")))
238
 
    (kill-region (car erg) (cdr erg))))
239
 
 
240
 
(defun py-kill-minor-block-bol ()
241
 
  "Delete minor-block bol at point.
242
 
 
243
 
Stores data in kill ring. Might be yanked back using `C-y'. "
244
 
  (interactive "*")
245
 
  (let ((erg (py--mark-base-bol "block")))
246
 
    (kill-region (car erg) (cdr erg))))
247
 
 
248
 
(defun py-kill-for-block-bol ()
249
 
  "Delete for-block bol at point.
250
 
 
251
 
Stores data in kill ring. Might be yanked back using `C-y'. "
252
 
  (interactive "*")
253
 
  (let ((erg (py--mark-base-bol "block")))
254
 
    (kill-region (car erg) (cdr erg))))
255
 
 
256
 
(defun py-kill-top-level-bol ()
257
 
  "Delete top-level bol at point.
258
 
 
259
 
Stores data in kill ring. Might be yanked back using `C-y'. "
260
 
  (interactive "*")
261
 
  (let ((erg (py--mark-base-bol "block")))
262
 
    (kill-region (car erg) (cdr erg))))
263
 
 
264
 
(defun py-kill-statement-bol ()
265
 
  "Delete statement bol at point.
266
 
 
267
 
Stores data in kill ring. Might be yanked back using `C-y'. "
268
 
  (interactive "*")
269
 
  (let ((erg (py--mark-base-bol "block")))
 
201
  "Delete try-block at point.
 
202
 
 
203
Stores data in kill ring. Might be yanked back using `C-y'. "
 
204
  (interactive "*")
 
205
  (let ((erg (py--mark-base-bol "try-block")))
270
206
    (kill-region (car erg) (cdr erg))))
271
207
 
272
208
(provide 'python-components-kill-forms)