Ruby模块与Mixin #

module MyModule
  CONSTANT = "value"

  def self.module_method
    "Module method"
  end

  def instance_method
    "Instance method"
  end
end

MyModule::CONSTANT
MyModule.module_method

module Graphics
  class Point
    attr_reader :x, :y

    def initialize(x, y)
      @x, @y = x, y
    end
  end

  class Rectangle
    attr_reader :width, :height

    def initialize(width, height)
      @width, @height = width, height
    end
  end
end

point = Graphics::Point.new(10, 20)
rect = Graphics::Rectangle.new(100, 200)

module App
  module Models
    class User
    end
  end

  module Controllers
    class UsersController
    end
  end
end

user = App::Models::User.new
controller = App::Controllers::UsersController.new

module Greeting
  def greet
    "Hello!"
  end
end

class Person
  include Greeting
end

person = Person.new
person.greet

module A
  def method_name
    "A"
  end
end

class B
  include A

  def method_name
    "B"
  end
end

B.new.method_name

class B
  def method_name
    super + " + B"
  end
end

B.new.method_name

module A
  def test
    "A"
  end
end

module B
  def test
    "B"
  end
end

class C
  include A
  include B
end

C.new.test
C.ancestors

module ClassMethods
  def class_method
    "Class method"
  end
end

class Person
  extend ClassMethods
end

Person.class_method

module Mixin
  def instance_method
    "Instance method"
  end

  module ClassMethods
    def class_method
      "Class method"
    end
  end
end

class Person
  include Mixin
  extend Mixin::ClassMethods
end

Person.class_method
Person.new.instance_method

module Mixin
  def instance_method
    "Instance method"
  end

  def self.included(base)
    base.extend(ClassMethods)
  end

  module ClassMethods
    def class_method
      "Class method"
    end
  end
end

class Person
  include Mixin
end

Person.class_method
Person.new.instance_method

module Override
  def greet
    "Override: " + super
  end
end

class Person
  prepend Override

  def greet
    "Hello!"
  end
end

Person.new.greet
Person.ancestors

module A
  def test
    "A -> " + super
  end
end

class B
  include A

  def test
    "B"
  end
end

B.new.test

class C
  prepend A

  def test
    "C"
  end
end

C.new.test

module Math
  module_function

  def square(n)
    n ** 2
  end

  def cube(n)
    n ** 3
  end
end

Math.square(5)
Math.cube(3)

class Calculator
  include Math
end

Calculator.new.square(4)

module Helper
  def public_method
    "Public"
  end

  module_function

  def utility_method
    "Utility"
  end
end

module Comparable
  def <(other)
    (self <=> other) < 0
  end

  def <=(other)
    (self <=> other) <= 0
  end

  def ==(other)
    (self <=> other) == 0
  end

  def >(other)
    (self <=> other) > 0
  end

  def >=(other)
    (self <=> other) >= 0
  end
end

class Point
  include Comparable

  attr_reader :x, :y

  def initialize(x, y)
    @x, @y = x, y
  end

  def <=>(other)
    [x, y] <=> [other.x, other.y]
  end
end

module Enumerable
  def map
    result = []
    each { |item| result << yield(item) }
    result
  end

  def select
    result = []
    each { |item| result << item if yield(item) }
    result
  end

  def reduce(initial = nil)
    accumulator = initial
    each do |item|
      accumulator = accumulator.nil? ? item : yield(accumulator, item)
    end
    accumulator
  end
end

module Loggable
  def log(message)
    puts "[#{self.class}] #{message}"
  end

  def self.included(base)
    base.extend(ClassMethods)
  end

  module ClassMethods
    def log_class(message)
      puts "[#{self}] #{message}"
    end
  end
end

class User
  include Loggable

  def save
    log("Saving user")
  end
end

User.new.save
User.log_class("Created")

module Cacheable
  def cached(key)
    @cache ||= {}
    return @cache[key] if @cache.key?(key)

    @cache[key] = yield
  end

  def clear_cache
    @cache&.clear
  end
end

class ExpensiveService
  include Cacheable

  def compute(n)
    cached(n) do
      puts "Computing..."
      sleep 1
      n ** 2
    end
  end
end

service = ExpensiveService.new
service.compute(5)
service.compute(5)

module MyApp
  module Models
    class User
    end
  end

  module Services
    class UserService
    end
  end

  module Repositories
    class UserRepository
    end
  end
end

module Swimmable
  def swim
    "Swimming"
  end
end

module Flyable
  def fly
    "Flying"
  end
end

class Duck
  include Swimmable
  include Flyable
end

duck = Duck.new
duck.swim
duck.fly

module SafeModule
  def self.included(base)
    base.send(:define_method, :safe_method) do
      "Safe method"
    end
  end
end