Class: DeepConnect::MethodSpec

Inherits:
Object
  • Object
show all
Extended by:
Exception2MessageMapper
Defined in:
lib/deep-connect/class-spec-space.rb

Defined Under Namespace

Classes: ArgSpecs, DValParamSpec, DefaultParamSpec, ParamSpec, RefParamSpec, TkIdentifier, Token, Tokener, ValParamSpec

Constant Summary collapse

ARG_SPEC =

*****method が記号の時できてない

["DEFAULT", "REF", "VAL", "DVAL"]
Name2ParamSpec = 
{
  "DEFAULT"=>DefaultParamSpec,
  "REF" => RefParamSpec,
  "VAL" => ValParamSpec,
  "DVAL" => DValParamSpec
}
TkMULT = 
"*"
TkLPAREN = 
"("
TkLBRACE = 
"{"
TkRPAREN = 
")"
TkRBRACE = 
"}"
TkCOMMA = 
","

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ MethodSpec

Returns a new instance of MethodSpec.



202
203
204
205
206
207
208
209
210
 
# File 'lib/deep-connect/class-spec-space.rb', line 202

def initialize
  @rets = nil
  @method = nil
  @args = nil
  @block_rets = nil
  @block_args = nil

  @interface = nil
end

Instance Attribute Details

#args ⇒ Object

Returns the value of attribute args.



214
215
216
 
# File 'lib/deep-connect/class-spec-space.rb', line 214

def args
  @args
end

#block_args ⇒ Object

Returns the value of attribute block_args.



216
217
218
 
# File 'lib/deep-connect/class-spec-space.rb', line 216

def block_args
  @block_args
end

#block_rets ⇒ Object

Returns the value of attribute block_rets.



215
216
217
 
# File 'lib/deep-connect/class-spec-space.rb', line 215

def block_rets
  @block_rets
end

#interface ⇒ Object Also known as: interface?

Returns the value of attribute interface.



217
218
219
 
# File 'lib/deep-connect/class-spec-space.rb', line 217

def interface
  @interface
end

#method ⇒ Object

Returns the value of attribute method.



213
214
215
 
# File 'lib/deep-connect/class-spec-space.rb', line 213

def method
  @method
end

#rets ⇒ Object

Returns the value of attribute rets.



212
213
214
 
# File 'lib/deep-connect/class-spec-space.rb', line 212

def rets
  @rets
end

Class Method Details

.mkkey(receiver, method_name) ⇒ Object 



642
643
644
645
646
647
648
649
650
 
# File 'lib/deep-connect/class-spec-space.rb', line 642

def self.mkkey(receiver, method_name)
  if receiver.__deep_connect_reference?
	receiver.class.name+"#"+method_name.to_s
  elsif receiver.kind_of?(Class)
	receiver.name+"."+method_name.to_s
  else
	receiver.class.name+"#"+method_name.to_s
  end
end

.spec(spec) ⇒ Object

VALができるのは, Array, Hash のみ, Structは相手にも同一クラスがあれば可能



189
190
191
192
193
194
195
196
197
198
199
200
 
# File 'lib/deep-connect/class-spec-space.rb', line 189

def self.spec(spec)
  mspec = MethodSpec.new
  case spec
  when String
	mspec.parse(spec)
  when Hash
	mspec.direct_setting(spec)
  else
	raise "スペック指定は文字列もしくはキーワード指定です"
  end
  mspec
end

Instance Method Details

#arg_zip(args, &block) ⇒ Object 



276
277
278
279
280
281
282
283
284
 
# File 'lib/deep-connect/class-spec-space.rb', line 276

def arg_zip(args, &block)
  argspecs = ArgSpecs.new(@args)
  begin
	param_zip(argspecs, args, &block)
  rescue ArgumentError
	raise ArgumentError,
	  "argument spec mismatch args: #{@args}"
  end
end

#block_arg_zip(args, &block) ⇒ Object 



286
287
288
289
290
291
292
293
294
 
# File 'lib/deep-connect/class-spec-space.rb', line 286

def block_arg_zip(args, &block)
  argspecs = ArgSpecs.new(@block_args)
  begin
	param_zip(argspecs, args, &block)
  rescue ArgumentError
	raise ArgumentError,
	  "argument spec mismatch block args: #{@block_args}"
  end
end

#direct_setting(opts) ⇒ Object 



407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
 
# File 'lib/deep-connect/class-spec-space.rb', line 407

def direct_setting(opts)
  if opts[:rets]
	@rets = ParamSpec.param_specs(opts[:rets])
	if @rets.size == 1
	  @rets = @rets.first
	end
  end

  @method = opts[:method]
  @method = @method.intern unless @method.kind_of?(Symbol)

  if opts[:args]
	@args = ParamSpec.param_specs(opts[:args])
  end

  if opts[:block_rets]
	@block_rets = ParamSpec.param_specs(opts[:block_rets])
	if @block_rets.size == 1
	  @block_rets = @block_rets.first
	end
  end
  if opts[:block_args]
	@block_args = ParamSpec.param_specs(opts[:block_args])
  end
end

#has_block? ⇒ Boolean

Returns:

  • (Boolean) 


220
221
222
 
# File 'lib/deep-connect/class-spec-space.rb', line 220

def has_block? 
  @block_rets || @block_args 
end

#override(mspec) ⇒ Object 



224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
 
# File 'lib/deep-connect/class-spec-space.rb', line 224

def override(mspec)
  if mspec.rets
	@rets = mspec.rets
  end
  if mspec.args
	@args = mspec.args
  end
  if mspec.block_rets
	@block_rets = mspec.block.rets
  end
  if mspec.block_args
	@block_args = mspec.block_args
  end
  if mspec.interface
	@interface = mspec.interface
  end
end

#param_zip(arg_specs, args, &block) ⇒ Object 



296
297
298
299
300
301
302
303
304
305
306
 
# File 'lib/deep-connect/class-spec-space.rb', line 296

def param_zip(arg_specs, args, &block)
  ary = []
  args.each do |arg|
	spec = arg_specs.succ
	unless spec
	  raise ArgumentError
	end
	ary.push yield(spec, arg)
  end
  ary
end

#parse(spec) ⇒ Object

private method



434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
 
# File 'lib/deep-connect/class-spec-space.rb', line 434

def parse(spec)
  tokener = Tokener.new(spec)
  
  tk1, tk2 = tokener.next, tokener.peek
  tokener.unget tk1
  case tk1
  when TkIdentifier
	case tk2
	when nil
	when TkIdentifier, TkCOMMA, TkMULT
	  parse_rets(tokener, spec)
	when TkLPAREN, TkLBRACE
	else
	  MethodSpec.Raise UnrecognizedError, spec
	end
  when TkMULTI
	parse_rets(tokener, spec)
  else
	MethodSpec.Raise UnrecognizedError, spec
  end
  
  parse_method(tokener, spec)
  parse_args(tokener, spec)
  parse_block(tokener, spec)
end

#parse_args(tokener, spec) ⇒ Object 



477
478
479
480
481
482
483
484
485
486
487
488
489
 
# File 'lib/deep-connect/class-spec-space.rb', line 477

def parse_args(tokener, spec)
  tk = tokener.next
  case tk
  when TkLPAREN
	@args = parse_params(tokener, spec)
	tk2 = tokener.next
	unless tk2 == TkRPAREN
	  MethodSpec.Raise UnrecognizedError, tk2 + " in " +spec
	end
  else
	# パラメータなし
  end
end

#parse_block(tokener, spec) ⇒ Object 



491
492
493
494
495
496
497
498
499
500
501
502
 
# File 'lib/deep-connect/class-spec-space.rb', line 491

def parse_block(tokener, spec)
  parse_block_rets(tokener, spec)
  tk = tokener.peek
  unless tk == TkLBRACE
	if @block_rets
	  MethodSpec.Raise UnrecognizedError, "ブロック定義では`{'が必要です(#{tk.to_s}, #{spec})"
	else
	  return
	end
  end
  parse_block_args(tokener, spec)
end

#parse_block_args(tokener, spec) ⇒ Object 



513
514
515
516
517
518
519
520
521
522
523
524
525
526
 
# File 'lib/deep-connect/class-spec-space.rb', line 513

def parse_block_args(tokener, spec)
  tk = tokener.next
  case tk
  when TkLBRACE
	@block_args = parse_params(tokener, spec)
	@args = parse_params(tokener, spec)
	tk2 = tokener.next
	unless tk2 == TkRBRACE
	  MethodSpec.Raise UnrecognizedError, tk2 +" in " +spec
	end
  else
	# パラメータなし
  end
end

#parse_block_rets(tokner, spec) ⇒ Object 



504
505
506
507
508
509
510
511
 
# File 'lib/deep-connect/class-spec-space.rb', line 504

def parse_block_rets(tokner, spec)
  @block_rets = parse_params(tokner, spec)
  if @block_rets
	if @block_rets && @block_rets.size == 1
	  @block_rets = @block_rets.first
	end
  end
end

#parse_method(tokener, spec) ⇒ Object 



467
468
469
470
471
472
473
474
475
 
# File 'lib/deep-connect/class-spec-space.rb', line 467

def parse_method(tokener, spec)
  tk = tokener.next
  case tk
  when TkIdentifier
	@method = tk.name.intern
  else
	MethodSpec.Raise UnrecognizedError, tk.to_s+ " in " +spec
  end
end

#parse_params(tokener, spec) ⇒ Object 



528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
 
# File 'lib/deep-connect/class-spec-space.rb', line 528

def parse_params(tokener, spec)
  args = []
  while token = tokener.next
	case token
	when TkIdentifier
	  case tk2 = tokener.peek
	  when nil
 args.push ArgSpec.identifier(token)
 break
	  when TkMULT
 MethodSpec.Raise UnrecognizedError, token
	  when TkCOMMA
 tokener.next
 args.push ParamSpec.identifier(token)
	  when TkIdentifier, TkRPAREN, TkRBRACE
 args.push  ParamSpec.identifier(token)
 break
	  when TkLPAREN, TkLBRACE
 args.push ParamSpec.identifier(token)
 break
	  else
 MethodSpec.Raise UnrecognizedError, "不正な文字#{tk2}が入っています"
	  end
	when TkMULT
	  case token2 = tokener.next
	  when nil
 MethodSpec.Raise UnrecognizedError, "*で終わっています"
	  when TkIdentifier
 args.push  ParamSpec.identifier(token2, :mult)
 break
	  else
 MethodSpec.Raise UnrecognizedError, "*の後に#{token2}が入っています"
	  end
	else # TkRPAREN, TkRBRACE
	  tokener.unget token
	  break
	end
  end
  if args.empty?
	nil
  else
	args
  end
end

#parse_rets(tokener, spec) ⇒ Object 



460
461
462
463
464
465
 
# File 'lib/deep-connect/class-spec-space.rb', line 460

def parse_rets(tokener, spec)
  @rets = parse_params(tokener, spec)
  if @rets && @rets.size == 1
	@rets = @rets.first
  end
end

#rets_zip(rets, &block) ⇒ Object 



266
267
268
269
270
271
272
273
274
 
# File 'lib/deep-connect/class-spec-space.rb', line 266

def rets_zip(rets, &block)
  retspecs = ArgSpecs.new(@rets)
  begin
	param_zip(retspecs, rets, &block)
  rescue ArgumentError
	raise ArgumentError,
	  "argument spec mismatch rets: #{@rets}"
  end
end

#to_s ⇒ Object 



308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
 
# File 'lib/deep-connect/class-spec-space.rb', line 308

def to_s
  spec = ""
  case @rets
  when nil
  when Array
	spec.concat(@rets.join(", "))
	spec.concat(" ")
  when
	spec.concat(@rets.to_s)
	spec.concat(" ")
  end
  
  if @method
	spec.concat(@method.to_s)
  else
	spec.concat("(missing)")
  end
  if @args
	spec.concat("("+@args.join(", ")+")")
  end
  if has_block?
	if @block_rets
	  spec.concat(@block_rets.join(", "))
	end
	if @block_args
	  spec.concat("{"+@block_args.join(", ")+"}")
	else
	  spec.concat("{}")
	end
  end
  "#<#{self.class} #{spec} >"
end