Forem: @kon_yu

How to debug Rails running on Ruby 3.1 using VSCode and Dev Containers

@kon_yu — Fri, 17 Mar 2023 08:45:25 +0000

Overview

Docker and Docker compose are now commonly used to build development environments on developers' machines. Until now, developers have been running the docker compose command from the terminal to test and verify their work, but we propose a more convenient way to develop with VS Code using the Dev Containers extension of VS Code.
In this article, I will introduce how to use VS Code's debugging features with Dev Containers in a Rails project using the debug.gem of Ruby 3.1.

Please refer to the previous article in the link below to learn how to set up the features we will be introducing.

How to use Docker containers for Ruby on Rails development in Visual Studio Code

Purpose

To make it more convenient to develop Rails using VS Code and Docker (Containers below refers to Docker containers and containers launched with Docker Compose)

Use VS Code's debugging feature to set breakpoints in the GUI for a debugging experience similar to RubyMine's debugger.
Establish a debug execution method through debug.gem (rdbg) in Rails projects running on Ruby 3.1 or later.

Body

Preparation

The sample code for this article can be found at the following URL (vscode tag)

GitHub - konyu/base_rails at vscode

Prerequisites

We tested the following environment

Mac with M2 CPU
Docker desktop for mac: 4.16.2
Ruby: 3.2.1
Rails: 7.0.4
MySQL: 8

Detailed version information can be found in the Dockerfile and docker-compose.yml.
Create an appropriate Rails project with the rails new command and create Post and Comment models with scaffold.

Please refer to the previous Blog for details on environment setup.
We have also installed VSCode rdbg Ruby Debugger, which is a necessary extension for this project. The following is a list of the extensions that are required for this project.

Let's develop Rails using Docker with VSCode ~Dev Containers~

Debug configuration using debug.gem

This section describes settings using debug.gem introduced in Ruby 3.1.

Please note that this is a work-around and there are some unclear points. (There are still some things that are unclear, such as the fact that bundle exec rails does not work well with the commands in launch.json, but bin/rails does work.

First, create a .vscode/launch.json file for use in the debugging part of VS Code in the right panel.

{
    "version": "0.2.0",
    "configurations": [
        {
            //Start Rails server
            "name": "Debug Rails",
            "type": "rdbg",
            "request": "launch",
            // "command": "bundle exec rails", #bundle exec rails won't stop in the debugger
            "command": "bin/rails",
            "script": "s",
            "args": ["-b","0.0.0.0"],
        },
        {
            // Run tests on the active rspec file
            "name": "Debug Rspec with current file",
            "type": "rdbg",
            "request": "launch",
            "command": "bundle exec rspec",
            "script": "${file}",
            "args": [],
             // Confirm the executed command in the window. Make it easy to specify options such as execution of 
            "askParameters": true
        }
    ]
}

Debug Rails startup

Select Debug Rails in Run and Debug to launch Rails and stop it at a breakpoint.

Debug Rspec

Display the file with the target test code in the forefront of the editor, then select Debug Rspec with current file to run that test code.

Tips Shortcut for debug execution.

F5 executes the currently active one.

You can also use Shift+F5 to execute without stopping in the debugger.

Considerations

Compare Pros/Cons of starting Rails server and running Rspec in Terminal

Pros

It allows you to temporarily enable/disable breakpoints, so if you insert a binding.debug line into your code, it will always stop, making it easier to investigate.
- This is especially useful when starting the Rails server to investigate the cause of a bug.
- Useful in situations where you want to disable a breakpoint once inside a loop

The GUI is intuitive because you can perform Step Over and other functions necessary for debugging, and there are also shortcuts such as F10, which is also convenient.

Cons

In the debug console, it's a pain to navigate to variables, panels to execute methods, or to use the mouse to display the terminal.
- In fact, we have adjusted the shortcuts for VS code on the Mac to counteract this problem.

Conclusion

I proposed a method of debugging Rails using debug.gem introduced in Ruby 3.1 in a local development environment for Rails projects using Docker (Docker Compose).

I have been looking for a way to debug Rails using debug.gem, but I couldn't find it, so I was able to establish a way to do it myself.

Reference link

How to use Docker containers for Ruby on Rails development in Visual Studio Code

@kon_yu — Fri, 17 Mar 2023 07:25:41 +0000

Introduction

It has become common practice to use Docker and Docker compose when building a development environment on a developer's machine. The theory is to run the docker compose command from the terminal to test and verify the operation, but we propose a convenient way to develop with VS Code by using the Dev Containers extension of VS Code.

In this article, we will show you how to set up Dev Containers using a Rails project.

If you want to debug using VS Code's debugging features, please refer to this post

How to debug Rails running on Ruby 3.1 using VSCode and Dev Containers

Purpose

To make Rails more convenient using VS Code and Docker (where Containers is mentioned below, it refers to Docker Containers and the group of containers launched with Docker Compose).

You can run a terminal in a container as if you were accessing a remote server via SSH, so you don't have to type docker commands like docker compose exec xxxx to make your development work easier.
The ability to specify VS Code extensions to run in the container standardizes the development environment by eliminating the need for developers to install and configure extensions such as Rubcop and Solargraph individually.

Body

Preparation

The sample code for this article can be found at the following URL (vscode tag)

GitHub - konyu/base_rails at vscode

Prerequisites

We tested the following environment

Mac with M2 CPU
Docker desktop for mac: 4.16.2
Ruby: 3.2.1
Rails: 7.0.4
MySQL: 8
Detailed version information can be found in the Dockerfile and docker-compose.yml.
Create an appropriate Rails project with the rails new command and create Post and Comment models with scaffold.

Create a base Dockerfile to run Rails



FROM ruby:3.2.1
ENV ROOT="/app"
ENV LANG=C.UTF-8
ENV TZ=Asia/Tokyo

WORKDIR ${ROOT}

COPY Gemfile ${ROOT}
COPY Gemfile.lock ${ROOT}

RUN gem install bundler
RUN bundle install --jobs 4

Create a docker-compose.yml to define middleware.



version: '3'
services:
  web:
    build: .
    command: /bin/sh -c "rm -f tmp/pids/server.pid && bundle exec rails s -p 3000 -b '0.0.0.0'"
    volumes:
      - .:/app:cached
      - bundle-volume:/usr/local/bundle
    ports:
      - 3000:3000
    depends_on:
      - db
    tty: true
    stdin_open: true
  db:
    image: mysql:8
    volumes:
      - mysql-volume:/var/lib/mysql
    environment:
      MYSQL_ROOT_PASSWORD: password
      TZ: "Asia/Tokyo"
    ports:
      - "3306:3306"
volumes:
  bundle-volume:
  mysql-volume:



docker compose up

Create a database



docker compose run --rm web rails db:prepare

Access http://localhost:3000
and verify that the top page is displayed.

Configure container settings for remote

Install the VS Code extension Remote Development.

Add from the following link

https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.vscode-remote-extensionpack

Since this is a pack of features for the following four expansion periods, you may only install Dev Containers for this use

Remote - SSH - Work with source code in any location by opening folders on a remote machine/VM using SSH. Supports x86_64, ARMv7l (AArch32), and ARMv8l (AArch64) glibc-based Linux, Windows 10/Server (1803+), and macOS 10.14+ (Mojave) SSH hosts.
Remote - Tunnels - Work with source code in any location by opening folders on a remote machine/VM using a VS Code Tunnel (rather than SSH).
Dev Containers - Work with a separate toolchain or container based application by opening any folder mounted into or inside a container.
WSL - Get a Linux-powered development experience from the comfort of Windows by opening any folder in the Windows Subsystem for Linux.

Add a configuration file to recommend (but not functionally enforce) the installation of this extension for other members.

.vscode/extensions.json



{
"recommendations": [
  "ms-vscode-remote.vscode-remote-extensionpack", // Remote Development
]
}

Create a configuration file for Dev Containers.

.devcontainer/devcontainer.json



{
    "name": "Existing Docker Compose",
    "dockerComposeFile": [ //Override the first configuration with a second docker-compose.yml
"../docker-compose.yml",
"docker-compose.yml"
    ],
    "service": "web",//Specify the service name and Rails service to be started as described in docker-compse.yml
"workspaceFolder": "/app"//　The directory to connect to at startup
}

Create a docker-compose.yml to override, so that Rails is not started by the startup command.

.devcontainer/docker-compose.yml



version: '3'

services:

web:

  # Prevent Rails from starting when docker starts

  command: /bin/sh -c "while sleep 1000; do :; done"

Open a container from VS Code.

Click on the green area in the lower left corner of VS Code or select Ropen in Container from the command palette. Specify the extensions to use in the container

Specify extensions to use inside the container

Extensions installed outside of a container cannot be used inside a container. They must be installed anew. This may seem inconvenient at first glance, but extensions to be used in a container can be specified in a configuration file to simplify setup.

In this case, the following extensions will be installed

solargraph
rubocop
Ruby extension
rdbg * for debugging

Add .devcontainer/devcontainer.json file.



{

  // omitted

// Extensions to use in containers

    "customizations": {

        "vscode": {

            "extensions": [

                "castwide.solargraph", // solargraph

                "rebornix.Ruby", // Ruby syntax highlighting, etc.

                "misogi.ruby-rubocop", // Rubocop

                "KoichiSasada.vscode-rdbg", // Ruby Debug see below

            ]

        }

    }

}

Configure VS Code for your project.

Configure project-specific settings. Here we set the indentation of Ruby to space 2.

.vscode/settings.json



{

  "[ruby]": {

      "editor.tabSize": 2

  }

}

Add gem for Solergraph and Rubocop to Gemfile

Specify the gem to be installed for use in extensions.



group :development do

gem 'solargraph'

gem 'rubocop', require: false

gem 'rubocop-rails', require: false

gem 'rubocop-performance', require: false

end

Confirmation of plugin operation

Please confirm that Rubocp and Solargraph are running by launching the container from VS Code.

Rubocop.

The familiar Linter for Ruby can be found in the Problems panel.

Solargraph

It is a useful tool for auto-completion and jumping to method and class definitions. If you are not using it, please try it.

The combination of Solargraph and VS Code is complicated to set up if you try to run it from outside a container, but using Dev Containers makes it easy to set up.

Solargraph: A Ruby Language Server

Rhythm of Rails development with Dev Containers

By using Dev Containers to develop, you can open a terminal in a Rails container, so you can develop as if you were developing locally without using Docker.

When executing commands from outside the container to Rails inside the container, you need to consider both Docker commands and Rails commands, which can be a bit brain-intensive.

If you set up Docker Compose to start Rails at startup, it is convenient to compare the commands to Rails from outside the container and the commands to Rails from inside the container, as shown in the table below.

Commands to Rails from outside the container	Commands to Rails from inside the container
docker compose run --rm web bundle install	bundle install
docker compose run --rm web bin/rails db:migrate	bin/rails db:migrate
docker compose exec web bin/rails c	bin/rails c
docker compose exec web bundle exec rspec	bundle exec rspec
docker compose run -e EDITOR=emacs web bin/rails credentials:edit	bin/rails credentials:edit

You can also start the rails server from the Terminal panel and run rspec from the terminal, so you can stop at breakpoints to check the operation.

Tips

If you want to get out of the container

Run Reopen Folder Locally from the command palette.

If you think your configuration is not reflected.

It is easy to solve this problem by rebuilding the container. You can try either of the following from the command palette

Pros and Cons

Pros

VS Code extensions can be standardized among development members
Easier to set up extensions that use Ruby in containers
VS Code terminal can work in a container, so you can skip Docker (Docker Component) commands for development
Easier to debug with breakpoints when launching Rails in a development environment
Easier to check operation and investigate bugs because docker attach command is not required

Cons

Not applicable for editors other than VS Code
Dev Containers extension is a bit quirky
Can't use the shell settings in the container with the usual development environment
Should we include Zsh, incremental search, aliases, etc.

Conclusion

I have shown how to use Docker and Docker compose and the VS Code extension Dev Containers when developing with VS Code, and I have shown an example from a Rails project.

Personally, my favorite part is the ease of setting up Solargraph and not having to use the docker attach command.

How to Get mp3 file's Durations with Python

@kon_yu — Mon, 14 Sep 2020 03:48:23 +0000

How to get durations of mp3 files are two ways.
One of them is using mutagen, the other is using pysox.
Each method has its own advantages and disadvantages.

The way using mutagen is lightweight, and faster than the way using pysox.

That's why mutagen just checks ID3 tag of mp3 files. The other hand, pysox seems to check binaries of mp3 files through Sox CLI.

The pysox method allows us to determine the duration without using ID3 information, i.e. to recognize files with invalid ID3 information or files without ID3 information. Using pysox, you can find out the duration of a file without using ID3 information, i.e. you can detect the duration of a file with invalid or no ID3 information.

The mutagen way example



from mutagen.mp3 import MP3

def mutagen_length(path):
    try:
        audio = MP3(path)
        length = audio.info.length
        return length
    except:
        return None

length = mutagen_length(wav_path)
print("duration sec: " + str(length))
print("duration min: " + str(int(length/60)) + ':' + str(int(length%60)))

The pysox way example

note: pysox needs SOX cli.



import sox

def sox_length(path):
    try:
        length = sox.file_info.duration(path)
        return length
    except:
        return None

length = sox_length(mp3_path)

print("duration sec: " + str(length))
print("duration min: " + str(int(length/60)) + ':' + str(int(length%60)))

Jun 24 '20

try pyxsox

I tried to use pysox to the audio file which includes this question post

note: pysox needs SOX cli.

how to use it is like this.

import sox
mp3_path = "YOUR STRANGE MP3 FILEPATH"
length = sox.file_info.duration(mp3_path)
print("duration sec: " + str(length))
print("duration min: " + str(int(length/60)) +

…

Open Full Answer

How to create a string of numbers with , $, €, or £ in JavaScript.

@kon_yu — Fri, 11 Sep 2020 04:40:33 +0000

To display a string of money in JavaScript with a comma, use the toLocaleString method.

ref: toLocaleString specification: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString

Japanese Yen

const price = 1234567890.1234
const jpy = price.toLocaleString('JP',
  { style: 'currency', currency: 'JPY' })

console.log(jpy)
// => ￥1,234,567,890

U.S. dollar

const price = 1234567890.1234
const usd = price.toLocaleString('US',
  { style: 'currency', currency: 'USD',})

console.log(usd)
// => $1,234,567,890.12"

Euro

const price = 1234567890.1234
const eur = price.toLocaleString('DE',
  { style: 'currency', currency: 'EUR' })
console.log(eur)
//=> 1.234.567.890,12 €

British pound

const pond = price.toLocaleString('GB',
  { style: 'currency', currency: 'GBP',})
console.log(pond)
//=> "£1,234,567,890.12"

Using JavaScript to determine whether the client is iOS or Android

@kon_yu — Mon, 07 Sep 2020 08:23:22 +0000

Introduction.

Contents of this function

Use ES2015 arrow functions.
When a web page is displayed in a browser, the OS of the access source is determined based on the user agent.
Reflects iOS, Android and other operating systems using regular expressions

User agents for each OS are available at here.

The iPad is now iPadOS instead of iOS from 13, and if you're set to display a website for a PC, it won't include the iPad in the UserAgent, so you'll have to make a tricky decision.
ref: https://stackoverflow.com/a/57924983/4480860

const getMobileOS = () => {
  const ua = navigator.userAgent
  if (/android/i.test(ua)) {
    return "Android"
  }
  else if (/iPad|iPhone|iPod/.test(ua))
     || (navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1){
    return "iOS"
  }
  return "Other"
}

Usage

const os = getMobileOS()
# console.log(os) => 'Android'
# console.log(os) => 'iOS'
# console.log(os) => 'Other'

Explanation of supplementary regular expressions

An example of /android/i.test(ua) used in the described functions

/android/ is the body of the regular expression
The "i" in /android/i is a regular expression flag and does not detect case.
- It will be compatible with Android, ANDROID and aNdRoId.
- The /android/i checks if any part of the string to be validated contains "android" regardless of the case of the string.
The test method of /android/i.test(ua) returns true/false whether the string contained in the argument ua hits the regular expression of /android/i or not.

Let's organize how to write asynchronous processing using arrow functions and async/await

@kon_yu — Sun, 06 Sep 2020 05:45:15 +0000

Introduction.

In today's modern browsers and smartphones, the use of Arrow functions and Promise using Async/Await doesn't need to be transpiled in Babel.

If you look into how to use these JavaScript functions individually, you'll find a lot of old ways of writing them, and you'll be confused as to how to write them in a modern way.

how to define a function in an arrow function and use async/await in it What happens when async/await is called in a nested manner?
how to execute multiple things that run asynchronously and wait for the results

The following table summarizes the

Browser support for each function

You can check the behavior from the demo link below. It's easier to understand how it works if you check the action while changing the value.
DEMO

How to write async/await using arrow functions

Example of a method that sleeps a few 100ms

You can use it as a dummy for an example to retrieve data asynchronously, like the Fetch method.

// sleep method Promise function that returns a time-consuming result such as fetch.
const sleep = (m) => new Promise( _ => setTimeout(_, m))

// Promise to use async-await to output a character after the Promise ends.
// Wait a few hundred ms at random.
const asyncFunc = async (mes) => {
    const waitTime = Math.floor((Math.random() * 100) + 1)
    await sleep(waitTime)
    console.log(mes)
    return `result_${mes}`
}

Enclose async at the head of the method, const asyncFunc = async (mes) => {

Attach an await to the asynchronous method await sleep(waitTime) when waiting for the completion of the method to be executed asynchronously.

If you define it in this way, you need to await to get the result_${mes} from asyncFunc itself. This isn't very easy.
The return value is not a string but a Promise object. This complicates JS already.

To get the result of the return, you need to prefix the method with await asyncFunc("message") and await in the caller.

what happens when async/await is called nested

To execute Awai, as shown in the following example, we need to create parentFunc using async and execute it in that function.
Please check the actions of basic, basic 2, and basic 3 in this function and see what comes back.
If you want to make sure that the last line of this function completes all the results of the previous commands, you can write it as in Basic 3.

In short, all you have to do is to write "await" before the function defined in async.

const parentFunc = async () => {
  // The method using async will return a promise, so if you don't call it using async, you can't use awit and it will be asynchronous processing.
  const async = asyncFunc
  const sync = asyncFunc

  // The Basics
  console.log(async("async")) // The Promise object just returns
  console.log("---1---") // 1
  console.log(await sync("sync")) // 2

  // Basic 2
  console.log(await sync("sync2")) // 1
  console.log(async("async2")) // It just returns the Promise object
  console.log("---2---") // 2

  // Basic 3
  const resultSync = await sync("sync3") // 1
  console.log(await sync(resultSync)) // 2 Wait for the resultSync result and then run it
  console.log("---3---") // 3
}

parentFunc() //Execute the parentFunc defined above here

Execute the function defined by async in an unnamed function

You can execute it without defining "parentFunc", but you need to write a lot of parentheses, which are difficult to understand, and the way to write it is not intuitive.
However, you need to write a lot of parentheses that are not easy to understand and the way to write it is not intuitive. I wouldn't say I like this kind of thing very much.

(async () => {
  console.log(await asyncFunc("run a promise method that defines an anonymous function in async and executes it asynchronously"))
})()

How do I run multiple things that run asynchronously and wait for the results?

Unfortunately, we need to write the Promise that we hid in the async/await code.
The keyword is Promise.all.
Promise.all, which is similar to the process of waiting for all threads to complete.

const parentFunc = async () => {
  // The method using async will return a promise, so if you don't call it using async, you can't use awit and it will be asynchronous processing.
  const async = asyncFunc
  const sync = asyncFunc

  // When asynchronous processing is entered in the map function
  // To take an array of id's and access the web API with each id as a parameter
  const arr = [1, 2, 3, 4, 5]

  // The order of the resultant array is the order of arr, even if the order in which each method in the map completes its execution is different.
  const result_arr1 = await Promise.all(arr.map((id)=>{
    return sync(id);
  })))
  console.log(result_arr1)
}

parentFunc()

How to Solve a AWS Lambda error - Runtime.ImportModuleError: Error: Cannot find module 'jmespath'

@kon_yu — Thu, 18 Jun 2020 08:56:50 +0000

AWS Lambda scripts written in nodejs8 were deprecated.
You run the same scripts via AWS Lambda nodejs10 or nodejs12 environment and may hit the following error message.



{"errorType":"Runtime.ImportModuleError","errorMessage":"Error: Cannot find module 'jmespath'","stack":["Runtime.ImportModuleError: Error: Cannot find module 'jmespath'","    at _loadUserApp (/var/runtime/UserFunction.js:100:13)","    at Object.module.exports.load (/var/runtime/UserFunction.js:140:17)","    at Object.<anonymous> (/var/runtime/index.js:36:30)","    at Module._compile (internal/modules/cjs/loader.js:701:30)","    at Object.Module._extensions..js (internal/modules/cjs/loader.js:712:10)","    at Module.load (internal/modules/cjs/loader.js:600:32)","    at tryModuleLoad (internal/modules/cjs/loader.js:539:12)","    at Function.Module._load (internal/modules/cjs/loader.js:531:3)","    at Function.Module.runMain (internal/modules/cjs/loader.js:754:12)","    at startup (internal/bootstrap/node.js:283:19)"]}

I hit the same problem Error: Cannot find module 'jmespath' and solved it.

Do you use aws-sdk via node_modules? like follows



var aws = require('aws-sdk');

If so you just remove aws-sdk from node_modules.

to remove aws-sdk for yarn



yarn remove aws-sdk

remove aws-sdk for npm



npm uninstall aws-sdk

aws-sdk has been included to lambda since nodejs10. see: https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html

Jun 18 '20

I hit the same problem Error: Cannot find module 'jmespath' and solved it.

Do you use aws-sdk via node_modules? like follows

var aws = require('aws-sdk')

If so you just remove aws-sdk from node_modules.

remove aws-sdk for yarn

yarn remove aws-sdk

remove aws-sdk for npm

npm uninstall aws-sdk

aws-sdk has been…

Open Full Answer

How to do not apply basic authentication to certain URLs in a Rails project with basic authentication method

@kon_yu — Tue, 16 Jun 2020 05:44:35 +0000

If you can write basic authentication in a staging environment or other environment, you can use the configuration file
For example, the following in the config/environment/production.rb

if ENV["STAGING"] #set environmental variable
  config.middleware.use Rack::Auth::Basic do |username, password|
    username == "YOUR_NAME" && password == "PASSWORD"
  end
end

Now, if you want to access certain URLs without using basic authentication, you need to extend Rack::Basic Auth::Basic to access certain URLs without using basic authentication.

There are several ways to write it, but the following conditions should be met

Only enable in the staging environment.
Do not apply basic authentication to certain URLs that match a regular expression.
Put the extended class files under the lib directory instead of config.ru. The file should be a separate file with the

Automatic loading of lib directory

If you want to have the lib directory and below loaded automatically, configure as follows
This way, you don't have to read every single class under the lib directory.
(You don't have to have it loaded, depending on your method.)

config/application.rb

module YourApp
  class Application < Rails::Application
    # Load the files under the lib directory
    # Rails4
    config.autoload_paths += Dir["#{config.root}/lib/**/"]
    # Rails5 or Rails6
    config.eager_load_paths << Rails.root.join("lib")
  end
end

Creating the Rack::Auth::Basic extension class

Extend lib/my_basic_auth.rb with the following class for basic authentication Create a file with

class MyBasicAuth < Rack::Auth::Basic
  def call(env)
    request = Rack::Request.new(env)
    # Match regex hits are not basic authentication
    if request.path.match(/^\/.well-known/)
      # Pass basic authentication
      @app.call(env)
    else
      # Execute basic authentication
      super
    end
  end
end

Loading Custom Basic Authentication into the Configuration File for the Staging Environment

config/environment/production.rb

Rails.application.configure do
  if ENV["STAGING"]  #set environmental variable
    # Load MyBasicAuth
    config.middleware.use MyBasicAuth do |username, password|
      username == "YOUR_NAME" && password == "PASSWORD"
    end
  end
  ..
  .
end

refs:
http://stackoverflow.com/questions/6049414/selectively-allow-some-urls-through-rackauthbasic
http://stackoverflow.com/questions/22336048/staging-env-password-protect-everything-except-for-webhook

Rake to flush out and delete unused image files in Rails

@kon_yu — Tue, 16 Jun 2020 04:50:14 +0000

Introduction.

If you run a web service for a few years, before you know it, you'll have an image file that you don't use at all.
It's hard to check if you're not using each one of them, so I'll use the Rake task to flush out all the unused image files and delete them.

Rake tasks are performed and committed in a local environment.

In this case, I use the silver searcher as a file search command.
The silver searcher checks the .gitignore file, for We don't want the files to be searched for.
You can exclude the gem from the search, which makes the process faster, for example, if you install the gem under /vendor/bundler.

Prerequisites.

For Git-managed Rails projects
You must have the silver searcher installed on your computer.

Install the silver searcher on homebrew

If you don't have the silver searcher installed, you can easily install it with homebrew.

brew install ag

Rake files to flush out and delete unused image files in Rails

Rake file body

# It requires AG - https://github.com/ggreer/the_silver_searcher
task :find_unused_images do
  images = Dir.glob("app/assets/images/**/*")

  images_to_delete = []
  images.each do |image|
    unless File.directory?(image)
      puts "Checking #{image}"
      # Use -G to specify the extension to check.　You can use --ruby, --sass options.
      result = `ag -G "slim|erb|js|css|sass|scss|rb" #{File.basename(image)} .`

      if result.empty?
        images_to_delete << image
      end
    end
  end
  puts "Delete unused files running the command below:"

  puts images_to_delete.join(" \n").to_s

  puts "-----------------------------------"
  puts "rm #{images_to_delete.join(" ")}"
end

Usage

> bin/rake find_unused_images

Execution result

# Searching for a file
Checking app/assets/images/xxx1.png
Checking app/assets/images/xxx/xxx2.png
..
.
# List of unused files
Delete unused files running the command below:
app/assets/images/xxx1.png
app/assets/images/xxx/xxx2.png
..
.
# The rm command to delete unused files in one shot
rm app/assets/images/xxx1.png　app/assets/images/xxx/xxx2.png

How to use (almost) all the functions of Enumerable modules: select, inject, take, and so forth

@kon_yu — Mon, 08 Jun 2020 04:31:42 +0000

Introduction.

If you only use each and map(collection), it's hard to refine your code.
So we'll give you an example of a method that can be used in the class Array, Hash, etc., which inherits from the Enumerable module, and we'll call
I would like to write an example of the same process with "EACH" to see how useful it is

I've left out some methods that are not very useful (like #zip)
If you have something you'd like to use in these places, I'd appreciate your comments and editing requests.
Also, I'm leaving out #lazy because it's a different color, and the real-world uses of lazy are I'm not sure.

all?

Returns true if all elements meet the conditional expression in the block.

usage

[1,2,3].all? { |v| v > 0 }
=> true

[1,2,3].all? { |v| v > 1 }
=> false

If you write in "each"

flg = true
[1,2,3].each do |v|
  if v <= 0
    flg = false
    break
  end
end
p flg
=> true

any?

If any one of the elements satisfies a conditional expression in the block, it returns true.

usage

[1,2,3].any? { |v| v == 2 }
=> true

If you write in "each"

flg = false
[1,2,3].each do |v|
  if v == 2
    flg = true
    break
  end
end
p flg
=> true

collect, map

Returns an array with all elements evaluated in a block
Collect and map work the same way.
I think map is used more often.

You'll feel like you're using Ruby if you can use the map instead of each.## usage

# Returns an array with each term doubled
[1,2,3].collect { |v| v * 2 }
=> [2, 4, 6]

[1,2,3].map { |v| v * 2 }
=> [2, 4, 6]

If you write in "each"

result = []
[1,2,3].each do |v|
  result << v * 2
end
p result
=> [2, 4, 6]

collect_concat, flat_map

Expand and return an array with all elements evaluated in a block
collect_concat and flat_map work the same way.
Combining map and flatten movements

I think map + flatten is more readable, as in the following example

usage

# Returns an array with each term doubled
[[1, 2], [3, 4]].flat_map { |v| v.map { |cv| cv * 2 } } 
=> [2, 4, 6, 8]

# When you combine map and flatten
[[1, 2], [3, 4]].map { |v| v.map { |cv| cv * 2 } }.flatten
=> [2, 4, 6, 8]

If you write in "each"

result = []
[[1, 2], [3, 4]].each do |v|
  v.each do |cv|
    result << cv * 2  
  end
end
p result
=> [2, 4, 6, 8]

count

Evaluate all elements in a block and return the number of true objects.
Returns the same number of elements as size or length if there is no block.

usage

# number of elements
[1,2,3].count
=> 3 

# Number of things with a value of 3
[1,2,3].count(3)
=> 1 

# Able to use a string
["1","2","3"].count("1")
=> 1 

# return an odd number
[1,2,3].count{ |v| v.odd? }
=> 2

# If you select and then count the size of the array, you can write
[1,2,3].select{ |v| v.odd? }.size

If you write in "each"

result = 0
[1,2,3].each do |v|
  result += 1 if v.odd?
end
p result
=> 2

detect, find

Evaluate all elements in the block and return the first element that is true
No further elements of the array are evaluated

I think it's more common to use "any?
or "select" to get all the elements that match a certain condition are more often used.

I think I use find more often than detect.

usage

# Returns the first element in the array with a value between 3 and 5
[1,3,7].detect { |v| (3..5).include?(v) } 
=> 3 

[1,3,7].find { |v| (3..5).include?(v) } 
=> 3

If you write in "each"

result = nil
[1,3,7].each do |v|
  if (3..5).include?(v)
    result = v
    break
  end
end
p result
=> 3

drop

Discard an Integer number of elements from the top and return an array of the remaining elements
It's nice that it returns an empty array without an error, even when the argument is larger than the size of the array.

usage

[1,2,3,4].drop(2)
=> [3.4]

# Even if the size of the array is larger than the size of the array, it is not an error.
[1,2,3,4].drop(5)
=> []

If you write in "each"

result = []
drop_num = 2
i = 0
[1,2,3,4].each do |v|
  i += 1
  next if i <= drop_num
  result << v
end
p result
=> [3.4]

# You can also use each_with_index to index the array, of course you can use drop to make it easier
result = []
drop_num = 2
[1,2,3,4].each_with_index do |v, i|
  next if i < drop_num
  result << v
end
p result
=> [3.4]

take

Extract the Integer number of elements from the top and return an array of them
It's nice that it returns an empty array without an error, even when the argument is larger than the size of the array.

It's good to remember that drop and take are a pair of functions

usage

[1,2,3,4].take(2)
=> [1.2]

# Even if the size of the array is larger than the size of the array, it is not an error.
[1,2,3,4].take(5)
=> [1, 2, 3, 4]

If you write in "each"

result = []
take_num = 2
i = 0
[1,2,3,4].each do |v|
  i += 1
  break if i > take_num
  result << v
end
p result
=> [1.2]

# You can also use each_with_index to write an array with an index number, of course you can use take to make it easier
result = []
take_num = 2
[1,2,3,4].each_with_index do |v, i|
  break if i >= take_num
  result << v
end
p result
=> [1.2]

drop_while

When a condition in a block is hit, discard the previous element and return the remaining elements in an array
If you want to discard the sorted sequences that are smaller than a certain condition, it's probably a good idea because, unlike the reject, not everything is evaluated.

usage

[1,2,3,4].drop_while { |v|  v < 3 }
=> [3, 4]

# Over here, I'd also rate 4. 
[1,2,3,4].reject { |v|  v < 3 }
=> [3, 4]

If you write in "each"

result = []
drop_num = 2
i = 0
ary =[1,2,3,4]
ary.each do |v|
  i += 1
  next if i <= drop_num
  result = ary[(i - 1)..-1]
  break
end
p result
=> [3, 4]

take_while

When the condition in the block is no longer hit (returning false), discard the subsequent elements and return the remaining elements in an array.
In the case of drop_while and sorted arrays, it may be better to discard all arrays that are smaller than a certain condition, because, unlike with select, everything is not evaluated.

usage

[1,2,3,4].take_while { |v| v < 3 }
=> [1, 2]

# Over here, I'd also rate 4.
[1,2,3,4].select { |v| v < 3 }
=> [1, 2]

If you write in "each"

result = []
take_num = 2
i = 0
[1,2,3,4].each do |v|
  i += 1
  break if i > take_num
  result << v
end
p result
=> [1, 2]

each_with_index

Pass the index of an element and its number of indices to the block for processing.
Indexed array using map.with_index rather than each_with_index I'm more likely to use it to return

usage

ary = []
[1,9,5,2].each_with_index { |v, i|  ary << [v, i] }
p ary
=> [[1, 0], [9, 1], [5, 2], [2, 3]]


# If you use map.with_index, it will look like this
[1,9,5,2].map.with_index { |v, i| [v, i] }
=> [[1, 0], [9, 1], [5, 2], [2, 3]]

If you write in "each"

result = []
i = 0
[1,9,5,2].each do |v|
  result << [v, i]
  i += 1
end
p result
=> [[1, 0], [9, 1], [5, 2], [2, 3]]

to_a, entries

Return an array containing all the elements (I see the explanation but it doesn't quite fit)
You can use hash to return an array of [key, value] combinations.
In Rails, I would use it to store ActiveRecord objects in the cache.

User.where(state: "alive").to_a

usage

{ a: 1, b: 2, c:3 }.entries
=> [[:a, 1], [:b, 2], [:c, 3]]


{ a: 1, b: 2, c:3 }.to_a
=> [[:a, 1], [:b, 2], [:c, 3]]

If you write in "each"

result = []
{ a: 1, b: 2, c:3 }.each do |v|
  result << [v.first.to_s, v.last]
end
p result
=> [[:a, 1], [:b, 2], [:c, 3]]

find_all, select

Evaluate each element in a block and return an array of only those that are true. If they are all false, it returns an empty array.

I wonder if I'll ever connect select + map together.

usage

[1, 2, 3, 4].find_all { |v| v.even? }
=> [2, 4]


# one could also write this way
[1, 2, 3, 4].select(&:even?)
=> [2, 4]

If you write in "each"

result = []
i = 0
[1, 2, 3, 4].each do |v|
  result << v if v.even?
end
p result
=> [2, 4]

reject

Evaluate each element in the block and return an array of only those that are false. If they are all true, it returns an empty array.
Think of it as the opposite of select, used when you want to remove a hit condition in a block.## usage

[1, 2, 3, 4].reject { |v| v.even? }
=> [1, 3]


# I could write this or that. I could write this or that, but it wouldn't perform well.
ary = [1,2,3,4]
ary - ary.select{ |v| v.even? }
=> [1, 3]

If you write in "each"

result = []
i = 0
[1, 2, 3, 4].each do |v|
  result << v if v.even?
end
p result
=> [2, 4]

partition

Evaluate each element in a block and return two arrays that are true and false.
You can think of it as a pair of selects and rejects

usage

[1, 2, 3, 4].partition { |v| v.even? }
=> [[2, 4], [1, 3]]

If you write in "each"

result = [[], []]
[1, 2, 3, 4].each do |v|
  if v.even?
    result[0] << v
  else
    result[1] << v
  end
end
p result
=> [[2, 4], [1, 3]]

find_index, index(In case of Array)

Evaluate each element in the block and return the index (how many) of the first one to be true. If they are all false, it is nil.
In the case of Array, the index method is an alias. The main thing is that the index.

usage

[1, 2, 3, 4].find_index { |v| v.even? }
=> 1

# one could also write this way
[1, 2, 3, 4].index { |v| v.even? }
=> 1

# It probably wouldn't make sense to use it in the case of Hash, but it could be written like this
{a: 1, b: 2}.find_index { |v| v.last.even? }
=> 1

If you write in "each"

result = nil
index = 0
[1, 2, 3, 4].each do |v|
  if v.even?
    result = index
    break
  end
  index += 1
end
p result
=> 1

first, last(in case of Array)

Retrieves the first element or the numeric element of an argument from the beginning of an element.
In the case of the Array, there is also a last that you can get from behind.

The empty array of
If there are no arguments, nil will be returned, and if there are arguments, the movement will return an array from
In the case of arguments, I think it's easier to use the take method

usage

[1, 2, 3, 4].first
=> 1

# If an argument is present
[1, 2, 3, 4].first(2)
=> [1, 2]

# In the case of the last
[1, 2, 3, 4].last(2)
=> [3, 4]

If you write in "each"

# First with no arguments, don't use "each"
result = [1, 2, 3, 4][0]
p result
=> 1

# If you write [1, 2, 3, 4].first(2) using
result = []
index = 0
num = 2
[1, 2, 3, 4].each do |v|
  unless index < num
    break
  end
  result << v
  index += 1

end
p result

grep

Returns an array of all elements that match the pattern argument.
pattern must have a === method.
Specifically, it is used to extract the matching regular expression using Regexp object.

Attaching a block returns an array containing the result of evaluating the elements of the block for each element of the matched array
The contents of the Array must be a simple Integer or String to work, or else If you want to make it work in your class, you'll probably need to extend the #=== method. If you want to do something tricky, it's probably easier to use the select method

Imagine using map + match together

usage

# Without blocking

["1", "2", "3"].grep(/2/)
=> ["2"]

# Without grep, it looks like this
["1", "2", "3"].map{ |v| v if v.match(/2/) }.compact
=> ["2"]

# If you have a block, multiply the number of matched "2" by a number and then double it.
["1", "2", "3"].grep(/2/){ |v| v.to_i * 2 }
=> [4]

If you write in "each"

# Make the number two of a match and then double it

result = []
["1", "2", "3", "4"].each do |v|
  if v.match(/2/)
    result << v.to_i * 2
  end
end
p result
=> [4]

member?, include?

Each element returns the evaluation value of the argument and ==. In short, it returns true if included, false if not included.

The ActiveSupport feature in Rails has an in? method like the reverse of the include?

usage

[1, 2, 3].include?(2)
=> true
[1, 2, 3].member?(2)
=> true

# Railsのin?メソッドはinclude?の逆のイメージ
2.in?([1, 2, 3])
=> true

If you write in "each"

result = false
num = 2
[1, 2, 3].each do |v|
  if v == num
    result = true
    break
  end
end
p result
=> true

inject, reduce

Returns the sequential value of the result of each block, the first one being the initial value if the argument is omitted.
When you pass a Symbol object as an argument, the method represented by the Symbol of each element is executed If you pass :+, it returns whether you executed the + method of each element.

I personally like this method, it feels good to put a shot on it.

usage

# The sum of each element with an initial value of 100
[1, 2, 3].inject(100) { |sum, v| sum + v}
=> 106

# You could write like this
[1, 2, 3].reduce(100) { |sum, v| sum + v}
=> 106

# If no argument is omitted
[1, 2, 3].inject{ |sum, v| sum + v}
=> 6

# You can use in Symbol and you can write this

[1, 2, 3].inject(:+)
=> 6

# When you want to create sample data, you can use
# 1 to 3, or a randomized array of values.
(1..3).inject([]){ |sum, v| sum << v}.shuffle
=> [1, 2, 3]

If you write in "each"

sum = 0
[1, 2, 3].each do |v|
  sum += v
end
p sum
=> 6

max, max_by

Returns the maximum value of each element, or if you don't pass a block, returns the result of the comparison with the <=> method.
If you pass a block, it seems that max_by can be executed in O(n) (seehere)

usage

[1, 2, 3].max
=> 3

# If the comparison conditions are complicated, click here.
["A", "bb", "ccc"].max_by { |a | a.length }
=> "ccc"

If you write in "each"

ary = [1, 2, 3]
max = ary.first

ary.each do |v|
  max = v if max < v
end
p max
=> 3

min, min_by

It returns the minimum value of each element, or if you don't pass the block, it returns the result of the comparison with the <=> method.
If you want to pass a block, min_by can be executed with O(n) as well as max_by (seehere)

usage

[1, 2, 3].min
=> 1

# If the comparison conditions are complicated, click here.
["A", "bb", "ccc"].min_by { |a | a.length }
=> "A"

If you write in "each"

ary = [1, 2, 3]
min = ary.first

ary.each do |v|
  min = v if min > v
end
p min
=> 1

sort, sort_by

It returns the sorted value of each element, or if you don't pass the block, it returns the result of the comparison using the <=> method.
If you want to pass a block, sort_by can be executed with O(n) as well as max_by (seehere)

usage

[3, 2, 1].sort
=> [1, 2, 3]

# If the comparison conditions are complicated, click here.
["aaa", "b", "cccc"].sort_by { |a | a.length }
=> ["b", "aaa", "cccc"]

If you write in "while"

ary = [3, 2, 1]
i = 0

while i < ary.length
  j = 1
  while j < ary.length - i
    if ary[i] > ary[i+j]
      ary[i], ary[i+j] = ary[i+j], ary[i]
    end
    j += 1
  end
  i += 1
end
p ary
=> [1, 2, 3]

reverse_each

Evaluate the blocks for each element in reverse order
A good use for this would be to implement Array#rindex on other Enumerable modules that apply to it.

usage

[1, 2, 3].reverse_each { |v| p v}
3
2
1
=> [1, 2, 3]

If you write in “each"

[1, 2, 3].reverse.each do |v|
 p v
end
3
2
1
=> [3, 2, 1]

I don't know how to use it.

zip, group_by, and so on.
Please comment what situations I should use those.

refs:
http://ruby-doc.org/core-2.3.0/Enumerable.html
https://repl.it/languages/ruby

Why Ruby Random object not to need a seed number

@kon_yu — Thu, 04 Jun 2020 08:34:23 +0000

Overview

Why Ruby can generate random numbers without seeded random numbers was investigated by a light reading of the source code of the Ruby language itself.

If the class that generates the random number does not put the seed of the random number in the argument, it calls the method that generates the seed of the random number, and in the logic that generates the random number, the seed of the random number is generated by calling the CPU clock number or the random number generation of the OS.

Since the seed of the random number does not depend on UNIX time alone, it seems that the seed value is the same even if the random number is generated at the same time in a high-access service or parallelized batch processing.

First things first

If you want to generate a random number in Ruby, you should write it like this.

r=Random.new
r.rand(10)
=> 5
# Outputs a random number (Integer) from 0 to 9 when an integer is inserted into the argument

r.rand(5.5)
=> 1.81617029321715
# Outputs a random result with Float type if a few arguments are input

rand method specification

Method: Random.rand — Documentation for core (2.7.0)

Random number generation in Ruby uses Mersenne Twister as a pseudo-random number sequence generator. The pseudo-random number generator needs an initial value called the seed of the random number. (There may be a pseudo-random number generator that doesn't need a seed, but that's not the subject of this article.)

I have the impression that many programming languages that use compilers prepare seeds of random numbers when generating random numbers, and many interpreters, like Ruby, can generate random numbers without using seeds of random numbers.

Random number generation logic in other languages than Ruby

An example of the need to seed a random number is the Go language

package main

import (
    "fmt"
    "math/rand"
    "time"
)

func main() {
    rand.Seed(time.Now().Unix())
    number:= rand.Int()
    fmt.Println(number)
}

JavaScript as an example of not needing to seed a random number

const number = Math.random()
console.log(number)

If you look at the definition of Math.random() in this JS, you'll see that you can't seed a random number in JavaScript.

The implementation selects the initial seed to the random number generation algorithm; it cannot be chosen or reset by the user.

For languages that don't need to seed random numbers, let's use Ruby as an example to find out how to seed random numbers

If you look at the specs of the Random constructor

Method: Random#initialize — Documentation for core (2.7.0)

Random.new_seed generates a random seed value and instantiates it.

Running Random.new_seed returns the following results

Random.new_seed
=> 115032730400174366788466674494640623225

*You're generating random numbers to seed random numbers? * So how do you generate the seed that generates the random number? They probably generate random numbers in a way that doesn't make use of pseudo-random number generators.

Since this is the target Ruby code and the main body of Ruby, it is the code of C. The code of Random.new_seed is made as follows. I'll read this one line at a time.

Method: Random.new_seed — Documentation for core (2.7.0)

static VALUE
random_seed(VALUE _)
{
    VALUE v;
    uint32_t buf[DEFAULT_SEED_CNT+1];
    fill_random_seed(buf, DEFAULT_SEED_CNT);
    v = make_seed_value(buf, DEFAULT_SEED_CNT);
    explicit_bzero(buf, DEFAULT_SEED_LEN);
    return v;
}

The variable VALUE v; at the first line is the return value of the function at the sixth line.

The second line, uint32_t buf[DEFAULT_SEED_CNT+1]; declares an array with a size 1 larger than DEFAULT_SEED_CNT, and the size of the fixed value DEFAULT_SEED_CNT is 4.

Line 3 fill_random_seed(buf, DEFAULT_SEED_CNT);
fill_random_seed to make a random number seed to make a random number seed.

If you read the logic of this method loosely, it looks like this method puts a random byte number with fill_random_bytes in each element of the size 4 seed of the array, and then takes a nanosecond or microsecond from the CPU time and overwrites it with XOR.
fill_random_bytes looks like it's reading a random number in a Linux system call at a glance, but I'm not following it too closely this time

static void
fill_random_seed(uint32_t *seed, size_t cnt)
{
    static int n = 0;
#if defined HAVE_CLOCK_GETTIME
    struct timespec tv;
#elif defined HAVE_GETTIMEOFDAY
    struct timeval tv;
#endif
    size_t len = cnt * sizeof(*seed);

    memset(seed, 0, len);

    fill_random_bytes(seed, len, FALSE);

#if defined HAVE_CLOCK_GETTIME
    clock_gettime(CLOCK_REALTIME, &tv);
    seed[0] ^= tv.tv_nsec;
#elif defined HAVE_GETTIMEOFDAY
    gettimeofday(&tv, 0);
    seed[0] ^= tv.tv_usec;
#endif
    seed[1] ^= (uint32_t)tv.tv_sec;
#if SIZEOF_TIME_T > SIZEOF_INT
    seed[0] ^= (uint32_t)((time_t)tv.tv_sec >> SIZEOF_INT * CHAR_BIT);
#endif
    seed[2] ^= getpid() ^ (n++ << 16);
    seed[3] ^= (uint32_t)(VALUE)&seed;
#if SIZEOF_VOIDP > SIZEOF_INT
    seed[2] ^= (uint32_t)((VALUE)&seed >> SIZEOF_INT * CHAR_BIT);
#endif
}

The fourth line, v = make_seed_value(buf, DEFAULT_SEED_CNT); generates a random number from the seed of the random number stored in buf.
In make_seed_value, I think that rb_integer_unpack joins the number of the array in buf to generate a random number.

static VALUE
make_seed_value(uint32_t *ptr, size_t len)
{
    VALUE seed;

    if (ptr[len-1] <= 1) {
        /* set leading-zero-guard */
        ptr[len++] = 1;
    }

    seed = rb_integer_unpack(ptr, len, sizeof(uint32_t), 0,
        INTEGER_PACK_LSWORD_FIRST|INTEGER_PACK_NATIVE_BYTE_ORDER);

    return seed;
}

To summarize the above logic, it can be said that the logic of random_seed is to prepare an array, store random numbers in the array using CPU time, etc., and then combine the arrays to create a random number seed.

Conclusion

If you consider whether or not seed data is needed to generate random numbers in Ruby, I can say that it is not needed from reading Ruby's code. I have a feeling there's a pattern we need, but I can't think of one at the moment.
I got a glimpse of how random numbers, which we use casually, are implemented.
I feel like it's been about five years since I read C.

Installing the latest version of Ruby on Raspberry pi

@kon_yu — Thu, 28 May 2020 05:49:59 +0000

First

This is almost the same way to install in Debian.
Please be patient because it may take several hours to install Razpai because the spec is low.

Prerequisites

Body: Raspberry Pi 1 Model B+
Memory card: 8GB
OS: Latest version of Raspbian installed

rbenv installation

Install rbenv and write the configuration to the bash configuration file, if you use zsh, etc.

> sudo apt-get install rbenv
> echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> .bashrc
> echo 'eval "$(rbenv init -)"' >> .bashrc

Confirmation of installation

> rbenv
> rbenv x.x.x #version to be displayed

Installing ### git

If git is not installed, install git.

> sudo apt-get install git

Install ruby-build

I'm going to clone ruby-build from git.

> git clone https://github.com/rbenv/ruby-build.git ~/.rbenv/plugins/ruby-build

> rbenv install --list
there are 2.3.1 and the latest version of Cruby 2.3

rbenv install 2.3.1

Troubleshooting

If you don't have enough libraries in your Ruby installation, you can try to add them by using the following command

> sudo apt-get install autoconf bison build-essential libssl-dev libyaml-dev libreadline6-dev zlib1g-dev libncurses5-dev libffi-dev libgdbm3 libgdbm-dev

Reference: https://github.com/rbenv/ruby-build/wiki#suggested-build-environment

If you installed ruby-build with apt-get

Even if I install ruby-build by apt-get, there is no latest version of Ruby in the list of available installables.
At runtime, ruby-2.2.0-preview is the latest version, and there is no 2.3 system of the latest version at this time.

> sudo apt-get install ruby-build
> rbenv install --list

To uninstall ruby-build, click here

> sudo apt-get remove ruby-build