relevium 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 44b99ef9b55ed25a5a759e50028e9a8277d07885c3a6326d44c07c39a93cadd3
+  data.tar.gz: 9890b23b1a7eb169031fa80c9dae4263a77caa84d3f26d95353e0bfedebf9c0f
+SHA512:
+  metadata.gz: ec1b431da475adea43c8ead05e35dda1134803666480b75ffcdc9744d4be9ef75418392550353074995f34eb51e9578bfa8f47d74184a0904f98c24598bb769a
+  data.tar.gz: 7c2f1f38cdea797feb9e9ea122dd955ff52986a96d0a1ffd891239806353a0355714afc0161cfc7aa17450362a959d3bffe88f7d5db47cfe922ece6db653189c

data/.gitignore

@@ -0,0 +1,19 @@
+# See https://help.github.com/articles/ignoring-files for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+#   git config --global core.excludesfile '~/.gitignore_global'
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore debugger history
+.byebug_history
+
+# Ignore IDE files
+.idea
+
+# Ignore local gems
+*.gem
+
+.DS_Store

data/Gemfile

@@ -0,0 +1,11 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+gemspec
+
+gem 'activemodel', '>= 4.2.6'
+
+group :development do
+  gem 'rspec', '>= 3.5.0'
+end

data/Gemfile.lock

@@ -0,0 +1,55 @@
+PATH
+  remote: .
+  specs:
+    relevium (0.0.1)
+      activemodel (>= 4.2.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.2.11.3)
+      activesupport (= 4.2.11.3)
+      builder (~> 3.1)
+    activesupport (4.2.11.3)
+      i18n (~> 0.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    builder (3.2.4)
+    byebug (11.0.1)
+    concurrent-ruby (1.1.7)
+    diff-lcs (1.4.4)
+    i18n (0.9.5)
+      concurrent-ruby (~> 1.0)
+    minitest (5.14.1)
+    rake (10.5.0)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.4)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.7)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activemodel (>= 4.2.6)
+  bundler (>= 1.15)
+  byebug (>= 11.0.1)
+  rake (>= 10.0)
+  relevium!
+  rspec (>= 3.5.0)
+
+BUNDLED WITH
+   1.17.3

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Kirill Bazeltsev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,356 @@
+# Relevium
+![Gem](https://img.shields.io/gem/v/gem?style=flat-square)
+
+#### Simple ruby gem for rails projects with some useful patterns that would help you build more scalable apps
+
+## Table of contents <a name='table-of-contents'></a>
+1. [Service object](#service-object)
+   1. [Listeners](#listeners)
+2. [Background service](#background-service)
+3. [Form object](#form)
+    1. [Serialization with forms](#form)
+
+
+## Service object <a name='service-object'></a>
+[To the start](#table-of-contents)
+
+Interface for running services - a place to move your business logic.
+
+Example:
+```ruby
+class TestService < Relevium::Service
+  attr_reader :user_id
+  
+  def initialize(user_id)
+    @user_id = user_id
+  end
+
+  def call
+    return broadcast(:fail) unless user_valid?
+
+    do_some_stuff
+    book = user.books.last
+    user.delete
+    broadcast(:ok, book)
+  end
+
+  private
+
+  def user_valid?
+    user.name == 'Kyle'
+  end
+
+  def do_some_stuff
+    #..more_code_here..
+  end
+
+  def user
+    @user ||= User.find_by(id: user_id)
+  end
+end
+```
+
+Results:
+
+```ruby
+@user = User.last # Name is 'Kyle'
+
+TestService.call(@user.id)
+# Will delete user and broadcast method won't take affect
+
+TestService.call(@user.id) do |obj|
+  obj.on(:fail) { raise 'Some error' } # Listener for fail broadcast
+  obj.on(:ok) { |book|  @book = book } # Listener for ok broadcast
+end
+# User will be deleted and @book variable will be assigned
+
+@user.update(name: 'Stan')
+TestService.call(@user.id) do |obj|
+  obj.on(:fail) { raise 'Some error' }
+  obj.on(:ok) { |book|  @book = book }
+end
+# User won't be deleted and Some error' will be raised
+```
+
+### Adding listeners <a name='listeners'></a>
+[To the start](#table-of-contents)
+
+Example:
+```ruby
+class TestListener < Relevium::Service
+  attr_reader :email
+
+  def initialize(email)
+    @email = email
+  end
+
+  def call
+    unsubscribe_from_sendgrid
+  end
+
+  private
+
+  def unsubscribe_from_sendgrid
+    # your code
+  end
+end
+```
+
+```ruby
+class TestService < Relevium::Service
+  set_listener TestListener, :ok
+  attr_reader :user_id
+  
+  def initialize(user_id)
+    @user_id = user_id
+  end
+
+  def call
+    do_some_stuff
+    user.delete
+    user.persisted? ? broadcast(:ok, user.email) : broadcast(:fail)
+  end
+
+  private
+
+  def do_some_stuff
+    #..more_code_here..
+  end
+
+  def user
+    @user ||= User.find_by(id: user_id)
+  end
+end
+```
+
+Results:
+
+```ruby
+@user = User.last
+
+TestService.call(@user.id)
+# Will delete user and broadcast method won't take affect.
+# However listener's `call` function will be called 
+# with `email` passed as the argument to initialize function.
+```
+---
+Specify which function from listener to call:
+
+```ruby
+class TestListener < Relevium::Service
+  def initialize(arg)
+    @arg = arg
+  end
+
+  def on_ok
+    # ok code
+  end
+
+  def on_fail
+    # fail code
+  end
+end
+
+set_listener TestListener, :ok, function: :on_ok
+set_listener TestListener, :fail, function: :on_fail
+```
+---
+Specify arguments that should be passed to the listener:
+```ruby
+class TestListener < Relevium::Service
+  attr_reader :arg
+
+  def initialize(arg)
+    @arg = arg
+  end
+
+  def call
+    puts arg
+  end
+end
+
+class TestService < Relevium::Service
+  set_listener TestListener, :ok, args: :user_id
+
+  def initialize(user_id)
+    @user_id = user_id
+  end
+
+  def call
+    # some code
+    broadcast(:ok, 'test')
+  end
+end
+```
+
+Result:
+```ruby
+TestService.call(1) do |service|
+  service.on(:ok) { |argument| puts argument }
+end
+
+# Output:
+# test
+# 1
+```
+---
+Set up condition to call listener:
+```ruby
+class TestService < Relevium::Service
+  set_listener TestListener, :ok, if: Proc.new { |service| !service.user.persisted? }
+
+  def initialize(user_id)
+    @user = User.find(user_id)
+  end
+
+  def call
+    @user.delete
+    broadcast(:ok)
+  end
+end
+```
+
+Results:
+```ruby
+TestService.call(User.last.id)
+# Listener would be trigger only if user was deleted.
+```
+
+## Background service <a name='background-service'></a>
+[To the start](#table-of-contents)
+
+Simple interface for running background jobs as services.
+Meant to be inherited like this:
+```ruby
+class SidekiqService < Relevium::BackgroundService
+  def initialize(options)
+    super(options, ServiceObjectWorker)
+  end
+end
+```
+Needs a sidekiq worker in order to work, that should look like this:
+```ruby
+class ServiceObjectWorker
+  include Sidekiq::Worker
+  sidekiq_options queue: :default, retry: true
+
+  def perform(klass, *args)
+    klass.constantize.call(args)
+  end
+end
+
+```
+
+Now you can create a service like this:
+```ruby
+class SimpleService < SidekiqService
+attr_reader :foo
+
+  def initialize(foo, options = {})
+    super(options)
+    @foo = foo
+  end
+
+  private
+
+  def perform
+    puts foo
+  end
+end
+
+```
+
+And invoke it like this:
+```ruby
+SimpleService.call('foo', background: true, perform_in: 15.minutes)
+# Will set sidekiq worker to be performd in 15 minutes,
+# that will print 'foo' in sidekiq console
+```
+Note that listeners won't work when service is being called as background job.
+
+## Form object <a name='form'></a>
+[To the start](#table-of-contents)
+
+Form object is used to move validations from models. Usually used when similar model needs different validations on
+different forms. Can be used to build attributes for model to save.
+
+Example:
+```ruby
+class UserForm < Relevium::Form
+
+  attribute :user_id, Integer
+  attribute :user_name, String
+  attribute :sibling_name, String, remove_from_hash: true
+
+  include_in_hash :sibling_id
+
+  validates :user_id, :user_name, presence: true
+  validate :is_kyle
+
+  private
+
+  def is_kyle
+    return true if user_name == 'Kyle'
+
+    errors.add(:user_name, 'should be Kyle')
+  end
+
+  def sibling_id
+    @sibling_id ||= User.find_by(name: sibling_name)
+  end
+end
+```
+Results:
+```ruby
+user_params = {user_id: 1, user_name: 'Kyle', sibling_name: 'John'}
+form = UserForm.new(user_params)
+form.valid? # true
+form = UserForm.new(user_params.merge(user_name: 'Steve'))
+form.valid? # false
+form.errors.full_messages # ["User name should be Kyle"]
+form = UserForm.new(user_params.merge(user_id: 'test'))
+form.valid? # false
+form.errors.full_messages # ["User can't be blank"]
+form = UserForm.new(user_params.merge(user_id: '1')) # Will convert user_id into Integer
+form.to_h # { user_id: 1, user_name: 'Kyle', sibling_id: 12 }
+
+form.set(user_name, 'Stan')
+form.set_attributes(user_id: 2, sibling_name: 'Ken')
+form.to_h # { user_id: 2, user_name: 'Stan', sibling_name: 'Ken' }
+```
+---
+### Serialization with forms <a name='serialization'></a>
+[To the start](#table-of-contents)
+
+```ruby
+class UserForm < Relevium::Form
+  attribute :available_cash, Float
+
+  serialize_attributes :user_id, :sibling_id, :available_cash, :user_full_name
+
+  def user_full_name
+    first_name + ' ' + last_name
+  end
+end
+```
+
+Now you can use this form to serialize active records to hash:
+```ruby
+ap User
+# User < ActiveRecord::Base {
+#  :user_id => :integer,
+#  :available_cash => :string,
+#  :sibling_id => :integer,
+#  :first_name => :string,
+#  :last_name => :string
+# }
+UserForm.from_model(User.last).serialize
+# Output: 
+# { user_id: 1, sibling_id: 2, available_cash: 123.45, user_full_name: 'Ken Stevenson' }
+```
+Also you can serialize active record collection or array of active records:
+```ruby
+UserForm.serialize_relation(User.where(id: (1..15)))
+UserForm.serialize_relation(User.last(3).to_a)
+```
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "spec"
+  t.libs << "lib"
+  t.test_files = FileList["rspec spec/*/"]
+end
+
+task :default => :test

data/bitbucket-pipelines.yml

@@ -0,0 +1,16 @@
+#  Template Ruby build
+
+#  This template allows you to validate your Ruby code.
+#  The workflow allows running tests and code linting on the default branch.
+
+image: ruby:2.7
+
+pipelines:
+  default:
+    - parallel:
+      - step:
+          name: Run Rspec
+          script:
+            - gem install bundler -v 1.17.2
+            - bundle install
+            - bundle exec rspec

data/lib/relevium.rb

@@ -0,0 +1,4 @@
+require 'relevium/version'
+require 'relevium/service'
+require 'relevium/form'
+require 'relevium/background_service'

data/lib/relevium/background_service.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'relevium/service'
+
+module Relevium
+  class BackgroundService < Service
+    attr_reader :options, :worker_class
+
+    def initialize(options, worker_class)
+      @options = options
+      @worker_class = worker_class
+    end
+
+    def call
+      return broadcast(:fail) unless valid?
+
+      background? ? setup_worker : perform
+    end
+
+    private
+
+    def perform
+      NoMethodError
+    end
+
+    def self.worker_attributes(*attributes)
+      @worker_attributes_array = attributes
+    end
+
+    def self.worker_attributes_array
+      @worker_attributes_array ||= []
+    end
+
+    def fetch_worker_attributes
+      self.class.worker_attributes_array.map do |worker_attribute|
+        instance_variable_get("@#{worker_attribute}")
+      end
+    end
+
+    def setup_worker
+      worker_class.perform_in(delay, self.class, *fetch_worker_attributes)
+    end
+
+    def delay
+      options[:perform_in] || 5.minutes
+    end
+
+    def background?
+      !options[:background].nil? && options[:background]
+    end
+
+    def valid?
+      true
+    end
+  end
+end

data/lib/relevium/form.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'active_model'
+
+module Relevium
+  class Form
+    include ActiveModel::Model
+
+    def initialize(hash)
+      set_attributes(hash)
+      self
+    end
+
+    def self.from_model(model)
+      new(model.attributes)
+    rescue StandardError => _e
+      nil
+    end
+
+    def to_h
+      hash = {}
+      self.instance_variables.each do |var|
+        var_name = var.to_s.delete('@')
+        attribute = self.class.attributes.find { |attr| attr.attribute_name == var_name.to_sym }
+        hash[var_name] = instance_variable_get(var) if attribute&.remove_from_hash == false
+      end
+      self.class.methods_for_hash.each do |method|
+        hash[method] = self.send(method)
+      end
+      hash.default_proc = proc { |h, k| h.key?(k.to_s) ? h[k.to_s] : nil }
+      hash
+    end
+
+    def serialize
+      hash = {}
+      self.class.attributes_to_serialize.each do |attribute|
+        hash[attribute] = self.send(attribute) rescue instance_variable_get("@#{attribute}")
+      end
+      hash.default_proc = proc { |h, k| h.key?(k.to_s) ? h[k.to_s] : nil }
+      hash
+    end
+
+    def set(name, value)
+      attribute = self.class.attributes.find { |attr| attr.attribute_name.to_s == name.to_s }
+      if attribute.present?
+        set_attribute(attribute, value)
+      else
+        instance_variable_set("@#{name}", value)
+      end
+      self
+    end
+
+    def set_attributes(hash)
+      hash.to_h.to_a.each do |attr_array|
+        set(attr_array[0], attr_array[1])
+      end
+      self
+    end
+
+    def errors_to_string
+      errors.full_messages.to_sentence
+    end
+
+    def self.i18n_scope
+      :activerecord
+    end
+
+    private
+
+    def set_attribute(attribute, value)
+      instance_variable_set(attribute.name_to_instance_variable, attribute.normalized_value(value))
+    end
+
+    def self.attribute(attribute, type = nil, remove_from_hash: false)
+      attributes << Attribute.new(attribute, type, remove_from_hash)
+      self.class_eval { attr_reader attribute }
+    end
+
+    def self.attributes
+      @attributes ||= Set.new
+    end
+
+    def self.include_in_hash(*methods)
+      @methods_for_hash = methods
+    end
+
+    def self.methods_for_hash
+      @methods_for_hash ||= []
+    end
+
+    def self.serialize_attributes(*attributes)
+      @attributes_to_serialize = attributes
+    end
+
+    def self.attributes_to_serialize
+      @attributes_to_serialize ||= []
+    end
+
+    def self.serialize_relation(relation)
+      relation.map { |model| from_model(model).serialize }
+    end
+
+    class Boolean; end
+  end
+
+  class Attribute
+    DATE_TYPES = [Date, Time, DateTime].freeze
+    TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE'].freeze
+
+    attr_reader :attribute_name, :type, :remove_from_hash
+
+    def initialize(attribute_name, type = nil, remove_from_hash = false)
+      @attribute_name = attribute_name
+      @type = type
+      @remove_from_hash = remove_from_hash
+    end
+
+    def normalized_value(value)
+      return nil if value.nil?
+      return value unless type
+      return value if value.is_a?(type)
+
+      cast_value_to_type(value)
+    rescue ArgumentError => _e
+      nil
+    end
+
+    def cast_value_to_type(value)
+      return TRUE_VALUES.include?(value) if type == ::Relevium::Form::Boolean
+      return method(type.to_s).call(value) unless DATE_TYPES.include?(type)
+
+      value.send("to_#{type.to_s.underscore}")
+    end
+
+    def name_to_instance_variable
+      "@#{attribute_name}"
+    end
+  end
+end

data/lib/relevium/service.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'byebug'
+
+module Relevium
+  class Service
+    def self.call(*args)
+      obj = new(*args)
+      yield obj if block_given?
+      obj.call
+    end
+
+    def initialize(*args); end
+
+    def on(name, &block)
+      local_registrations << BlockRegistration.new(name, block)
+      self
+    end
+
+    private
+
+    def broadcast(name, *args)
+      set_off_local_listeners(name, *args)
+      set_off_global_listeners(name, *args)
+      self
+    end
+
+    def set_off_local_listeners(name, *args)
+      local_registrations.select { |registration| registration.listener == name }.first&.broadcast(*args)
+    end
+
+    def set_off_global_listeners(name, *args)
+      select_proc = Proc.new { |registration| registration.message == name }
+      registrations = self.class.global_registrations.select(&select_proc)
+      registrations += self.class.superclass&.global_registrations&.select(&select_proc)
+      registrations.each do |registration|
+        next unless registration.condition.nil? || registration.condition.call(self)
+
+        registration.args.nil? ? registration.broadcast(*args) : registration.broadcast(*get_args(*registration.args))
+      end
+    end
+
+    def get_args(*args)
+      args.map { |arg| instance_variable_get("@#{arg}") }
+    end
+
+    def transaction(&block)
+      ActiveRecord::Base.transaction(&block) if block_given?
+    end
+
+    def local_registrations
+      @local_registrations ||= Set.new
+    end
+
+    def self.set_listener(klass, message, options = {})
+      global_registrations << GlobalRegistration.new(klass, message, options, self)
+    end
+
+    def self.global_registrations
+      @global_registrations ||= Set.new
+    end
+
+    def call
+      raise NoMethodError
+    end
+  end
+
+  class BlockRegistration
+    attr_reader :listener, :message
+
+    def initialize(listener, message)
+      @listener = listener
+      @message = message
+    end
+
+    def broadcast(*args)
+      message.call(*args)
+    end
+  end
+
+  class GlobalRegistration < BlockRegistration
+    attr_reader :function, :condition, :args, :whisperer
+
+    def initialize(listener, message, options = {}, whisperer = nil)
+      super(listener, message)
+      @function = options[:function] || 'call'
+      @condition = options[:if]
+      @args = options[:args]
+      @whisperer = whisperer
+    end
+
+    def broadcast(*args)
+      listener_obj = listener.new(*args)
+      listener_obj.instance_variable_set('@whisperer', whisperer)
+      listener_obj.send(function)
+    end
+
+    def validate!
+      raise 'Invalid function name for listener' unless [String, Symbol].include?(function.class)
+      raise 'Invalid condition for listener' unless condition.is_a?(Proc)
+    end
+  end
+end

data/lib/relevium/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Relevium
+  VERSION = '0.0.1'
+end

data/relevium.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "relevium/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "relevium"
+  spec.version       = Relevium::VERSION
+  spec.authors       = ['Bazeltsev Kirill']
+  spec.email         = ['kirill.bazeltsev@flender.ie']
+
+  spec.summary       = 'A Ruby gem, that helps keep models and controllers thin'
+  spec.description   = ''
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.add_dependency 'activemodel', '>= 4.2.6'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", ">= 1.15"
+  spec.add_development_dependency "rake", ">= 10.0"
+  spec.add_development_dependency "rspec", ">= 3.5.0"
+  spec.add_development_dependency "byebug", '>= 11.0.1'
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: relevium
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Bazeltsev Kirill
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-02-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.6
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 11.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 11.0.1
+description: ''
+email:
+- kirill.bazeltsev@flender.ie
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bitbucket-pipelines.yml
+- lib/relevium.rb
+- lib/relevium/background_service.rb
+- lib/relevium/form.rb
+- lib/relevium/service.rb
+- lib/relevium/version.rb
+- relevium.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.8
+signing_key:
+specification_version: 4
+summary: A Ruby gem, that helps keep models and controllers thin
+test_files: []