ryanb

<%# app/views/layouts/application.html.erb %>
...
<%= javascript_include_tag "locales/#{I18n.locale}", nonce: true %>

hopsoft

# Builds an SQL insert query for a given record
#
# @param record [ActiveRecord::Base] Record used to build the SQL insert query
# @return [String] SQL insert query
def build_insert_query(record)
  columns = record.class.columns.reject { |col| col.name == record.class.primary_key }
  values = columns.map { |col| record[col.name] }
  insert_manager = Arel::InsertManager.new
  insert_manager.into(record.class.arel_table)
  insert_manager.insert(columns.zip(values)).to_sql

bradgessler

require "bundler/inline"

gemfile do
  source "https://rubygems.org"
  gem "phlex"
end

require "phlex/testing/view_helper"
include Phlex::Testing::ViewHelper

marvinhagemeister

import { options } from "preact";
import { Signal } from "@preact/signals";

// Add `bind:value` to JSX types
declare global {
  namespace preact.createElement.JSX {
    interface HTMLAttributes {
      "bind:value"?: Signal<string | string[] | number | undefined>;
    }
  }

flickgradley

Measure = Data.define(:amount, :unit) do
  def diff(other)
    raise ArgumentError.new("other must be same class") unless other.is_a?(self.class)

    members.inject({}) do |memo, key|
      thisVal, otherVal = send(key), other.send(key)
      memo[key] = [thisVal, otherVal] unless thisVal == otherVal
      
      memo
    end

joeldrapper

# frozen_string_literal: true

module Packer
  # A special packer class for globally identifiable objects. It takes a global ID and packs it as a String, then rehydrates it as a GlobalID lookup.
  class GloballyIdentifiable
    def self.from_pack(uri)
      GlobalID::Locator.locate(uri)
    end

    def initialize(identifiable)

devongovett

// Turn all HTML <a> elements into client side router links, no special framework-specific <Link> component necessary!
// Example using the Next.js App Router.
import { useRouter } from 'next/navigation';
import { useEffect } from 'react';

function useLinkHandler() {
  let router = useRouter();

  useEffect(() => {
    let onClick = e => {

kaspth

class Object::Proxy < SimpleDelegator
  def initialize(object, **values)
    super(object)
    @values = values
  end

  def method_missing(name, ...)
    @values.fetch(name) { super }
  end
end

okuramasafumi

require 'syntax_tree'

class RSpecEnvironment
  def initialize
    @contexts = []
    @results = []
  end

  def klass(k)
    @contexts << k

skatkov

# config/environments/test.rb

ActiveSupport.on_load(:active_record_postgresqladapter) do
  # For this optimization to work, you need to recreate your test database
  self.create_unlogged_tables = true
end