bryanhunter

#!/bin/bash
# Pull this file down, make it executable and run it with sudo
# wget https://gist.githubusercontent.com/bryanhunter/10380945/raw/build-erlang-17.0.sh
# chmod u+x build-erlang-17.0.sh
# sudo ./build-erlang-17.0.sh

if [ $(id -u) != "0" ]; then
echo "You must be the superuser to run this script" >&2
exit 1
fi

dhh

# config/routes.rb
resources :documents do
  scope module: 'documents' do
    resources :versions do
      post :restore, on: :member
    end

    resource :lock
  end
end

banister

class Blah
  def add(x, y)
    x + y
  end
end
# => nil
class Symbol
  def call(*args, &block)
    ->(o) { o.send(self, *args, &block) }
  end

edubkendo

I want to write plugins for Atom's editor in Ruby. Opal makes this possible. Atom is one of several projects in recent times to combine Chromium with Node.js for a desktop app. While it utilizes chromium for it's gui, and boasts "[e]very Atom window is essentially a locally-rendered web page", writing Atom plugins is more like writing a server-side node.js app than a typical single-page client-side app (albeit with really awesome integration with Chrome Devtools). Opal development, on the other hand, has to-date been focused primarily on the browser use-case.

Because of this, I had to make a choice between using the opal-node package from npm, using Opal via Ruby w/ a compile step, or packaging up opal-parser.js, including it with the app, and writing in compilation on the fly. Each choice came with compromises. Using opal-node would have been easiest, just create a top level index.coffee that required opal-node, and then require in your ruby

gmorpheme

(ns ^{:doc "Evaluator from ch1 of lisp in small pieces. Warning:
  NON-IDIOMATIC clojure!"}
  lisp.chapter1.eval
  (:refer-clojure :exclude [extend]))

(defn wrong [& msgs]
  (throw (RuntimeException. (apply str msgs))))

;; -- runtime support, environments are represented as a seq of pairs,
;; -- stored in an atom. Non-idiomatic but faithful to the book.

jj1bdx

Installation of Erlang R16B03-1 and 17.0-rc2 to OS X 10.9.2 with Xcode and wxWidgets 3.0.0

• Note: always set umask 022 for system-shared libraries
• See http://blog.equanimity.nl/blog/2014/02/09/erlang-r17-rc1-on-osx-with-wx-and-a-working-observer/ for the details
• wxWidgets 3.0.0 works the same in R16B03-1 and 17.0-rc2
• Note well: wx:demo() on OS X 10.9.2 with wxWidgets 3.0.0 is still unstable, though observer:start() is more stable.
• If you really don't have time, try Erlang Solutions' 32bit (not 64bit) distribution at https://www.erlang-solutions.com/downloads/download-erlang-otp to use it as a debugging console.
• Update 28-FEB-2014 0230UTC: Leo Liu reports brew install wxmac --disable-monolithic will do. See http://erlang.org/pipermail/erlang-questions/2014-February/077952.html.

Installing wxWidgets

malixsys

form i.icon.error {
  color: $assertive;
}

form input + i.icon.error {
  display: none;
  margin-left: 8px;
}

form.ng-submitted input.ng-invalid + i.icon.error {

Myuzu

# UPD from 2018:
# This gist was written for pre-1.0 version of Elixir and won't work on post-1.0 versions.
# You probably consider using something else!

defmodule SecureRandom do
  @moduledoc """
  Ruby-like SecureRandom module.

  ## Examples

weilu

# spec/support/rspec-rails/controller-example-group.rb
module RSpec::Rails
  module ControllerExampleGroup

    def process *args
      @requested = true
      super
    end

    def self.included(base)

rubysolo

defmodule Ring do
  def run(member_count, loop_count, message) do
    log(:ringleader, "building ring with #{ member_count - 1 } more nodes...")
    next_pid = spawn_link(__MODULE__, :build_ring, [member_count - 2, self])

    log(:ringleader, "sending initial message to #{ inspect(next_pid) }...")
    next_pid <- {:message, message, loop_count}

    message_loop(next_pid)
  end