console_buddy 0.1.1

data/lib/console_buddy.rb

@@ -0,0 +1,216 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'active_support'
+require 'active_support/all'
+
+require_relative "console_buddy/method_store"
+require_relative "console_buddy/augment"
+require_relative "console_buddy/base"
+require_relative "console_buddy/helpers"
+require_relative "console_buddy/irb"
+require_relative "console_buddy/version"
+
+require_relative "console_buddy/one_off_job"
+require_relative "console_buddy/job"
+
+# Only load the one-off job classes if the gems are installed
+# 
+begin
+  require 'sidekiq'
+  require_relative "console_buddy/jobs/sidekiq"
+rescue LoadError
+  # puts "Sidekiq gem not installed, skipping sidekiq job integration."
+end
+
+begin
+  require 'resque'
+  require_relative "console_buddy/jobs/resque"
+rescue LoadError
+  # puts "Resque gem not installed, skipping resque job integration."
+end
+
+begin
+  require 'activejob'
+  require_relative "console_buddy/jobs/active_job"
+rescue LoadError
+  # puts "ActiveJob gem not installed, skipping active job integration."
+end
+
+module ConsoleBuddy
+  class << self
+    attr_accessor :verbose_console, :allowed_envs, :use_in_debuggers, :ignore_startup_errors, :use_in_tests, :one_off_job_service_type
+
+    def store
+      @store ||= ::ConsoleBuddy::MethodStore.new
+    end
+
+    def start!
+      # Initialize the default values
+      set_config_defaults
+      # Check if there is a .console_buddy/config file
+      load_console_buddy_config
+
+      # Only start the buddy in the allowed environments. e.g. development, test
+      return if !allowed_env?
+
+      # Do not start the buddy in test environment if use_in_tests is false
+      return if test? && !use_in_tests
+
+      begin
+        load_console_buddy_files
+        augment_classes
+        augment_console
+        start_buddy_in_irb
+        start_buddy_in_rails
+        start_buddy_in_byebug
+        puts "ConsoleBuddy session started! Debugger: #{use_in_debuggers} | Test: #{current_env}" if verbose_console
+      rescue ::StandardError => error
+        puts "ConsoleBuddy encountered an during startup. [Error]: #{error.message}" if ignore_startup_errors
+      end
+    end
+
+    def load_byebug!
+      start_buddy_in_byebug
+    end
+
+    private
+
+    def set_config_defaults
+      @verbose_console = true
+      @use_in_tests = false
+      @use_in_debuggers = false
+      @ignore_startup_errors = false
+      @allowed_envs = %w[development test]
+      @one_off_job_service_type = :inline
+    end
+
+    # Only start the buddy in the allowed environments
+    def allowed_env?
+      if current_env.present?
+        can_start = allowed_envs.include?(current_env)
+        if verbose_console && can_start
+          puts "ConsoleBuddy is starting in #{current_env} environment."
+        end
+        return can_start
+      end
+
+      true
+    end
+
+    def test?
+      current_env == 'test'
+    end
+
+    def current_env
+      ENV['RAILS_ENV'] == 'test' || ENV['RACK_ENV']
+    end
+
+    # Loads the .console_buddy/config file if present
+    def load_console_buddy_config
+      config_path = Pathname.new(File.join(Dir.pwd, '.console_buddy', 'config.rb'))
+      if config_path.exist? && config_path.file?
+        require config_path.to_s
+      else
+        puts ".console_buddy/config file not found."
+      end
+    end
+
+    # Loads all the files in the .console_buddy folder
+    # .console_buddy folder should be in the root of the project
+    def load_console_buddy_files
+      console_buddy_path = Pathname.new(File.join(Dir.pwd, '.console_buddy'))
+      if console_buddy_path.exist? && console_buddy_path.directory?
+        console_buddy_path.each_child do |file|
+          next unless file.file?
+          require file.to_s
+        end
+      else
+        puts ".console_buddy folder not found in the root of the project."
+      end
+    end
+
+    # Augment the classes with the methods defined in the store
+    def augment_classes
+      ::ConsoleBuddy.store.augment_helper_methods.each do |klass, methods|
+        begin
+          klass.constantize
+        rescue NameError
+          puts "Class #{klass} not found. Skipping..." if verbose_console
+          next
+        end
+
+        methods.each do |method|
+          case method[:method_type]
+          when :instance
+            klass.constantize.define_method(method[:method_name]) do |*args|
+              instance_exec(*args, &method[:block])
+            end
+          when :class
+            klass.constantize.define_singleton_method(method[:method_name]) do |*args|
+              instance_exec(*args, &method[:block])
+            end
+          else
+            next
+          end
+        end
+      end
+    end
+
+    # Augment the console with the methods defined in the store
+    def augment_console
+      ::ConsoleBuddy.store.console_method.each do |method_name, block|
+        ::ConsoleBuddy::IRB.define_method(method_name, block)
+      end
+    end
+
+    # This will add the buddy methods to the IRB session
+    # So that they can be called without instantiating the `ConsoleBuddy::Base` class
+    def start_buddy_in_irb
+      if defined? IRB::ExtendCommandBundle
+        IRB::ExtendCommandBundle.include(ConsoleBuddy::IRB)
+        require 'progress_bar/core_ext/enumerable_with_progress'
+      end
+    end
+
+    # This will add the buddy methods to the Rails console
+    # So that they can be called without instantiating the `ConsoleBuddy::Base` class
+    def start_buddy_in_rails
+      if defined? Rails::ConsoleMethods
+        Rails::ConsoleMethods.include(ConsoleBuddy::IRB)
+        require 'progress_bar/core_ext/enumerable_with_progress'
+      end
+    end
+
+    # This will add the buddy methods to the Byebug console
+    # TODO: Add support for Pry
+    def start_buddy_in_byebug
+      return if !use_in_debuggers
+
+      if defined?(Byebug)
+        byebug_path = Pathname.new(File.join(__dir__, 'console_buddy', 'byebug'))
+
+        if byebug_path.exist? && byebug_path.directory?
+          byebug_path.each_child do |file|
+            next unless file.file?
+            require file.to_s
+          end
+        end
+
+        [
+          ConsoleBuddy::Byebug::HelloCommand,
+          ConsoleBuddy::Byebug::BuddyCommand,
+        ].each do |command_class|
+          ::Byebug.const_set(
+            command_class.name.split('::').last,
+            command_class,
+          )
+        end
+      end
+    end
+  end
+end
+
+require_relative "console_buddy/initializers/byebug"
+require_relative "console_buddy/initializers/rails"
+require_relative "console_buddy/initializers/rspec"

data/spec/console_buddy/augment_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require_relative '../../lib/console_buddy/augment'
+require_relative '../../lib/console_buddy/method_store'
+
+RSpec.describe ConsoleBuddy::Augment do
+  describe '.define' do
+    it 'executes the given block in the context of ConsoleBuddy::Augment::DSL' do
+      dsl_instance = instance_double(ConsoleBuddy::Augment::DSL)
+      allow(ConsoleBuddy::Augment::DSL).to receive(:new).and_return(dsl_instance)
+      expect(dsl_instance).to receive(:instance_eval)
+
+      described_class.define {}
+    end
+
+    it 'does nothing if no block is given' do
+      expect { described_class.define }.not_to raise_error
+    end
+  end
+
+  describe ConsoleBuddy::Augment::DSL do
+    let(:klass) { Class.new }
+    let(:method_name) { :test_method }
+    let(:new_method_name) { :new_test_method }
+    let(:block) { proc { 'test' } }
+    let(:store) { ConsoleBuddy::MethodStore.new }
+    
+    before do
+      allow(ConsoleBuddy).to receive(:store).and_return(store)
+    end
+
+    describe '#method' do
+      it 'stores the method definition in the augment_helper_methods store' do
+        subject.method(klass, method_name, &block)
+        expect(store.augment_helper_methods[klass.to_s]).to include(
+          method_name: method_name,
+          block: block,
+          method_type: :instance
+        )
+      end
+
+      it 'raises an error for invalid method type' do
+        expect {
+          subject.method(klass, method_name, type: :invalid, &block)
+        }.to raise_error(ConsoleBuddy::Augment::DSL::InvalidTypeError, "Invalid method type. Must be either :instance or :class")
+      end
+    end
+
+    describe '#method_alias' do
+      it 'stores the method alias definition in the augment_helper_methods store' do
+        subject.method_alias(klass, method_name, new_method_name)
+        expect(store.augment_helper_methods[klass.to_s]).to include(
+          method_name: new_method_name,
+          block: an_instance_of(Proc),
+          method_type: :instance
+        )
+      end
+
+      it 'raises an error for invalid method type' do
+        expect {
+          subject.method_alias(klass, method_name, new_method_name, type: :invalid)
+        }.to raise_error(ConsoleBuddy::Augment::DSL::InvalidTypeError, "Invalid method type. Must be either :instance or :class")
+      end
+    end
+  end
+end

data/spec/console_buddy/csv_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'csv'
+require 'fileutils'
+require 'tempfile'
+require_relative '../../lib/console_buddy/csv'
+
+RSpec.describe ConsoleBuddy::CSV do
+  include ConsoleBuddy::CSV
+
+  describe '#generate_csv' do
+    let(:headers) { ['Name', 'Age'] }
+    let(:rows) { [['Alice', "30"], ['Bob', "25"]] }
+    let(:dir) { 'tmp' }
+    let(:filename) { 'test_csv' }
+    let(:file_path) { File.join(dir, "#{filename}.csv") }
+
+    before do
+      FileUtils.mkdir_p(dir)
+    end
+
+    after do
+      FileUtils.rm_rf(dir)
+    end
+
+    it 'creates a CSV file with the given headers and rows' do
+      generate_csv(headers, rows, filename: filename, dir: dir)
+      expect(File).to exist(file_path)
+
+      csv_content = ::CSV.read(file_path)
+      expect(csv_content).to eq([headers, *rows])
+    end
+
+    it 'creates the directory if it does not exist' do
+      new_dir = 'new_tmp'
+      new_file_path = File.join(new_dir, "#{filename}.csv")
+
+      generate_csv(headers, rows, filename: filename, dir: new_dir)
+      expect(File).to exist(new_file_path)
+
+      csv_content = ::CSV.read(new_file_path)
+      expect(csv_content).to eq([headers, *rows])
+
+      FileUtils.rm_rf(new_dir)
+    end
+  end
+
+  describe '#read_csv' do
+    let(:headers) { ['Name', 'Age'] }
+    let(:rows) { [['Alice', "30"], ['Bob', "25"]] }
+    let(:tempfile) { Tempfile.new(['test_csv', '.csv']) }
+
+    before do
+      ::CSV.open(tempfile.path, 'w') do |csv|
+        csv << headers
+        rows.each { |row| csv << row }
+      end
+    end
+
+    after do
+      tempfile.close
+      tempfile.unlink
+    end
+
+    it 'reads the CSV file and returns the data without headers' do
+      data = read_csv(tempfile.path, skip_headers: true)
+      expect(data.count).to eq(rows.count)
+    end
+
+    it 'reads the CSV file and returns the data with headers' do
+      data = read_csv(tempfile.path, skip_headers: false)
+      expect(data).to eq([headers, *rows])
+    end
+  end
+end

data/spec/console_buddy/helpers_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require_relative '../../lib/console_buddy/helpers'
+require_relative '../../lib/console_buddy/method_store'
+
+RSpec.describe ConsoleBuddy::Helpers do
+  describe '.define' do
+    it 'executes the given block in the context of ConsoleBuddy::Helpers::DSL' do
+      dsl_instance = instance_double(ConsoleBuddy::Helpers::DSL)
+      allow(ConsoleBuddy::Helpers::DSL).to receive(:new).and_return(dsl_instance)
+      expect(dsl_instance).to receive(:instance_eval)
+
+      described_class.define {}
+    end
+
+    it 'does nothing if no block is given' do
+      expect { described_class.define }.not_to raise_error
+    end
+  end
+
+  describe ConsoleBuddy::Helpers::DSL do
+    let(:method_name) { :call_api }
+    let(:block) { proc { |status, message| puts "RESPONSE: { #{status}, #{message} }" } }
+    let(:store) { ConsoleBuddy::MethodStore.new }
+
+    before do
+      allow(ConsoleBuddy).to receive(:store).and_return(store)
+    end
+
+    describe '#console_method' do
+      it 'stores the method definition in the console_method store' do
+        subject.console_method(method_name, &block)
+        expect(store.console_method[method_name]).to eq(block)
+      end
+    end
+  end
+end

data/spec/console_buddy/http_request_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'webmock/rspec'
+require 'httparty'
+require_relative '../../lib/console_buddy/http_request'
+
+RSpec.describe ConsoleBuddy::HttpRequest do
+  include ConsoleBuddy::HttpRequest
+
+  describe '#ping' do
+    let(:url) { 'http://example.com' }
+    let(:response_body) { { 'message' => 'Hello, world!' }.to_json }
+
+    before do
+      stub_request(:get, url).to_return(body: response_body, headers: { 'Content-Type' => 'application/json' })
+    end
+
+    it 'makes an HTTP GET request to the given URL' do
+      expect(HTTParty).to receive(:get).with(url).and_call_original
+      ping(url)
+    end
+
+    it 'parses the JSON response' do
+      result = ping(url)
+      expect(result).to eq('message' => 'Hello, world!')
+    end
+  end
+end

data/spec/console_buddy/irb_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require_relative '../../lib/console_buddy/irb'
+require_relative '../../lib/console_buddy/base'
+
+RSpec.describe ConsoleBuddy::IRB do
+  include ConsoleBuddy::IRB
+
+  describe '#buddy' do
+    it 'returns a new instance of ConsoleBuddy::Base' do
+      expect(buddy).to be_an_instance_of(ConsoleBuddy::Base)
+    end
+  end
+
+  describe '#console_buddy' do
+    it 'is an alias for #buddy' do
+      expect(console_buddy).to be_an_instance_of(ConsoleBuddy::Base)
+    end
+  end
+end

data/spec/console_buddy/job_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+require 'sidekiq'
+require 'active_job'
+require 'resque'
+
+require_relative '../../lib/console_buddy/job'
+require_relative '../../lib/console_buddy/jobs/resque'
+require_relative '../../lib/console_buddy/jobs/sidekiq'
+require_relative '../../lib/console_buddy/jobs/active_job'
+
+RSpec.describe ConsoleBuddy::Job do
+  let(:args) { ['foo', 'bar'] }
+
+  describe '#perform' do
+    subject { described_class.new }
+
+    context 'when service_type is :resque' do
+      before { allow(ConsoleBuddy::OneOffJob).to receive(:service_type).and_return(:resque) }
+
+      it 'delegates to ConsoleBuddy::Jobs::Resque.perform' do
+        expect(ConsoleBuddy::Jobs::Resque).to receive(:perform).with(*args)
+        subject.perform(*args)
+      end
+    end
+
+    context 'when service_type is :sidekiq' do
+      before { allow(ConsoleBuddy::OneOffJob).to receive(:service_type).and_return(:sidekiq) }
+
+      it 'delegates to ConsoleBuddy::Jobs::Sidekiq.new.perform' do
+        sidekiq_instance = instance_double(ConsoleBuddy::Jobs::Sidekiq)
+        allow(ConsoleBuddy::Jobs::Sidekiq).to receive(:new).and_return(sidekiq_instance)
+        expect(sidekiq_instance).to receive(:perform).with(*args)
+        subject.perform(*args)
+      end
+    end
+
+    context 'when service_type is :active_job' do
+      before { allow(ConsoleBuddy::OneOffJob).to receive(:service_type).and_return(:active_job) }
+
+      it 'delegates to ConsoleBuddy::Jobs::ActiveJob.perform' do
+        expect(ConsoleBuddy::Jobs::ActiveJob).to receive(:perform).with(*args)
+        subject.perform(*args)
+      end
+    end
+
+    context 'when service_type is unknown' do
+      before { allow(ConsoleBuddy::OneOffJob).to receive(:service_type).and_return(:unknown) }
+
+      it 'delegates to ConsoleBuddy::OneOffJob.perform' do
+        expect(ConsoleBuddy::OneOffJob).to receive(:perform).with(*args)
+        subject.perform(*args)
+      end
+    end
+  end
+
+  describe '.perform_async' do
+    context 'when service_type is :resque' do
+      before { allow(ConsoleBuddy::OneOffJob).to receive(:service_type).and_return(:resque) }
+
+      it 'delegates to ConsoleBuddy::Jobs::Resque.perform_later' do
+        expect(ConsoleBuddy::Jobs::Resque).to receive(:perform_later).with(*args)
+        described_class.perform_async(*args)
+      end
+    end
+
+    context 'when service_type is :sidekiq' do
+      before { allow(ConsoleBuddy::OneOffJob).to receive(:service_type).and_return(:sidekiq) }
+
+      it 'delegates to ConsoleBuddy::Jobs::Sidekiq.perform_async' do
+        expect(ConsoleBuddy::Jobs::Sidekiq).to receive(:perform_async).with(*args)
+        described_class.perform_async(*args)
+      end
+    end
+
+    context 'when service_type is :active_job' do
+      before { allow(ConsoleBuddy::OneOffJob).to receive(:service_type).and_return(:active_job) }
+
+      it 'delegates to ConsoleBuddy::Jobs::ActiveJob.perform_later' do
+        expect(ConsoleBuddy::Jobs::ActiveJob).to receive(:perform_later).with(*args)
+        described_class.perform_async(*args)
+      end
+    end
+
+    context 'when service_type is unknown' do
+      before { allow(ConsoleBuddy::OneOffJob).to receive(:service_type).and_return(:unknown) }
+
+      it 'delegates to ConsoleBuddy::OneOffJob.perform' do
+        expect(ConsoleBuddy::OneOffJob).to receive(:perform).with(*args)
+        described_class.perform_async(*args)
+      end
+    end
+  end
+
+  describe '.perform_later' do
+    it 'delegates to .perform_async' do
+      expect(described_class).to receive(:perform_async).with(*args)
+      described_class.perform_later(*args)
+    end
+  end
+end

data/spec/console_buddy/method_store_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require_relative '../../lib/console_buddy/method_store'
+
+RSpec.describe ConsoleBuddy::MethodStore do
+  describe '#initialize' do
+    it 'initializes augment_helper_methods as a hash with default array values' do
+      method_store = ConsoleBuddy::MethodStore.new
+      expect(method_store.augment_helper_methods).to be_a(Hash)
+      expect(method_store.augment_helper_methods.default_proc).not_to be_nil
+      expect(method_store.augment_helper_methods[:some_key]).to eq([])
+    end
+
+    it 'initializes console_method as an empty hash' do
+      method_store = ConsoleBuddy::MethodStore.new
+      expect(method_store.console_method).to be_a(Hash)
+      expect(method_store.console_method).to be_empty
+    end
+  end
+
+  describe 'attributes' do
+    let(:method_store) { ConsoleBuddy::MethodStore.new }
+
+    it 'allows reading and writing for :augment_helper_methods' do
+      method_store.augment_helper_methods[:test] = ['method1']
+      expect(method_store.augment_helper_methods[:test]).to eq(['method1'])
+    end
+
+    it 'allows reading and writing for :console_method' do
+      method_store.console_method[:test_method] = 'some_method'
+      expect(method_store.console_method[:test_method]).to eq('some_method')
+    end
+  end
+end

data/spec/console_buddy/report_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'table_print'
+require 'terminal-table'
+require_relative '../../lib/console_buddy/report'
+
+RSpec.describe ConsoleBuddy::Report do
+  include ConsoleBuddy::Report
+
+  describe '#table_print' do
+    let(:data) { [{ username: 'user1' }, { username: 'user2' }] }
+    let(:options) { { columns: [:username] } }
+
+    it 'prints the table using TablePrint' do
+      expect(::TablePrint::Printer).to receive(:table_print).with(data, options)
+      table_print(data, options)
+    end
+  end
+
+  describe '#table_for' do
+    let(:rows) { [['foo', 'bar'], ['baz', 'qux']] }
+    let(:headers) { ['col1', 'col2'] }
+
+    it 'prints the table using Terminal::Table' do
+      table = ::Terminal::Table.new(headings: headers, rows: rows)
+      expect(::Terminal::Table).to receive(:new).with(headings: headers, rows: rows).and_return(table)
+      expect { table_for(rows, headers) }.to output("#{table}\n").to_stdout
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+require "bundler/setup"
+require "byebug"
+require 'rails'
+
+require "console_buddy"
+
+ENV['RAILS_ENV'] ||= 'test'
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = ".rspec_status"
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end
+
+
+# RSpec.configure do |config|
+#   config.expect_with :rspec do |expectations|
+#     expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+#   end
+
+#   config.mock_with :rspec do |mocks|
+#     mocks.verify_partial_doubles = true
+#   end
+
+#   config.shared_context_metadata_behavior = :apply_to_host_groups
+# end