Ruby

• the "nouns" of Ruby

• "do NOT mind code duplication in tests" - PragmaticRuby
• assert_, refute_
• _equal, _empty

require_relative "words_from_string"
require "minitest/autorun" # runs all the test_*
class TestWordsFromString < Minitest::Test
  def setup # called before each test_ method in class
    @playlist = Playlist.new("Gonzo")
    @movie1 = Movie.new("A", 10)
    @movie2 = Movie.new("B", 9)
    $stdout = StringIO.new # supress stdout
  end
  def test_high_number
    @playlist.stub(:roll_die, 6) do  # override method to return a constant value
      @playlist.play()
      assert_equal 11, @movie1.rank
    end
  end
  def test_empty_string # methods starting with "test" automatically run
    assert_equal([], words_from_string(""))
    assert_equal([], words_from_string("   "))
  end
end

• https://docs.ruby-lang.org/en/2.4.0/Open3.html
  • child process stdin/stdout/stderr and a thread for it
• https://ruby-doc.org/stdlib-2.6.3/libdoc/pathname/rdoc/Pathname.html
  • wrapper around File class, crossplatform
• popen - for r/w from/to a process
• system - if you don't care about the output just stdout
• p
  • calls #inspect
• pp
• puts
  • calls #to_s, to get its string representation
  • short for "outPUT String"
  • available to all objects
  • often written without parentheses

• guide https://github.com/airbnb/ruby
• guide https://github.com/rubocop/ruby-style-guide
• tool: linter/formatter https://github.com/standardrb/standard
• tool: linter/formatter https://github.com/rubocop/rubocop/
• 2 spaces for indentation
• book_in_stock.rb (file) / BookInStock (class)
• variable/parameters/methods
• @instance_var @X @_
• @@class_var @@N @@x_pos @@SINGLE
• $global $CUSTOMER $_ $plan9 $Global
• ClassName
• ModuleName
• CONSTANT_NAME

https://rubyreferences.github.io/rubychanges/evolution.html

• if/elsif/else/end
• unless/
• while/end

• statement modifiers

  return nil if user.nil? # guards clause, usually at the beginning of a method
  
  puts "Danger" if radiation > 3000
  
  square = 4
  square = square * square while square < 1000
  

• loop/end
  • infinite loop
  • break out of them

  • it will also auto-break if the Enumerator inside runs out of values

    short_enum = [1,2,3].to_enum
    long_enum = ('a'..'z').to_enum
    loop do # loops 3 times
      puts "#{short_enum.next} - #{long_enum.next}"
    end
    

• blocks are closures
• is a chunk of code you can pass to a method, as it were another parameter

• assign a block to a variable, all of these return a Proc from the block

  bo = ->(param) { puts "You called me with #{param}" } # stabby lambda, optional parens
  bo = lambda { |param| puts "You called me with #{param}" } # Kernel method "lambda", error on wrong nargs
  bo = proc { |param| puts "You called me with #{param}" } # Kernel method "proc", bubble ups "return"
  bo = Proc.new { |param| puts "You called me with #{param}" } # same but OLD style
  bo.call(99)
  

• can be passed to a method either
  1. extra IMPLICIT last argument that's passed to a method

  2. (&) EXPLICIT last argument, to call store it and call it later (callbacks)

     class ProcExample
       def pass_in_block(&action)
         @stored_proc = action
       end
       def use_proc(parameter)
         @stored_proc.call(parameter) # .call stored block
       end
     end
     eg = ProcExample.new
     eg.pass_in_block { |param| puts "The parameter is #{param}" }
     eg.use_proc(99)
     

• parameters to a block are ALWAYS local to that block
• has access to variables outside his scope
• Iterator or Enumerator a method that can invoke a block of code repeatedly
• you can only pass one block per method call greet("dave", "loyal customer") { puts "hi" }
• invoked in a method using yield

  • block parameters put after a ; are considered locals to that block (awk-ish) (RARE!)

    square = "some shape"
    sum = 0
    [1,2,3,4].each do |value;square| # 2 block parameters
      square = value * value
      sum += square
    end
    puts sum
    puts square
    

  • no argument

    def call_block
      puts "Start of method"
      yield
      yield
      puts "End of method"
    end
    call_block { puts "In the block" }
    

  • with arguments

    def who_says_what
      yield("Dave", "hello")
      yield("Andy", "goodbye")
    end
    who_says_what { |person, phrase| puts "#{person} says #{phrase}" }
    

  • for transactions (ME: using blocks for meta-programming stuff)

    class File
      def self.open_and_process(*args) # class method
        f = File.open(*args)
        yield f
        f.close()
      end
    end
    
    File.open_and_process("testfile", "r") do |file|
      while line = file.gets
        puts line
      end
    end
    

• created with NAME.new
• has/can have
  • each instance has an object_id property
  • instance variables
• attributes are just methods without arguments
• the "only easy" way to change an object's state is by calling onf its methods
• templates for creating objectss

class BookInStock
  attr_accessor :price      # would create a attr_reader/attr_writer
  attr_reader :isbn #, :price   # creates the reader accessor methods #isbn and #price, for @isbn and @price
  def initialize(isbn, price) # called by BookInStock.new
    @isbn = isbn
    @price = Float(price)
  end
  # def price=(new_price) # setter
  #   @price = new_price
  # end
  def price_in_cents
    (price * 100).round # !!!! is valid to refer to it either as "price" or "@price"
  end
  def price_in_cents=(cents) # setter for a "virtual isntance variable", giving a "uniform access principle"
    @price = cents / 100.0
  end
end
book = BookInStock.new("isbn1", 33.80)
book.price = book.price * 0.75 # using the setter and getter

class File
  def self.my_open(*args) # CLASS METHOD, parameter list into array "args"
    file = File.new(*args) # spread array "args", into individual arguments
    return file unless block_given? # guard return if no block_given?
    result = yield file
    file.close
    result
  end
end

• private/public/protected def
• can be redefining (just warns about it)
• the verbs of ruby
• attached at the end of variables with by a dot
• some methods (such as print) are kernel methods, won't use the dot
• parameters
  • positional foo
  • keyword rank: 10 needs the keyword to be passed
  • default rank = 10 with a possible computed default (ME: aka &optional)
• kinds
  • module methods (::) self.
  • Class Methods (::) self.
    • attached after variables and constants by a double colon
  • instance methods (.)
    • called by RECEIVER.METHODNAME
    • a message is being send to the object, which contains the method name along with arguments
• special
  • to_s
  • inspect
  • each
• arguments, keyword args, *,**splats, &arguments
• Types
  • public: by default (except initialize which is private) (RARE explicit)
  • protected: can be invoked by class or subclasses (RARE!) can be used on attr_reader/w/a
  • private: cannot be invoked without an explicit receiver

• to group related constants/methods, or for mixins or namespaces

module Snackbar
  Snack = Data.define(:name, :price)
  SNACKS = [
    Snack.new("popcorn", 3),
    Snack.new("candy", 1)
  ]
  def self.random_snack # self. declares a "module method"
    SNACKS.sample
  end
end

require_relative "snackbar"
Snackbar::SNACKS.each do { |snack| puts snack.name }

• Ruby 2: diagram of classes http://jeromedalbert.com/a-diagram-of-the-ruby-core-object-model/
• Constants
  • capitalized
  • proper nouns of Ruby
• nil
  • is an object, just like any other
  • represents the concept of nothing
• Numeric https://ruby-doc.org/3.0.7/Numeric.html
  • #positive?, #negative?, #nonzero?, #zero?
  • Float https://ruby-doc.org/3.0.7/Float.html
  • Integer https://ruby-doc.org/3.0.7/Integer.html
    • #times, #upto(N)
• Strings
  • "",%{},'',%q{} are string literals, from more to less work done
  • "",%{} checks for escape sequences (\) and expression interpolation (#{})
  • Both single and double quotes are used to create strings
  • #each_char returns an Enumerator if not given a block, you can call .each_with_index on it
  • alternatively #each_char.with_index
• Regexp // https://ruby-doc.org/3.2.2/Regexp.html
  • the match operator =~ can be used to match a string against it returns that starting position or nil
    • also through String#match? or Regex#match?
  • Regexp#sub
  • Regexp#gsub
• Symbols :foo
  • like lightweight strings
  • immutable
  • same named symbols have the same object_id
  • used
    • as keys and identifiers
    • when you need a string but you won't be printing it
    • when you need to use the same string over and over

• Struct

  Snack = Struct.new(:name, :price)
  

  • when you have date and no behaviour
  • it creates accessors (r/w) automatically

• Data

  Snack = Data.define(:name, :price)
  

  • when you have date and no behaviour
  • it creates readers automatically
    • immutable

• new format
  • https://ruby-doc.org/3.0.4/standard_library_rdoc.html
  • https://docs.ruby-lang.org/en/master/standard_library_rdoc.html
    • better colors
    • some clickable links
• old format https://ruby-doc.org/stdlib-3.0.4/
• list all versions, without descriptions https://rubydoc.info/stdlib
• guide 2.7 https://rubyreferences.github.io/rubyref/stdlib.html
• https://stdgems.org/
  • Every Ruby version ships a specific set of
    1. default gems
    2. default libraries
    3. and bundled gems