808 lines
27 KiB
Plaintext
808 lines
27 KiB
Plaintext
|
|
(BUTTON)
|
|
|
|
Lucian Ghinda
|
|
|
|
All about coding
|
|
|
|
(BUTTON) (BUTTON)
|
|
Follow
|
|
|
|
[1]All about coding
|
|
|
|
Follow
|
|
Ruby open source: feedbin Ruby open source: feedbin
|
|
|
|
Ruby open source: feedbin
|
|
|
|
[2]Lucian Ghinda's photo Lucian Ghinda's photo
|
|
[3]Lucian Ghinda
|
|
·[4]Nov 17, 2023·
|
|
|
|
11 min read
|
|
|
|
Table of contents
|
|
|
|
* The product
|
|
* Open source
|
|
|
|
* License
|
|
|
|
Technical review
|
|
* Ruby and Rails version
|
|
* Architecture
|
|
* Stats
|
|
* Style Guide
|
|
* Storage, Persistence and in-memory storage
|
|
* Gems used
|
|
* Code & Design Patterns
|
|
|
|
* Code Organisation
|
|
* Routes
|
|
* Controllers
|
|
* Models
|
|
* Jobs
|
|
* Presenters
|
|
* ApplicationComponents
|
|
* ComponentsPreview
|
|
|
|
Testing
|
|
* Custom assertions
|
|
|
|
Conclusion
|
|
|
|
The product
|
|
|
|
[5]https://feedbin.com
|
|
|
|
"Feedbin is the best way to enjoy content on the Web. By combining
|
|
RSS, and newsletters, you can get all the good parts of the Web in
|
|
one convenient location"
|
|
|
|
Open source
|
|
|
|
The open-source repository can be found at
|
|
[6]https://github.com/feedbin/feedbin
|
|
|
|
License
|
|
|
|
The [7]license they use is MIT:
|
|
|
|
Technical review
|
|
|
|
Ruby and Rails version
|
|
|
|
They are currently using:
|
|
* Ruby version 3.2.2
|
|
* They used a fork of Rails at [8]https://github.com/feedbin/rails
|
|
forked from [9]https://github.com/Shopify/rails. They are using a
|
|
branch called [10]7-1-stable-invalid-cache-entries - It seems to be
|
|
Rails 7.1 and about 1 month behind the Shopify/rails which is
|
|
usually pretty up to date with main Rails
|
|
|
|
Architecture
|
|
|
|
Code Architecture:
|
|
* They are using the standard Rails organisation of MVC.
|
|
|
|
Database:
|
|
* The DB is PostgreSQL
|
|
|
|
Jobs queue:
|
|
* Sidekiq
|
|
|
|
On the front-end side:
|
|
* They use .html.erb
|
|
* They are using Phlex for [11]components
|
|
* They are using [12]Jquery for the JS library
|
|
* They have some custom JS code written in [13]CoffeeScript
|
|
* They are using Hotwire via [14]importmaps
|
|
* They are using [15]Tailwind
|
|
|
|
Stats
|
|
|
|
Running /bin/rails stats will output the following:
|
|
|
|
Running VSCodeCounter will give the following stats:
|
|
|
|
Style Guide
|
|
|
|
For Ruby:
|
|
* They are using [16]standardrb as the Style Guide with no
|
|
customisations.
|
|
|
|
Storage, Persistence and in-memory storage
|
|
|
|
The DB is PostgreSQL.
|
|
|
|
They are not using the schema.rb but the [17]structure.sql format for
|
|
DB schema dump is configured via application.rb:
|
|
module Feedbin
|
|
class Application < Rails::Application
|
|
# other configs
|
|
config.active_record.schema_format = :sql
|
|
# other configs
|
|
end
|
|
end
|
|
|
|
Enabled PSQL extensions:
|
|
* hstore - "data type for storing sets of (key, value) pairs"
|
|
* pg_stat_statements - "track planning and execution statistics of
|
|
all SQL statements executed"
|
|
* uuid-ossp - "generate universally unique identifiers (UUIDs)"
|
|
|
|
CREATE EXTENSION IF NOT EXISTS hstore WITH SCHEMA public;
|
|
COMMENT ON EXTENSION hstore IS 'data type for storing sets of (key, value) pairs
|
|
';
|
|
|
|
CREATE EXTENSION IF NOT EXISTS pg_stat_statements WITH SCHEMA public;
|
|
COMMENT ON EXTENSION pg_stat_statements IS 'track planning and execution statist
|
|
ics of all SQL statements executed';
|
|
|
|
|
|
CREATE EXTENSION IF NOT EXISTS "uuid-ossp" WITH SCHEMA public;
|
|
COMMENT ON EXTENSION "uuid-ossp" IS 'generate universally unique identifiers (UU
|
|
IDs)';
|
|
|
|
Redis is configured to be used with Sidekiq.
|
|
|
|
This is what the [18]redis initializer looks like:
|
|
# https://github.com/feedbin/feedbin/blob/main/config/initializers/redis.rb#L1
|
|
|
|
defaults = {connect_timeout: 5, timeout: 5}
|
|
defaults[:url] = ENV["REDIS_URL"] if ENV["REDIS_URL"]
|
|
|
|
$redis = {}.tap do |hash|
|
|
options2 = defaults.dup
|
|
if ENV["REDIS_URL_PUBLIC_IDS"] || ENV["REDIS_URL_CACHE"]
|
|
options2[:url] = ENV["REDIS_URL_PUBLIC_IDS"] || ENV["REDIS_URL_CACHE"]
|
|
end
|
|
hash[:refresher] = ConnectionPool.new(size: 10) { Redis.new(options2) }
|
|
end
|
|
|
|
Further, there is a [19]RedisLock configured like this:
|
|
# https://github.com/feedbin/feedbin/blob/main/app/models/redis_lock.rb#L1
|
|
|
|
class RedisLock
|
|
def self.acquire(lock_name, expiration_in_seconds = 55)
|
|
Sidekiq.redis { _1.set(lock_name, "locked", ex: expiration_in_seconds, nx: t
|
|
rue) }
|
|
end
|
|
end
|
|
|
|
Further down this is used in a [20]clock.rb (that defines scheduled
|
|
tasks to run):
|
|
# https://github.com/feedbin/feedbin/blob/main/lib/clock.rb#L8
|
|
|
|
every(10.seconds, "clockwork.very_frequent") do
|
|
if RedisLock.acquire("clockwork:send_stats:v3", 8)
|
|
SendStats.perform_async
|
|
end
|
|
|
|
if RedisLock.acquire("clockwork:cache_entry_views", 8)
|
|
CacheEntryViews.perform_async(nil, true)
|
|
end
|
|
|
|
if RedisLock.acquire("clockwork:downloader_migration", 8)
|
|
FeedCrawler::PersistCrawlData.perform_async
|
|
end
|
|
end
|
|
|
|
every(1.minutes, "clockwork.frequent") do
|
|
if RedisLock.acquire("clockwork:feed:refresher:scheduler:v2")
|
|
FeedCrawler::ScheduleAll.perform_async
|
|
end
|
|
|
|
if RedisLock.acquire("clockwork:harvest:embed:data")
|
|
HarvestEmbeds.perform_async(nil, true)
|
|
end
|
|
end
|
|
|
|
every(1.day, "clockwork.daily", at: "7:00", tz: "UTC") do
|
|
if RedisLock.acquire("clockwork:delete_entries:v2")
|
|
EntryDeleterScheduler.perform_async
|
|
end
|
|
|
|
if RedisLock.acquire("clockwork:trial_expiration:v2")
|
|
TrialExpiration.perform_async
|
|
end
|
|
|
|
if RedisLock.acquire("clockwork:web_sub_maintenance")
|
|
WebSub::Maintenance.perform_async
|
|
end
|
|
end
|
|
|
|
Gems used
|
|
|
|
Here are some of the gems used:
|
|
* [21]sax-machine - "A declarative sax parsing library backed by
|
|
Nokogiri"
|
|
* [22]feedjira - "Feedjira is a Ruby library designed to parse feeds"
|
|
* [23]html-pipeline - "HTML processing filters and utilities. This
|
|
module is a small framework for defining CSS-based content filters
|
|
and applying them to user provided content"
|
|
* [24]apnotic - "A Ruby APNs HTTP/2 gem able to provide instant
|
|
feedback"
|
|
* [25]autoprefixer-rails - "Autoprefixer is a tool to parse CSS and
|
|
add vendor prefixes to CSS rules using values from the Can I Use
|
|
database. This gem provides Ruby and Ruby on Rails integration with
|
|
this JavaScript tool"
|
|
* [26]clockwork - "Clockwork is a cron replacement. It runs as a
|
|
lightweight, long-running Ruby process which sits alongside your
|
|
web processes (Mongrel/Thin) and your worker processes
|
|
(DJ/Resque/Minion/Stalker) to schedule recurring work at particular
|
|
times or dates"
|
|
* [27]down - "Streaming downloads using net/http, http.rb, HTTPX or
|
|
wget"
|
|
* [28]phlex-rails - "Phlex is a framework that lets you compose web
|
|
views in pure Ruby"
|
|
* [29]premailer-rails - "This gem is a drop in solution for styling
|
|
HTML emails with CSS without having to do the hard work yourself"
|
|
* [30]raindrops - "raindrops is a real-time stats toolkit to show
|
|
statistics for Rack HTTP servers. It is designed for preforking
|
|
servers such as unicorn, but should support any Rack HTTP server on
|
|
platforms supporting POSIX shared memory"
|
|
* [31]strong_migrations - "Catch unsafe migrations in development"
|
|
* [32]web-push - "This gem makes it possible to send push messages to
|
|
web browsers from Ruby backends using the Web Push Protocol"
|
|
* [33]stripe-ruby-mock - "A drop-in library to test stripe without
|
|
hitting their servers"
|
|
* [34]rails-controller-testing - "Brings back assigns and
|
|
assert_template to your Rails tests"
|
|
|
|
There are many other gems used, I only selected few here. Browse the
|
|
[35]Gemfile to discover more.
|
|
|
|
What could be mentioned is that they use their fork for some of the
|
|
gems included in the file:
|
|
# https://github.com/feedbin/feedbin/blob/main/Gemfile
|
|
|
|
# other gems
|
|
|
|
gem "rails", github: "feedbin/rails", branch: "7-1-stable-invalid-cache-entries"
|
|
|
|
# some other gems
|
|
|
|
gem "http", github: "feedbin/http", branch: "feedb
|
|
in"
|
|
gem "carrierwave", github: "feedbin/carrierwave", branch: "feedb
|
|
in"
|
|
gem "sax-machine", github: "feedbin/sax-machine", branch: "feedb
|
|
in"
|
|
gem "feedjira", github: "feedbin/feedjira", branch: "f2"
|
|
gem "feedkit", github: "feedbin/feedkit", branch: "maste
|
|
r"
|
|
gem "html-pipeline", github: "feedbin/html-pipeline", branch: "feedb
|
|
in"
|
|
gem "html_diff", github: "feedbin/html_diff", ref: "013e1bb"
|
|
gem "twitter", github: "feedbin/twitter", branch: "feedb
|
|
in"
|
|
|
|
# other gems
|
|
|
|
group :development, :test do
|
|
gem "stripe-ruby-mock", github: "feedbin/stripe-ruby-mock", branch: "feedbin",
|
|
require: "stripe_mock"
|
|
# other gems
|
|
end
|
|
|
|
# other gem groups
|
|
|
|
Code & Design Patterns
|
|
|
|
Code Organisation
|
|
|
|
Under /app there are 3 folders different from the ones that Rails comes
|
|
with:
|
|
* presenters
|
|
* uploaders
|
|
* validators
|
|
|
|
The lib folder includes very few extra objects. Most of them seems to
|
|
be related to communicating with external services.
|
|
|
|
Maybe worth mentioning from lib folder is the
|
|
[36]ConditionalSassCompressor
|
|
# https://github.com/feedbin/feedbin/blob/main/lib/conditional_sass_compressor.r
|
|
b#L1
|
|
|
|
class ConditionalSassCompressor
|
|
def compress(string)
|
|
return string if string =~ /tailwindcss/
|
|
options = { syntax: :scss, cache: false, read_cache: false, style: :compress
|
|
ed}
|
|
begin
|
|
Sprockets::Autoload::SassC::Engine.new(string, options).render
|
|
rescue => e
|
|
puts "Could not compress '#{string[0..65]}'...: #{e.message}, skipping com
|
|
pression"
|
|
string
|
|
end
|
|
end
|
|
end
|
|
|
|
This is used to configure:
|
|
# https://github.com/feedbin/feedbin/blob/main/config/application.rb#L47
|
|
config.assets.css_compressor = ConditionalSassCompressor.new
|
|
|
|
Routes
|
|
|
|
There is a combination of RESTful routes and non-restful routes.
|
|
|
|
Here is an example from entries in the [37]routes.rb :
|
|
# https://github.com/feedbin/feedbin/blob/main/config/routes.rb#L133
|
|
|
|
resources :entries, only: [:show, :index, :destroy] do
|
|
member do
|
|
post :content
|
|
post :unread_entries, to: "unread_entries#update"
|
|
post :starred_entries, to: "starred_entries#update"
|
|
post :mark_as_read, to: "entries#mark_as_read"
|
|
post :recently_read, to: "recently_read_entries#create"
|
|
post :recently_played, to: "recently_played_entries#create"
|
|
get :push_view
|
|
get :newsletter
|
|
end
|
|
collection do
|
|
get :starred
|
|
get :unread
|
|
get :preload
|
|
get :search
|
|
get :recently_read, to: "recently_read_entries#index"
|
|
get :recently_played, to: "recently_played_entries#index"
|
|
get :updated, to: "updated_entries#index"
|
|
post :mark_all_as_read
|
|
post :mark_direction_as_read
|
|
end
|
|
end
|
|
|
|
Controllers
|
|
|
|
The controllers are mostly what I would call vanilla Rails controllers.
|
|
|
|
Three notes about them:
|
|
* Some of them are responding with JS usually using USJ or JQuery to
|
|
change elements from the page.
|
|
* They contain non-Rails standard actions (actions that are not show,
|
|
index, new, create ...)
|
|
* There is a namespaced api folder that contains APIs used by mobile
|
|
apps
|
|
|
|
Here is one simple example for DELETE /entries/:id , the controller
|
|
looks like this:
|
|
# https://github.com/feedbin/feedbin/blob/main/app/controllers/entries_controlle
|
|
r.rb#L238
|
|
def destroy
|
|
@user = current_user
|
|
@entry = @user.entries.find(params[:id])
|
|
if @entry.feed.pages?
|
|
EntryDeleter.new.delete_entries(@entry.feed_id, @entry.id)
|
|
end
|
|
end
|
|
|
|
And here is the view [38]destroy.js.erb :
|
|
$('[data-behavior~=entries_target] [data-entry-id=<%= @entry.id %>]').remove();
|
|
|
|
feedbin.Counts.get().removeEntry(<%= @entry.id %>, <%= @entry.feed_id %>, 'unrea
|
|
d')
|
|
feedbin.Counts.get().removeEntry(<%= @entry.id %>, <%= @entry.feed_id %>, 'starr
|
|
ed')
|
|
feedbin.applyCounts(true)
|
|
|
|
feedbin.clearEntry();
|
|
feedbin.fullScreen(false)
|
|
|
|
The main pattern adopted to controllers is to have some logic in them
|
|
and delegate to jobs some part of the processing.
|
|
|
|
The repo contains mostly straight-forward controllers like this one:
|
|
# https://github.com/feedbin/feedbin/blob/main/app/controllers/pages_internal_co
|
|
ntroller.rb#L1
|
|
class PagesInternalController < ApplicationController
|
|
|
|
def create
|
|
@entry = SavePage.new.perform(current_user.id, params[:url], nil)
|
|
get_feeds_list
|
|
end
|
|
end
|
|
|
|
But also few controllers that include some logic:
|
|
# https://github.com/feedbin/feedbin/blob/main/app/controllers/api/podcasts/v1/f
|
|
eeds_controller.rb#L8
|
|
|
|
def show
|
|
url = hex_decode(params[:id])
|
|
@feed = Feed.find_by_feed_url(url)
|
|
if @feed.present?
|
|
if @feed.standalone_request_at.blank?
|
|
FeedStatus.new.perform(@feed.id)
|
|
FeedUpdate.new.perform(@feed.id)
|
|
end
|
|
else
|
|
feeds = FeedFinder.feeds(url)
|
|
@feed = feeds.first
|
|
end
|
|
|
|
if @feed.present?
|
|
@feed.touch(:standalone_request_at)
|
|
else
|
|
status_not_found
|
|
end
|
|
rescue => exception
|
|
if Rails.env.production?
|
|
ErrorService.notify(exception)
|
|
status_not_found
|
|
else
|
|
raise exception
|
|
end
|
|
end
|
|
|
|
Even with this structure, I find all controllers easy to read and I
|
|
think they can be easier to change.
|
|
|
|
Models
|
|
|
|
The app/models folders contain both ActiveRecord and normal Ruby
|
|
objects. With few exceptions, they are not namespaced.
|
|
|
|
Jobs
|
|
|
|
The jobs folder contains Sidekiq jobs which are used to do processing
|
|
on various objects. They are usually called from controllers and most
|
|
of them are async.
|
|
|
|
Here is one job that is caching views:
|
|
# https://github.com/feedbin/feedbin/blob/main/app/jobs/cache_entry_views.rb#L1
|
|
|
|
class CacheEntryViews
|
|
include Sidekiq::Worker
|
|
include SidekiqHelper
|
|
|
|
SET_NAME = "#{name}-ids"
|
|
|
|
def perform(entry_id, process = false)
|
|
if process
|
|
cache_views
|
|
else
|
|
add_to_queue(SET_NAME, entry_id)
|
|
end
|
|
end
|
|
|
|
def cache_views
|
|
entry_ids = dequeue_ids(SET_NAME)
|
|
entries = Entry.where(id: entry_ids).includes(feed: [:favicon])
|
|
ApplicationController.render({
|
|
partial: "entries/entry",
|
|
collection: entries,
|
|
format: :html,
|
|
cached: true
|
|
})
|
|
ApplicationController.render({
|
|
layout: nil,
|
|
template: "api/v2/entries/index",
|
|
assigns: {entries: entries},
|
|
format: :html,
|
|
locals: {
|
|
params: {mode: "extended"}
|
|
}
|
|
})
|
|
end
|
|
end
|
|
|
|
Presenters
|
|
|
|
There is a [39]BasePresenter and all other presenters are extending it
|
|
via inheritance:
|
|
|
|
This controller defines a private method called presents:
|
|
# https://github.com/feedbin/feedbin/blob/main/app/presenters/base_presenter.rb#
|
|
L1
|
|
|
|
class BasePresenter
|
|
def initialize(object, locals, template)
|
|
@object = object
|
|
@locals = locals
|
|
@template = template
|
|
end
|
|
|
|
# ...
|
|
|
|
private
|
|
|
|
def self.presents(name)
|
|
define_method(name) do
|
|
@object
|
|
end
|
|
end
|
|
end
|
|
|
|
and it is used like this for example:
|
|
# https://github.com/feedbin/feedbin/blob/main/app/presenters/user_presenter.rb#
|
|
L2
|
|
|
|
class UserPresenter < BasePresenter
|
|
presents :user
|
|
delegate_missing_to :user
|
|
|
|
# ... more code
|
|
|
|
def theme
|
|
result = settings["theme"].present? ? settings["theme"] : nil
|
|
result || user.theme || "auto"
|
|
end
|
|
# ... other code
|
|
end
|
|
|
|
To use the presenters, there is a helper defined in ApplicationHelper
|
|
will instantiate the proper helper based on the object class:
|
|
module ApplicationHelper
|
|
def present(object, locals = nil, klass = nil)
|
|
klass ||= "#{object.class}Presenter".constantize
|
|
presenter = klass.new(object, locals, self)
|
|
yield presenter if block_given?
|
|
presenter
|
|
end
|
|
|
|
# more code ...
|
|
end
|
|
|
|
and it is used [40]like this in views:
|
|
<% present @user do |user_presenter| %>
|
|
<% @class = "settings-body settings-#{params[:action]} theme-#{user_presente
|
|
r.theme}"%>
|
|
<% end %>
|
|
|
|
ApplicationComponents
|
|
|
|
Components are based on Phlex and they inherit from
|
|
[41]ApplicationComponent
|
|
|
|
It defines a method to add Stimulus controller in components like this:
|
|
# https://github.com/feedbin/feedbin/blob/main/app/views/components/application_
|
|
component.rb#L25
|
|
|
|
def stimulus(controller:, actions: {}, values: {}, outlets: {}, classes: {}, d
|
|
ata: {})
|
|
stimulus_controller = controller.to_s.dasherize
|
|
|
|
action = actions.map do |event, function|
|
|
"#{event}->#{stimulus_controller}##{function.camelize(:lower)}"
|
|
end.join(" ").presence
|
|
|
|
values.transform_keys! do |key|
|
|
[controller, key, "value"].join("_").to_sym
|
|
end
|
|
|
|
outlets.transform_keys! do |key|
|
|
[controller, key, "outlet"].join("_").to_sym
|
|
end
|
|
|
|
classes.transform_keys! do |key|
|
|
[controller, key, "class"].join("_").to_sym
|
|
end
|
|
|
|
{ controller: stimulus_controller, action: }.merge!({ **values, **outlets, *
|
|
*classes, **data})
|
|
end
|
|
|
|
Where we can also see a bit of hash literal omission at {controller:
|
|
stimulus_controller, action: }
|
|
|
|
But more interesting that this method that helps defining a Stimulus
|
|
controller, is the method used to define a Stimulus item that uses
|
|
binding to get variables from the object where it is used:
|
|
# https://github.com/feedbin/feedbin/blob/main/app/views/components/application_
|
|
component.rb#L47
|
|
|
|
def stimulus_item(target: nil, actions: {}, params: {}, data: {}, for:)
|
|
stimulus_controller = binding.local_variable_get(:for).to_s.dasherize
|
|
|
|
action = actions.map do |event, function|
|
|
"#{event}->#{stimulus_controller}##{function.to_s.camelize(:lower)}"
|
|
end.join(" ").presence
|
|
|
|
params.transform_keys! do |key|
|
|
:"#{binding.local_variable_get(:for)}_#{key}_param"
|
|
end
|
|
|
|
defaults = { **params, **data }
|
|
|
|
if action
|
|
defaults[:action] = action
|
|
end
|
|
|
|
if target
|
|
defaults[:"#{binding.local_variable_get(:for)}_target"] = target.to_s.came
|
|
lize(:lower)
|
|
end
|
|
|
|
defaults
|
|
end
|
|
|
|
The part with binding does the following:
|
|
* stimulus_controller =
|
|
binding.local_variable_get(:for).to_s.dasherize This line retrieves
|
|
the value of the local variable for, converts it to a string, and
|
|
then applies the dasherize method (presumably to format it for use
|
|
in a specific context, like a CSS class or an identifier in HTML).
|
|
* Apparently binding.local_variable_get should not be needed as the
|
|
variable is passed a keyword parameter to the method. But the name
|
|
of the variable is for which is a reserved word and thus if the
|
|
code would have been stimulus_controller = for.to_s_dasherize that
|
|
would have raised syntax error, unexpected '.' (SyntaxError)
|
|
|
|
This is a way to have keyword arguments named as reserved words and
|
|
still be able to use them.
|
|
|
|
ComponentsPreview
|
|
|
|
All components can be previewed via Lookbook and they can be found in
|
|
test/components
|
|
|
|
Testing
|
|
|
|
For testing it uses Minitest, the default testing framework from Rails.
|
|
It uses fixtures to set up the test db.
|
|
|
|
Tests are simple and direct, containing all preconditions and
|
|
postconditions in each test. This is great for following what each test
|
|
is doing.
|
|
|
|
There are controller tests, model tests, job tests and some system
|
|
tests. There are more controller tests than system tests making the
|
|
test suite run quite fast. Also the jobs are covered pretty good with
|
|
testing as there is a log of logic in the jobs.
|
|
|
|
Custom assertions
|
|
|
|
There are some custom assertions created specifically to work with
|
|
collections: assert_has_keys will check if all keys are included in the
|
|
hash and assert_equal_ids will check if the two collections provided
|
|
have the same ids (one being a collection of objects and the other one
|
|
being a hash).
|
|
# https://github.com/feedbin/feedbin/blob/main/test/support/assertions.rb#L3
|
|
|
|
def assert_has_keys(keys, hash)
|
|
assert(keys.all? { |key| hash.key?(key) })
|
|
end
|
|
|
|
def assert_equal_ids(collection, results)
|
|
expected = Set.new(collection.map(&:id))
|
|
actual = Set.new(results.map { |result| result["id"] })
|
|
assert_equal(expected, actual)
|
|
end
|
|
|
|
Conclusion
|
|
|
|
In conclusion, Feedbin is an open-source project that combines RSS
|
|
feeds and newsletters into a convenient platform.
|
|
|
|
It utilizes Ruby on Rails, PostgreSQL, Sidekiq, and various other
|
|
technologies to provide a robust and efficient service.
|
|
|
|
The code is well-organized and simple to follow the logic and what is
|
|
happening. I think it will make it easy for anyone to contribute to
|
|
this repo. If you want to run this yourself locally you should take a
|
|
look at the [42]feedbin-docker.
|
|
__________________________________________________________________
|
|
|
|
Enjoyed this article?
|
|
|
|
👉 Join my [43]Short Ruby News newsletter for weekly Ruby updates from
|
|
the community and visit [44]rubyandrails.info, a directory with
|
|
learning content about Ruby.
|
|
|
|
👐 Subscribe to my Ruby and Ruby on rails courses over email at
|
|
[45]learn.shortruby.com - effortless learning anytime, anywhere
|
|
|
|
🤝 Let's connect on [46]Ruby.social or [47]Linkedin or [48]Twitter where
|
|
I post mainly about Ruby and Rails.
|
|
|
|
🎥 Follow me on [49]my YouTube channel for short videos about Ruby
|
|
|
|
Did you find this article valuable?
|
|
|
|
Support Lucian Ghinda by becoming a sponsor. Any amount is appreciated!
|
|
(BUTTON) Sponsor
|
|
[50]See recent sponsors | [51]Learn more about Hashnode Sponsors
|
|
|
|
[52]Ruby[53]Ruby on Rails[54]Open Source[55]coding[56]Programming Blogs
|
|
|
|
References
|
|
|
|
Visible links:
|
|
1. https://allaboutcoding.ghinda.com/?source=top_nav_blog_home
|
|
2. https://hashnode.com/@lucianghinda
|
|
3. https://hashnode.com/@lucianghinda
|
|
4. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin
|
|
5. https://feedbin.com/
|
|
6. https://github.com/feedbin/feedbin/blob/main/LICENSE.md
|
|
7. https://github.com/feedbin/feedbin/blob/main/LICENSE.md
|
|
8. https://github.com/feedbin/rails
|
|
9. https://github.com/Shopify/rails
|
|
10. https://github.com/feedbin/rails/tree/7-1-stable-invalid-cache-entries
|
|
11. https://github.com/feedbin/feedbin/tree/main/app/views/components
|
|
12. https://github.com/feedbin/feedbin/blob/main/Gemfile#L38
|
|
13. https://github.com/feedbin/feedbin/tree/main/app/assets/javascripts/web
|
|
14. https://github.com/feedbin/feedbin/blob/abf1ad883dab8a3464fe12e4653de6323296175b/config/importmap.rb#L1
|
|
15. https://github.com/feedbin/feedbin/blob/abf1ad883dab8a3464fe12e4653de6323296175b/Gemfile#L66
|
|
16. https://github.com/feedbin/feedbin/blob/abf1ad883dab8a3464fe12e4653de6323296175b/Gemfile#L94
|
|
17. https://github.com/feedbin/feedbin/blob/main/db/structure.sql
|
|
18. https://github.com/feedbin/feedbin/blob/abf1ad883dab8a3464fe12e4653de6323296175b/config/initializers/redis.rb#L1
|
|
19. https://github.com/feedbin/feedbin/blob/main/app/models/redis_lock.rb#L1
|
|
20. https://github.com/feedbin/feedbin/blob/main/lib/clock.rb#L8
|
|
21. https://github.com/pauldix/sax-machine
|
|
22. https://github.com/feedjira/feedjira
|
|
23. https://github.com/feedbin/html-pipeline
|
|
24. https://github.com/ostinelli/apnotic
|
|
25. https://github.com/ai/autoprefixer-rails
|
|
26. https://github.com/Rykian/clockwork
|
|
27. https://github.com/janko/down
|
|
28. https://github.com/phlex-ruby/phlex-rails
|
|
29. https://github.com/fphilipe/premailer-rails
|
|
30. https://rubygems.org/gems/raindrops
|
|
31. https://github.com/ankane/strong_migrations
|
|
32. https://github.com/pushpad/web-push
|
|
33. https://github.com/stripe-ruby-mock/stripe-ruby-mock
|
|
34. https://github.com/rails/rails-controller-testing
|
|
35. https://github.com/feedbin/feedbin/blob/main/Gemfile
|
|
36. https://github.com/feedbin/feedbin/blob/main/lib/conditional_sass_compressor.rb#L1
|
|
37. https://github.com/feedbin/feedbin/blob/main/config/routes.rb#L133
|
|
38. https://github.com/feedbin/feedbin/blob/main/app/views/entries/destroy.js.erb#L1
|
|
39. https://github.com/feedbin/feedbin/blob/main/app/presenters/base_presenter.rb#L1
|
|
40. https://github.com/feedbin/feedbin/blob/main/app/views/layouts/settings.html.erb#L1
|
|
41. https://github.com/feedbin/feedbin/blob/main/app/views/components/application_component.rb#L3
|
|
42. https://github.com/angristan/feedbin-docker
|
|
43. https://shortruby.com/
|
|
44. http://rubyandrails.info/
|
|
45. https://learn.shortruby.com/
|
|
46. http://Ruby.social/
|
|
47. https://linkedin.com/in/lucianghinda
|
|
48. https://x.com/lucianghinda
|
|
49. https://www.youtube.com/@shortruby
|
|
50. https://allaboutcoding.ghinda.com/sponsor
|
|
51. https://hashnode.com/sponsors
|
|
52. https://allaboutcoding.ghinda.com/tag/ruby?source=tags_bottom_blogs
|
|
53. https://allaboutcoding.ghinda.com/tag/ruby-on-rails?source=tags_bottom_blogs
|
|
54. https://allaboutcoding.ghinda.com/tag/opensource?source=tags_bottom_blogs
|
|
55. https://allaboutcoding.ghinda.com/tag/coding?source=tags_bottom_blogs
|
|
56. https://allaboutcoding.ghinda.com/tag/programming-blogs?source=tags_bottom_blogs
|
|
|
|
Hidden links:
|
|
58. https://allaboutcoding.ghinda.com/
|
|
59. https://allaboutcoding.ghinda.com/?source=top_nav_blog_home
|
|
60. https://twitter.com/lucianghinda
|
|
61. https://github.com/lucianghinda
|
|
62. https://shortruby.com/
|
|
63. https://hashnode.com/@lucianghinda
|
|
64. https://app.daily.dev/lucianghinda
|
|
65. https://linkedin.com/in/lucianghinda
|
|
66. https://ruby.social/@lucian
|
|
67. https://allaboutcoding.ghinda.com/rss.xml
|
|
68. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-the-product
|
|
69. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-open-source
|
|
70. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-license
|
|
71. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-technical-review
|
|
72. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-ruby-and-rails-version
|
|
73. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-architecture
|
|
74. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-stats
|
|
75. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-style-guide
|
|
76. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-storage-persistence-and-in-memory-storage
|
|
77. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-gems-used
|
|
78. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-code-amp-design-patterns
|
|
79. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-code-organisation
|
|
80. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-routes
|
|
81. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-controllers
|
|
82. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-models
|
|
83. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-jobs
|
|
84. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-presenters
|
|
85. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-applicationcomponents
|
|
86. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-componentspreview
|
|
87. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-testing
|
|
88. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-custom-assertions
|
|
89. https://allaboutcoding.ghinda.com/ruby-open-source-feedbin#heading-conclusion
|
|
90. https://feedbin.com/about
|
|
91. https://github.com/feedbin/feedbin/blob/main/LICENSE.md
|
|
92. http://rubyandrails.info/
|
|
93. https://ruby.social/@lucian
|