vasilakisfil

use tokio::sync::mpsc::{self, Receiver, Sender};
use tokio_stream::wrappers::ReceiverStream;
use tokio_util::sync::{PollSendError, PollSender};
use std::pin::Pin;
use std::task::{Poll, Context};

pub struct Duplex<T: Send + 'static> {
    channel1: Channel<T>,
    channel2: Channel<T>,
}

vasilakisfil

use deadpool_postgres::tokio_postgres::NoTls;
use deadpool_postgres::{Config, ManagerConfig, Pool, PoolError, RecyclingMethod};
use once_cell::sync::Lazy;
use std::sync::Arc;

static DB_POOL: Lazy<Arc<Pool>> = Lazy::new(|| {
    let mut cfg = Config::new();
    cfg.dbname = Some(
        std::env::var("DATABASE_URL")
            .map_err(|_| String::from("Environment variable Database URL could not be read"))

vasilakisfil

use std::{error::Error as StdError, fmt};

#[derive(Debug)]
pub struct Error {
    pub kind: ErrorKind,
    pub context: ErrorContext,
}

#[derive(Debug)]
pub enum ErrorKind {

vasilakisfil

class TimingBenchmark
  def measure(label, &block)
    @label_times ||= {}

    start = Time.now
    result = block.call
    @label_times[label] = Time.now - start

    return result
  end

vasilakisfil

require 'benchmark/ips'
require 'faker'

_hash = 100.times.inject({}){|hash, i|
  hash[Faker::Lorem.word] = Faker::Lorem.word
  hash
}
_hash[:aaa] = 'a'
HASH = _hash

vasilakisfil

require 'bundler/setup'
Bundler.require(:default)

class Serializer
  def user_path(id)
    "/user/#{id}"
  end
end

class User

vasilakisfil

#ENV:  Ruby 2.4.1, a  i7-6700HQ CPU, 16GB RAM

require 'benchmark'
require 'delegate'
require 'forwardable'

class Person
  def initialize(name)
    @name = name
  end

vasilakisfil

module NestedControllers
  CALLBACKS_OPTS = [:filter, :if, :unless, :kind].freeze

  #adds the relative paths to controller so you can do `render 'subcontroller/something'`
  #instead of `render 'parent_controller/subcontroller/something'`
  #(solves 2)
  def self.extended(base)
    base.prepend_view_path("app/views/#{base.controller_path}/")
  end

vasilakisfil

class Foobar
  def run!
    self.foobar = 'test' #doesn't fail?
    hey = self.foobar #bang! fails
  end
  private
    attr_accessor :foobar
end

Foobar.new.run!

vasilakisfil

module ActionDispatch
  class Flash
    class FlashHash
      # Returns a hash that includes everything but the given keys.
      #   hash = { a: true, b: false, c: nil}
      #   hash.except(:c) # => { a: true, b: false}
      #   hash # => { a: true, b: false, c: nil}
      #
      # This is useful for limiting a set of parameters to everything but a few known toggles:
      #   @person.update(params[:person].except(:admin))