justinko

Dear Rubyists,

I just lost a contract because of my code in a Rails project.

The specific code in question is related to a "posting a comment" feature. Here are the details:

In this project, "posting a comment" does not simply entail inserting a row into the database. It involves a procedure to yes, insert a row, but also detect its language, check for spam, send emails, and "share" it to Twitter and Facebook. I believe this algorithm should be encapsulated. I do not believe it belongs in a controller or a model. I do not believe Active Record callbacks should be used.

The "senior developer", whom is the stake holder's right hand man, said this:

vsavkin

# Framework
# ===========================================
module ContextAccessor
  def context
    Thread.current[:context]
  end
end

module Context
  include ContextAccessor

maccman

(function($){
  function dragEnter(e) {
    $(e.target).addClass("dragOver");
    e.stopPropagation();
    e.preventDefault();
    return false;
  };

  function dragOver(e) {
    e.originalEvent.dataTransfer.dropEffect = "copy";

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.

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.

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

jnicklas

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

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/^/       /"
}

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
}

plentz

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