{"id":3020,"date":"2020-04-24T08:53:36","date_gmt":"2020-04-24T08:53:36","guid":{"rendered":"http:\/\/the-codest.localhost\/blog\/a-simple-ruby-application-from-scratch-with-active-record\/"},"modified":"2026-04-24T11:29:23","modified_gmt":"2026-04-24T11:29:23","slug":"a-simple-ruby-application-from-scratch-with-active-record","status":"publish","type":"post","link":"https:\/\/thecodest.co\/en\/blog\/a-simple-ruby-application-from-scratch-with-active-record\/","title":{"rendered":"A Simple Ruby Application from Scratch with Active Record"},"content":{"rendered":"\n

I like working with Rails<\/a><\/strong> because I can easily and quickly create an application that works and show it to the world or just my friends. However, there are types of applications that do not need such a large framework as Rails<\/strong> and all its functionalities.<\/p>\n\n\n\n

It may happen that our application needs only M (Model) out of the whole MVC pattern Model-Controller<\/a>. Is it worth starting a project<\/a> in Rails<\/strong> if we know that the V-C (View-Controller) part will not be needed?<\/p>\n\n\n\n

It\u2019s good to know that Active Record <\/b>, Active Model, Action Pack and Action View, which are responsible for MVC, can be used independently outside Rails<\/strong>. This allows us<\/a> to create a simple Ruby<\/a> application<\/strong> that has a database connection and develop it without the unnecessary code<\/a> and libraries that we would get in a package by running the rails new command.<\/p>\n\n\n\n

I have described step by step how to achieve this and you can find the whole code on GitHub. The link is at the bottom of this article. <\/p>\n\n\n\n

Structure<\/h2>\n\n\n\n

To start our project, we don’t need much. Let’s start by creating a Gemfile<\/code> where we add the gems we need to work on the application, along with the version of Ruby<\/strong> we will be using.<\/p>\n\n\n\n

 cat Gemfile\n\n# frozen_string_literal: true\n\nsource 'https:\/\/rubygems.org'\n\nruby '2.7.2'\n<\/code><\/pre>\n\n\n\n
An optional README.md<\/code> file is to describe how our application works and how to continue working on it, both for ourselves and other developers who will want to develop the project with us in the future.<\/p>\n\n\n\n
cat README.md\n\n# Application\n\nTO DO: Delete this and the text above, and describe your app<\/code><\/pre>\n\n\n\n
app<\/code> directory with application.rb<\/code> file, which will be responsible for configuration and loading libraries and files we will be adding in our application. Remember to run bundle install<\/code> to generate the Gemfile.lock<\/code>. The structure of our application at this stage should look like this:<\/p>\n\n\n\n
 tree\n .\n \u251c\u2500\u2500 Gemfile\n \u251c\u2500\u2500 Gemfile.lock\n \u251c\u2500\u2500 README.md\n \u2514\u2500\u2500 app\n \u00a0\u00a0\u00a0\u00a0\u2514\u2500\u2500 application.rb<\/code><\/code><\/pre>\n\n\n\n
Database<\/h2>\n\n\n\n
With such a structure prepared, we can consider which database engine to choose and configure. For this article, I chose PostgresQL, with which I have the most experience. It can also be MySQL<\/a> or SQlite3, or any other engine working with Active Record<\/em>. When choosing technology, it is good to be guided by the purpose of the application, what it will be used for and what its purpose will be. <\/p>\n\n\n\n
For a quick and simple database configuration, I used docker<\/a> and docker-compose. I don’t want to elaborate on the configuration of these tools, their pros and cons, but if you’ve never used docker before then I’d refer you to the official documentation for Docker <\/a> and Docker Compose<\/a> for more information.<\/p>\n\n\n\n
# docker-compose.yml\n\nversion: '3.7'\nservices:\n\u00a0\u00a0postgresql:\n\u00a0\u00a0\u00a0\u00a0image: postgres:12.0-alpine\n\u00a0\u00a0\u00a0\u00a0ports:\n- 5432:5432\n\u00a0\u00a0\u00a0\u00a0environment:\n- PGDATA=\/postgresql\n- POSTGRESPASSWORD=postgres\n- POSTGRESUSER=postgres\n\u00a0\u00a0\u00a0\u00a0volumes:\n- db-volume:\/postgresql\nvolumes:\n\u00a0\u00a0db-volume:<\/code><\/pre>\n\n\n\n
We will also need to add to our Gemfile<\/code><\/p>\n\n\n\n
 gem 'pg'\n<\/code><\/code><\/pre>\n\n\n\n
and to our application.rb<\/code> file<\/p>\n\n\n\n
# app\/application.rb\n\nrequire 'pg'\n\nmodule Application\n\n\u00a0\u00a0class Error < StandardError; end\n\n# Your code goes here...\n\nend<\/code><\/pre>\n\n\n\n
Standalone Migrations, Rake<\/h2>\n\n\n\n
The next step in configuring our application is to add the standalone_migrations<\/code> and rake<\/code> gems, which will allow us to manage our migrations just like in Rails and gain access to rake db: commands. <\/p>\n\n\n\n
    \n
  1. Update Gemfile<\/code> with the necessary gems, and do a bundle install<\/code><\/li>\n<\/ol>\n\n\n\n
    # gem used in non-rails and non-ruby applications\n\ngem 'standalone_migrations'\n\n# standalone_migrations need rake to be able to create migrations and run them, as in Rails\n\ngem 'rake'\n\n# Gem needed to load environment variables\n\ngem 'dotenv'<\/code><\/pre>\n\n\n\n
      \n
    1. Let’s add a Rakefile<\/code> to our project in the root directory, where we will load dotenv<\/code> and standalone_migrations<\/code> that we added earlier <\/li>\n<\/ol>\n\n\n\n
      # frozen_string_literal: true\n\nrequire 'dotenv'\n\nDotenv.load\n\nrequire 'standalone_migrations'\n\nStandaloneMigrations::Tasks.load_tasks<\/code><\/pre>\n\n\n\n
      <\/p>\n\n\n\n
      With the Rakefile<\/code> configured this way, we can check if our rake<\/code> is working by using the rake -T<\/code> command, which should return a list of available commands in our application.<\/p>\n\n\n\n
      \"ruby<\/figure>\n\n\n\n
        \n
      1. Before rake db:create<\/code>, we still need to have a configuration file in our project to connect to the Postgres instance. To do this, we need to create a db directory along with a config.yml<\/code> file that should look like the one below:<\/li>\n<\/ol>\n\n\n\n
        # db\/config.yml\n\ndefault: &default\n\n  adapter: postgresql\n\n  encoding: unicode\n\n  pool: <%= ENV.fetch('MAX_THREADS') { 5 } %>\n\n  database: <%= ENV.fetch('DATABASE_NAME') %>\n\n  username: <%= ENV.fetch('DATABASE_USER') %>\n\n  password: <%= ENV.fetch('DATABASE_PASSWORD') %>\n\n  host: <%= ENV.fetch('DATABASE_HOST') %>\n\n  port: <%= ENV.fetch('DATABASE_PORT') %>\n\ndevelopment:\n\n  <<: *default\n\ntest:\n\n  <<: *default\n\nstaging:\n\n  <<: *default\n\nproduction:\n\n  <<: *default<\/code><\/pre>\n\n\n\n
        As you can see, I used environment variables to configure the connection to our Postgres, where we will keep sensitive data<\/a> that should not be in the repository. For this I used the previously added gem dotenv<\/code>, which was also added in the Rakefile<\/code> along with standalone_migrations<\/code>. If we are using Git to manage version control of our application, let\u2019s remember to add a .gitignore<\/code> file where we will disable the possibility of tracking the .env<\/code> file from our project.<\/p>\n\n\n\n
         # .gitignore\n.env*\n!.env.example<\/code><\/pre>\n\n\n\n
        and add an.env<\/code> file containing the correctly configured ENV<\/p>\n\n\n\n
        # .env\n\nDATABASE_NAME=\"development\"\n\nDATABASE_USER=\"postgres\"\n\nDATABASE_PASSWORD=\"postgres\"\n\nDATABASE_HOST=\"localhost\"\n\nDATABASE_PORT=\"5432\"<\/code><\/pre>\n\n\n\n
          \n
        1. \n
          At this stage, we should be able to run the rake db:create<\/code> command which will create the database<\/p>\n
          \"Ruby<\/figure>
          <\/p>\n<\/li>\n\n\n\n
        2. \n
          Let’s try adding a new migration via rake db:new_migration name=<\/code>, where we create a posts<\/code> table with a :title<\/code> column<\/p>\n
          \"Rails<\/figure>
          <\/p>\n<\/li>\n<\/ol>\n\n\n\n
          # frozen_string_literal: true\n\nclass CreatePosts < ActiveRecord::Migration[6.0]\n\n  def change\n\n    create_table :posts do |t|\n\n      t.string :title\n\n    end\n\n  end\n\nend\n<\/code><\/pre>\n\n\n\n
          \"Ruby<\/figure>\n\n\n\n
          You should notice that the db\/migrate<\/code> directory was automatically added and schema.rb<\/code> was created after successful migration. Currently, our project structure looks as follows:<\/p>\n\n\n\n
           tree\n.\n\u251c\u2500\u2500 Gemfile\n\u251c\u2500\u2500 Gemfile.lock\n\u251c\u2500\u2500 README.md\n\u251c\u2500\u2500 Rakefile\n\u251c\u2500\u2500 .gitignore\n\u251c\u2500\u2500 .env.example\n\u251c\u2500\u2500 app\n\u2502   \u2514\u2500\u2500 application.rb\n\u251c\u2500\u2500 db\n\u2502   \u251c\u2500\u2500 config.yml\n\u2502   \u251c\u2500\u2500 migrate\n\u2502   \u2502   \u2514\u2500\u2500 20210504135128_create_posts.rb\n\u2502   \u2514\u2500\u2500 schema.rb\n\u2514\u2500\u2500 docker-compose.yml<\/code><\/pre>\n\n\n\n
          Active Record<\/h2>\n\n\n\n
          The last but not least, another step in creating our application is to add activerecord<\/code> and its configuration. For this, we will need to update our Gemfile with 3 more gems:<\/p>\n\n\n\n
          gem 'activerecord'\ngem 'erb'\ngem 'yaml'<\/code><\/pre>\n\n\n\n
          Why we add erb<\/code> and ymal<\/code> is explained below in the comments. The entire active_record<\/code> configuration will be in the app\/application.rb<\/code> file.<\/p>\n\n\n\n
          Let’s go through what happens here, one by one:<\/p>\n\n\n\n
          # frozen_string_literal: true\n\n# If we want to be able to run the application in different environments,\n# e.g. test or production, it is good to set the ENVIRONMENT value\n# at the beginning, which is taken from the environment variable\n# or `development` by default.\n\nENV['ENVIRONMENT'] ||= 'development'\n\n# To use the added gems, we need to load them using the Kernel#require method,\n# which loads the file or library passed as a parameter\n\nrequire 'pg'\nrequire 'active_record'\nrequire 'dotenv'\nrequire 'yaml'\nrequire 'erb'\n\n# By default Dotenv.load for loading environment variables reaches out\n# to the `.env` file, so if we want to use other environments it is worth\n# extending this to the method below, which will first for a set development\n# environment look for a file ending in `.env.development.local`,\n# then `.env.development` and finally `.env`.\n\nDotenv.load(\".env.#{ENV.fetch('ENVIRONMENT')}.local\", \".env.#{ENV.fetch('ENVIRONMENT')}\", '.env')\n\n# Method needed for loading database settings\ndef db_configuration\n  # The method below returns the path to the file with our configuration\n  db_configuration_file_path = File.join(File.expand_path('..', __dir__), 'db', 'config.yml')\n\n  # Having the path to the file, we can read its values. Because the config.yml\n  # file contains environment variables and, as you may have noticed,\n  # the erb <%= %> syntax, we also need to use the erb gem. Without this,\n  # the values of the variables will not be read correctly and activerecord\n  # will not be able to connect to postgres.The following method will return\n  # the configuration as a string\n\n  db_configuration_result = ERB.new(File.read(db_configuration_file_path)).result\n\n  # Using the previously added `yaml` gem, we can safely load our configuration\n\n  YAML.safe_load(db_configuration_result, aliases: true)\nend\n\n# Finally, we need to create a connection between activerecord and postgres\n# using the `establish_connection` method\nActiveRecord::Base.establish_connection(db_configuration[ENV['ENVIRONMENT']])\n\nmodule Application\n  class Error < StandardError; end\n  # Your code goes here...\nend<\/code><\/pre>\n\n\n\n
          We already have the configurations, so we can add the Post model in our ruby<\/strong> app.\u00a0<\/p>\n\n\n\n
          `\u251c\u2500\u2500 app`\n\n`\u2502   \u2514\u2500\u2500 models`\n\n`\u2502       \u2514\u2500\u2500 post.rb`<\/code><\/pre>\n\n\n\n
          app\/models\/post.rb\n# frozen_string_literal: true\n\nclass Post < ActiveRecord::Base;end\n<\/code><\/pre>\n\n\n\n
          and remember to load the file in application.rb<\/code><\/p>\n\n\n\n
          require 'app\/models\/post'<\/code><\/pre>\n\n\n\n
          Also, remember to add require 'app\/runner'<\/code> to app\/application.rb<\/code><\/p>\n\n\n\n
          If we want to add new files in our application, services, more models, we need to load them in application.rb<\/code>.<\/p>\n\n\n\n
          SUMMARY<\/h2>\n\n\n\n
          Currently, our ruby application is ready to continue. We have configured:<\/p>\n\n\n\n