rubiclifier 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fd4ba1b9ad523fe07ff82c350cb25fdbc4e888b05d3706acb65939af67fb3fed
+  data.tar.gz: b99ec401e3abe0a155c7548babe520dad1385ab64151162237bb92a3080361a6
+SHA512:
+  metadata.gz: e543847ffc6a0f3a9de7a6fdc19355bd5a13157f721c3924d1b5e9ac839f8d7e56660e63aca4a21f497b31dc4393fb7ffa0af02ed8692d21c4e8cf497e3e2199
+  data.tar.gz: b3b203e291003208172f463cb2d9241fb7b99b5ad2e185513b0002701d1c4466c71bed82497d14671fa7f7b3281e20fea2623e0af4fb0971e55e94a761c5fdae

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "httparty"
+gem "sqlite3"

data/lib/args.rb

@@ -0,0 +1,35 @@
+module Rubiclifier
+  class Args
+    attr_reader :args
+    private :args
+
+    def initialize(args)
+      @args = args
+    end
+
+    def command
+      args[0]
+    end
+
+    def subcommand
+      args[1]
+    end
+
+    def none?
+      args.length == 0
+    end
+
+    def string(full_name, aliased = nil)
+      pos = args.find_index { |a| a == "--#{full_name}" || a == "-#{aliased}" }
+      pos && args[pos + 1]
+    end
+
+    def number(full_name, aliased = nil)
+      string(full_name, aliased)&.to_i
+    end
+
+    def boolean(full_name, aliased = nil)
+      !!args.find_index { |a| a == "--#{full_name}" || a == "-#{aliased}" }
+    end
+  end
+end

data/lib/base_api.rb

@@ -0,0 +1,52 @@
+require "httparty"
+
+module Rubiclifier
+  class BaseApi
+    include HTTParty
+
+    def self.api_token
+      base_uri(base_api_url)
+      @api_token ||= DB.get_setting(api_token_db_key) ||
+        begin
+          t = login_and_get_api_token
+          if t.nil?
+            invalid_credentials_error
+          else
+            DB.save_setting(api_token_db_key, t, is_secret: true)
+            t
+          end
+        end
+    end
+
+    def self.invalid_credentials_error
+      raise "Invalid credentials!"
+    end
+
+    def self.login_and_get_api_token
+      raise NotImplementedError
+    end
+
+    def self.api_token_db_key
+      raise NotImplementedError
+    end
+
+    def self.base_api_url_db_key
+      raise NotImplementedError
+    end
+
+    def self.wrap_with_authentication(&block)
+      res = block.call
+      if res.code == 401 || res.code == 403
+        @api_token = nil
+        DB.save_setting(api_token_db_key, nil, is_secret: false)
+        block.call
+      else
+        res
+      end
+    end
+
+    def self.base_api_url
+      @base_api_url ||= DB.get_setting(base_api_url_db_key)&.chomp("/")
+    end
+  end
+end

data/lib/base_application.rb

@@ -0,0 +1,118 @@
+require "io/console"
+require_relative "./args.rb"
+require_relative "./colorized_strings.rb"
+require_relative "./setting.rb"
+
+module Rubiclifier
+  class BaseApplication
+    attr_reader :args
+    private :args
+
+    def initialize(args)
+      @args = Args.new(args)
+      DB.hydrate(data_directory, migrations_location)
+    end
+
+    def call
+      show_help if args.command == "help" || args.boolean("help", "h")
+      setup_or_fail
+      run_application
+    end
+
+    def show_help
+      raise NotImplementedError
+    end
+
+    def run_application
+      raise NotImplementedError
+    end
+
+    def additional_setup
+    end
+
+    def not_setup
+    end
+
+    def is_background_service?
+      raise NotImplementedError
+    end
+
+    def sends_notifications?
+      raise NotImplementedError
+    end
+
+    def settings
+      raise NotImplementedError
+    end
+
+    def executable_name
+      raise NotImplementedError
+    end
+
+    def data_directory
+      raise NotImplementedError
+    end
+
+    def migrations_location
+      nil
+    end
+
+    def brew_dependencies
+      []
+    end
+
+    def setup_or_fail
+      if args.command == "setup" || args.boolean("setup", "s")
+        puts("Installing brew dependencies...")
+        all_brew_dependencies = [
+          "sqlite",
+          ("terminal-notifier" if sends_notifications?)
+        ].concat(brew_dependencies).compact
+        system("brew install #{all_brew_dependencies.join(" ")}")
+
+        puts
+
+        settings.each do |s|
+          s.populate
+        end
+
+        additional_setup
+
+        puts
+
+        if is_background_service?
+          setup_as_background_service
+        else
+          puts("Finished setup! Run with `#{executable_name}`".green)
+        end
+        exit
+      end
+
+      unless settings.all?(&:is_setup?)
+        not_setup
+        puts
+        puts("Oops! You must finish setup first by running with the `--setup` option.".red)
+        puts("  `#{executable_name} --setup`".red)
+        exit
+      end
+    end
+
+    def setup_as_background_service
+      puts("It's recommended that you set this up as a system service with serviceman. You can check it out here: https://git.rootprojects.org/root/serviceman".blue)
+      puts("Set #{executable_name} to run on startup with `serviceman add --name #{executable_name} #{executable_name}`".blue)
+      puts
+      print("Would you like this script to set it up for you? (y/n) ")
+      if STDIN.gets.chomp.downcase == "y"
+        puts "Installing serviceman..."
+        system("curl -sL https://webinstall.dev/serviceman | bash")
+        puts "Adding #{executable_name} as a service..."
+        system("serviceman add --name #{executable_name} #{executable_name}")
+        puts
+        puts("Finished setup! The service is set to run in the background!".green)
+      else
+        puts
+        puts("Finished setup!".green)
+      end
+    end
+  end
+end

data/lib/cipher.rb

@@ -0,0 +1,29 @@
+require "base64"
+require "openssl"
+require "digest/sha1"
+
+class Cipher
+  def self.encrypt(text)
+    cipher = OpenSSL::Cipher.new("aes-256-cbc")
+    cipher.encrypt
+    key = Digest::SHA1.hexdigest("yourpass")[0..31]
+    iv = cipher.random_iv
+    cipher.key = key
+    cipher.iv = iv
+    encrypted = cipher.update(text)
+    encrypted << cipher.final
+    ["#{key}:#{Base64.encode64(iv).encode("utf-8")}", Base64.encode64(encrypted).encode("utf-8")]
+  end
+
+  def self.decrypt(encrypted, salt)
+    key, iv = salt.split(":")
+    iv = Base64.decode64(iv.encode("ascii-8bit"))
+    cipher = OpenSSL::Cipher.new("aes-256-cbc")
+    cipher.decrypt
+    cipher.key = key
+    cipher.iv = iv
+    decrypted = cipher.update(Base64.decode64(encrypted.encode("ascii-8bit")))
+    decrypted << cipher.final
+    decrypted
+  end
+end

data/lib/colorized_strings.rb

@@ -0,0 +1,29 @@
+class String
+  def colorize(color_code)
+    "\e[#{color_code}m#{self}\e[0m"
+  end
+
+  def red
+    colorize(31)
+  end
+
+  def green
+    colorize(32)
+  end
+
+  def yellow
+    colorize(33)
+  end
+
+  def blue
+    colorize(34)
+  end
+
+  def pink
+    colorize(35)
+  end
+
+  def light_blue
+    colorize(36)
+  end
+end

data/lib/database.rb

@@ -0,0 +1,62 @@
+require "sqlite3"
+require_relative "./cipher.rb"
+
+module Rubiclifier
+  class DB
+    SETTINGS_TABLE_MIGRATION = "CREATE TABLE IF NOT EXISTS settings (key VARCHAR(50) PRIMARY KEY, value TEXT, salt TEXT);"
+
+    def self.hydrate(data_directory, migrations_location)
+      system("mkdir -p \"#{data_directory.sub("~", "$HOME")}\"")
+      @conn = SQLite3::Database.new(File.expand_path("#{data_directory}/data.sqlite3"))
+      migrate_if_needed(migrations_location)
+    end
+
+    def self.conn
+      @conn
+    end
+
+    def self.execute(sql)
+      conn.execute(sql)
+    end
+
+    def self.query_single_row(sql)
+      conn.execute(sql) do |row|
+        return row
+      end
+      return nil
+    end
+
+    def self.get_setting(key)
+      row = query_single_row("SELECT value, salt FROM settings WHERE key = '#{key}'")
+      if row && row[1]
+        Cipher.decrypt(row[0], row[1])
+      elsif row
+        row[0]
+      end
+    end
+
+    def self.save_setting(key, value, is_secret:)
+      salt = "NULL"
+      if is_secret
+        salt, encrypted = Cipher.encrypt(value)
+        salt = "'#{salt}'"
+        value = encrypted
+      end
+      conn.execute("DELETE FROM settings WHERE key = '#{key}';")
+      conn.execute("INSERT INTO settings (key, value, salt) VALUES('#{key}', '#{value}', #{salt});")
+    end
+
+    def self.migrate_if_needed(migrations_location)
+      all_migrations = [SETTINGS_TABLE_MIGRATION]
+      all_migrations.concat(eval(File.read(migrations_location))) if migrations_location
+      conn.execute("CREATE TABLE IF NOT EXISTS migrations (id INT PRIMARY KEY);")
+      last_migration = query_single_row("SELECT id FROM migrations ORDER BY id DESC LIMIT 1;")&.to_a&.fetch(0) || -1
+      if all_migrations.length - 1 > last_migration
+        all_migrations[(last_migration + 1)..-1].each_with_index do |sql, i|
+          conn.execute(sql)
+          conn.execute("INSERT INTO migrations (id) VALUES (#{i + last_migration + 1});")
+        end
+      end
+    end
+  end
+end

data/lib/notification.rb

@@ -0,0 +1,30 @@
+module Rubiclifier
+  class Notification
+    attr_reader :title, :message, :subtitle, :icon, :url
+    private :title, :message, :subtitle, :icon, :url
+    def initialize(title, message, subtitle = nil, icon = nil, url = nil)
+      @title = title
+      @message = message
+      @subtitle = subtitle
+      @icon = icon
+      @url = url
+    end
+
+    def send
+      args = {
+        "title" => title,
+        "message" => message,
+        "subtitle" => subtitle,
+        "appIcon" => icon,
+        "open" => url
+      }
+      all_args = args.keys.reduce("") do |arg_string, key|
+        if args[key]
+          arg_string += " -#{key} '#{args[key]}'"
+        end
+        arg_string
+      end
+      system("/usr/local/bin/terminal-notifier #{all_args}")
+    end
+  end
+end

data/lib/rubiclifier.rb

@@ -0,0 +1,8 @@
+require_relative "./args.rb"
+require_relative "./base_api.rb"
+require_relative "./base_application.rb"
+require_relative "./cipher.rb"
+require_relative "./colorized_strings.rb"
+require_relative "./database.rb"
+require_relative "./notification.rb"
+require_relative "./setting.rb"

data/lib/setting.rb

@@ -0,0 +1,39 @@
+module Rubiclifier
+  class Setting
+    attr_reader :key, :label, :explanation, :is_secret, :nullable
+    private :key, :label, :explanation, :is_secret, :nullable
+
+    def initialize(key, label, explanation: nil, is_secret: false, nullable: false)
+      @key = key
+      @label = label
+      @explanation = explanation
+      @is_secret = is_secret
+      @nullable = nullable
+    end
+
+    def populate
+      print("What's the #{label}? #{explanation_text}")
+      input = if is_secret
+                STDIN.noecho(&:gets).chomp.tap { puts }
+              else
+                STDIN.gets.chomp
+              end
+      if input == ""
+        input = nil
+      end
+      DB.save_setting(key, input, is_secret: is_secret) unless input.nil?
+    end
+
+    def explanation_text
+      if explanation.is_a?(Proc)
+        "(#{explanation.call}) "
+      elsif explanation
+        "(#{explanation}) "
+      end
+    end
+
+    def is_setup?
+      DB.get_setting(key) || nullable
+    end
+  end
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: rubiclifier
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kyle Grinstead
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-07-08 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: kyleag@hey.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- lib/args.rb
+- lib/base_api.rb
+- lib/base_application.rb
+- lib/cipher.rb
+- lib/colorized_strings.rb
+- lib/database.rb
+- lib/notification.rb
+- lib/rubiclifier.rb
+- lib/setting.rb
+homepage: https://rubygems.org/gems/rubiclifier
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/MrGrinst/rubiclifier
+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: []
+rubyforge_project: 
+rubygems_version: 2.7.6.2
+signing_key: 
+specification_version: 4
+summary: Easily spin up new Ruby CLI applications with built-in backgrounding and
+  data storage.
+test_files: []