Програмиране с Ruby

Курс във Факултета по Математика и Информатика към СУ

Abomination

Краен срок
21.12.2012 12:00

Срокът за предаване на решения е отминал

Да се напише клас Abomination, който да има следното поведение:

Конструкторът му приема непразен списък от обекти (винаги ще бъде подаден поне един обект):

a = Abomination.new 5, 'foo', [1, 2], :bar

Инстанциите на класа Abomination трябва да отговарят на всички методи, на които отговарят подадените при конструиране обекти:

a.abs           # => 5     (от 5.abs)
a.gsub 'o', 'a' # => 'faa' (от 'foo'.gsub 'o', 'a')
a.join ','      # => "1,2" (от [1, 2].join ',')

Ако един метод го има в няколко обекта, то превес взима обектът, който е по-напред в списъка:

a.to_s # => '5' (от 5.to_s)
a.length # => 3   (от 'foo'.length)

Ако поисканият метод го няма никъде, то се вдига NoMethodError:

a.foo # NoMethodError: undefined method `foo' for a:Abomination

Освен това, предефинирайте is_a? метода, така че Abomination обектите да се представят като всеки от подадените обекти:

a.is_a? Fixnum      # => true
a.is_a? String      # => true
a.is_a? Symbol      # => true
a.is_a? Float       # => false
a.is_a? Abomination # => true

Предполагам, че няма нужда да се казва, че такива извращения в реална система много рядко са смислена идея. Като toy example обаче са супер :-)

Hint: Тъй като по същество Abomination е proxy, чудесна идея е да наследява от BasicObject, за да има по-малко пречкащи ви се методи:

class Abomination < BasicObject
  # ...
end

Решения

Станислав Гатев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Станислав Гатев
class Abomination < BasicObject
def initialize(*objects)
@objects = objects
end
def class
(class << self; self end).superclass
end
def method_missing(name, *args, &block)
@objects.each do |object|
return object.send(name, *args, &block) if object.respond_to? name
end
super(name, *args, &block)
end
def is_a?(clazz)
self.class == clazz or @objects.any? { |object| object.is_a? clazz }
end
end
Александър Иванов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Александър Иванов
class Abomination < BasicObject
def initialize(*bases)
@bases = bases
end
def method_missing(name, *args)
method = @bases.find { |base| base.respond_to? name.to_sym }
if method
method.send name, *args
else
::Kernel::raise ::Exception::NoMethodError.new(
"undefined method '#{name}' of an instance of Abomination")
end
end
def object_id
@bases[0].object_id
end
def is_a?(klass)
klass >= ::Abomination or @bases.any? { |base| klass === base }
end
end
Ангел Николов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Ангел Николов
class Abomination < BasicObject
def initialize(*objects)
@objects = objects
end
def is_a?(type)
type == ::Abomination or @objects.map { |obj| obj.is_a? type }.any?
end
def method_missing(method_name, *args, &block)
recipient = @objects.detect { |obj| obj.respond_to? method_name }
unless recipient.nil?
recipient.send method_name, *args, &block
else
super
end
end
end
Николай Димитров
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Николай Димитров
class Abomination < BasicObject
def initialize(*objects)
@objects = objects
end
def method_missing(name, *args, &block)
receiver = @objects.drop_while { |object| !object.respond_to? name }[0]
if receiver.nil?
super
else
receiver.send(name, *args, &block)
end
end
def is_a?(class_name)
@objects.any? { |object| object.is_a? class_name } or class_name.to_s == "Abomination"
end
end
Елена Денева
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Елена Денева
class Abomination < BasicObject
attr_accessor :arg
def initialize *arg
@arg = arg
end
def method_missing(name, *arg, &block)
el = @arg.select { |x| x.respond_to? name }
raise NoMethodError, " undefined method" unless el
el[0].send(name, *arg, &block)
end
def is_a? a
return true if a >= ::Abomination
@arg.map { |x| return true if x.is_a?(a) }
false
end
end
Живко Чобанов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Живко Чобанов
class TestBonus5 < MiniTest::Unit::TestCase
def abomination_example
Abomination.new 5, 'foo', [1, 2], :bar
end
def test_method_missig
assert_equal 5, abomination_example.abs
assert_equal 'faa', abomination_example.gsub('o', 'a')
assert_equal '1,2', abomination_example.join(',')
assert_equal '5', abomination_example.to_s
assert_equal 3, abomination_example.length
assert_raises(NoMethodError) { abomination_example.foo }
end
def test_is_a
assert abomination_example.is_a? Fixnum
assert abomination_example.is_a? String
assert abomination_example.is_a? Symbol
refute abomination_example.is_a? Float
assert abomination_example.is_a? Abomination
end
def test_respond_to
refute abomination_example.respond_to?(:sdfvdsv)
assert abomination_example.respond_to?(:abs)
end
end
class Abomination < BasicObject
def initialize(*objects)
@objects = objects
end
def method_missing(name, *args, &block)
@objects.each do |obj|
return obj.public_send(name, *args, &block) if obj.respond_to? name
end
raise @objects.first.NoMethodError
false
end
def is_a?(class_name)
if class_name.to_s == 'Abomination' then return true end
@objects.each do |obj|
if obj.is_a? class_name then return true end
end
false
end
def respond_to_missing?(method_name, include_private)
@objects.each do |obj|
return true if obj.respond_to? method_name
end
false
end
def respond_to?(method_name, include_private = false)
respond_to_missing?(method_name, include_private)
end
end
Николай Колев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Николай Колев
class Abomination < BasicObject
def initialize(*objects)
@objects = objects
end
def method_missing(method_name, *args, &block)
object = @objects.find { |o| o.respond_to?(method_name) }
if object.nil?
::Kernel::raise ::Kernel.const_get(:NoMethodError)
end
object.send(method_name, *args, &block)
end
def is_a?(type)
type.to_s == "Abomination" or @objects.any? { |o| o.is_a?(type) }
end
end
Свилен Андонов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Свилен Андонов
class Abomination < BasicObject
attr_accessor :value
def initialize *value
@value = value
end
def raise
::Kernel::raise ::Object.const_get(:NoMethodError)
end
def method_missing(name, *args , &block)
@value.each do |element|
return element.send(name,*args) if element.respond_to? name
end
raise
end
def is_a? type
@value.each do |element|
return true if element.send(:is_a?,type)
end
type.to_s == "Abomination"
end
end
Явор Лилянов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Явор Лилянов
class Abomination < BasicObject
def initialize(list)
@list = list
end
def method_missing(name, *args, &block)
@list.each do |item|
return item.send(name, *args, &block) if item.respond_to? name
end
super
end
def is_a?(class_name)
@list.each do |item|
return true if item.is_a? class_name
end
false
end
end
Изабела Недялкова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Изабела Недялкова
class Abomination < BasicObject
def initialize(*objects)
@objects = objects
end
def method_missing(method, *args, &block)
@objects.each do |object|
return object.send method, *args, &block if object.respond_to? method
end
super method, *args, &block
end
def is_a?(object_class)
return true if object_class >= ::Abomination
@objects.any? { |object| object.is_a? object_class }
end
end
Милан Миланов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Милан Миланов
class Abomination < BasicObject
def initialize(*objects)
@objects = objects
end
def method_missing(method, *arguments, &block)
object = @objects.find { |object| object.respond_to?(method.to_sym) }
object.nil? ? super : object.send(method, *arguments, &block)
end
def is_a?(class_name)
return true if class_name == ::Abomination
@objects.any? { |object| object.class == class_name }
end
end
Теодор Илиев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Теодор Илиев
class Abomination < BasicObject
def initialize(first, *rest)
@objects = rest
@objects.insert 0, first
end
def method_missing(name, *args, &block)
@objects.select { |object| object.respond_to? name }.each do |object|
if arity_responding? object.method(name).arity, args.size
return object.send(name, *args, &block)
end
end
::Kernel.raise ::NoMethodError
end
def is_a?(clazz)
@objects.any? { |object| object.is_a? clazz } || clazz.name == 'Abomination'
end
alias :kind_of? :is_a?
private
def arity_responding?(method_arity, args_length)
if method_arity >= 0
return true if args_length == method_arity
else
return true if method_arity.abs - 1 <= args_length
end
return false
end
end
Филарета Йорданова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Филарета Йорданова
class Abomination < BasicObject
TYPE = /\bAbomination\b/
def initialize(*array)
@array = array
end
def method_missing(name, *args, &block)
result = @array.detect{ |item| item.respond_to? name }
result ? result.send(name, *args, &block) : super
end
def is_a?(type)
@array.each { |item| return true if item.is_a? type }
if type.to_s =~ TYPE
true
else
false
end
end
end
Стоян Стоянов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Стоян Стоянов
class Abomination < BasicObject
attr_accessor :list_of_arguments
def initialize(first_argument,*list)
@list_of_arguments = list
@list_of_arguments.insert(0,first_argument)
end
def method_missing(method_name, *args, &block)
@list_of_arguments.each do |el|
if el.respond_to?(method_name)
return el.send(method_name, *args, &block)
end
end
super
end
def is_a? class_name
return true if class_name.name == 'Abomination'
@list_of_arguments.any? { |el| el.is_a? class_name }
end
end
Мартин Попов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Мартин Попов
class Abomination < BasicObject
def initialize(*objects)
@objects = objects
end
def method_missing(name, *args, &block)
@objects.each do |object|
if object.respond_to?(name)
return object.send(name, *args, &block)
end
end
::Kernel.raise ::NoMethodError
end
def is_a?(a_class)
ancestors_array = @objects.map(&:class).map(&:ancestors).flatten
ancestors_array << ::Object.const_get('Abomination')
ancestors_array.member? a_class
end
end
Нели Хатева
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Нели Хатева
# encoding: utf-8
class Abomination < BasicObject
def initialize(*array_of_objects)
@array_of_objects = *array_of_objects
end
def method_missing(name, *args, &block)
object = @array_of_objects.find { |object| object.respond_to? name }
object.send(name, *args, &block)
end
def is_a?(some_class)
@array_of_objects.map { |object| object.class}.include? some_class or \
some_class.to_s == "Abomination"
end
end
Кирчо Кирев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Кирчо Кирев
class Abomination < BasicObject
Abomination = self
def initialize(*elements)
@elements = elements
end
def method_missing(name, *args, &block)
responding_elements = @elements.select { |element| element.respond_to? name }
if responding_elements.empty?
super
else
responding_elements.first.send name, *args, &block
end
end
def is_a?(other)
other == Abomination or @elements.any? { |element| element.is_a? other }
end
end
Атанас Пройчев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Атанас Пройчев
class Abomination < BasicObject
def initialize(*args)
@objects = args
end
def method_missing(name, *args, &block)
items_that_have_method = @objects.select { |item| item.methods.include? name }
if items_that_have_method.empty?
super
else
items_that_have_method[0].send(name, *args, &block)
end
end
def is_a? something
@objects.each { |item| return true if item.is_a? something }
something.to_s == 'Abomination'
end
end
Йордан Петров
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Йордан Петров
class Abomination < BasicObject
def initialize(*arguments)
@arguments = arguments
end
def method_missing(method, *args, &block)
if @arguments.none? { |argument| argument.respond_to? method } then super
else @arguments.select { |argument| argument.respond_to? method }.
first.send(method, *args, &block)
end
end
def respond_to?(method)
if @arguments.none? { |argument| argument.respond_to? method } then super
else true
end
end
def is_a?(type)
type.to_s == 'Abomination' or @arguments.any? { |argument| argument.is_a? type }
end
end
Пламен Тотев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Пламен Тотев
class Abomination < BasicObject
def initialize(*objects_list)
@objects_list = objects_list
end
def method_missing(method_name, *args, &block)
object_to_resond = @objects_list.find { |obj| obj.respond_to? method_name }
::Kernel.raise ::NoMethodError if !object_to_resond
object_to_resond.send method_name, *args, &block
end
def is_a?(type)
@objects_list.any? { |obj| type == ::Abomination || obj.is_a?(type) }
end
end
Орлин Христов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Орлин Христов
class Abomination
def initialize(*body_parts)
@body_parts = body_parts
end
def method_missing(name, *args, &block)
begin
super
rescue NoMethodError
@body_parts.each { |body_part| return body_part.public_send name, *args, &block if body_part.respond_to? name }
raise
end
end
def is_a?(class_)
super or @body_parts.any? { |body_part| body_part.is_a? class_ }
end
end
Георги Гърдев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Георги Гърдев
class Abomination < BasicObject
def initialize(*objects)
@objects = objects
end
def is_a? (type)
return true if type.to_s == "Abomination"
not @objects.detect{ |i| i.is_a? type }.nil?
end
def method_missing(m, *args, &block)
@objects.find{ |i| i.respond_to? m }.send(m, *args)
end
end
Петър Костов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Петър Костов
class Abomination < BasicObject
def self.const_missing(name)::Object.const_get(name)
end
def initialize(*objects)
@objects = objects
end
def method_missing(name, *args, &block)
first_object = @objects.detect { |object| object.respond_to? name }
first_object ? first_object.send(name, *args, &block) : super
end
def is_a?(type)
@objects.any? { |object| object.is_a? type } or type == Abomination
end
def kind_of?(type)
is_a? type
end
end
Гергана Петрова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Гергана Петрова
class Abomination < BasicObject
attr_accessor :list_of_arguments
def initialize(*arguments)
@list_of_arguments = *arguments
end
def method_missing(method_name, *args, &block)
if respond_to_missing(method_name)
list_of_arguments.find { |argument| argument.respond_to? method_name }.send(method_name, *args, &block)
else
raise NoMethodError.new "undefined method #{method_name} for #{self}:Abomination"
end
end
def respond_to_missing(method_name, include_method = true)
list_of_arguments.any? { |argument| argument.respond_to? method_name }
end
def is_a?(klass)
list_of_arguments.any? { |argument| argument.is_a? klass }
end
end
Михаил Жеков
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Михаил Жеков
class Abomination
def initialize *array
@array = array
end
def method_missing method, *args, &block
@array.each do |x|
begin
puts x.send(method, *args, &block)
return
rescue
end
end
raise NoMethodError.new('NoMethodError', method, *args)
end
def is_a? class_type
result = false
@array.each { |x| result = true if x.send("is_a?", class_type) or class_type == Abomination }
result
end
end
Илиян Величков
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Илиян Величков
class Abomination < BasicObject
def initialize(*objects)
@objects = objects
end
def method_missing(name, *args, &block)
object = @objects.find { |obj| obj.respond_to? name}
super if object.nil?
object.public_send name, *args, &block
end
def is_a?(klass)
__class__ == klass or @objects.any? { |object| object.is_a? klass }
end
def __class__
::Abomination
end
end
Чанита Иванова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Чанита Иванова
class Abomination < BasicObject
attr_accessor :array
def initialize(*array)
@array = array
end
def method_missing(name, *args, &block)
array.map{|x| return x.send(name, *args, &block) if(x.respond_to? name)}
return super
end
def is_a?(other)
array.map{|x| return true if(x.class == other)}
return true if(other.to_s == "Abomination")
false
end
end
Румен Палетов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Румен Палетов
class Abomination < BasicObject
def initialize(*objects)
@objects = objects
end
def method_missing(name, *args, &block)
object = @objects.detect { |i| i.respond_to?(name) }
if object != nil then object.send(name, *args, &block)
else raise super.NoMethodError
end
end
def is_a?(name)
name.to_s == "Abomination" or @objects.detect { |i| i.is_a?(name) } != nil
end
end
Виктория Христова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Виктория Христова
class Abomination
def initialize(*args)
@args = args
end
def is_a?(type)
not @args.select { |elem| elem.is_a? type }.empty? or type == Abomination
end
def method_missing(name, *arguments)
first = @args.select { |elem| elem.respond_to? name } .first
first ? first.send(name, *arguments) : NoMethodError.new("undefined method #{name} for Abomination", name)
end
end
Цвета Гергичанова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Цвета Гергичанова
class Abomination < BasicObject
def initialize(*arg)
@array = arg
end
def method_missing(name, *args, &block)
element = @array.find { |element| element.respond_to? name }
if element == nil
p "NoMethodError: undefind method #{name} for #{self}:Abomination"
else
case(args.size)
when 0
block != nil ? element.send(name, block) : element.send(name)
when 1
block != nil ? element.send(name, args[0], block) : element.send(name, args[0])
when 2
block != nil ? element.send(name, args[0], args[1], block) : element.send(name, args[0], args[1])
end
end
end
def is_a?(string)
@array.map { |element| element.is_a? string}.inject{ |a, b| a or b } or string.to_s == "Abomination"
end
end
Тихомир Янев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Тихомир Янев
class Abomination
def initialize(*args)
@unique_class_args = args.uniq { |element| element.class }
end
def method_missing(method_name, *args)
@unique_class_args.each do |element|
return element.send(method_name, *args) if element.public_methods.include? method_name
end
raise NoMethodError.new("NoMethodError: undefined method #{method_name} for #{inspect}:#{self.class}")
end
def is_a? (class_name)
! @unique_class_args.select { |element| element.class == class_name or element.class == self.class }.empty?
end
end
Йоана Тодорова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Йоана Тодорова
class Abomination
attr_accessor :values
def initialize(*values)
@values = *values
end
def is_a?(obj_class)
obj_class.to_s.eql? 'Abomination' or @values.any? { |obj| obj.is_a? obj_class }
end
def method_missing(name, *args, &block)
@values.map { |obj| return obj.send(name, *args) if obj.respond_to? name }
NoMethodError.new("no method")
end
end
Христо Владев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Христо Владев
class Abomination < BasicObject
def initialize(*objects)
@objects = objects
end
def is_a?(class_name)
class_name == ::Object::Abomination or
!!@objects.detect { |object| object.is_a? class_name }
end
def method_missing(method_name, *args, &block)
detected = @objects.detect { |object| object.respond_to? method_name }
detected ? detected.send(method_name, *args, &block) : super
end
end
Георги Георгиев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Георги Георгиев
class Abomination < BasicObject
def initialize (*mixture)
@mixture = mixture
end
def class
class << self
self.superclass
end
end
def method_missing(name, *args, &block)
super unless p = @mixture.find { |element| element.respond_to? name }
p.send(name, *args, &block)
end
def is_a?(constant)
self.class == constant or
@mixture.any? { |element| element.is_a? constant }
end
end
Елена Миронова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Елена Миронова
class Abomination
attr_accessor :objects
def initialize(*objects)
@objects = objects
end
def method_missing(name, *arg, &block)
@objects.each do |object|
return object.send(name, *arg) if (object.class.method_defined? name)
end
raise NoMethodError.new("undefined method '#{name}':Abomination")
end
def is_a? klass
@objects.each { |object| return true if (object.is_a? klass) }
return true if klass == Abomination
return false
end
end
Никола Таушанов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Никола Таушанов
class Abomination < BasicObject
def initialize(*objects)
@objects = objects
end
def method_missing(name, *arg, &block)
object = @objects.find { |x| x.respond_to? name }
return super if object.nil?
object.send(name, *arg, &block) if not object.nil?
end
def is_a?(type)
super || @objects.any? { |x| x.is_a?(type) }
end
end
Стоян Найденов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Стоян Найденов
class Abomination
def initialize(*objects)
@objects = objects
end
def method_missing(name, *args, &block)
@objects.each do |obj|
return obj.send(name, *args) if obj.respond_to?(name)
end
raise NoMethodError
end
def is_a?(argument)
@objects.any? {|obj| obj.is_a? argument} || argument === self
end
end