shelldon 0.0.1

data/lib/helpers/timer.rb

@@ -0,0 +1,17 @@
+module Shelldon
+  class Timer
+    def initialize(strftime = '%s')
+      @strftime = strftime
+    end
+
+    def start
+      @start = Time.now
+    end
+
+    def stop
+      res = (Time.now - @start) * 1000
+      @start = nil
+      Time.at(res).strftime(@strftime)
+    end
+  end
+end

data/lib/opts/opt_factory.rb

@@ -0,0 +1,30 @@
+module Shelldon
+  class OptFactory
+    def initialize(&block)
+      @opt_arr = []
+      instance_eval(&block)
+      Shelldon.opts = get_opts
+    end
+
+    def get_opts
+      @opt_arr.empty? ? [] : Getopt::Long.getopts(*@opt_arr)
+    end
+
+    private
+
+    def opt(*args, type)
+      @opt_arr << [args.first, args[1] || '', getopt_constant(type)]
+    end
+
+    def getopt_constant(sym)
+      case sym.to_sym
+      when :boolean
+        Getopt::BOOLEAN
+      when :required
+        Getopt::REQUIRED
+      else
+        fail StandardError
+      end
+    end
+  end
+end

data/lib/opts/opts.rb

@@ -0,0 +1,13 @@
+module Shelldon
+  class Opts
+    include Singleton
+    attr_reader :opts
+    def initialize
+    end
+
+    def set(opts_arr)
+      fail StandardError unless @opts.nil?
+      @opts ||= opts_arr
+    end
+  end
+end

data/lib/shell/shell.rb

@@ -0,0 +1,167 @@
+require 'byebug'
+require 'readline'
+
+module Shelldon
+  class Shell
+    attr_accessor :command_list, :config,
+                  :accept_errors, :reject_errors
+    attr_reader :home, :name
+    attr_writer :history, :history_file
+
+    def initialize(name, &block)
+      @accept_errors = {}
+      @reject_errors = {}
+      @name          = name
+      @errors        = {}
+      @history       = true
+      @command_list  = CommandList.new(self)
+      @config        = Config.new(self)
+      setup(&block) if block_given?
+    end
+
+    def self.method_missing(meth_name, *args, &block)
+      Shelldon::ShellIndex[:default].send(meth_name, *args, &block)
+    end
+
+    def setup(&block)
+      instance_eval(&block)
+      FileUtils.mkdir_p(@home.to_s) unless File.exist?(@home)
+      Dir.chdir(@home) if @home
+      Readline.completion_proc = proc { [] }
+      if @history_path && @history
+        @history_helper = Shelldon::HistoryFile.new(@history_path)
+        @history_helper.load if @history_helper
+      end
+      @config.load_config_file
+      run
+    end
+
+    def quit
+      @history_helper.save if @history_helper
+      puts "\n"
+      exit 0
+    end
+
+    def run
+      instance_eval(&@startup) if @startup
+      begin
+        run_repl
+      rescue *@accept_errors.keys => e
+        print_error(e)
+        on_error(e, @accept_errors[e.class])
+        retry
+      rescue *@reject_errors.keys => e
+        print_error(e)
+        on_error(e, @reject_errors[e.class])
+      rescue StandardError => e
+        print_error(e)
+        puts "Reached fatal error. G'bye!"
+        raise e
+      ensure
+        instance_eval(&@shutdown) if @shutdown
+        @history_helper.save if @history_helper
+        quit
+      end
+    end
+
+    def on_error(e, proc)
+      instance_exec(e, &proc)
+    end
+
+    def print_error(e)
+      return false unless @config[:debug_mode]
+      puts e.message
+      puts e.backtrace.join("\n")
+    end
+
+    def get_prompt
+      if @prompt_setter
+        instance_eval(&@prompt_setter)
+      else
+        @prompt || '> '
+      end
+    end
+
+    def run_repl
+      while cmd = Readline.readline(get_prompt, true)
+        run_commands(cmd)
+      end
+    end
+
+    def opts
+      @config.opts
+    end
+
+    def opts=(arr)
+      @config.opts = arr
+    end
+
+    def run_commands(commands)
+      commands.split(';').each { |cmd| run_command(cmd) }
+    end
+
+    def run_command(cmd)
+      @history_helper << cmd
+      run_precommand(cmd)
+      @command_list.run(cmd)
+      run_postcommand(cmd)
+    end
+
+    def run_precommand(cmd)
+      instance_exec(cmd, &@pre_command) if @pre_command
+    end
+
+    def run_postcommand(cmd)
+      instance_exec(cmd, &@post_command) if @post_command
+    end
+
+    def init(&block)
+      instance_eval(&block)
+    end
+
+    # DSL
+
+    private
+
+    def history(history)
+      @history = history
+    end
+
+    def history_file(file)
+      @history_path = file
+    end
+
+    def prompt(str = '> ', &block)
+      if block_given?
+        @prompt_setter = block
+      else
+        @prompt = str
+      end
+    end
+
+    def shutdown(&block)
+      @shutdown = block
+    end
+
+    def startup(&block)
+      @startup = block
+    end
+
+    def pre_command(&block)
+      @pre_command = block
+    end
+
+    def post_command(&block)
+      @post_command = block
+    end
+
+    def home(path)
+      @home = Pathname.new(path).expand_path
+    end
+
+    def errors(&block)
+      @accept_errors, @reject_errors =
+          Shelldon::ErrorFactory.new(&block).get
+    end
+  end
+end

data/lib/shell/shell_factory.rb

@@ -0,0 +1,38 @@
+module Shelldon
+  class ShellFactory
+    def initialize(name, &block)
+      if Shelldon[name]
+        @shell = Shelldon[name]
+      else
+        @shell = Shell.new(name)
+      end
+      instance_eval(&block)
+    end
+
+    def register
+      Shelldon::ShellIndex << @shell
+    end
+
+    def shell(&block)
+      @shell.setup(&block)
+    end
+
+    def command(name, &block)
+      cmd = Shelldon::Command.new(name, @shell.command_list, &block)
+      @shell.command_list.register(cmd)
+    end
+
+    def config(&block)
+      Shelldon::ConfigFactory.create(@shell, &block)
+    end
+
+    def opts(&block)
+      OptFactory.new(&block)
+    end
+
+    def command_missing(&block)
+      cmd = Shelldon::Command.new(:not_found, @shell, &block)
+      @shell.command_list.register_default(cmd)
+    end
+  end
+end

data/lib/shell/shell_index.rb

@@ -0,0 +1,33 @@
+# This allows subshelling - You can define multiple shells in one program and nest them.
+# This is the opposite approach to shell-as-singleton, which makes access easy but prevents multiple shells.
+# This is why all of the factories pass the shell parent into their respective products.
+
+module Shelldon
+  class ShellIndex
+    include Singleton
+
+    def self.method_missing(meth_name, *args, &block)
+      if block_given?
+        instance.send(meth_name, *args, &block)
+      else
+        instance.send(meth_name, *args)
+      end
+    end
+
+    def initialize
+      @shell_index = {}
+    end
+
+    def [](key)
+      @shell_index[key.to_sym]
+    end
+
+    def <<(shell)
+      if shell.is_a?(Shelldon::Shell)
+        @shell_index[shell.name] = shell
+      else
+        fail StandardError
+      end
+    end
+  end
+end

data/lib/shelldon.rb

@@ -0,0 +1,26 @@
+require 'shelldon/version'
+require 'singleton'
+require 'readline'
+require 'getopt/long'
+require 'yaml'
+
+require 'shell/shell'
+require 'config/config'
+require 'config/param'
+require 'config/param/string_param'
+require 'config/param/boolean_param'
+require 'config/param/number_param'
+require 'dsl'
+require 'shell/shell_index'
+require 'shell/shell_factory'
+require 'config/config_factory'
+require 'opts/opt_factory'
+require 'config/param_factory'
+require 'command/command'
+require 'command/command_list'
+require 'file_management/file_manager'
+require 'file_management/yaml_manager'
+require 'file_management/config_file_manager'
+require 'exceptions/error_factory'
+require 'opts/opts'
+require 'file_management/history_file'

data/lib/shelldon/version.rb

@@ -0,0 +1,3 @@
+module Shelldon
+  VERSION = '0.0.1'
+end

data/shelldon.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'shelldon/version'
+
+Gem::Specification.new do |spec|
+  spec.name    = 'shelldon'
+  spec.version = Shelldon::VERSION
+  spec.authors = ['Wesley Boynton']
+  spec.email   = ['wes@boynton.io']
+  spec.homepage = "https://github.com/wwboynton/shelldon"
+
+  spec.summary     = 'An expressive DSL for building interactive command-line apps'
+  spec.description = "Shelldon is an expressive DSL for build interactive command-line apps (REPLs)\
+with minimal effort. It supports all kinds of fun features, like config/history management, \
+error handling, subcommands, subshells, and more!"
+      spec.license = 'MIT'
+
+
+  spec.files         = Dir["#{File.dirname(__FILE__)}/**/**/**/**/*"].reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'bin'
+  spec.executables   = 'shelldon'
+  spec.require_paths = %w(lib bin)
+
+  spec.add_development_dependency 'bundler', '~> 1.10'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rubocop', '~> 0.33.0'
+end

data/test_shell/Gemfile

@@ -0,0 +1,3 @@
+gem 'shelldon', path: '/Users/wwboynton/repositories/shelldon/'
+gem 'getopt'
+gem 'byebug'

data/test_shell/Gemfile.lock

@@ -0,0 +1,20 @@
+PATH
+  remote: /Users/wwboynton/repositories/shelldon
+  specs:
+    shelldon (0.0.1)
+
+GEM
+  specs:
+    byebug (8.2.1)
+    getopt (1.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  byebug
+  getopt
+  shelldon!
+
+BUNDLED WITH
+   1.10.6

data/test_shell/run.sh

@@ -0,0 +1,3 @@
+#! /usr/bin/env bash 
+bundle exec ruby test_shell.rb "$@"
+

data/test_shell/simple_shell.rb

@@ -0,0 +1,106 @@
+require 'shelldon'
+require 'pp'
+
+Shelldon.shell do
+  opts do
+    opt '--myopt', '-m', :boolean
+  end
+
+  config do
+    # Set the config file, which can hold values one level higher than their default
+    # The order of precedence for params is: Set in-session > set by command-line flag > set by config file > default
+    config_file '.my-config-file'
+
+    param :myparam do # Create a config option (a 'param')
+      type :boolean # Make it a boolean
+      default false # Make its default value false
+      opt 'myopt' # Override it with the value of command-line opt '--myopt' if present
+    end
+  end
+
+  # Define a command that sets a config option
+  command :set do
+    # Set up some help information for the command
+    help 'Set a configuration option for the remainder of the session.'
+    examples ['set myparam']
+    usage 'set [config_option]'
+
+    # Define the command's action - this has access to some helpers, like 'config'
+    #   You can also give the block access to the remaining (unusued) tokens of the command
+    #   "Unused" meaning tokens that weren't used up to call the command in the first place
+    action do |args|
+      tokens                   = args.split(' ')
+      config[tokens[0].to_sym] = tokens[1]
+    end
+  end
+
+
+  # Here's a simplification of grabbing args for use in an action
+  command :arg do
+    help 'Show your args off!'
+    action { |args| puts args }
+  end
+
+  # This command will show the active config if called witout args, or
+  #   show the value of a specific option if called with an argument
+  command :config do
+    help 'Show the configuration of the current session.'
+    usage 'config'
+    action do |args|
+      if args.empty?
+        pp config.to_a
+      else
+        param = config.find(args.to_sym)
+        puts "#{param.name}: #{param.val}"
+      end
+    end
+
+    # This is a subcommand - it will automatically take precedence
+    #   if you call a command beginning with "config save"
+    subcommand :save do
+      help 'Save your current configuration'
+      usage 'config save'
+      action { config.save }
+    end
+  end
+
+
+  # This will show all that nice help information we've been defining.
+  #   This produces a two-dimensional array, so you could make it into a table with some
+  #   table-printing gem if you wanted.
+  command :help do
+    action { |args| pp command_list.help(args) }
+    help 'Show help. Optionally specify specific command for more information.'
+    usage 'help [cmd]'
+    examples ['help', 'help quit']
+  end
+
+  # Define a default command - This is what happens when a command doesn't match up
+  command_missing do
+    action { |cmd| puts "No such command \"#{cmd}\"" }
+  end
+
+  # LASTLY, define some basic shell properties. The shell will run at the end of this block.
+  shell do
+    # You can make your prompt a string or a block
+    prompt 'shelldon> '          # This is okay
+    prompt { "shelldon#{4+2}>" } # This is okay too
+
+    # This is the "home" directory of your shell, used for config files, history files, etc.
+    home '~/.my-test'
+
+    # Enable in-session history (enabled by default)
+    history true
+
+    # Enable history logging and reloading between sessions
+    history_file '.my-history'
+
+    # Error handling - You can 'accept' an error or 'reject' it.
+    #   The only difference is an accepted error won't kill the shell.
+    #   You can also pass a block to run when that specific command is caught.
+    errors do
+      reject StandardError
+      accept(Interrupt) { puts '^C' }
+    end
+  end
+end