yields each element. each yielded element is the result of self[index]
 for each index of the instance (see #[]).
 returns an Enumerator if no block is given.
 @yield [Object] each element of this JSI array
 @return [self, Enumerator]
2830
def each
      return to_enum(__method__) { instance.size } unless block_given?
      instance.each_index { |i| yield(self[i]) }
      self
    end
778136
def each_page_each_resource(args={})
      self.each_page(args) do |page|
        page.resources.each do |item|
          yield(item)
        end
      end
    end
1333346
def each_recursive(&block) # :yields: node
      self.elements.each {|node|
        block.call(node)
        node.each_recursive(&block)
      }
    end
1262353
def reverse_each
      return enum_for(__method__) unless block_given?
      each.to_a.reverse.each { |v| yield v }
    end
1348146
def each
      body_parts = self.body.respond_to?(:each) ? self.body : [self.body]
      return body_parts.to_enum unless block_given?
      body_parts.each { |part| yield(part) }
    end
309169
def each_base_nibble
      return to_enum(:each_base_nibble) unless block_given?
      from.name.split('::').reduce Object do |mod, const|
        mod = mod.const_get const
        yield [mod, const]
        mod
      end
    end
125977
def each_element(path, elements)
      elements = Array(elements)
      Nokogiri::XML::Reader(::File.open(path, 'rb'), nil, nil, Nokogiri::XML::ParseOptions::NOBLANKS).each do |node|
        next unless node.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT && elements.include?(node.name)
        yield Nokogiri::XML(node.outer_xml).root if block_given?
      end
    end
469038
def each_capitalized
      block_given? or return enum_for(__method__)
      @header.each do |k,v|
        yield capitalize(k), v.join(', ')
      end
    end
316160
def each
      @lock.synchronize do
        @items.each do |id, ref|
          begin
            yield id, ref.__getobj__
          rescue WeakRef::RefError
          end
        end
      end
    end
21327
def collect_rows &block
      return to_enum(:collect_rows) unless block_given?

      Daru::Vector.new(each_row.map(&block), index: @index)
    end
881520
def each(offset = 0)
      return to_enum(:each, offset) unless block_given?
      @collection[offset..-1].each { |element| yield(element) }
      unless exhausted?
        offset = [@collection.size, offset].max
        fetch_next
        each(offset, &Proc.new)
      end
      self
    end
790075
def each
      @dir.synchronize do
        ensure_reader_open
        (0...@reader.max_doc).each do |i|
          yield @reader[i].load unless @reader.deleted?(i)
        end
      end
    end
1113492
def each_header   #:yield: +key+, +value+
      block_given? or return enum_for(__method__)
      @header.each do |k,va|
        yield k, va.join(', ')
      end
    end
690589
def each
      return enum_for(:each) unless block_given?

      execute.each do |result|
        yield(model.new(result.merge(api: api)))
      end
    end
1236373
def each_field
      return to_enum(:each_field) unless block_given?

      self.class.all_fields.each do |field|
        value = self[field.name]
        yield(field, value)
      end
    end
1204254
def each
      return enum_for(__method__) unless block_given?

      each_event { |v, _, _, i|
        break if i > 0
        yield v
      }
    end
218555
def each
      loop do
        results.each do |result|
          yield(result)
        end
        go_next!
      end
    rescue UserEngage::NoNextPageAvailableException
      true
    end