lecture.slim

section.center data-background="#000"
  h1.white The Road to Enumerable

section
  h2 Prelude
  p We have a facebook group!

section
  h2 Prelude
  p It isn't really funny anymore, cause I still ain't got one

section.center
  img.inline src="img/troll.png"

section
  h2 Say Hi
  p Introduce yourself over to the forums
  p: a href="https://hackbulgaria.com/forum/topic/33/" https://hackbulgaria.com/forum/topic/33/

section.center data-background="#000"
  h2.white Intuition

section
  h2 Class
  ul
    li Like a recipe
    li A recipe for an object
    li A recipe can take properties from another

section
  h2 Object
  ul
    li Has data, as the recipe prescribed, kinda
    li Has behavior, as the recipe prescribed

section.center data-background="#000"
  h2.white Abstract

section
  h2 Class
  p Its opened with the keyword class
  pre: code.ruby
    '
      class Version
        attr_accessor :major
        attr_accessor :minor
        attr_accessor :patch

        def initialize(major, minor, patch)
          @major, @minor, @patch = major, minor, patch
        end
      end

section
  h2 Class
  ul
    li It contains methods and instance variables
    li Some of those methods are a bit special
  pre: code.ruby
    '
      class Version
        attr_accessor :major
        attr_accessor :minor
        attr_accessor :patch

        def initialize(major, minor, patch)
          @major, @minor, @patch = major, minor, patch
        end
      end

section
  h2 Object
  p Is an instance of a class
  pre: code.ruby
    '
      >> version = Version.new(1, 0, 0)
      => #<Version:0x007fa5239c1088 @major=1, @minor=0, @patch=0>

      >> version.major
      => 1

section
  h2 Object
  h2 Class
  p Its opened with the keyword class
  pre: code.ruby
    '
      class Version
        def initialize(major, minor, patch)
          @major, @minor, @patch = major, minor, patch
        end
      end

section
  h2 Object
  p Usually, the method Class#new
  pre: code.ruby
    '
      >> version = Version.new(1, 0, 0)
      => #<Version:0x007fa5239c1088 @major=1, @minor=0, @patch=0>

      >> version.major
      => 1

section
  h2 Instance Variables
  p Identifier prefixed with a @
  pre: code.ruby
    '
      class Version
        def initialize(major, minor, patch)
          @major, @minor, @patch = major, minor, patch
        end
      end

section
  h2 Instance Variables
  p Object specific
  pre: code.ruby
    '
      class Version
        def initialize(major, minor, patch)
          @major, @minor, @patch = major, minor, patch
        end
      end

section
  h2 Instance Variables
  p Cannot be accessed outside of an object
  pre: code.ruby
    '
      >> version = Version.new(1, 0, 0)
      => #<Version:0x007fa5239c1088 @major=1, @minor=0, @patch=0>

      >> version.@major
      SyntaxError: (irb):11: syntax error, unexpected tIVAR, expecting '('

section
  h2 Instance Variables
  p Nil if undefined

section
  h2 attr_accessor
  p To solve that, there are methods available to expose them
  pre: code.ruby
    '
      class Version
        attr_accessor :major
        attr_accessor :minor
        attr_accessor :patch

        def initialize(major, minor, patch)
          @major, @minor, @patch = major, minor, patch
        end
      end

section
  h2 attr_accessor
  p Creates a getter and setter
  pre: code.ruby
    '
      class Version
        attr_accessor :major
        attr_accessor :minor
        attr_accessor :patch

        def initialize(major, minor, patch)
          @major, @minor, @patch = major, minor, patch
        end
      end

section
  h2 attr_accessor
  p Creates a getter and setter
  pre: code.ruby
    '
      class Version
        attr_accessor :major, :minor, :patch

        def initialize(major, minor, patch)
          @major, @minor, @patch = major, minor, patch
        end
      end

section
  h2 attr_accessor
  p Under the hood
  pre: code.ruby
    '
      class Version
        def major
          @major
        end

        def major=(value)
          @major = value
        end

        # ...
      end

section
  h2 attr_accessor
  p Creates a getter and setter
  pre: code.ruby
    '
      >> version = Version.new(1, 0, 0)
      => #<Version:0x007fa5239c1088 @major=1, @minor=0, @patch=0>

      >> version.major = 2
      => 2
      >> version.major
      => 2

section
  h2 attr_reader
  p Creates a getter only
  pre: code.ruby
    '
      class Version
        attr_reader :major
        attr_reader :minor
        attr_reader :patch

        def initialize(major, minor, patch)
          @major, @minor, @patch = major, minor, patch
        end
      end

section
  h2 attr_reader
  p Creates a getter only
  pre: code.ruby
    '
      >> version = Version.new(1, 0, 0)
      => #<Version:0x007fa5239c1088 @major=1, @minor=0, @patch=0>

      >> version.major
      => 1
      >> version.major = 2
      NameError: undefined local variable or method `major=' for main:Object

section
  h2 attr_writter
  p Creates a setter only
  pre: code.ruby
    '
      class Version
        attr_writter :major
        attr_writter :minor
        attr_writter :patch

        def initialize(major, minor, patch)
          @major, @minor, @patch = major, minor, patch
        end
      end

section
  h2 attr_writter
  p Creates a setter only
  pre: code.ruby
    '
      >> version = Version.new(1, 0, 0)
      => #<Version:0x007fa5239c1088 @major=1, @minor=0, @patch=0>

      >> version.major
      NameError: undefined local variable or method `major' for main:Object
      >> version.major = 2
      => 2

section.center
  h2 This was a bad example ;)

section
  h2 attr_writter
  p Creates a setter only
  pre: code.ruby
    '
      >> version = Version.new(1, 0, 0)
      => #<Version:0x007fa5239c1088 @major=1, @minor=0, @patch=0>

      >> version.major
      NameError: undefined local variable or method `major' for main:Object
      >> version.major = 2
      => 2

section
  h2 self
  p Returns the object itself
  pre: code.ruby
    '
      class Object
        def itself
          self
        end
      end

section
  h2 self
  p Can be used to call methods on
  pre: code.ruby
    '
      class Array
        def filter_primes
          self.filter { |element| element.prime? }
        end
      end

section
  h2 self
  p If omitted it is called implicitly
  pre: code.ruby
    '
      class Array
        def filter_primes
          filter { |element| element.prime? }
        end
      end

section
  h2 Module
  ul
    li Store methods
    li Those methods can be included in other modules
    li Cannot be instantiated

section
  h2 Module
  p Defined by the keyword module
  pre: code.ruby
    '
      module Filterable
        def filter
          result = []
          each do |element|
            result << element if yield(element)
          end
          result
        end
      end

section
  h2 Module
  p Included in a class or module with the method Module#include
  pre: code.ruby
    '
      class Collection
        include Filterable

        def initialize(*data)
          @data = data
        end

        def each(&block)
          @data.each(&block)
        end
      end


section
  h2 Module
  p The newly added methods are available
  pre: code.ruby
    '
      >> collection = Collection.new(1, 2, 3, 4, 5)
      => #<Collection:0x007fa5238d4440 @data=[1, 2, 3, 4, 5]>
      >> collection.filter(&:odd?)
      => [1, 3, 5]

section.center data-background="#000"
  h2.white Abstract

section.center
  pre
    '
      OBJECTS ARE                   _________
      LIKE A                      .`.        `.
      MAILBOX                    /   \ .======.\
                                 |   | |______||
                                 |   |   _____ |
                                 |   |  /    / |
      THEY COMMUNICATE           |   | /____/  |
      WITH                       | _ |         |
      MESSAGES                   |/ \|.-"```"-.|
                                 `` |||      |||
                              jgs   `"`      `"

section.center
  pre
    '
      OBJECTS ARE                   _________
      LIKE A                      .`.        `.
      MAILBOX                    /   \ .======.\
                                 |   | |______||
                                 |   |   _____ |
                                 |   |  /    / |
      CALLING A METHOD           |   | /____/  |
      ON AN OBJECT               | _ |         |
      IS SENDING A MESSAGE       |/ \|.-"```"-.|
                                 `` |||      |||
                              jgs   `"`      `"

section.center data-background="#000"
  h2.white Solutions

section.center
  pre: code.ruby
    '
      def histogram(string)
        Hash.new(0).tap do |hist|
          string.each_char { |char| hist[char] += 1 }
        end
      end

section.center
  pre: code.ruby
    '
      def prime?(n)
        n > 1 && 2.upto(Math.sqrt n).all? { |k| n % k != 0 }
      end

section.center
  pre: code.ruby
    '
      def ordinal(n)
        return "#\{n}th" if (11..13).include? n % 100

        case n % 10
          when 1 then "#\{n}st"
          when 2 then "#\{n}nd"
          when 3 then "#\{n}rd"
          else        "#\{n}th"
        end
      end

section.center
  pre: code.ruby
    '
      def palindrome?(n)
        n.to_s == n.to_s.reverse
      end


section.center
  pre: code.ruby
    '
      def anagram?(word, other)
        histogram(word) == histogram(other)
      end

section.center
  pre: code.ruby
    '
      def remove_prefix(string, pattern)
        if index = string.index(pattern)
          string[pattern] = '' if index.zero?
        end

        string
      end

section.center
  pre: code.ruby
    '
      def remove_prefix(string, prefix)
        string.sub(/\A#\{pattern}/, '')
      end

section.center
  pre: code.ruby
    '
      def remove_suffix(string, pattern)
        remove_prefix(string.reverse!, pattern.reverse).reverse!
      end

section.center
  pre: code.ruby
    '
      def remove_suffix(string, pattern)
        string.sub(/#\{pattern}\z/, '')
      end

section.center
  pre: code.ruby
    '
      def digits(n)
        n.to_s.each_char.map(&:to_i)
      end

section.center
  pre: code.ruby
    '
      def fizzbuzz(range)
        range.map do |n|
          case
          when [n % 3, n % 5].all?(&:zero?) :fizzbuzz
          when (n % 3).zero?                :fizz
          when (n % 5).zero?                :buzz
          else                              n
          end
        end
      end

section.center
  pre: code.ruby
    '
      def count(array)
        array.each_with_object({}) do |element, h|
          h[element] = array.count(element)
        end
      end

section.center
  pre: code.ruby
    '
      def count_words(*sentances)
        count sentances.join.scan(/\w+/).map(&:downcase)
      end