shelldon 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1050dd8126c65561d242ce862a4cf2947ed61618
+  data.tar.gz: fd6ad927cc21f2087011bd1584e652d4b4ac415d
+SHA512:
+  metadata.gz: f9a2c2be6b2cba4b8bd61fa6b666fd1b5daf9d15bc9d8d04eb2c1bfb2c7811aa3836f18357d779d8ca86ef6f98b9fbe64cdcbb2c0c48f23d2ee0150bb1a767c4
+  data.tar.gz: 168ab3b8d30c478081e3d2dbac3f032f5b74f93d93736c618eb2909e235207eb5f0bcf9a409bdb75ae8bf440b05c270aee8148e81feb79fcdea04d457f77787d

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gem 'byebug'
+gem 'terminal-table'
+gem 'rb-readline'
+gem 'getopt'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,43 @@
+PATH
+  remote: .
+  specs:
+    shelldon (0.0.1)
+      rb-readline
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.1.0)
+    astrolabe (1.3.1)
+      parser (~> 2.2)
+    byebug (8.2.1)
+    getopt (1.4.2)
+    parser (2.2.2.6)
+      ast (>= 1.1, < 3.0)
+    powerpack (0.1.1)
+    rainbow (2.0.0)
+    rake (10.4.2)
+    rb-readline (0.5.3)
+    rubocop (0.33.0)
+      astrolabe (~> 1.3)
+      parser (>= 2.2.2.5, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.4)
+    ruby-progressbar (1.7.5)
+    terminal-table (1.5.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.10)
+  byebug
+  getopt
+  rake (~> 10.0)
+  rubocop
+  shelldon!
+  terminal-table
+
+BUNDLED WITH
+   1.10.6

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Wesley Boynton
+
+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,138 @@
+# Shelldon
+
+Shelldon is an expressive DSL for building interactive terminal applications, or REPLs (Read-Evaluate-Print-Loops).
+
+There are some good gems out there for building command-line executables, but I couldn't find anything that built a REPL in the way that I wanted it -- and I build a lot of REPLs.
+
+## Installation
+
+```ruby
+# Gemfile
+gem 'shelldon'
+
+
+$ bundle install
+```
+Or just `gem install shelldon` -- You know the drill.
+
+## Usage
+
+Here's a simple Shelldon app, available in `test_shell/simple_shell.rb`
+
+```ruby
+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 '~/.shelldon-test'
+
+    # Enable in-session history (enabled by default)
+    history true
+
+    # Enable history logging and reloading between sessions
+    history_file '.shelldon-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
+```
+## Contributing
+Bug reports and pull requests are welcome on GitHub at https://github.com/wwboynton/shelldon.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+Let me know if you find a cool use for Shelldon!

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/bin/shelldon

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require 'pathname'
+bin_file = Pathname.new(__FILE__).realpath
+$LOAD_PATH.unshift File.expand_path('../../lib', bin_file)
+
+require_relative '../lib/cli'
+Shelldon::CLI.source_root(File.expand_path('../../templates', bin_file))
+Shelldon::CLI.start(ARGV)

data/build_and_install.sh

@@ -0,0 +1,3 @@
+rm shelldon*.gem
+gem build shelldon.gemspec
+gem install shelldon-*.gem

data/lib/Exceptions/error_factory.rb

@@ -0,0 +1,26 @@
+module Shelldon
+  class ErrorFactory
+    def initialize(&block)
+      @accept_errors = {}
+      @reject_errors = {}
+      @default = proc { |e| on_error(e) }
+      instance_eval(&block)
+    end
+
+    def default(&block)
+      @default = block
+    end
+
+    def accept(e, &block)
+      @accept_errors[e] = (block_given? ? block : nil)
+    end
+
+    def reject(e, &block)
+      @reject_errors[e] = (block_given? ? block : nil)
+    end
+
+    def get
+      [@accept_errors, @reject_errors]
+    end
+  end
+end

data/lib/cli.rb

@@ -0,0 +1,19 @@
+require 'thor'
+require 'open-uri'
+
+module Shelldon
+  class CLI < Thor
+    include Thor::Actions
+
+    desc 'new PROJECT_NAME', 'Sets up ALL THE THINGS needed for your Shelldon project.'
+
+    def new(name)
+      name = Thor::Util.snake_case(name)
+      system("bundle gem #{name}")
+      directory(:project, "#{name}/lib/")
+      File.open(name, 'a') { |f| f.write("gem 'shelldon'") }
+      system("cd #{name}")
+      system('bundle install')
+    end
+  end
+end

data/lib/command/command.rb

@@ -0,0 +1,134 @@
+module Shelldon
+  class Command
+    attr_reader :name, :aliases, :subcommands, :parent
+
+    def initialize(name, parent, &block)
+      @name        = name
+      @aliases     = []
+      @subcommands = {}
+      @show        = true
+      @parent      = parent
+      instance_eval(&block)
+    end
+
+    def christian_name
+      if @parent.is_a?(Shelldon::Command)
+        "#{@parent.christian_name} #{@name}"
+      else
+        @name
+      end
+    end
+
+    def command_list
+      @parent
+    end
+
+    def shell
+      # This will recurse through subcommands until
+      # eventually .shell gets called on the command list :)
+      @parent.shell
+    end
+
+    def config
+      shell.config
+    end
+
+    def run(tokens = [])
+      tokens = [tokens] unless tokens.is_a?(Array)
+      instance_exec(tokens.join(' '), &@action)
+    end
+
+    def valid?(input)
+      return true unless @validator
+      if instance_exec(input, &@validator)
+        true
+      else
+        @error ? fail(@error) : false
+      end
+    end
+
+    def auto_complete(_input)
+      @autocomplete = @subcommands.values
+    end
+
+    def has_subcommand?
+      !@subcommands.empty?
+    end
+
+    def find(tokens)
+      tokens = tokens.split(' ') if tokens.is_a?(String)
+      return [self, tokens] if tokens.empty?
+
+      if @subcommands.key?(tokens.first.to_sym)
+        key = tokens.shift.to_sym
+        @subcommands[key].find(tokens)
+      else
+        [self, tokens]
+      end
+    end
+
+    def first_token(arr)
+      arr.first.to_sym
+    end
+
+    def register
+      command_list.register(self)
+    end
+
+    # DSL
+
+    def show(bool = nil)
+      bool.nil? ? @show : @show = (bool ? true : false)
+    end
+
+    def help(str = nil)
+      str ? @help = str : @help
+    end
+
+    def usage(str = nil)
+      str ? @usage = str : @usage
+    end
+
+    def examples(arr = nil)
+      if arr
+        arr       = [arr] unless arr.is_a?(Array)
+        @examples = arr
+      else
+        @examples
+      end
+    end
+
+    def timeout(i = nil)
+      i ? @timeout = i : @timeout
+    end
+
+    # DSL Only
+
+    private
+
+    def validate(error, &block)
+      @error     = error if error
+      @validator = block
+    end
+
+    def aliased(names)
+      [names].flatten.each { |n| @aliases << n }
+    end
+
+    def action(&block)
+      @action = block
+    end
+
+    def subcommand(name, &block)
+      @subcommands[name.to_sym] = Shelldon::Command.new(name, self, &block)
+    end
+
+    def completion(arr = [], &block)
+      @completion = (block_given? ? block : arr)
+    end
+
+    def placeholder
+      @action = proc { fail StandardError }
+    end
+  end
+end

data/lib/command/command_list.rb

@@ -0,0 +1,72 @@
+module Shelldon
+  class CommandList
+    attr_reader :shell
+    alias_method :parent, :shell
+
+    def initialize(parent)
+      @shell    = parent
+      @commands = {}
+    end
+
+    def register(command)
+      @commands[command.name] = command
+      command.aliases.each { |a| @commands[a.to_sym] = command }
+    end
+
+    def register_default(cmd)
+      @default_command = cmd
+    end
+
+    def run(str)
+      cmd, tokens = find(str)
+      cmd.run(tokens)
+    end
+
+    def find(str)
+      tokens = str.split(' ')
+      key    = tokens.first.to_sym
+      if @commands.key?(key)
+        @commands[key].find(tokens[1..-1])
+      else
+        [@default_command, tokens.first]
+      end
+    end
+
+    def is_default?(cmd)
+      puts cmd.inspect unless cmd.is_a?(Command)
+      cmd.name == @default_command.name
+    end
+
+    def compile_help(cmd)
+      res = [['Command', cmd.christian_name]]
+      res << ['Help', cmd.help] if cmd.help
+      res << ['Usage', "\"#{cmd.usage}\""] if cmd.usage
+      res << ['Examples', cmd.examples] if cmd.examples
+      res << ['Subcommands', cmd.subcommands.values.map(&:name)] unless cmd.subcommands.empty?
+      res
+    end
+
+    def help(str)
+      if str.empty?
+        to_a
+      else
+        cmd = find(str).first
+        if cmd.show && !is_default?(cmd)
+          compile_help(cmd)
+        else
+          fail StandardError
+        end
+      end
+    end
+
+    def config
+      @shell.config
+    end
+
+    def to_a
+      @commands.values.uniq
+        .map { |cmd| cmd.show ? [cmd.name, cmd.aliases, cmd.help] : nil }
+        .compact.sort_by { |(n, _, _)| n.to_s }
+    end
+  end
+end