havenwood

class Enumerator
  def self.unfold tuple
    new do |yielder|
      loop do
        current, tuple = yield tuple
        yielder << current
      end
    end
  end
end

ejangi

[Unit]
Description=Passenger Standalone Application Server
After=network.target
 
[Service]
Type=forking
PrivateTmp=yes
User=nginx
Group=nginx
WorkingDirectory=/srv/www/%i

stevenharman

AngularJS + Rails Asset Pipeline

This is my hand-rolled solution for getting Angular assets (Controllers, Models, Directives, Templates, etc.) integrated into the Rails Asset Pipeline.

Templates and the $templateCache

Of particular note: this hack will also load the AngularJS $templateCache with your templates, while allowing you to use Slim, ERB, etc. to write your templates.

plentz

# to generate your dhparam.pem file, run in the terminal
openssl dhparam -out /etc/nginx/ssl/dhparam.pem 2048

mamut

#!/bin/bash
set -e

pivotal_ticket_id=$1

function commits_from_master() {
  git checkout master > /dev/null 2>&1
  git log --reverse --oneline --no-abbrev-commit --grep $1 | cut -d ' ' -f 1
}

nu7hatch

# _utils.sh --- Utilities used across all the scripts.

set -e
set -o pipefail

# Prints spaces as a prefix to the command's output.
function prefixed {
    sed -e "s/^/       /"
}

jnicklas

Capybara.add_selector :record do
  xpath { |record| XPath.css("#" + ActionController::RecordIdentifier.dom_id(record)) }
  match { |record| record.is_a?(ActiveRecord::Base) }
end

brettfishman

# Given a controller that looks like this
class ModelsController < ApplicationController
  load_and_authorize_resource  #CanCan

  def show
    if stale? @model
      respond_to do |format|
        format.json do
          @model
        end

vsavkin

Building Rich Domain Models in Rails.

Part 1. Decoupling Persistence.

Abstract

Domain model is an effective tool for software development. It can be used to express really complex business logic, and to verify and validate the understanding of the domain among stakeholders. Building rich domain models in Rails is hard. Primarily, because of Active Record, which doesn't play well with the domain model approach.

One way to deal with this problem is to use an ORM implementing the data mapper pattern. Unfortunately, there is no production ready ORM doing that for Ruby. DataMapper 2 is going to be the first one.

Another way is to use Active Record just as a persistence mechanism and build a rich domain model on top of it. That's what I'm going to talk about in this article.

andrzejkrzywda

Here is my solution, based on use-cases and AOP.

1. you need to separate persistence from your domain
2. you need to have a proper use-case, not a single request-class, like above.
3. notifications are notifications (twitter, fb), they are implemented with AOP
4. spam detection and language detection are separated (discussable) with an aspect.
5. there is an "app" object that wraps it all together.

The first file is the original example. The second file is mine.