scide 0.0.12 → 0.1.0

data/lib/scide/config.rb

@@ -1,105 +0,0 @@
-require 'yaml'
-
-module Scide
-
-  # Complete scide configuration as an object graph.
-  class Config
-    
-    # The file from which the configuration is normally loaded.
-    # This defaults to <tt>$HOME/.scide/config.yml</tt>.
-    DEFAULT_CONFIG_FILE = File.join File.expand_path('~'), '.scide', 'config.yml'
-
-    # The file from which this configuration will be loaded.
-    attr_accessor :file
-    
-    # GNU Screen options. Accessible after calling {#load!}.
-    attr_reader :screen
-
-    # The global configuration. Accessible after calling {#load!}.
-    attr_reader :global
-    
-    # The project definitions (windows, option overrides, etc). Accessible
-    # after calling {#load!}.
-    attr_reader :projects
-
-    # Returns an empty configuration.
-    #
-    # == Arguments
-    # * <tt>file</tt> - The file from which to load the configuration. If not
-    #   given, this defaults to {DEFAULT_CONFIG_FILE}.
-    def initialize file = nil
-      @file = file.try(:to_s) || DEFAULT_CONFIG_FILE
-    end
-
-    # Loads this configuration. This will read from {#file} and parse the contents
-    # as YAML. Configuration elements can then be retrieved with #global,
-    # #projects and #screen.
-    #
-    # == Errors
-    # * <tt>config_not_found</tt> - {#file} does not exist.
-    # * <tt>config_not_readable</tt> - {#file} cannot be read by the user running scide.
-    # * <tt>malformed_config</tt> - {#file} contains malformed YAML.
-    # * <tt>invalid_config</tt> - {#file} contains invalid configuration (see README).
-    # * <tt>unexpected</tt> - {#file} could not be read.
-    def load!
-      check_config
-
-      begin
-        raw_config = load_config
-      rescue StandardError => err
-        Scide.fail :unexpected, "ERROR: could not read configuration #{@file}"
-      end
-
-      begin
-        @config = parse_config raw_config
-      rescue SyntaxError, ArgumentError => err
-        Scide.fail :malformed_config, "ERROR: could not parse configuration #{@file}\n   #{err}"
-      end
-
-      invalid_config 'configuration must be a hash' unless @config.kind_of? Hash
-
-      # laziness
-      @config = HashWithIndifferentAccess.new @config
-
-      invalid_config 'screen configuration must be a hash' unless @config[:screen].nil? or @config[:screen].kind_of?(Hash)
-      invalid_config 'projects configuration must be a hash' unless @config[:projects].nil? or @config[:projects].kind_of?(Hash)
-
-      begin
-        @screen = @config[:screen] || HashWithIndifferentAccess.new
-        @global = Scide::Global.new @config[:global]
-        @projects = (@config[:projects] || {}).inject(HashWithIndifferentAccess.new) do |memo,obj|
-          memo[obj[0]] = Scide::Project.new @global, obj[0], obj[1]; memo
-        end
-      rescue ArgumentError => err
-        invalid_config err
-      end
-    end
-
-    private
-
-    # Causes scide to fail with a <tt>config_not_found</tt> error if the configuration
-    # file does not exist, or with a <tt>config_not_readable</tt> error if it is not
-    # readable (see {Scide.fail}).
-    def check_config
-      Scide.fail :config_not_found, "ERROR: expected to find configuration at #{@file}" unless File.exists? @file
-      Scide.fail :config_not_readable, "ERROR: configuration #{@file} is not readable" unless File.readable? @file
-    end
-
-    # Returns the contents of {#file}.
-    def load_config
-      File.open(@file, 'r').read
-    end
-
-    # Returns the parsed configuration.
-    def parse_config raw
-      YAML::load raw
-    end
-
-    # Causes scide to fail with an <tt>invalid_config</tt> error (see {Scide.fail}).
-    # Builds a complete error message containing the full path to the
-    # configuration file and the given message.
-    def invalid_config msg
-      Scide.fail :invalid_config, "ERROR: configuration #{@file} is invalid.\n   #{msg}"
-    end
-  end
-end

data/lib/scide/global.rb

@@ -1,30 +0,0 @@
-module Scide
-
-  # Global scide options (base path for all projects,
-  # shared options).
-  class Global
-    
-    # The path under which all projects reside by default.
-    # (Can be overriden at the project level.)
-    attr_reader :path
-
-    # Global options shared by all projects.
-    attr_reader :options
-  
-    # Builds global options.
-    #
-    # == Arguments
-    # * <tt>contents</tt> - The global options hash.
-    def initialize contents
-      raise ArgumentError, 'global configuration must be a hash' unless contents.kind_of? Hash
-      raise ArgumentError, 'global options must be a hash' unless contents[:options].nil? or contents[:options].kind_of?(Hash)
-
-      @options = contents[:options].try(:dup) || {}
-
-      # default to home directory
-      @path = contents[:path].try(:to_s) || File.expand_path('~')
-      # expand from home directory unless absolute
-      @path = File.join File.expand_path('~'), @path unless @path.match /^\//
-    end
-  end
-end

data/lib/scide/opts.rb

@@ -1,35 +0,0 @@
-module Scide
-
-  # Pre-configured scide option parser.
-  class Opts < Upoj::Opts
-
-    # Returns the scide option parser. Run scide with <tt>--usage</tt>
-    # to see available options.
-    def initialize
-      super({
-        :banner => {
-          :usage => '[OPTION]... PROJECT',
-          :description => 'generates GNU Screen configuration files.'
-        }
-      })
-
-      on '-c', '--config FILE', 'load configuration from FILE'
-      on '--dry-run', 'show what would be run but do not execute'
-      on('--version', 'show version and exit'){ puts "#{program_name} #{Scide::VERSION}"; exit 0 }
-
-      help!.usage!
-    end
-
-    # Parses the given arguments.
-    #
-    # Causes scide to fail with an <tt>invalid_argument</tt> error (see {Scide.fail})
-    # if an argument is invalid.
-    def parse! args
-      begin
-        super args
-      rescue StandardError => err
-        Scide.fail :invalid_argument, err
-      end
-    end
-  end
-end

data/lib/scide/overmind.rb

@@ -1,70 +0,0 @@
-require 'tempfile'
-
-module Scide
-
-  # Utility class to run scide in a script.
-  class Overmind
-
-    # Awakens the overmind. Use at your own risk.
-    def initialize
-      @cli = Scide::Opts.new
-      @config = Scide::Config.new
-    end
-
-    # Parses command-line arguments and loads the configuration file.
-    # Any error will be run through {Scide.fail}.
-    def brood
-      @cli.parse! ARGV
-      @config.file = @cli.funnel[:config] if @cli.funnel.key? :config
-      @config.load!
-      @initialized = true
-      self
-    end
-
-    # Runs GNU Screen with the project given as argument.
-    # The <tt>--dry-run</tt> option will cause scide to print the
-    # resulting configuration instead of running it.
-    #
-    # == Errors
-    # * <tt>not_initialized</tt> - If {#brood} was not called.
-    # * <tt>unknown_project</tt> - If the given project is not found
-    #   in the configuration file.
-    # * <tt>screen_not_found</tt> - If the GNU Screen binary is not
-    #   found with <tt>which</tt>.
-    def dominate
-
-      Scide.fail :not_initialized, 'ERROR: call #brood to initialize.' unless @initialized
-    
-      project_key = ARGV.shift
-      
-      if project_key.blank?
-        available_projects = @config.projects.keys.join(', ')
-        Scide.fail :invalid_argument, "You must choose a project. Available projects: #{available_projects}."
-      end
-
-      unless @config.projects.key? project_key
-        Scide.fail :unknown_project, "ERROR: there is no project '#{project_key}' in configuration #{@config.file}."
-      end
-
-      screen = Scide::Screen.new @config.projects[project_key], @config.screen
-      screen.check_binary
-
-      if @cli.funnel[:'dry-run']
-        puts
-        puts Paint['COMMAND', :bold]
-        puts "   #{screen.to_command}"
-        puts
-        puts Paint['SCREEN CONFIGURATION', :bold]
-        puts screen.to_s.gsub(/^/, '   ')
-        puts
-      else
-        file = Tempfile.new 'scide'
-        file.write screen.to_s
-        file.rewind
-        file.close
-        system screen.to_command(file.path)
-        file.unlink
-      end
-    end
-  end
-end

data/lib/scide/project.rb

@@ -1,93 +0,0 @@
-module Scide
-
-  # Scide configuration for one project.
-  class Project
-
-    # The project key in the projects configuration hash.
-    attr_reader :key
-
-    # The path where the project is located. See {#initialize}.
-    attr_reader :path
-
-    # Project-specific options. Can be used by commands. See {#initialize}.
-    attr_reader :options
-
-    # The GNU Screen windows of this project.
-    attr_reader :windows
-
-    # The name or index of the window that should be displayed by default for
-    # this project (defaults to the last window).
-    attr_reader :default_window
-
-    # Returns a project configuration.
-    #
-    # If not given in the project hash, {#path} is built by joining
-    # the global path and <tt>key</tt>.
-    #
-    # == Arguments
-    # * <tt>global</tt> - The global configuration.
-    # * <tt>key</tt> - The key identifying the project. This is the
-    #   key in the projects hash.
-    # * <tt>contents</tt> - The project hash.
-    #
-    # == Project Options
-    #
-    # {#options} is built by merging the options given in the project
-    # hash with the global options.
-    #
-    # The following default options are added if not given:
-    # * <tt>name</tt> - Defaults to the project key.
-    # * <tt>path</tt> - The path where the project is located.
-    def initialize global, key, contents
-      raise ArgumentError, "project '#{key}' must be a hash" unless contents.kind_of? Hash
-      raise ArgumentError, "windows of project '#{key}' must be an array" unless contents[:windows].kind_of?(Array)
-      raise ArgumentError, "options of project '#{key}' must be a hash" unless contents[:options].nil? or contents[:options].kind_of?(Hash)
-
-      @key = key
-
-      # path defaults to project key
-      @path = contents[:path].try(:to_s) || key.to_s
-      unless path.match /^\//
-        # if not absolute
-        if global.path
-          # expand from global directory
-          @path = File.join global.path, @path
-        else
-          # or from home directory
-          @path = File.join File.expand_path('~'), @path
-        end
-      end
-
-      @options = global.options.dup
-      @options[:name] = key
-      @options[:path] = @path
-      @options.merge!(contents[:options] || {})
-
-      @windows = contents[:windows].collect{ |w| Scide::Window.new self, w }
-
-      # find default window if specified
-      @default_window = if contents[:default_window].kind_of? Fixnum
-        @windows[contents[:default_window]]
-      elsif contents[:default_window].kind_of?(String) or contents[:default_window].kind_of?(Symbol)
-        @windows.find{ |w| w.name == contents[:default_window].to_s }
-      elsif !contents[:default_window].nil?
-        raise ArgumentError, "default window of project '#{key}' should be an integer, string or symbol"
-      end
-      raise ArgumentError, "default window of project '#{key}' must be the name or index of one of its windows" if !contents[:default_window].nil? and @default_window.nil?
-    end
-
-    # Returns a representation of this project as a GNU Screen
-    # configuration fragment. Returns nil if this project has
-    # no configured windows.
-    def to_screen
-      return nil if @windows.blank?
-      String.new.tap do |s|
-        @windows.each_with_index do |w,i|
-          s << w.to_screen(i)
-          s << "\n" if i != (@windows.length - 1)
-        end
-        s << "\nselect #{@default_window.name}" if @default_window
-      end
-    end
-  end
-end

data/lib/scide/screen.rb

@@ -1,77 +0,0 @@
-require 'which_works'
-
-module Scide
-
-  # Configuration of a GNU Screen session (windows for a specific project).
-  #
-  # The configuration will disable the startup message and display a hardstatus line.
-  # It will also display the windows of the given project.
-  class Screen
-    
-    # The default screen hardstatus line.
-    DEFAULT_HARDSTATUS = '%{= kG}[ %{G}%H %{g}][%= %{=kw}%?%-Lw%?%{r}(%{W}%n*%f%t%?(%u)%?%{r})%{w}%?%+Lw%?%?%= %{g}][%{B}%Y-%m-%d %{W}%c %{g}]'
-
-    # Options for this screen.
-    attr_accessor :options
-
-    # Returns a screen configuration for the given project.
-    #
-    # == Arguments
-    # * <tt>project</tt> - The project.
-    # * <tt>options</tt> - Screen-specific options (see below).
-    #
-    # == Options
-    # * <tt>binary</tt> - Screen binary (defaults to <tt>screen</tt>).
-    # * <tt>args</tt> - Command-line arguments that will be given to screen (e.g. <tt>-U</tt> for unicode).
-    # * <tt>hardstatus</tt> - Hardstatus line configuration (defaults to {DEFAULT_HARDSTATUS}).
-    def initialize project, options
-      raise ArgumentError, 'screen configuration must be a hash' unless options.nil? or options.kind_of?(Hash)
-
-      @project = project
-      @options = options.try(:dup) || {}
-    end
-
-    # Returns the command that will be used to run screen with this configuration.
-    #
-    # == Arguments
-    # * <tt>tmp_file</tt> - The temporary file in which the configuration will be stored.
-    #   (Optional for dry-run.)
-    def to_command tmp_file = 'TEMPORARY_FILE'
-      [ "cd #{@project.path} &&", binary, args, "-c #{tmp_file}" ].select(&:present?).join(' ')
-    end
-
-    # Verifies that the screen binary is there. If not, causes scide
-    # to fail with a <tt>screen_not_found</tt> error (see {Scide.fail}).
-    def check_binary
-      Scide.fail :screen_not_found, "ERROR: #{binary} not found" unless Which.which(binary)
-    end
-
-    # Returns a representation of this configuration as a string.
-    def to_s
-      String.new.tap do |s|
-        s << "startup_message off\n"
-        s << "hardstatus on\n"
-        s << "hardstatus alwayslastline\n"
-        s << "hardstatus string '#{hardstatus}'\n\n"
-        s << @project.to_screen
-      end
-    end
-
-    # Returns the screen hardstatus line given as option, or
-    # the default {DEFAULT_HARDSTATUS}.
-    def hardstatus
-      @options[:hardstatus].try(:to_s) || DEFAULT_HARDSTATUS
-    end
-
-    # Returns the screen binary given as option, or the
-    # default (<tt>screen</tt>).
-    def binary
-      @options[:binary].try(:to_s) || 'screen'
-    end
-
-    # Returns the screen command-line arguments given as options.
-    def args
-      @options[:args].try(:to_s)
-    end
-  end
-end

data/lib/scide/window.rb

@@ -1,88 +0,0 @@
-module Scide
-
-  # Configuration of a GNU Screen window (name, command).
-  class Window
-
-    # The name of the window as it will shown in GNU Screen.
-    # See {#initialize}.
-    attr_reader :name
-
-    # The optional command that will be shown in this window.
-    attr_reader :command
-
-    # Window-specific options. Can be used by commands. See {#initialize}.
-    attr_reader :options
-    
-    # Returns a window for the given project.
-    #
-    # == Arguments
-    # * <tt>project</tt> - The project owning this window.
-    # * <tt>contents</tt> - The window configuration (String or Hash).
-    #
-    # == String Initialization
-    # The string must be in the format <tt>NAME [COMMAND]</tt> where
-    # <tt>NAME</tt> is the window name and <tt>COMMAND</tt> (optional)
-    # is the command configuration (see {Scide::Command}).
-    #
-    # == Hash Initialization
-    # The following options can be given:
-    # * <tt>:name => string</tt> - The window name.
-    # * <tt>:options => hash</tt> - Window-specific options (will be
-    #   merged to the project options).
-    # * <tt>:command => string</tt> - The command to use for this window
-    #   (will be built using {Scide::Command.resolve}).
-    # * <tt>:string => string</tt> - If given, <tt>:name</tt> and <tt>:command</tt>
-    #   are ignored and string initialization will be performed with <tt>string</tt>.
-    #   <tt>:options</tt> can still be used to override project options.
-    def initialize project, contents
-      @project = project
-
-      if contents.kind_of? Hash
-        init_from_hash! contents
-      elsif contents.kind_of? String
-        init_from_string! contents
-      else
-        raise ArgumentError, "window '#{contents}' must be a string or a hash"
-      end
-    end
-
-    # Returns a representation of this window as a GNU Screen
-    # configuration frament.
-    #
-    # == Arguments
-    # * <tt>index</tt> - The position of the window (zero-based).
-    def to_screen index
-      String.new.tap do |s|
-        s << "screen -t #{@name} #{index}"
-        s << "\n#{@command.to_screen}" if @command
-      end
-    end
-
-    private
-
-    # Initializes this window from a hash. See {#initialize} for options.
-    def init_from_hash! contents
-      raise ArgumentError, "options of window '#{@name}' must be a hash" unless contents[:options].nil? or contents[:options].kind_of?(Hash)
-      @options = @project.options.dup.merge(contents[:options] || {})
-
-      if contents[:string].present?
-        init_from_string! contents[:string]
-      else
-        raise ArgumentError, "window '#{contents}' must have a name" unless contents[:name].present?
-        @name = contents[:name]
-        @command = Command.resolve self, contents if contents.key? :command
-      end
-    end
-
-    # Initializes this window from a string. See {#initialize} for format.
-    def init_from_string! contents
-      raise ArgumentError, "window '#{contents}' must not be an empty string" unless contents.present?
-      content_parts = contents.split /\s+/, 2
-      @name = content_parts[0]
-      @options ||= @project.options.dup
-      if content_parts.length == 2
-        @command = Command.resolve self, content_parts[1]
-      end
-    end
-  end
-end

data/spec/command_spec.rb

@@ -1,86 +0,0 @@
-require 'helper'
-
-module Scide
-  module Commands
-    class FuBar < Scide::Commands::Show
-    end
-  end
-end
-
-describe Scide::Command do
-
-  it "should be abstract" do
-    com = Scide::Command.new 'fubar'
-    lambda{ com.to_screen }.should raise_error(StandardError)
-  end
-
-  it "should use given contents as text" do
-    com = Scide::Command.new 'fubar'
-    com.text_with_options.should == 'fubar'
-  end
-
-  it "should take options" do
-    com = Scide::Command.new 'fubar %{foo} %{bar}', :foo => 1, :bar => 2
-    com.text_with_options.should == 'fubar 1 2'
-  end
-
-  describe 'Class' do
-    before :each do
-      @options = { :a => 1, :b => true }
-      @window = double('window')
-      @window.stub(:options){ @options }
-    end
-    
-    it "should resolve command with a string" do
-      com = Scide::Command.resolve @window, 'SHOW fubar'
-      com.should be_a(Scide::Commands::Show)
-    end
-
-    it "should use second part of string as contents when resolving a command with a string" do
-      com = Scide::Command.resolve @window, 'SHOW fubar'
-      com.text_with_options.should == 'fubar'
-    end
-
-    it "should resolve command with a hash" do
-      com = Scide::Command.resolve @window, :command => 'SHOW', :contents => 'fubar'
-      com.should be_a(Scide::Commands::Show)
-    end
-
-    it "should give duplicated window options to the resolved string command" do
-      @window.should_receive :options
-      com = Scide::Command.resolve @window, 'SHOW fubar'
-      com.options.should == @options
-      com.options.should_not equal(@options)
-    end
-
-    it "should give duplicated window options to the resolved hash command" do
-      @window.should_receive :options
-      com = Scide::Command.resolve @window, :command => 'SHOW', :contents => 'fubar'
-      com.options.should == @options
-      com.options.should_not equal(@options)
-    end
-
-    it "should resolve camel-case command class names with a string" do
-      com = Scide::Command.resolve @window, 'FU_BAR'
-      com.should be_a(Scide::Commands::FuBar)
-    end
-
-    it "should resolve camel-case command class names with a hash" do
-      com = Scide::Command.resolve @window, :command => 'FU_BAR'
-      com.should be_a(Scide::Commands::FuBar)
-    end
-
-    it "should raise an error when type of contents is unknown" do
-      lambda{ Scide::Command.resolve(@window, []) }.should raise_error(ArgumentError)
-    end
-
-    it "should raise an error when trying to resolve a blank string" do
-      lambda{ Scide::Command.resolve(@window, '   ') }.should raise_error(ArgumentError)
-    end
-
-    it "should raise an error when trying to resolve an unknown command" do
-      lambda{ Scide::Command.resolve(@window, 'SHW fubar') }.should raise_error(ArgumentError)
-      lambda{ Scide::Command.resolve(@window, :command => 'SHW', :contents => 'fubar') }.should raise_error(ArgumentError)
-    end
-  end
-end

data/spec/commands/edit_spec.rb

@@ -1,19 +0,0 @@
-require 'helper'
-
-describe Scide::Commands::Edit do
-
-  it "should use the preferred editor" do
-    com = Scide::Commands::Edit.new nil
-    com.text_with_options.should == '$EDITOR\012'
-  end
-
-  it "should use given contents as arguments to the editor" do
-    com = Scide::Commands::Edit.new 'fubar'
-    com.text_with_options.should == '$EDITOR fubar\012'
-  end
-
-  it "should use the :edit option as arguments to the editor" do
-    com = Scide::Commands::Edit.new 'fubar', :edit => '-c MyCommand'
-    com.text_with_options.should == '$EDITOR -c MyCommand fubar\012'
-  end
-end

data/spec/commands/run_spec.rb

@@ -1,9 +0,0 @@
-require 'helper'
-
-describe Scide::Commands::Run do
-
-  it "should use given contents and a carriage return as text" do
-    com = Scide::Commands::Run.new 'fubar'
-    com.text_with_options.should == 'fubar\012'
-  end
-end

data/spec/commands/show_spec.rb

@@ -1,15 +0,0 @@
-require 'helper'
-
-describe Scide::Commands::Show do
-
-  it "should produce a GNU Screen stuff command" do
-    com = Scide::Commands::Show.new 'fubar'
-    com.to_screen.should == 'stuff "fubar"'
-  end
-
-  it "should use #text_with_options as argument to stuff" do
-    com = Scide::Commands::Show.new 'fubar'
-    text_with_options = com.text_with_options
-    com.to_screen.should == %|stuff "#{text_with_options}"|
-  end
-end

data/spec/commands/tail_spec.rb

@@ -1,14 +0,0 @@
-require 'helper'
-
-describe Scide::Commands::Tail do
-
-  it "should use given contents as argument -f of tail" do
-    com = Scide::Commands::Tail.new 'fubar'
-    com.text_with_options.should == 'tail -f fubar\012'
-  end
-
-  it "should use the :tail option as arguments to tail" do
-    com = Scide::Commands::Tail.new 'fubar', :tail => '-n 1000'
-    com.text_with_options.should == 'tail -n 1000 -f fubar\012'
-  end
-end