shelldon 0.0.1

data/lib/config/config.rb

@@ -0,0 +1,85 @@
+require 'pathname'
+
+module Shelldon
+  class Config
+    attr_reader :opts
+    attr_accessor :on_opts, :config_file_manager
+
+    def initialize(shell)
+      @shell   = shell
+      @opt_arr = []
+      @on_opts = {}
+      @config  = {}
+    end
+
+    def opts=(arr)
+      @opts ||= arr
+    end
+
+    def setup
+      load_config_file
+    end
+
+    def register(param)
+      fail StandardError if @config.key?(param.name)
+      @config[param.name] = param
+    end
+
+    def [](key)
+      @config.key?(key) ? @config[key].val : nil
+    end
+
+    def find(key)
+      @config.key?(key) ? @config[key] : nil
+    end
+
+    def []=(key, val)
+      check_param(key, true)
+      @config[key].val = (val)
+    end
+
+    def set(key, val)
+      @config[key].set(val)
+    end
+
+    def to_a
+      @config.map { |k, v| [k, v.pretty] }.sort_by(&:first)
+    end
+
+    def to_hash
+      Hash[@config.map { |_, param| [param.name, param.val] }]
+    end
+
+    def check_param(key, raise = false)
+      if @config.key?(key.to_sym)
+        true
+      else
+        raise ? fail(StandardError) : false
+      end
+    end
+
+    def to_yaml
+      to_hash.to_yaml
+    end
+
+    def import(hash)
+      # We load all of the params in first without validation, to avoid param dependency issues
+      # Then we validate them all
+      hash.each do |k, v|
+        key = k.to_sym
+        @config.key?(key) ? set(key, v) : fail(StandardError)
+      end
+      hash.each do |k, _|
+        @config[k].valid? unless @config[k].val == @config[k].default
+      end
+    end
+
+    def load_config_file
+      import(@config_file_manager.import) if @config_file_manager
+    end
+
+    def save
+      @config_file_manager.export if @config_file_manager
+    end
+  end
+end

data/lib/config/config_factory.rb

@@ -0,0 +1,41 @@
+module Shelldon
+  class ConfigFactory
+    def self.create(shell, &block)
+      ConfigFactory.new(shell, &block)
+    end
+
+    def initialize(shell, &block)
+      @shell = shell
+      @config = Shelldon::Config.new(@shell)
+      instance_eval(&block)
+      @shell.config = @config
+    end
+
+    private
+
+    def config_file(filepath)
+      filepath                    = Pathname.new(filepath)
+      @config.config_file_manager = Shelldon::ConfigFileManager.new(@shell, filepath)
+    end
+
+    def param(name, &block)
+      ParamFactory.create(@config, name, &block)
+    end
+
+    def on_opt(opt, &block)
+      if @config.on_opts.has_key(opt)
+        @config.on_opts[opt] << block
+      else
+        @config.on_opts[opt] = [block]
+      end
+    end
+
+    def timeout(i)
+      param :timeout do
+        type :number
+        default i
+        pretty { Time.at(val).utc.strftime('%H:%M:%S') }
+      end
+    end
+  end
+end

data/lib/config/param.rb

@@ -0,0 +1,54 @@
+module Shelldon
+  class Param
+    attr_accessor :pretty, :default, :opt, :validator, :adjustor, :error
+    attr_reader :name
+
+    def self.create(name, &block)
+      ParamFactory.create(name, &block)
+    end
+
+    def initialize(name)
+      @name    = name
+      @default = nil
+    end
+
+    def val
+      if @val.nil?
+        if Shelldon.opts.key?(@opt)
+          Shelldon.opts[@opt]
+        else
+          @default
+        end
+      else
+        @val
+      end
+    end
+
+    def val=(value)
+      value = instance_exec(value, &adjustor) if adjustor
+      valid?(value) ? @val = value : fail(StandardError)
+    end
+
+    def set(value)
+      value = instance_exec(value, &adjustor) if adjustor
+      @val  = value
+    end
+
+    def pretty
+      if @pretty
+        instance_exec(val, &@pretty)
+      else
+        val.to_s
+      end
+    end
+
+    def valid?(value = @val)
+      return true if validator.nil?
+      if instance_exec(value, &validator)
+        true
+      else
+        @error ? fail(@error) : false
+      end
+    end
+  end
+end

data/lib/config/param/boolean_param.rb

@@ -0,0 +1,28 @@
+module Shelldon
+  class BooleanParam < Param
+    def initialize(name)
+      @validator ||= proc { |v| v.is_a?(TrueClass) || v.is_a?(FalseClass) }
+      super
+    end
+
+    def fix_val(v)
+      if valid?(v) || v.nil?
+        v
+      elsif v.is_a?(String)
+        return true   if v == true || v =~ (/(true|t|yes|y|1)$/i)
+        return false  if v == false || v.blank? || v =~ (/(false|f|no|n|0)$/i)
+        fail(ArgumentError, "invalid value for Boolean: \"#{v}\"")
+      else
+        v ? true : false
+      end
+    end
+
+    def val=(v)
+      @val = fix_val(v)
+    end
+
+    def toggle
+      @val = !@val
+    end
+  end
+end

data/lib/config/param/number_param.rb

@@ -0,0 +1,7 @@
+module Shelldon
+  class NumberParam < Param
+    def val=(value)
+      @val = value.to_f
+    end
+  end
+end

data/lib/config/param/string_param.rb

@@ -0,0 +1,8 @@
+module Shelldon
+  class StringParam < Param
+    # def initialize(name)
+    # @validator ||= Proc.new { |v| v.is_a(String) }
+    # super
+    # end
+  end
+end

data/lib/config/param_factory.rb

@@ -0,0 +1,75 @@
+require 'config/param/string_param'
+
+module Shelldon
+  class ParamFactory
+    attr_writer :default, :opt
+
+    def self.create(config, name, &block)
+      new(config, name, &block)
+    end
+
+    def initialize(config, name, &block)
+      @config = config
+      @name = name
+      instance_eval(&block) if block_given?
+      register
+    end
+
+    private
+
+    def default(default_value)
+      @default = default_value
+    end
+
+    def opt(opt)
+      @opt = opt
+    end
+
+    def register
+      manufacture
+      if @param
+        @param.pretty    = @pretty_proc if @pretty_proc
+        @param.default   = @default unless @default.nil?
+        @param.opt       = @opt if @opt
+        @param.error     = @error if @error
+        @param.validator = @validator if @validator
+        @param.adjustor  = @adjustor if @adjustor
+        @config.register(@param)
+      else
+        fail StandardError
+      end
+    end
+
+    def pretty(&block)
+      @pretty_proc = block
+    end
+
+    def validate(error = nil, &block)
+      @error     = error if error
+      @validator = block
+    end
+
+    def adjust(&block)
+      @adjustor = block
+    end
+
+    def manufacture
+      case @type
+      when :string, :str
+        @param = Shelldon::StringParam.new(@name)
+      when :boolean, :bool
+        @param = Shelldon::BooleanParam.new(@name)
+      when :array, :arr
+        @param = Shelldon::ArrayParam.new(@name)
+      when :number, :num
+        @param = Shelldon::NumberParam.new(@name)
+      else
+        @param = Shelldon::StringParam.new(@name)
+      end
+    end
+
+    def type(t)
+      @type = t.to_sym
+    end
+  end
+end

data/lib/dsl.rb

@@ -0,0 +1,21 @@
+module Shelldon
+  def self.[](key)
+    ShellIndex.instance[key.to_sym]
+  end
+
+  def self.<<(shell)
+    ShellIndex.instance << shell if shell.is_a?(Shelldon::Shell)
+  end
+
+  def self.shell(name = (:default), &block)
+    ShellFactory.new(name.to_sym, &block)
+  end
+
+  def self.opts=(opts_arr)
+    Shelldon::Opts.instance.set(opts_arr)
+  end
+
+  def self.opts
+    Shelldon::Opts.instance.opts
+  end
+end

data/lib/file_management/config_file_manager.rb

@@ -0,0 +1,34 @@
+require 'fileutils'
+
+module Shelldon
+  class ConfigFileManager < YamlManager
+    def initialize(shell, config_file)
+      @shell = shell
+      @config_file = config_file
+    end
+
+    def ensure_dir(dir)
+      FileUtils.mkdir_p(dir)
+    end
+
+    def ensure_file(file)
+      File.open(file, 'w') { |f| f.write({}.to_yaml) } unless File.exist?(file)
+    end
+
+    def export
+      super(@shell.config)
+    end
+
+    def setup
+      @file     = @config_file.expand_path
+      @file_dir = @config_file.dirname.expand_path
+      ensure_dir(@file_dir)
+      ensure_file(@file)
+    end
+
+    def import
+      setup
+      super(@file)
+    end
+  end
+end

data/lib/file_management/file_manager.rb

@@ -0,0 +1,20 @@
+require 'fileutils'
+
+module Shelldon
+  class FileManager
+    def initialize(_file)
+      @file     = config_file.expand_path
+      @file_dir = config_file.dirname.expand_path
+      ensure_dir(@file_dir)
+      ensure_file(@file)
+    end
+
+    def ensure_dir(dir)
+      FileUtils.mkdir_p(dir)
+    end
+
+    def ensure_file(file)
+      File.open(file, 'w') { |f| f.write('') } unless File.exist?(file)
+    end
+  end
+end

data/lib/file_management/history_file.rb

@@ -0,0 +1,34 @@
+module Shelldon
+  class HistoryFile < FileManager
+    def initialize(history_file)
+      @file = history_file
+      ensure_dir(Pathname.new(@file).dirname)
+      ensure_file(@file)
+    end
+
+    def load
+      @file = Pathname.new(@file).expand_path
+      hist  = File.open(@file, 'r') { |f| f.read }.split("\n")
+      hist.each do |line|
+        # puts line
+        # pp Readline::HISTORY.to_a
+        Readline::HISTORY.push(line)
+      end
+    end
+
+    def <<(line)
+      File.open(@file, 'a') { |f| f.write("#{line}\n") }
+    end
+
+    def save
+    end
+
+    def truncate(lines)
+      File.open(@file, 'w') do
+        arr      = f.read.split("\n")
+        last_100 = arr[-lines..-1].join("\n")
+        f.write(last_100)
+      end
+    end
+  end
+end

data/lib/file_management/yaml_manager.rb

@@ -0,0 +1,16 @@
+
+module Shelldon
+  class YamlManager < FileManager
+    def ensure_file(file)
+      File.open(file, 'w') { |f| f.write({}.to_yaml) } unless File.exist?(file)
+    end
+
+    def export(yaml)
+      File.open(@file, 'w') { |f| f.write(yaml.to_yaml) }
+    end
+
+    def import(_yaml)
+      YAML.load_file(@file)
+    end
+  end
+end