vimius 0.0.1.beta1

data/lib/vimius/shell.rb

@@ -0,0 +1,19 @@
+module TechnoGate
+  module Vimius
+    module Shell
+      extend self
+
+      def shell(command, debug = false)
+        if debug
+          `#{command}`
+        else
+          `#{command} 2> /dev/null`
+        end
+      end
+
+      alias :exec :shell
+    end
+
+    include Shell
+  end
+end

data/lib/vimius/submodules.rb

@@ -0,0 +1,175 @@
+module TechnoGate
+  module Vimius
+    class Submodules < TgConfig
+
+      # Return the submodules
+      #
+      # @return [Hash]
+      def submodules
+        @submodules ||= self[:submodules].map { |k, v| v.merge(:name => k) }
+      end
+
+      # Return the submodules bu group
+      #
+      # @param [HashWithIndifferentAccess] submodules
+      # @return [Hash]
+      def submodules_by_group(submodules = nil)
+        submodules ||= self.submodules
+
+        submodules.group_by { |submodule| submodule[:group] }
+      end
+
+      # Return the submodules bu name
+      #
+      # @param [HashWithIndifferentAccess] submodules
+      # @return [Hash]
+      def submodules_by_name(submodules = nil)
+        submodules ||= self.submodules
+
+        res = {}
+        submodules.each do |submodule|
+          res[submodule[:name]] = submodule
+        end
+        res
+      end
+
+      # Return the active submodules by group
+      #
+      # @return [Hash]
+      def active_by_group
+        submodules_by_group(active)
+      end
+
+      # Return the active submodules by name
+      #
+      # @return [Hash]
+      def active_by_name
+        submodules_by_name(active)
+      end
+
+      # Return the inactive submodules by group
+      #
+      # @return [Hash]
+      def inactive_by_group
+        submodules_by_group(inactive)
+      end
+
+      # Return the inactive submodules by name
+      #
+      # @return [Hash]
+      def inactive_by_name
+        submodules_by_name(inactive)
+      end
+
+      # Return a submodule along with all its dependencies
+      #
+      # @return [Array]
+      def submodule_with_dependencies(name)
+        res = [submodule(name)]
+        dependencies(name).each do |dependency|
+          res << submodule(dependency)
+        end
+
+        res.flatten.uniq
+      end
+
+      # Find the submodule given bu the name
+      #
+      # @param [String] name
+      # @return [Hash]
+      def submodule(name)
+        submodules.select { |s| s[:name].to_s == name.to_s }.
+          first
+      end
+
+      # Return an array of active submodules
+      #
+      # @return [Array]
+      def active
+        Vimius.config[:submodules].map do |submodule|
+          submodule(submodule)
+        end
+      end
+
+      # Return an array of inactive submodiles
+      #
+      # @return [Array]
+      def inactive
+        submodules - active
+      end
+
+      # Return all available groups
+      #
+      # @return [Array]
+      def groups
+        submodules.map { |submodule| submodule[:group] }.uniq.sort
+      end
+
+      # Activate a submodule
+      #
+      # @param [String] Submodule's name
+      def activate(submodule_name)
+        Vimius.config[:submodules] ||= []
+        Vimius.config[:submodules] += [submodule_name] unless active?(submodule_name)
+      end
+
+      # Deactive a submodule
+      #
+      # @param [String] Submodule's name
+      def deactivate(submodule_name)
+        return unless Vimius.config[:submodules]
+        return unless active?(submodule_name)
+
+        Vimius.config[:submodules] -= [submodule_name]
+      end
+
+      # Check if a submodule is active
+      #
+      # @param [String] Submodule's name
+      # @return [Boolean] true if submodule is active
+      def active?(submodule_name)
+        active_by_name.map {|k, v| k.to_s}.include?(submodule_name.to_s)
+      end
+
+      # Check if a submodule is inactive
+      #
+      # @param [String] Submodule's name
+      # @return [Boolean] true if submodule is inactive
+      def inactive?(submodule_name)
+        !!!active?(submodule_name) && submodule(submodule_name).present?
+      end
+
+      # Toggle a submodule
+      #
+      # @param [String] Submodule's name
+      # @raise [SubmoduleNotFoundError]
+      def toggle(submodule_name)
+        if active?(submodule_name)
+          deactivate(submodule_name)
+        elsif inactive?(submodule_name)
+          activate(submodule_name)
+        else
+          raise SubmoduleNotFoundError
+        end
+      end
+
+      protected
+      # Return a list of all dependencies of a submodule (recursive)
+      #
+      # @param [String] name
+      # @return [Array]
+      def dependencies(name)
+        dependencies = []
+        submodule = submodule(name)
+        if submodule.has_key?(:dependencies)
+          submodule[:dependencies].each do |dependency|
+            dependencies << dependency
+            dependencies << dependencies(dependency)
+          end
+        end
+
+        dependencies.flatten.uniq.sort
+      end
+    end
+  end
+end

data/lib/vimius/version.rb

@@ -0,0 +1,17 @@
+module TechnoGate
+  module Vimius
+    MAJOR = 0
+    MINOR = 0
+    TINY = 1
+    PRE = 'beta1'
+
+    def self.version
+      # Init the version
+      version = [MAJOR, MINOR, TINY]
+      # Add the pre if available
+      version << PRE unless PRE.nil? || PRE !~ /\S/
+      # Return the version joined by a dot
+      version.join('.')
+    end
+  end
+end

data/lib/vimius/vim.rb

@@ -0,0 +1,12 @@
+module TechnoGate
+  module Vimius
+    module VIM
+      extend self
+
+      # Folders
+      def folders
+        %w[ _backup _temp ]
+      end
+    end
+  end
+end

data/lib/vimius/vimius_ascii.txt

@@ -0,0 +1,13 @@
+
+___       __      ______                                
+__ |     / /_____ ___  /_____________ _______ ___ _____ 
+__ | /| / / _  _ \__  / _  ___/_  __ \__  __ `__ \_  _ \
+__ |/ |/ /  /  __/_  /  / /__  / /_/ /_  / / / / //  __/
+____/|__/   \___/ /_/   \___/  \____/ /_/ /_/ /_/ \___/ 
+                                                        
+
+_____             ___    _______             _____                 ______
+__  /_______      __ |  / /___(_)_______ ___ ___(_)____  _____________  /
+_  __/_  __ \     __ | / / __  / __  __ `__ \__  / _  / / /__  ___/__  / 
+/ /_  / /_/ /     __ |/ /  _  /  _  / / / / /_  /  / /_/ / _(__  )  /_/  
+\__/  \____/      _____/   /_/   /_/ /_/ /_/ /_/   \__,_/  /____/  (_)   

data/spec/lib/vimius/cli/install_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+class CliInstallTestClass < ::Thor
+  include CLI::Install
+end
+
+module CLI
+  describe Install do
+    subject { CliInstallTestClass.new }
+
+    before(:each) do
+      @file_handler = mock "File Handler"
+      @file_handler.stubs(:write)
+      ::File.stubs(:open).with('/tmp/vimius_bootstrap.sh', 'w').yields(@file_handler)
+      Shell.stubs(:exec)
+    end
+
+    context "#install" do
+      it { should respond_to :install }
+
+      it "should call sanity_check" do
+        subject.expects(:sanity_check).once
+
+        subject.install
+      end
+
+      it "should write the bootstrap" do
+        ::File.expects(:open).with('/tmp/vimius_bootstrap.sh', 'w').
+          yields(@file_handler).once
+
+        subject.install
+      end
+
+      it "should call Shell.exec" do
+        Shell.expects(:exec).with("cat /tmp/vimius_bootstrap.sh | sh", true).once
+
+        subject.install
+      end
+    end
+
+    context '#sanity_check' do
+      before(:each) do
+        ::File.stubs(:exists?).with(USER_GVIMRC_PATH).returns(true)
+        ::File.stubs(:exists?).with(USER_VIMRC_PATH).returns(true)
+        ::File.stubs(:exists?).with(USER_VIM_PATH).returns(true)
+      end
+
+      it "should check that USER_VIM_PATH exists" do
+        ::File.expects(:exists?).with(USER_VIM_PATH).returns(true).once
+
+        subject.send :sanity_check
+      end
+
+      it "should check that USER_VIMRC_PATH exists" do
+        ::File.expects(:exists?).with(USER_VIMRC_PATH).returns(true).once
+
+        subject.send :sanity_check
+      end
+
+      it "should check that USER_GVIMRC_PATH exists" do
+        ::File.expects(:exists?).with(USER_GVIMRC_PATH).returns(true).once
+
+        subject.send :sanity_check
+      end
+
+      context 'failure' do
+        it "should abort if USER_VIM_PATH exists." do
+          ::File.expects(:exists?).with(USER_VIM_PATH).returns(false).once
+
+          subject.send(:sanity_check).should be_false
+          "#{USER_VIM_PATH} exists, cannot continue.".should be_in_output
+        end
+
+        it "should abort if USER_VIMRC_PATH exists." do
+          ::File.expects(:exists?).with(USER_VIMRC_PATH).returns(false).once
+
+          subject.send(:sanity_check).should be_false
+          "#{USER_VIMRC_PATH} exists, cannot continue.".should be_in_output
+        end
+
+        it "should abort if USER_GVIMRC_PATH exists." do
+          ::File.expects(:exists?).with(USER_GVIMRC_PATH).returns(false).once
+
+          subject.send(:sanity_check).should be_false
+          "#{USER_GVIMRC_PATH} exists, cannot continue.".should be_in_output
+        end
+      end
+    end
+  end
+end

data/spec/lib/vimius/cli/version_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+class CliVersionTestClass < ::Thor
+  include CLI::Version
+end
+
+module CLI
+  describe Version do
+    subject { CliVersionTestClass.new }
+
+    context "#version#" do
+      it { should respond_to :version }
+
+      it "should prints Vimius version" do
+        subject.version
+
+        "Vimius version #{Vimius.version}".
+          should be_in_output
+      end
+    end
+  end
+end

data/spec/lib/vimius/cli_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+module CLI
+  describe Runner do
+    subject { Runner }
+
+    context 'Thor' do
+      it { should respond_to :start }
+    end
+  end
+end

data/spec/lib/vimius/shell_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Shell do
+  it { should respond_to :shell }
+
+  it "should include the shell method into the Vimius module" do
+    Vimius.should respond_to :shell
+  end
+end

data/spec/lib/vimius/submodules_spec.rb

@@ -0,0 +1,474 @@
+require 'spec_helper'
+
+describe Submodules do
+  let(:submodules) do
+    {
+      "submodules" => {
+        "pathogen" => {
+          "path"  => "vimius/vim/core/pathogen",
+          "group" => "core",
+        },
+        "tlib" => {
+          "path"  => "vimius/vim/tools/tlib",
+          "group" => "tools",
+          "dependencies" => ["pathogen"],
+        },
+        "github" => {
+          "path"  => "vimius/vim/tools/github",
+          "group" => "tools",
+          "dependencies" => ["tlib", "pathogen"],
+        },
+        "command-t" => {
+          "path"  => "vimius/vim/tools/command-t",
+          "group" => "tools",
+          "dependencies" => ["tlib"],
+        },
+      },
+    }
+  end
+
+  let(:expected_submodules) do
+    [
+      {
+        "path"  => "vimius/vim/core/pathogen",
+        "group" => "core",
+        "name"  => "pathogen",
+      },
+      {
+        "path"  => "vimius/vim/tools/tlib",
+        "group" => "tools",
+        "dependencies" => ["pathogen"],
+        "name"  => "tlib",
+      },
+      {
+        "path"  => "vimius/vim/tools/github",
+        "group" => "tools",
+        "dependencies" => ["tlib", "pathogen"],
+        "name"  => "github",
+      },
+      {
+        "path"  => "vimius/vim/tools/command-t",
+        "group" => "tools",
+        "dependencies" => ["tlib"],
+        "name"  => "command-t",
+      },
+    ]
+  end
+
+  let(:expected_active_submodules) do
+    [
+      {
+        "path"  => "vimius/vim/core/pathogen",
+        "group" => "core",
+        "name"  => "pathogen",
+      },
+      {
+        "path"  => "vimius/vim/tools/tlib",
+        "group" => "tools",
+        "dependencies" => ["pathogen"],
+        "name"  => "tlib",
+      },
+      {
+        "path"  => "vimius/vim/tools/github",
+        "group" => "tools",
+        "dependencies" => ["tlib", "pathogen"],
+        "name"  => "github",
+      },
+    ]
+  end
+
+  let(:expected_inactive_submodules) do
+    [
+      {
+        "path"  => "vimius/vim/tools/command-t",
+        "group" => "tools",
+        "dependencies" => ["tlib"],
+        "name"  => "command-t",
+      },
+    ]
+  end
+
+  let(:submodules_by_group) do
+    {
+      "core" =>
+      [
+        {
+          "path"  => "vimius/vim/core/pathogen",
+          "group" => "core",
+          "name"  => "pathogen",
+        },
+      ],
+      "tools" =>
+      [
+        {
+          "path"  => "vimius/vim/tools/tlib",
+          "group" => "tools",
+          "dependencies" => ["pathogen"],
+          "name" => "tlib",
+        },
+        {
+          "path"  => "vimius/vim/tools/github",
+          "group" => "tools",
+          "dependencies" => ["tlib", "pathogen"],
+          "name" => "github",
+        },
+        {
+          "path"  => "vimius/vim/tools/command-t",
+          "group" => "tools",
+          "dependencies" => ["tlib"],
+          "name" => "command-t",
+        },
+      ],
+    }
+  end
+
+  let (:submodules_by_name) do
+    {
+      "pathogen" => {
+        "path"  => "vimius/vim/core/pathogen",
+        "group" => "core",
+        "name"  => "pathogen",
+      },
+      "tlib" => {
+        "path"  => "vimius/vim/tools/tlib",
+        "group" => "tools",
+        "dependencies" => ["pathogen"],
+        "name"  => "tlib",
+      },
+      "github" => {
+        "path"  => "vimius/vim/tools/github",
+        "group" => "tools",
+        "dependencies" => ["tlib", "pathogen"],
+        "name"  => "github",
+      },
+      "command-t" => {
+        "path"  => "vimius/vim/tools/command-t",
+        "group" => "tools",
+        "dependencies" => ["tlib"],
+        "name"  => "command-t",
+      },
+    }
+  end
+
+  let(:active_by_group) do
+    {
+      "core" =>
+      [
+        {
+          "path"  => "vimius/vim/core/pathogen",
+          "group" => "core",
+          "name"  => "pathogen",
+        },
+      ],
+      "tools" =>
+      [
+        {
+          "path"  => "vimius/vim/tools/tlib",
+          "group" => "tools",
+          "dependencies" => ["pathogen"],
+          "name" => "tlib",
+        },
+        {
+          "path"  => "vimius/vim/tools/github",
+          "group" => "tools",
+          "dependencies" => ["tlib", "pathogen"],
+          "name" => "github",
+        },
+      ],
+    }
+  end
+
+  let (:active_by_name) do
+    {
+      "pathogen" => {
+        "path"  => "vimius/vim/core/pathogen",
+        "group" => "core",
+        "name"  => "pathogen",
+      },
+      "tlib" => {
+        "path"  => "vimius/vim/tools/tlib",
+        "group" => "tools",
+        "dependencies" => ["pathogen"],
+        "name"  => "tlib",
+      },
+      "github" => {
+        "path"  => "vimius/vim/tools/github",
+        "group" => "tools",
+        "dependencies" => ["tlib", "pathogen"],
+        "name"  => "github",
+      },
+    }
+  end
+
+  let(:inactive_by_group) do
+    {
+      "tools" =>
+      [
+        {
+          "path"  => "vimius/vim/tools/command-t",
+          "group" => "tools",
+          "dependencies" => ["tlib"],
+          "name" => "command-t",
+        },
+      ],
+    }
+  end
+
+  let (:inactive_by_name) do
+    {
+      "command-t" => {
+        "path"  => "vimius/vim/tools/command-t",
+        "group" => "tools",
+        "dependencies" => ["tlib"],
+        "name"  => "command-t",
+      },
+    }
+  end
+
+  before(:each) do
+    ::File.stubs(:exists?).with(MODULES_FILE).returns(true)
+    ::File.stubs(:readable?).with(MODULES_FILE).returns(true)
+    ::File.stubs(:writable?).with(MODULES_FILE).returns(true)
+
+    ::File.stubs(:exists?).with(CONFIG_FILE).returns(true)
+    ::File.stubs(:readable?).with(CONFIG_FILE).returns(true)
+    ::File.stubs(:writable?).with(CONFIG_FILE).returns(true)
+
+    Vimius::Submodules.any_instance.stubs(:parse_config_file).
+      returns(submodules.with_indifferent_access)
+    TgConfig.any_instance.stubs(:parse_config_file).
+      returns({"submodules" => ["pathogen", "tlib", "github"]}.with_indifferent_access)
+  end
+
+  after(:each) do
+    Vimius.config.send(:instance_variable_set, :@config, nil)
+    subject.send(:instance_variable_set, :@config, nil)
+  end
+
+  subject { Submodules.new MODULES_FILE }
+
+  context "#submodules" do
+    it { should respond_to :submodules }
+
+    it "should return submodules" do
+      subject.submodules.should == expected_submodules
+    end
+
+    it "should add the name for each submodule" do
+      subject.submodules.first["name"].should == "pathogen"
+    end
+  end
+
+  context "#dependencies" do
+    it {should respond_to :dependencies}
+
+    it "should return tlib and pathogen as dependencies of command-t" do
+      subject.send(:dependencies, 'command-t').should == ["pathogen", "tlib"]
+    end
+  end
+
+  context "#submodule" do
+    it { should respond_to :submodule }
+
+    it "should return the submodule we're looking for" do
+      subject.send(:submodule, :pathogen).should == expected_submodules.first
+    end
+  end
+
+  context "#submodule_with_dependencies" do
+    it { should respond_to :submodule_with_dependencies}
+
+    it "should return the correct module from the submodules hash" do
+      subject.submodule_with_dependencies("pathogen").first.should == expected_submodules.first
+    end
+
+    it "should return the name with the submodule" do
+      subject.submodule_with_dependencies("pathogen").first["name"].should == "pathogen"
+    end
+
+    it "should return all dependencies when getting the module command-t" do
+      subject.submodule_with_dependencies("command-t").should include expected_submodules[1]
+      subject.submodule_with_dependencies("command-t").should include expected_submodules.first
+    end
+
+    it "should not include the same dependency twice" do
+      subject.submodule_with_dependencies("github").select { |c| c["name"] == "pathogen"}.size.should == 1
+    end
+  end
+
+  context "#groups" do
+    it { should respond_to :groups }
+
+    it "should return core and tools " do
+      subject.groups.should == ["core", "tools"]
+    end
+  end
+
+  context "#active" do
+    it { should respond_to :active }
+
+    its(:active) { should == expected_active_submodules }
+  end
+
+  context "#inactive" do
+    it { should respond_to :inactive }
+
+    its(:inactive) { should == expected_inactive_submodules }
+  end
+
+  context "#submodules_by_group" do
+    it { should respond_to :submodules_by_group }
+
+    it "should return submodules_by_group" do
+      subject.submodules_by_group.should == submodules_by_group
+    end
+  end
+
+  context "#submodules_by_name" do
+    it { should respond_to :submodules_by_name }
+
+    it "should return submodules_by_name" do
+      subject.submodules_by_name.should == submodules_by_name
+    end
+  end
+
+  context "#active_by_group" do
+    it { should respond_to :active_by_group }
+
+    it "should return active_by_group" do
+      subject.active_by_group.should == active_by_group
+    end
+  end
+
+  context "#active_by_name" do
+    it { should respond_to :active_by_name }
+
+    it "should return active_by_name" do
+      subject.active_by_name.should == active_by_name
+    end
+  end
+
+  context "#active_by_name" do
+    it { should respond_to :active_by_name }
+
+    it "should return active_by_name" do
+      subject.active_by_name.should == active_by_name
+    end
+  end
+
+  context "#active_by_name" do
+    it { should respond_to :active_by_name }
+
+    it "should return active_by_name" do
+      subject.active_by_name.should == active_by_name
+    end
+  end
+
+  context "#active?" do
+    it { should respond_to :active? }
+
+    it "should return true for tlib" do
+      subject.active?(:tlib).should be_true
+    end
+
+    it "should return false for command-t" do
+      subject.active?("command-t").should be_false
+    end
+  end
+
+  context "#inactive?" do
+    it { should respond_to :inactive? }
+
+    it "should return false for tlib" do
+      subject.inactive?(:tlib).should be_false
+    end
+
+    it "should return true for command-t" do
+      subject.inactive?("command-t").should be_true
+    end
+  end
+
+  context "#activate" do
+    it { should respond_to :activate }
+
+    it "should activate a module" do
+      subject.active.should == expected_active_submodules
+
+      subject.activate("command-t")
+
+      subject.active.should == expected_submodules # => expected_submodules includes command-t
+                                                   #    and all activated submodules
+    end
+
+    it "should not call save on the config" do
+      Vimius.config.expects(:save).never
+
+      subject.activate("command-t")
+    end
+
+    it "should not blow if there's no initially active submodules" do
+      TgConfig.any_instance.stubs(:parse_config_file).  returns({}.with_indifferent_access)
+
+      Vimius.config[:submodules].should be_nil
+
+      lambda { subject.activate("command-t") }.should_not raise_error NoMethodError
+    end
+
+    it "should not activate an existing active submodule" do
+      subject.activate("tlib")
+
+      subject.active.should == expected_active_submodules
+    end
+  end
+
+  context "#deactivate" do
+    it { should respond_to :deactivate }
+
+    it "should deactivate a module" do
+      subject.activate("command-t")
+      subject.active.should == expected_submodules
+      subject.deactivate("command-t")
+      subject.active.should == expected_active_submodules
+    end
+
+    it "should not call save on the config" do
+      Vimius.config.expects(:save).never
+
+      subject.deactivate("command-t")
+    end
+
+    it "should not blow if there's no initially active submodules" do
+      TgConfig.any_instance.stubs(:parse_config_file).  returns({}.with_indifferent_access)
+
+      Vimius.config[:submodules].should be_nil
+
+      lambda { subject.deactivate("command-t") }.should_not raise_error NoMethodError
+    end
+
+    it "should not deactivate an inactive submodule" do
+      subject.deactivate("command-t")
+
+      subject.active.should == expected_active_submodules
+    end
+  end
+
+  context "#toggle" do
+    it { should respond_to :toggle }
+
+    it "should call activate if the submodule is inactive" do
+      subject.expects(:activate).with("command-t").once
+
+      subject.toggle("command-t")
+    end
+
+    it "should call deactivate if the submodule is inactive" do
+      subject.expects(:deactivate).with("tlib").once
+
+      subject.toggle("tlib")
+    end
+
+    it "should raise SubmoduleNotFoundError if no submodule by that name exists" do
+      lambda {subject.toggle("invalid-submodule") }.should raise_error SubmoduleNotFoundError
+    end
+  end
+end