CSC 322.01, Class 39: Rethinking object-oriented design (6)

class A
  def initialize(args)
    puts "Initializing A"
  end

  def speak
    "eh"
  end
end

class B < A
  def initialize (args)
    puts "Initializing B"
    super
  end
     
  def speak
    "be"
  end

  # ...
  def something
    # I want to call the speak method from my superclass
    A.speak  #no
  end
end

class Super
  def flies
    true
  end
end

class Uber
  def flies
    ["fruit", "horse"]
  end
end

class Sub < Super, Uber
end

s = Sub.new
s.flies

public class Point {
  double x;
  double y;

  public void hshift(double amt) {
    x += amt;
  }
}

public class AlphabetEncoding {
  int a = 1;
  int b = 2;
  ...
  int x = 24;
  int y = 25;
  int z = 26;
}

public class Insane extends Point extends AlphabetEncoding {
  ...
}

class Point
  attr_reader :x, :y

  def initialize
    @x = 0
    @y = 0
  end

  def hshift(amt)
    @x += amt
  end
end

class AlphabetEncoding
  attr_reader :a, :b, :c, ...., :x, :y, :z
  def initialize
    @a = 1;
    @b = 2;
    ...
    @x = 24;
    @y = 25;
    @z = 26;
  end
end

class Stupid < Point, AlphabetEncoding
end

module Tom
  def describe
    "American Actor"
  end
end

module Chex
  def describe
    ["wheat chex", "pretzels", "bagel chips", "extra gluten"]
  end
end

class Mixup
  include Tom
  include Chex
end

class AlphabetEncoding
  def valid(sym)
    sym.length == 1 and "a" <= sym.to_s and sym.to_s <= "z"
  end

  def respond_to_missing?(method)
    valid method
  end

  def method_missing(method, *args, &block)
    if valid method
      1 + (method.to_s.ord - "a".ord)
    else
      super
    end
  end
end

class Schedule
  def scheduled?(schedulable, start_date, end_date)
    puts "This #{schedulable.class} " +
         "is not scheduled\n" +
         "  between #{start_date} and #{end_date}"
    false
  end
end

module Schedulable
  attr_writer :schedule

  def schedule
    @schedule ||= ::Schedule.new
  end

  def schedulable?(start_date, end_date)
    !scheduled?(start_date - lead_days, end_date)
  end

  def scheduled?(start_date, end_date)
    schedule.scheduled?(self, start_date, end_date)
  end

  # includers may override
  def lead_days
    0
  end

end

class Vehicle
  include Schedulable

  def lead_days
    3
  end

  # ...
end

class Mechanic
  include Schedulable

  def lead_days
    4
  end

  # ...
end

require 'date'
starting = Date.parse("2015/09/04")
ending   = Date.parse("2015/09/10")

v = Vehicle.new
v.schedulable?(starting, ending)
# Note: schedulable? calls scheduled with self as the first parameter,
#   which calls scheduled in the Schedule class, which takes
#   start_date and end_date as parameters.
#   puts "This #{schedulable.class} " +
#        "is not scheduled\n" +
#        "  between #{start_date} and #{end_date}"
# I expect to see
#   This Vehicle is not scheduled 
#     between 2015-09-01 and 2015-09-10
# Metz shows us
# This Vehicle is not scheduled
#   between 2015-09-01 and 2015-09-10
#  => true

m = Mechanic.new
m.schedulable?(starting, ending)
# I expect to see
#   This Mechanic is not scheduled 
#     between 2015-08-31 and 2015-09-10
# This Mechanic is not scheduled
#   between 2015-02-29 and 2015-09-10
# Whoops!  There wasn't a February 29, 2015
#  => true

module Schedulable
  attr_writer :schedule

module Mutate
  attr_writer :x
end

class Thing
  include Mutate
end

t = Thing.new
t.x = 5 # Okay, even if not the intent of THing
t.y = 5 # Not okay, not defined
t.x # Not okay, not defined
t.y # Not okay, not defined

class Bicycle
  attr_reader :size, :chain, :tire_size

  def initialize(args={})
    @size       = args[:size]
    @chain      = args[:chain]     || default_chain
    @tire_size  = args[:tire_size] || default_tire_size
    post_initialize(args)
  end

  def spares
    { tire_size: tire_size,
      chain:     chain}.merge(local_spares)
  end

  def default_tire_size
    raise NotImplementedError
  end

  # subclasses may override
  def post_initialize(args)
    nil
  end

  def local_spares
    {}
  end

  def default_chain
    '10-speed'
  end

end

class RoadBike < Bicycle
  attr_reader :tape_color

  def post_initialize(args)
    @tape_color = args[:tape_color]
  end

  def local_spares
    {tape_color: tape_color}
  end

  def default_tire_size
    '23'
  end
end

class MountainBike < Bicycle
  attr_reader :front_shock, :rear_shock

  def post_initialize(args)
    @front_shock = args[:front_shock]
    @rear_shock =  args[:rear_shock]
  end

  def local_spares
    {rear_shock:  rear_shock}
  end

  def default_tire_size
    '2.1'
  end
end

class RecumbentBike < Bicycle
  attr_reader :flag

  def post_initialize(args)
    @flag = args[:flag]
  end

  def local_spares
    {flag: flag}
  end

  def default_chain
    '9-speed'
  end

  def default_tire_size
    '28'
  end
end

module A
  def comment
    '#{@user} says "eh"'
  end
end

module B
  def comment
    'Where can #{@user} be?'
  end
end

class C
  include A
  include B
  def initialize(name = "Sam")
    @user = name
  end

  def both
    A::instance_method(:comment).bind(self).call + "\n" + 
    B::instance_method(:comment).bind(self).call
  end
end

module Flag
  def post_initialize(args)
    puts "Flag"
  end
  def announce
    "Flag me down!"
  end
end

module Shocks
  def post_initialize(args)
    puts "Shocks"
  end
  def announce
    "So shocking!"
  end
end

class Bicycle
  def initialize(args)
    # Get the list of included modules (which I'm calling the parts)
    @parts = self.class.included_modules
    @parts.delete(Kernel)

    @parts.each do |part|
      if part.instance_methods.include?(:post_initialize) then
        part.instance_method(:post_initialize).bind(self).call(args)
      end
    end
  end

  # Override!
  def local_parts
    []
  end

  # Override
  def post_initialize(args)
  end
end

class RecumbentMountainBike < Bicycle
  include Flag
  include Shocks
end