SOLID and Design Patterns

# frozen_string_literal: true

require "shelf"

# KISS: Comparable#clamp states the intent that a hand-written if/elsif chain hides.
def loan_days(requested) = requested.clamp(1, 28)

loan_days(0) # => 1
loan_days(14) # => 14
loan_days(90) # => 28

# DRY: the late-fee rule lives in one place and every caller uses it.
module Shelf
  module Fines
    CENTS_PER_DAY = 25
    MAX_CENTS = 1000

    def self.for(days_late) = (days_late * CENTS_PER_DAY).clamp(0, MAX_CENTS)
  end
end

Shelf::Fines.for(-3) # => 0
Shelf::Fines.for(4) # => 100
Shelf::Fines.for(400) # => 1000

# frozen_string_literal: true

require "shelf"

module Shelf
  # A factory method: validates and normalises raw input before building a Book.
  module Books
    def self.from_hash(row)
      Book.new(isbn: Isbn.new(row.fetch(:isbn)), title: row.fetch(:title), author: Author.new(row.fetch(:author)))
    end
  end

  # A registry-based factory: new store kinds plug in without editing build.
  module Stores
    @registry = { memory: Store::Memory }

    def self.register(kind, klass) = @registry[kind] = klass

    def self.build(kind, ...) = @registry.fetch(kind).new(...)
  end
end

book = Shelf::Books.from_hash(isbn: "978-0-306-40615-7", title: "The Dispossessed", author: "Ursula K. Le Guin")
book.to_s # => "The Dispossessed by Ursula K. Le Guin"

Shelf::Stores.build(:memory).class # => Shelf::Store::Memory

begin
  Shelf::Stores.build(:sqlite)
rescue KeyError => e
  e.message # => "key not found: :sqlite"
end

Shelf::Stores.register(:sqlite, Class.new(Shelf::Store::Memory))
Shelf::Stores.build(:sqlite).all # => []

begin
  Shelf::Books.from_hash(title: "No ISBN", author: "Anonymous")
rescue KeyError => e
  e.message # => "key not found: :isbn"
end

# frozen_string_literal: true

require "shelf"

module Shelf
  # The strategy is anything that responds to #call(days_late): a lambda,
  # a Method object, a Symbol#to_proc or a small class.
  class FineCalculator
    def initialize(strategy = Fines.method(:for), &block)
      @strategy = block || strategy
    end

    def fine_for(days_late) = @strategy.call(days_late)
  end

  module Fines
    CENTS_PER_DAY = 25

    def self.for(days_late) = days_late.clamp(0, 40) * CENTS_PER_DAY
  end

  class FlatFine
    def initialize(cents) = @cents = cents

    def call(days_late) = days_late.positive? ? @cents : 0
  end
end

Shelf::FineCalculator.new.fine_for(4) # => 100
Shelf::FineCalculator.new { |days| days * 10 }.fine_for(4) # => 40
Shelf::FineCalculator.new(Shelf::FlatFine.new(500)).fine_for(4) # => 500
Shelf::FineCalculator.new(Shelf::FlatFine.new(500)).fine_for(0) # => 0

# Callables compose with >> and <<.
cap = ->(cents) { [cents, 300].min }
capped = Shelf::Fines.method(:for) >> cap
capped.call(30) # => 300
Shelf::FineCalculator.new(capped).fine_for(2) # => 50

# Built-in strategies: sort_by and max_by take the strategy as a block.
words = %w[Dune Emma Ubik Kindred]
words.sort_by(&:length) # => ["Dune", "Emma", "Ubik", "Kindred"]
words.max_by(&:length) # => "Kindred"

# frozen_string_literal: true

require "observer"
require "shelf"

module Shelf
  # 1. A hand-rolled observer: listeners are blocks or anything that responds to #call.
  class WatchedCatalog < Catalog
    def initialize(...)
      super
      @listeners = []
    end

    def subscribe(listener = nil, &block)
      @listeners << (listener || block)
      self
    end

    def add(book)
      super
      @listeners.each { |listener| listener.call(book) }
      self
    end
  end

  # 2. The `observer` gem (a bundled gem since Ruby 3.4): Observable plus #update.
  class Notifier
    include Observable

    def publish(message)
      changed
      notify_observers(message)
    end
  end

  Subscriber = Struct.new(:seen) do
    def update(message) = seen << message
  end
end

author = Shelf::Author.new("Ursula K. Le Guin")
book = Shelf::Book.new(isbn: Shelf::Isbn.new("978-0-306-40615-7"), title: "The Dispossessed", author:)

log = []
catalog = Shelf::WatchedCatalog.new(store: Shelf::Store::Memory.new)
catalog.subscribe { |added| log << "added #{added.title}" }
catalog.add(book)
log.first # => "added The Dispossessed"

notifier = Shelf::Notifier.new
subscriber = Shelf::Subscriber.new([])
notifier.add_observer(subscriber)
notifier.publish("overdue: The Dispossessed")
subscriber.seen # => ["overdue: The Dispossessed"]
notifier.count_observers # => 1

# frozen_string_literal: true

require "delegate"
require "shelf"

module Shelf
  # Decorator: SimpleDelegator forwards everything not defined here to the wrapped object.
  class BookPresenter < SimpleDelegator
    def headline = "#{title.upcase} (#{author.name})"

    def to_s = "[#{__getobj__}]"
  end

  # Decorating a collaborator: same interface (#all, #add), extra behaviour.
  class CountingStore < SimpleDelegator
    attr_reader :adds

    def initialize(store)
      super
      @adds = 0
    end

    def add(book)
      @adds += 1
      super
    end
  end
end

author = Shelf::Author.new("Ursula K. Le Guin")
book = Shelf::Book.new(isbn: Shelf::Isbn.new("978-0-306-40615-7"), title: "The Dispossessed", author:)

presenter = Shelf::BookPresenter.new(book)
presenter.headline # => "THE DISPOSSESSED (Ursula K. Le Guin)"
presenter.title # => "The Dispossessed"
presenter.to_s # => "[The Dispossessed by Ursula K. Le Guin]"
presenter.__getobj__.equal?(book) # => true

# Pitfalls: the decorator is not the object, so identity and class checks differ.
presenter.is_a?(Shelf::Book) # => false
[presenter == book, presenter.eql?(book), book == presenter] # => [true, true, false]

counting = Shelf::CountingStore.new(Shelf::Store::Memory.new)
catalog = Shelf::Catalog.new(store: counting)
catalog.add(book).add(book)
counting.adds # => 2
counting.all.size # => 2

# frozen_string_literal: true

require "shelf"

module Shelf
  # An imaginary third-party client with its own vocabulary.
  class RemoteCatalogClient
    def initialize = @rows = {}

    def put_row(isbn, row) = @rows[isbn] = row

    def fetch_rows = @rows.values
  end

  # Adapter: translates the client to the store interface Catalog expects (#all, #add).
  class RemoteStoreAdapter
    def initialize(client) = @client = client

    def all
      @client.fetch_rows.map do |row|
        Book.new(isbn: Isbn.new(row[:isbn]), title: row[:title], author: Author.new(row[:author]))
      end
    end

    def add(book)
      @client.put_row(book.isbn.digits, { isbn: book.isbn.digits, title: book.title, author: book.author.name })
      self
    end
  end

  # Facade: one small entry point over Catalog, Report and the store choice.
  class Library
    def initialize(store: Store::Memory.new)
      @catalog = Catalog.new(store:)
    end

    def register(isbn:, title:, author:)
      book = Book.new(isbn: Isbn.new(isbn), title:, author: Author.new(author))
      @catalog.add(book)
      book
    end

    def titles = @catalog.map(&:title).sort
  end
end

client = Shelf::RemoteCatalogClient.new
library = Shelf::Library.new(store: Shelf::RemoteStoreAdapter.new(client))
library.register(isbn: "978-0-306-40615-7", title: "The Dispossessed", author: "Ursula K. Le Guin")
library.register(isbn: "978-0-14-143951-8", title: "Pride and Prejudice", author: "Jane Austen")
library.titles # => ["Pride and Prejudice", "The Dispossessed"]
client.fetch_rows.size # => 2

# frozen_string_literal: true

require "shelf"

module Shelf
  # Command: an object that knows how to do and undo one action.
  AddBook = Data.define(:books, :book) do
    def call = books << book

    def undo = books.delete(book)
  end

  # Invoker: runs commands and keeps a history for undo.
  class History
    def initialize = @done = []

    def run(command)
      command.call
      @done << command
      self
    end

    def undo = @done.pop&.undo

    def size = @done.size
  end
end

author = Shelf::Author.new("Ursula K. Le Guin")
book = Shelf::Book.new(isbn: Shelf::Isbn.new("978-0-306-40615-7"), title: "The Dispossessed", author:)

books = []
history = Shelf::History.new
history.run(Shelf::AddBook.new(books, book))
books.size # => 1
history.size # => 1
history.undo.title # => "The Dispossessed"
books.size # => 0
history.undo # => nil

# A command can also be a plain lambda when no undo is needed.
queue = [-> { books << book }, -> { books.size }]
queue.map(&:call).last # => 1

# frozen_string_literal: true

require "shelf"

authors = ["Ursula K. Le Guin", "Jane Austen", "Octavia E. Butler"].map { |name| Shelf::Author.new(name) }
isbns = %w[978-0-306-40615-7 978-0-14-143951-8 978-0-8070-8310-9].map { |digits| Shelf::Isbn.new(digits) }
titles = ["The Dispossessed", "Pride and Prejudice", "Kindred"]
catalog = Shelf::Catalog.new(store: Shelf::Store::Memory.new)
titles.zip(isbns, authors) { |title, isbn, author| catalog.add(Shelf::Book.new(isbn:, title:, author:)) }

# Catalog defines only #each and includes Enumerable: all of these come for free.
catalog.map(&:title) # => ["The Dispossessed", "Pride and Prejudice", "Kindred"]
catalog.min_by { |book| book.title.length }.title # => "Kindred"
catalog.sort_by(&:title).map(&:title) # => ["Kindred", "Pride and Prejudice", "The Dispossessed"]
catalog.include?(catalog.first) # => true
catalog.each_slice(2).map { |pair| pair.map(&:title) } # => [["The Dispossessed", "Pride and Prejudice"], ["Kindred"]]

# Without a block, #each returns an Enumerator: external iteration with #next.
cursor = catalog.each
cursor.next.title # => "The Dispossessed"
cursor.next.title # => "Pride and Prejudice"
cursor.peek.title # => "Kindred"
cursor.next.title # => "Kindred"

begin
  cursor.next
rescue StopIteration => e
  e.message # => "iteration reached an end"
end

# Enumerator.new builds an iterator without defining a class.
isbn_digits = Enumerator.new { |yielder| catalog.each { |book| yielder << book.isbn.digits } }
isbn_digits.lazy.select { |digits| digits.start_with?("97803") }.first(1) # => ["9780306406157"]

# frozen_string_literal: true

require "forwardable"
require "shelf"

module Shelf
  # Template method: the base class fixes the algorithm, subclasses fill the hook.
  # The hook raises NoMethodError, not NotImplementedError (a ScriptError that a bare
  # rescue does not catch and that the docs reserve for missing platform features).
  class Exporter
    def export(books) = [header, *books.map { |book| row(book) }].join("\n")

    def header = "title"

    def row(_book) = raise(NoMethodError, "#{self.class} must implement #row")
  end

  class TitleExporter < Exporter
    def row(book) = book.title
  end

  # Forwardable is delegation without a wrapper class (the standard-library
  # counterpart of Rails' class-level delegate).
  class Bookcase
    extend Forwardable

    def_delegators :@books, :size, :first, :each
    def_delegator :@books, :push, :put

    include Enumerable

    def initialize = @books = []
  end
end

author = Shelf::Author.new("Ursula K. Le Guin")
book = Shelf::Book.new(isbn: Shelf::Isbn.new("978-0-306-40615-7"), title: "The Dispossessed", author:)

Shelf::TitleExporter.new.export([book]) # => "title\nThe Dispossessed"

begin
  Shelf::Exporter.new.export([book])
rescue NoMethodError => e
  e.message # => "Shelf::Exporter must implement #row"
end

bookcase = Shelf::Bookcase.new
bookcase.put(book)
bookcase.size # => 1
bookcase.map(&:title) # => ["The Dispossessed"]

# frozen_string_literal: true

require "singleton"
require "shelf"

module Shelf
  # The Singleton module makes .new private, creates the instance thread-safely
  # on first use and handles dup/clone; `@instance ||= new` does none of that.
  class Clock
    include Singleton

    def now = Time.new(2026, 10, 18, 9, 30)
  end
end

Shelf::Clock.instance.equal?(Shelf::Clock.instance) # => true
Shelf::Clock.instance.now.year # => 2026

begin
  Shelf::Clock.new
rescue NoMethodError => e
  e.message # => "private method 'new' called for class Shelf::Clock"
end

begin
  Shelf::Clock.instance.dup
rescue TypeError => e
  e.message # => "can't dup instance of singleton Shelf::Clock"
end