consular 1.0.0.rc1

data/lib/consular/cli.rb

@@ -0,0 +1,220 @@
+require 'thor'
+
+module Consular
+
+  # The CLI provides the command line interface for Consular. These are
+  # interfaced via the consular bin file.
+  class CLI < Thor
+    include Thor::Actions
+
+    # Source root for Thor to find templates
+    def self.source_root; File.expand_path('../../', __FILE__); end
+
+    # Run the Termfile or project script.
+    #
+    # @param [String] project
+    #   Name of the project script. Otherwise leave blank for Termfile.
+    #
+    # @example
+    #
+    #   # Executes global script foobar.term
+    #   Consular::CLI.start ['start', 'foobar']
+    #
+    #   # Executes global script foobar.yml
+    #   Consular::CLI.start ['start', 'foobar.yml']
+    #
+    #   # Executes the Termfile
+    #   Consular::CLI.start ['start'] # ./Termfile
+    #   Consular::CLI.start ['start', '-r=/tmp'] # /tmp/Termfile
+    #
+    # @api public
+    desc 'start [PROJECT]', 'runs the consular script. ex: `consular start` or `consular start foobar`'
+    method_option :root, :type => :string, :default => '.', :aliases => '-r'
+    def start(project = nil)
+      path = termfile_path(project)
+      message_unless_file(path) { valid_core.new(path).process! }
+    end
+
+    # Run the Termfile or project script setup.
+    #
+    # @param [String] project
+    #   Name of the project script. Otherwise leave blank for Termfile.
+    #
+    # @example
+    #
+    #   # Executes global script setup  for foobar.term
+    #   Consular::CLI.start ['setup', 'foobar']
+    #
+    #   # Executes global script setup for foobar.yml
+    #   Consular::CLI.start ['setup', 'foobar.yml']
+    #
+    #   # Executes the Termfile setup
+    #   Consular::CLI.start ['setup'] # ./Termfile
+    #   Consular::CLI.start ['setup', '-r=/tmp'] # /tmp/Termfile
+    #
+    # @api public
+    desc 'setup [PROJECT]', 'run the consular script setup. ex: `consular setup` or `consular setup foobar`'
+    method_option :root, :type => :string, :default => '.', :aliases => '-r'
+    def setup(project = nil)
+      path = termfile_path(project)
+      message_unless_file(path) { valid_core.new(path).setup! }
+    end
+
+    # Lists all avaiable global scripts
+    #
+    # @example
+    #
+    #   Consular::CLI.start ['list']
+    #
+    # @api public
+    desc 'list', 'lists all consular scripts'
+    def list
+      say "Global scripts available: \n"
+      Dir.glob("#{Consular.global_path}/*[^~]").each do |file|
+        name  = File.basename(file, '.term')
+        title = file_comment(file)
+        say "  * #{name} - #{title}"
+      end
+    end
+
+    # Create the global script directory for Consular.
+    #
+    # @example
+    #
+    #   Consular::CLI.start ['init']
+    #
+    # @api public
+    desc 'init', 'create consular directory'
+    def init
+      empty_directory Consular.global_path
+      template 'templates/consularc.tt', File.join(ENV['HOME'],'.consularc'), :skip => true
+    end
+
+    # Edit the specified global script or Termfile.
+    #
+    # @param [String] project
+    #   Name of project script.
+    #
+    # @example
+    #
+    #   # opens foobar for editing
+    #   Consular::CLI.start ['edit', 'foobar']
+    #   # opens foobar with specified editor
+    #   Consular::CLI.start ['edit', 'foobar', '-e=vim']
+    #   # opens /tmp/Termfile
+    #   Consular::CLI.start ['edit', '-r=/tmp']
+    #
+    # @api public
+    desc 'edit [PROJECT]', 'opens the Termfile to edit. ex: `consular edit` or `consular edit foobar`'
+    method_option :root,    :type => :string,  :default => '.',    :aliases => '-r'
+    method_option :editor,  :type => :string,  :default => nil,    :aliases => '-e'
+    method_option :capture, :type => :boolean, :default => false,  :aliases => '-c'
+    def edit(project = nil)
+      type = project && project =~ /\.yml$/ ? 'yml' : 'term'
+      path = termfile_path project
+      template "templates/example.#{type}.tt", path, :skip => true
+      open_in_editor path, options[:editor]
+    end
+
+    # Delete the global script or Termfile
+    #
+    # @param [String] project
+    #   Name of the project script.
+    #
+    # @example
+    #
+    #   # deletes global script foobar.term
+    #   Consular::CLI.start ['delete', 'foobar']
+    #   # deletes global script foobar.yml
+    #   Consular::CLI.start ['delete', 'foobaryml']
+    #   # deletes /tmp/Termfile
+    #   Consular::CLI.start ['delete', '-r=/tmp']
+    #
+    # @api public
+    desc 'delete [PROJECT]', 'delete the Termfile script. ex: `consular delete` or `consular delete foobar`'
+    method_option :root, :type => :string, :default => '.', :aliases => '-r'
+    def delete(project = nil)
+      path = termfile_path(project)
+      message_unless_file(path) { remove_file path }
+    end
+
+    no_tasks do
+
+      # Returns the first core that matchees the currrent system.
+      #
+      # @return [Core] Core that matches the system.
+      #
+      # @api private
+      def valid_core
+        Consular.cores.detect { |core| core.valid_system? }
+      end
+      # Returns the first comment in file. This is used
+      # as the title when listing out the scripts.
+      #
+      # @param [String] file
+      #   path to file
+      #
+      # @api private
+      def file_comment(file)
+        first_line = File.readlines(file).first
+        first_line =~ /^\s*?#/ ? first_line.gsub('#','') : "\n"
+      end
+
+      # Returns the full pathname of the Termfile
+      #
+      # @param [String] project
+      #   designated file/project name
+      #
+      # @return [String] full path name for Termfile.
+      #
+      # @example
+      #   termfile_path           #=> ROOT/Termfile
+      #   termfile_path 'foo'     #=> GLOBAL_PATH/foo.term
+      #   termfile_path 'bar.yml' #=> GLOBAL_PATH/bar.yml
+      #
+      # @api private
+      def termfile_path(project = nil)
+        if !project || project.empty?
+           File.join(options[:root], 'Termfile')
+        else
+          path = project =~ /\..*/ ? project : project + '.term'
+          Consular.global_path path
+        end
+      end
+
+      # Opens Termfile in specified editor.
+      #
+      # @param [String] path
+      #   Path to Termfile
+      # @param [String] editor
+      #   Editor to open Termfile with.
+      #
+      # @example
+      #   open_in_editor '/path/to/Termfile', 'vim'
+      #
+      # @api private
+      def open_in_editor(path, editor = nil)
+        editor = editor || Consular.default_editor || ENV['EDITOR']
+        system "#{editor || 'open'} #{path}"
+      end
+
+      # Returns an error message unless the file exists. If it does
+      # execute the block
+      #
+      # @param [String] file
+      #   Path of file
+      # @param [Proc] blk
+      #   Proc to execute if file exists.
+      #
+      # @api private
+      def message_unless_file(file, &blk)
+        if File.exists?(file)
+          blk.call
+        else
+          say "#{file} does not exist. Try running `consular edit` first.", :yellow
+        end
+      end
+    end
+
+  end
+end

data/lib/consular/core.rb

@@ -0,0 +1,65 @@
+module Consular
+  # Defines the abstract definition of a core. This needs to be
+  # subclassed and have the appropriate methods defined so that
+  # the CLI runner knows how to execute the Termfile on
+  # each core. You will need to add the core to Consular like so:
+  #
+  #   Consular.add_core self
+  #
+  class Core
+    attr_accessor :termfile
+
+    # Instantiated the hash from the Termfile into the
+    # core.
+    #
+    # @param [String] path
+    #   Path to Termfile
+    #
+    # @api public
+    def initialize(path)
+      @termfile = Consular::DSL.new(path).to_hash
+    end
+
+
+    # Method called by runner to execute the Termfile setup
+    # on the core.
+    #
+    # @api public
+    def setup!
+      raise NotImplementedError, ".setup! needs to be defined for it to be ran by `terminitor setup`"
+    end
+
+    # Method called by the runner to execute the Termfile
+    # on the core.
+    #
+    # @api public
+    def process!
+      raise NotImplementedError, ".process! needs to be defined for it to be ran by `terminitor start`"
+    end
+
+    class << self
+      # Checks to see if the current system/terminal is the right
+      # one to use for this core. This is called by the CLI to check
+      # if a particular core should be used.
+      #
+      # @return [Boolean] Whether the current system is valid.
+      #
+      # @api public
+      def valid_system?
+        raise NotImplementedError, ".valid_system? needs to be defined for Consular to determine what system is belongs to."
+      end
+
+      # Captures the current terminal settings for the system. It will
+      # return a hash format like that of Consular::DSL so that Consular
+      # can write it back out into a Termfile.
+      #
+      # @return [Hash] Consular style hash.
+      #
+      # @api public
+      def capture!
+        raise NotImplementedError, "capture! is currently unavailable for this core."
+      end
+    end
+
+  end
+end

data/lib/consular/dsl.rb

@@ -0,0 +1,220 @@
+require 'active_support/ordered_hash'
+require 'active_support/core_ext/array/extract_options'
+require 'yaml'
+
+module Consular
+
+  # The DSL class provides the DSL for the Consular scripting file.
+  # It provides the basic commands such as:
+  #   #setup  - commands to run when invoked by 'consular setup'
+  #   #window - commands to run in the context of a window
+  #   #tab    - commands to run in the context of tab
+  #   #before - commands to run in the context before every tab context
+  #
+  # The DSL class can be extended to provide additional API's for core specific
+  # DSL.
+  class DSL
+
+    attr_reader :_setup, :_windows, :_context
+
+    # Initializes the DSL library and stores the commands.
+    #
+    # @param [String] path
+    #   path to Consular script/ Termfile
+    #
+    # @example
+    #   Consular::DSL.new 'foo/bar.term'
+    #
+    # @api public
+    def initialize(path)
+      @_setup              = []
+      @_windows            = ActiveSupport::OrderedHash.new
+      @_windows['default'] = window_hash
+      @_context            = @_windows['default']
+      file = File.read(path)
+      if path =~ /\.yml$/
+        @_file = YAML.load file
+        extend Yaml
+      else
+        instance_eval file, __FILE__, __LINE__
+      end
+    end
+
+    # Run commands using prior to the workflow using the command `consular setup`.
+    # This allows you to perform any command that needs to be ran prior to setup
+    # a particular project/script.
+    #
+    # @param [Array<String>] commands
+    #   Commands to be executed.
+    # @param [Proc] block
+    #   Proc of commands to run.
+    #
+    # @example
+    #   setup 'bundle install', 'brew update'
+    #   setup { run 'bundle install' }
+    #
+    # @api public
+    def setup(*commands, &block)
+      block_given? ? run_context(@_setup, &block) : @_setup.concat(commands)
+    end
+
+    # Run commands prior to each tab context.
+    #
+    # @param [Array<String>] commands
+    #   Commands to be executed.
+    # @param [Proc] block
+    #   Proc of commands to run
+    #
+    # @example
+    #   # Executes `whoami` before tab with `ls` and `gitx`
+    #   window do
+    #     before { run 'whoami' }
+    #     tab 'ls'
+    #     tab 'gitx'
+    #   end
+    #
+    # @api public
+    def before(*commands, &block)
+      context = (@_context[:before] ||= [])
+      block_given? ? run_context(context, &block) : context.concat(commands)
+    end
+
+    # Run commands in the conext of a window.
+    #
+    # @param [Array] args
+    #   Hash to pass options to each context of a window. Each core can
+    #   implement the desired behavior for the window based on the options set here.
+    #   Can also pass a string as first parameter which will be set as
+    #   the :name
+    # @param [Proc] block
+    #   block of commands to run in window context.
+    #
+    # @example
+    #   window 'my project', :size => [80, 30] do
+    #     run 'ps aux'
+    #   end
+    #
+    # @api public
+    def window(*args, &block)
+      key            = "window#{@_windows.keys.size}"
+      options        = args.extract_options!
+      options[:name] = args.first unless args.empty?
+      context = (@_windows[key] = window_hash.merge(:options => options))
+      run_context context, &block
+    end
+
+    # Run commands in the context of a tab.
+    #
+    # @param [Array] args
+    #   Accepts either:
+    #     - an array of string commands
+    #     - a hash containing options for the tab.
+    # @param [Proc] block
+    #
+    # @example
+    #   tab 'first tab', :settings => 'Grass' do
+    #     run 'ps aux'
+    #   end
+    #
+    #   tab 'ls', 'gitx'
+    #
+    # @api public
+    def tab(*args, &block)
+      tabs = @_context[:tabs]
+      key  = "tab#{tabs.keys.size}"
+      return (tabs[key] = { :commands => args }) unless block_given?
+
+      context           = (tabs[key] = {:commands => []})
+      options           = args.extract_options!
+      options[:name]    = args.first unless args.empty?
+      context[:options] = options
+
+      run_context context, &block
+      @_context = @_windows[@_windows.keys.last] # Jump back out into the context of the last window.
+    end
+
+    # Store commands to run in context.
+    #
+    # @param [Array<String>] commands
+    #   Array of commands to be executed.
+    #
+    # @example
+    #   run 'brew update', 'gitx'
+    #
+    # @api public
+    def run(*commands)
+      context = case
+                when @_context.is_a?(Hash) && @_context[:tabs]
+                  @_context[:tabs]['default'][:commands]
+                when @_context.is_a?(Hash)
+                  @_context[:commands]
+                else
+                  @_context
+                end
+      context << commands.map { |c| c =~ /&$/ ? "(#{c})" : c }.join(" && ")
+    end
+
+
+    # Returns yaml file as Consular formmatted hash
+    #
+    # @return [Hash] Return hash format of Termfile
+    #
+    # @api semipublic
+    def to_hash
+      { :setup => @_setup, :windows => @_windows }
+    end
+
+    private
+
+    # Execute the context
+    #
+    # @param [Hash] context
+    #   hash of current context.
+    # @param [Proc] block
+    #   the context's block to be executed
+    #
+    # @example
+    #   run_context @_setup, &block
+    #   run @tabs['name'], &block
+    #
+    # @api private
+    def run_context(context, &block)
+      @_context, @_old_context = context, @_context
+      instance_eval &block
+      @_context = @_old_context
+    end
+
+    def clean_up_context(context = last_open_window, old_context = nil)
+      @_context = context
+      @_old_context = old_context
+    end
+
+    def last_open_window
+      @_windows[@_windows.keys.last]
+    end
+
+    # Return the default hash format for windows
+    #
+    # @api private
+    def window_hash
+      {:tabs => {'default' =>{:commands=>[]}}}.dup
+    end
+
+    module Yaml
+      # Returns yaml file as formmatted hash
+      #
+      # @return [Hash] Hash format of Termfile
+      #
+      # @api public
+      def to_hash
+        @_file ||= {}
+        combined = @_file.inject({}) do |base, item| 
+          item = {item.keys.first => {:commands => item.values.first, :options => {}}}
+          base.merge!(item)
+          base
+        end # merge the array of hashes.
+         { :setup => nil, :windows => { 'default' => { :tabs => combined } } }
+      end
+    end
+  end
+end

data/lib/consular/version.rb

@@ -0,0 +1,3 @@
+module Consular
+  VERSION = "1.0.0.rc1"
+end

data/lib/consular.rb

@@ -0,0 +1,68 @@
+lib_dir = File.expand_path("..", __FILE__)
+$:.unshift( lib_dir ) unless $:.include?( lib_dir )
+
+require 'consular/version'
+require 'consular/core'
+require 'consular/dsl'
+require 'consular/cli'
+
+module Consular
+
+  class << self
+    attr_accessor :global_path, :default_editor
+
+    # Returns all avaialble cores.
+    #
+    # @return [Array<Core>] Consular cores.
+    #
+    # @api semipublic
+    def cores
+      @cores ||= []
+    end
+
+    # Add a core to Consular.
+    #
+    # @param [Core] klass
+    #   Core to add.
+    #
+    # @example
+    #   Consular.add_core Consular::Cores::OSX
+    #
+    # @api semipublic
+    def add_core(klass)
+      cores << klass
+    end
+
+    # Returns the global script path. If not set,
+    # defaults to ~/.config/consular
+    #
+    # @param [String] path
+    #   File name in path
+    #
+    # @return [String] global script path
+    #
+    # @api public
+    def global_path(path = nil)
+      root = @global_path || File.join(ENV['HOME'],'.config','consular')
+      File.join root, (path || '')
+    end
+
+    # Configure Consular options.
+    #
+    # @param [Proc] block
+    #   Configuration block
+    #
+    # @example
+    #
+    #   Consular.configure do |c|
+    #     c.global_path    = '~/.consular'
+    #     c.default_editor = 'vim'
+    #   end
+    #
+    # @api public
+    def configure(&block)
+      yield self
+    end
+
+  end
+end

data/lib/templates/consularc.tt

@@ -0,0 +1,9 @@
+# You can require your additional core gems here.
+# require 'some_core_gem'
+
+# You can set specific Consular configurations
+# here.
+Consular.configure do |c|
+  # c.global_path    = '~/.config/consular'
+  # c.default_editor = 'vim'
+end

data/lib/templates/example.term.tt

@@ -0,0 +1,21 @@
+# COMMENT OF SCRIPT HERE
+# you can make as many tabs as you wish...
+# tab names are actually arbitrary at this point too.
+
+setup 'echo "setup"'
+
+tab "echo 'default'", "echo 'default tab'"
+
+window do
+
+  tab "echo 'first tab'", "echo 'of window'"
+  
+  tab "named tab", :settings => "Ocean" do
+    run "echo 'named tab'"
+    run "ls"
+  end
+end
+
+window "autotest" do 
+  tab "echo 'window and tab without options'"
+end

data/lib/templates/example.yml.tt

@@ -0,0 +1,16 @@
+# COMMENT OF SCRIPT HERE
+# you can make as many tabs as you wish...
+# tab names are actually arbitrary at this point too.
+---
+- tab1:
+  - cd ~/foo/bar
+  - gitx
+- tab2:
+  - mysql -u root
+  - use test;
+  - show tables;
+- tab3: echo "hello world"
+- tab4: cd ~/baz/ && git pull
+- tab5:
+  - cd ~/foo/project
+  - autotest