chid 0.1.4.pre.beta → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a7a695ae60bfe3af5f460e5d2272fa495d7103a9
-  data.tar.gz: 9bd8b66acd50421cbc5d7982f3ef15a970ada9bc
+  metadata.gz: 03442575a6b3ffa0fcd60f867ac6d95827c87144
+  data.tar.gz: c6cadbbf436b85a9e6b72a2257902414fb17e126
 SHA512:
-  metadata.gz: 4a97cf5fc860979e4da8ed581c1d0359d944aaf46cbeafc6a1be257631b50e8609881640b8426620088176729b9d929f54012ed7ffa7f6edd62af35c40adf695
-  data.tar.gz: 91a2a7b7797423cdd168ee901b80403bc0ab2ed41b7429f3719f553dd1d01a197345ed8217ee91527c17ff685e24c47cd9afb418c6512c8c6a753e76b30a6aee
+  metadata.gz: a70853be7604a95274f0f069d5f9f9a70b52a2568bd4841e45f9d052efba9ba5bbdf3ff41de94b3d9cc52860ad0e3a18a355fce7fb1e4376154ffd833f44f47e
+  data.tar.gz: ff2c4a51b2ea646ccce92c9c71a1619e2dbda433c3c1752ce63c7e6554031240e62e1270f0a10c03e15aa9147b00db9315b5052d4a2377a5a7e9a472123a7c69

data/CHANGELOG.md

@@ -1,7 +1,15 @@
-### 0.1.3 - Beta
+### 0.1.4
+
+* Add:  
+  - Chid Installs Command
+  - Chid Workstation Command
+  - Chid Gitflow Command
+
+### 0.1.3
 
 * Add:  
   - Chid Executable
+  - Chid Commit Command
 
 * Update:
   - Change way to show the Helper task

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    chid (0.1.1)
+    chid (0.1.4.pre.beta)
       easy_translate
       http
       rake
@@ -10,26 +10,27 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    addressable (2.5.0)
+    addressable (2.5.1)
       public_suffix (~> 2.0, >= 2.0.2)
     coderay (1.1.1)
-    domain_name (0.5.20170223)
+    diff-lcs (1.3)
+    domain_name (0.5.20170404)
       unf (>= 0.0.5, < 1.0.0)
     easy_translate (0.5.0)
       json
       thread
       thread_safe
     equatable (0.5.0)
-    http (2.2.1)
+    http (2.2.2)
       addressable (~> 2.3)
       http-cookie (~> 1.0)
       http-form_data (~> 1.0.1)
       http_parser.rb (~> 0.6.0)
     http-cookie (1.0.3)
       domain_name (~> 0.5)
-    http-form_data (1.0.1)
+    http-form_data (1.0.3)
     http_parser.rb (0.6.0)
-    json (2.0.3)
+    json (2.1.0)
     method_source (0.8.2)
     necromancer (0.4.0)
     pastel (0.7.1)
@@ -41,19 +42,32 @@ GEM
       slop (~> 3.4)
     public_suffix (2.0.5)
     rake (12.0.0)
+    rspec (3.6.0)
+      rspec-core (~> 3.6.0)
+      rspec-expectations (~> 3.6.0)
+      rspec-mocks (~> 3.6.0)
+    rspec-core (3.6.0)
+      rspec-support (~> 3.6.0)
+    rspec-expectations (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-mocks (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-support (3.6.0)
     slop (3.6.0)
     thread (0.2.2)
     thread_safe (0.3.6)
     tty-color (0.4.2)
     tty-cursor (0.4.0)
-    tty-prompt (0.11.0)
+    tty-prompt (0.12.0)
       necromancer (~> 0.4.0)
       pastel (~> 0.7.0)
       tty-cursor (~> 0.4.0)
       wisper (~> 1.6.1)
     unf (0.1.4)
       unf_ext
-    unf_ext (0.0.7.2)
+    unf_ext (0.0.7.4)
     wisper (1.6.1)
 
 PLATFORMS
@@ -62,6 +76,7 @@ PLATFORMS
 DEPENDENCIES
   chid!
   pry
+  rspec
 
 BUNDLED WITH
-   1.14.6
+   1.15.2

data/bin/chid

@@ -5,24 +5,26 @@ require 'rake'
 
 task = ARGV.join(" ")
 
+puts "TASK: #{ARGV}"
+
 if task.empty?
   #Rake.application.run
   Chid::start
 else
-  puts "TASK: #{ARGV.join(" ")}"
-  if task == 'install node'
-    Chid::Commands::Installs::Node.new().run
-  elsif task == 'install postgres'
-    Chid::Commands::Installs::Postgres.new().run
-  elsif task == 'install rvm'
-    Chid::Commands::Installs::Rvm.new().run
-  elsif task == 'install dotfile'
-    Chid::Commands::Installs::Dotfile.new().run
-  elsif task == 'install'
-    Chid::Commands::Install.new(Chid::chid_config_path).run
-  else
-    puts "Invalid task name. Try again"
-  end
+  Chid::Command.run(ARGV)
+  #if task == 'install node'
+  #  Chid::Commands::Installs::Node.new().run
+  #elsif task == 'install postgres'
+  #  Chid::Commands::Installs::Postgres.new().run
+  #elsif task == 'install rvm'
+  #  Chid::Commands::Installs::Rvm.new().run
+  #elsif task == 'install dotfile'
+  #  Chid::Commands::Installs::Dotfile.new().run
+  #elsif task == 'install'
+  #  Chid::Commands::Install.new(Chid::chid_config_path).run
+  #else
+  #  puts "Invalid task name. Try again"
+  #end
 end
 
 #Rake.application[task].invoke

data/chid.gemspec

@@ -19,6 +19,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib", "tasks"]
 
   spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rspec'
 
   # Tasks runner
   spec.add_dependency 'rake'

data/lib/chid.rb

@@ -4,15 +4,11 @@ require 'tty-prompt'
 require 'http'
 require 'easy_translate'
 
-require 'chid/commands/install'
-require 'chid/commands/installs/dotfile'
-require 'chid/commands/installs/node'
-require 'chid/commands/installs/postgres'
-require 'chid/commands/installs/rvm'
+require 'chid/command'
 
 # Require all files inside the chid folder
 dir = File.join(File.dirname(__FILE__))
-glob = Dir.glob(dir + "/chid/*.rb")
+glob = Dir.glob(dir + "/chid/**/*.rb")
 glob.each { |r| require r }
 
 dir_tasks = File.expand_path('..', File.dirname(__FILE__))
@@ -20,61 +16,64 @@ dir = File.join(dir_tasks, 'tasks')
 glob = Dir.glob(dir + "/**/*.rake")
 glob.each { |r| load r }
 
-
 module Chid
-  def self.start
-    chid_config = ChidConfig.new
-  prompt = TTY::Prompt.new(help_color: :green)
-  confirm_install = -> (action, &block) {
-    matched = /^install:(.*)/.match(action)
-    return block.() unless matched
-
-    action_name = matched.captures.first
-    if  prompt.yes?("Can I install the #{action_name}?")
-      block.()
-    else
-      puts "\nNo problem. What do you need?"
-    end
-  }
 
-  Main.new(chid_config).init do |action, args|
-    rake_task = Rake::Task[action]
-    task_args = Rake::TaskArguments.new(rake_task.arg_names, args)
+  def self.chid_config
+    @chid_config ||= ChidConfig.new
+  end
 
-    confirm_install.(action) do
-      rake_task.execute(task_args)
+  def self.start
+    prompt = TTY::Prompt.new(help_color: :green)
+    confirm_install = -> (action, &block) {
+      matched = /^install:(.*)/.match(action)
+      return block.() unless matched
+
+      action_name = matched.captures.first
+      if  prompt.yes?("Can I install the #{action_name}?")
+        block.()
+      else
+        puts "\nNo problem. What do you need?"
+      end
+    }
+
+    Main.new(chid_config).init do |action, args|
+      rake_task = Rake::Task[action]
+      task_args = Rake::TaskArguments.new(rake_task.arg_names, args)
+
+      confirm_install.(action) do
+        rake_task.execute(task_args)
+      end
+
+      puts "\nDone! What else?"
     end
-
-    puts "\nDone! What else?"
   end
-end
 
   def self.chid_config_path
-  home_path = File.expand_path("~/")
-  chid_config_path = File.join(home_path, '.chid.config')
-  chid_config_path
-end
+    home_path = File.expand_path("~/")
+    chid_config_path = File.join(home_path, '.chid.config')
+    chid_config_path
+  end
 
   def self.username
-  on_linux { return  %x[echo $USER].strip }
-  on_osx   { return  %x[echo $(logname)].strip }
-end
+    on_linux { return  %x[echo $USER].strip }
+    on_osx   { return  %x[echo $(logname)].strip }
+  end
 
   def self.on_linux
-  if  platform =~ /Linux/
-    yield
+    if  platform =~ /Linux/
+      yield
+    end
   end
-end
 
   def self.on_osx
-  if  platform =~ /Darwin/
-    yield
+    if  platform =~ /Darwin/
+      yield
+    end
   end
-end
 
   def self.platform
-  %x{echo $(uname -s)}.strip
-end
+    %x{echo $(uname -s)}.strip
+  end
 
 
   # The Regex Actions are used to execute automatically some Rake::Task

data/lib/chid/command.rb

@@ -0,0 +1,150 @@
+module Chid
+  class Command
+
+    class << self
+
+      attr_accessor :summary, :description, :arguments
+
+      COMMANDS = {}
+
+      def command(cmd)
+        COMMANDS[cmd] = self.to_s
+      end
+
+      def help
+        if self.description.nil?
+          commands = String.new
+          COMMANDS.keys.each {|k| commands <<  "  #{k.to_s}\n" }
+          self.description = <<-DESC
+Usage:
+
+  $ chid [COMMAND]
+
+   To see what the Command do:
+
+    $ chid [COMMAND] -h
+
+Commands:
+
+#{commands}
+          DESC
+        end
+
+        puts summary
+        print description
+      end
+
+      def run(argv)
+        command_key = command_key(argv)
+        return self.help unless command_key_is_included?(command_key)
+        invoke(argv)
+      end
+
+      # Returns a mapped options with your values from @argv
+      #
+      # @param [Array<String>] argv
+      #        The arguments passed from input.
+      #
+      # @return [Hash<String, Array>] Mapped options with your values
+      #         The keys of hash are the options and the values of hash
+      #         are all values for the option.
+      #
+      # @example Map an argv
+      #   argv = ['init', '-option_1', 'value_for_option_1']
+      #
+      #   map_options_with_values(argv) #=> {'-option1' => ['value_for_option_1']}
+      #
+      def map_options_with_values(argv)
+        return argv.reduce({}) do |options, arg|
+          new_options = options
+
+          if arg_is_an_option?(arg)
+            new_options[arg] = []
+            next(new_options)
+          end
+
+         options_with_values(new_options, arg)
+        end
+      end
+
+      private
+
+      def arg_is_an_option?(arg)
+        arg.include?('-')
+      end
+
+      def options_with_values(options, arg)
+        new_options = options
+        last_option = new_options.keys.last
+        new_options[last_option] << arg if last_option
+
+        new_options
+      end
+
+      def command_key_is_included?(command_key)
+        COMMANDS.include?(command_key)
+      end
+
+      # Returns the command key based on argv parameter.
+      # That command could be a single or compost command.
+      #
+      # @param [Array<String>] argv
+      #        The arguments passed from input.
+      #
+      # @return [Sym] the sym of the command
+      #
+      # @example Get the command_key in an argv
+      #   argv = ['init', '-option_1', 'value_for_option_1']
+      #
+      #   command_key(argv) #=> :init
+      #
+      #   argv = ['init', 'chid', '-option_1', 'value_for_option_1']
+      #
+      #   command_key(argv) #=> :'init chid'
+      #
+      def command_key(argv)
+        argv.reduce('') { |command, arg|
+          break(command) if arg_is_an_option?(arg)
+          command << "#{arg} "
+        }.strip.to_sym
+      end
+
+      # Convenience method.
+      # Instantiate the command and run it with the provided arguments at once.
+      #
+      # @param [String..., Array<String>] args
+      #        The arguments to initialize the command with
+      #
+      def invoke(argv)
+        options = map_options_with_values(argv)
+        command = new_command_instance(command_key(argv), options)
+        return command.run if has_no_arguments?(options) || has_valid_arguments?(command.class, options)
+        command.class.help
+      end
+
+      def new_command_instance(command_key, options)
+        Object.const_get(COMMANDS[command_key]).new(options)
+      end
+
+      def has_no_arguments?(options)
+        options.empty?
+      end
+
+      def has_valid_arguments?(command_class, options)
+        !(command_class.arguments & options.keys).empty?
+      end
+
+    end
+
+    # --- Instance methods ---
+
+    public
+
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+  end
+end

data/lib/chid/commands/gitflow/commit.rb

@@ -0,0 +1,92 @@
+module Chid
+  module Commands
+    module Gitflow
+      class Commit < Command
+
+        command :commit
+        self.summary = 'Create a commits in based on gitFlow pattern'
+        self.description = <<-DESC
+
+Usage:
+
+  $ chid commit
+
+    An easy way to create commits following simple steps:
+
+    First:
+      Choose your commit type in this options (add,Remove, Update, Refactor, Fix)
+
+    Second:
+      Type your commit title, a brief description of your changes
+
+    Third:
+      Add your description lines, describing exactly what you did
+
+    Thats it! Your commit will be created and pushed like this sample:
+
+    feature/#123 Add specific file needed to app
+
+    - specific file have now this line
+    - this is the description line two
+
+        DESC
+
+        self.arguments = []
+
+        def run
+          commit = build_commit
+          system("git commit -sm \"#{commit}\"")
+          system("git push origin #{branch}")
+        end
+
+        def build_commit
+          @commit_lines = "\n"
+          commit_kind  = add_commit_kind
+          commit_title = add_commit_title
+          add_commit_description
+          commit = "#{branch_name} #{commit_kind} #{commit_title} \n #{@commit_lines}"
+        end
+
+        def branch
+          @branch ||= %x[git rev-parse --abbrev-ref HEAD].strip
+        end
+
+        def branch_name
+          @branch_name ||= branch[/\w{1,}\/#?\d{1,}/] || branch
+        end
+
+        def add_commit_kind
+          @prompt = TTY::Prompt.new
+          choices = ['Add', 'Remove','Update', 'Refactor','Fix']
+          result = @prompt.select('Select commit type: ', choices)
+        end
+
+        def add_commit_title
+          puts 'Tell me the commit title'
+          print '> '
+          commit_title = STDIN.gets.strip
+        end
+
+        def add_commit_description
+          puts 'Tell me the commit description, one action per line'
+          print "> "
+          commit_description ="- #{STDIN.gets.strip} \n"
+          @commit_lines << commit_description
+          add_commit_description unless did_commit_finished?
+        end
+
+        def do_push?
+          answers = ['Yes','No']
+          result_should_push = @prompt.select('Push changes?', answers)
+          result_should_push == 'Yes'
+        end
+
+        def did_commit_finished?
+          answers = ['Yes','No']
+          result_description_finished = @prompt.select('more?', answers)
+          result_description_finished == 'No'
+        end
+      end
+    end
+  end
+end

data/lib/chid/commands/init.rb

@@ -0,0 +1,71 @@
+module Chid
+  module Commands
+    class Init < Command
+
+      command :init
+
+      self.summary = 'Generate a .chid.config file on root directory'
+      self.description = <<-DESC
+
+Usage:
+
+  $ chid init
+
+    Creates a .chid.config file on root directory if none .chid.config file exists.
+
+    To access that file will be created in `~/.chid.config`
+
+      DESC
+      self.arguments = []
+
+      def run
+        create_or_update_chid_config_file
+      end
+
+      private
+      def chid_config_path
+       @chid_config_path ||= ::Chid::chid_config_path
+      end
+
+      def create_or_update_chid_config_file
+        print_informations
+        dump_on_chid_config_file(chid_configurations)
+      end
+
+      def print_informations
+        print "\n--- Installing chid ---\n "
+        print "\nCreating the " unless chid_config_file_exist?
+        print "\nUpdating the " if chid_config_file_exist?
+        print "~/.chid.config ".blue
+        print "file\n"
+      end
+
+      def dump_on_chid_config_file(configurations)
+        File.open(chid_config_path, 'w') do |file|
+          YAML.dump(configurations, file)
+        end
+      end
+
+      def chid_configurations
+        return base_configurations unless chid_config_file_exist?
+
+        data = YAML.load_file chid_config_path
+        data[:chid][:workstations] = data[:chid].fetch(:workstations, {})
+        data
+      end
+
+      def base_configurations
+        {
+          chid: {
+            workstations: {}
+          }
+        }
+      end
+
+      def chid_config_file_exist?
+        File.exist?(chid_config_path)
+      end
+
+    end
+  end
+end

data/lib/chid/commands/installs/dotfile.rb

@@ -1,7 +1,23 @@
 module Chid
   module Commands
     module Installs
-      class Dotfile
+      class Dotfile < Command
+
+        command :'install dotfile'
+
+        self.summary = 'Install the Dotfile'
+        self.description = <<-DESC
+
+Usage:
+
+  $ chid install dotfile
+
+    For Linux users will install through curl and will isntall zsh and git-core
+
+    For OSx users will install through curl
+
+        DESC
+        self.arguments = []
 
         def run
           puts "\nInstalling the YADR Dotfiles..."

data/lib/chid/commands/installs/node.rb

@@ -1,7 +1,23 @@
 module Chid
   module Commands
     module Installs
-      class Node
+      class Node < Command
+
+        command :'install node'
+
+        self.summary = 'Install the Node'
+        self.description = <<-DESC
+
+Usage:
+
+  $ chid install node
+
+    For Linux users will install through apt-get
+
+    For OSx users will install through brew
+
+        DESC
+        self.arguments = []
 
         def run
           puts "\nInstalling the Node..."

data/lib/chid/commands/installs/postgres.rb

@@ -1,7 +1,25 @@
 module Chid
   module Commands
     module Installs
-      class Postgres
+      class Postgres < Command
+
+        command :'install postgres'
+
+        self.summary = 'Install the Postgres'
+        self.description = <<-DESC
+
+Usage:
+
+  $ chid install postgres
+
+    For Linux users will install through apt-get
+
+    For OSx users will install through brew
+
+        DESC
+        self.arguments = []
+
+
 
         def run
           puts "\nInstalling the Postgres..."

data/lib/chid/commands/installs/rvm.rb

@@ -1,7 +1,24 @@
 module Chid
   module Commands
     module Installs
-      class Rvm
+      class Rvm < Command
+
+        command :'install rvm'
+
+        self.summary = 'Install the RVM'
+        self.description = <<-DESC
+
+Usage:
+
+  $ chid install rvm
+
+    For Linux users will install through apt-get
+
+    For OSx users will install through curl
+
+        DESC
+        self.arguments = []
+
 
         def run
           puts "\nInstalling the RVM..."

data/lib/chid/commands/workstation/list.rb

@@ -0,0 +1,27 @@
+module Chid
+  module Commands
+    module Workstation
+      class List < Command
+
+        command :'workstation list'
+
+        self.summary = 'List all existent workstations'
+        self.description = <<-DESC
+
+Usage:
+
+  $ chid workstation list
+
+        DESC
+        self.arguments = []
+
+        def run
+          chid_config = ChidConfig.new
+          puts "Workstations availabbe:".blue
+          puts chid_config.all_workstations.keys
+        end
+
+      end
+    end
+  end
+end

data/lib/chid/commands/workstation/open.rb

@@ -0,0 +1,90 @@
+module Chid
+  module Commands
+    module Workstation
+      class Open < Command
+
+        command :'workstation open'
+
+        self.summary = 'Open a specific named workstation'
+        self.description = <<-DESC
+
+Usage:
+
+  $ chid workstation open
+    or
+  $ chid workstation open -name some_workstation_name
+
+    Open all apps listed in the created workstations.
+
+    To see all workstations you can run
+
+      $ chid workstation list
+
+    If no options are specified, chid will show a list of Workstations created
+    to be selected.
+
+Options:
+
+  -name workstation_name  Open all applications in the 'workstation_name'
+  -n "base two"           Open all applications in the 'base two'
+
+        DESC
+        self.arguments = ['-name', '-n']
+
+        def run
+          workstation_name = workstation_name_from_options
+          workstation_name = select_workstation if workstation_name.empty?
+
+          open_apps(workstation_name)
+        end
+
+        private
+
+        # Returns the workstation name mapped from the values of the options attribute.
+        # Will remove all nil values and join the array of values into String
+        #
+        # @return [String] Mapped values from options attribute
+        #                  If the options does not exist, will return empty String #=> ""
+        #
+        # @example Workstation Name
+        #   options = {'-name' => ['base', 'two']}
+        #
+        #   workstation_name #=> 'base two'
+        #
+        def workstation_name_from_options
+          @workstation_name ||= self.class.arguments.map { |a| options[a] }.compact.join(' ')
+        end
+
+        def chid_config
+          ::Chid.chid_config
+        end
+
+        def workstations
+          @workstations ||= chid_config.all_workstations
+        end
+
+        def select_workstation
+          prompt  = TTY::Prompt.new
+          choices = workstations.keys
+          selected_workstation = prompt.select('Choose a workstation to open', choices)
+          selected_workstation
+        end
+
+        def open_apps(workstation_name)
+          puts "\nOpening all Apps"
+          apps = workstations[workstation_name.to_sym]
+          apps.each do |app_name|
+            chid_config.on_osx do
+              system("open -a #{app_name}")
+            end
+
+            chid_config.on_linux do
+              system("#{app_name} >/dev/null 2>&1 &")
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/chid/version.rb

@@ -1,3 +1,3 @@
 module Chid
-  VERSION = "0.1.4-beta"
+  VERSION = "0.1.4"
 end

data/spec/lib/chid/command_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe Chid::Command do
+
+  let(:subject_class) { Chid::Command }
+
+  describe '.run' do
+
+    context 'When no pass any command' do
+      let(:argv) { options }
+
+      let(:setup_allows) { allow(subject_class).to receive(:help) }
+
+      before do
+        setup_allows
+        Chid::Command.run(argv)
+      end
+
+      context 'When pass :helper option' do
+        let(:options) { ['-h'] }
+
+        it 'Should call :help method' do
+          expect(subject_class).to have_received(:help)
+        end
+      end
+
+      context 'When pass invalid option' do
+        let(:options) { ['-invalid_option'] }
+
+        it 'Should call :help method' do
+          expect(subject_class).to have_received(:help)
+          end
+      end
+
+    end
+
+    context 'When pass an invalid command' do
+      let(:command) { 'invalid_command' }
+      let(:options) { [] }
+      let(:argv) { [command].concat(options) }
+
+      let(:setup_allows) { allow(subject_class).to receive(:help) }
+
+      before do
+        setup_allows
+        Chid::Command.run(argv)
+      end
+
+      it 'Should call :help method' do
+        expect(subject_class).to have_received(:help)
+      end
+    end
+
+    context 'When pass a valid command' do
+      let(:init_command_class) { double arguments: [] }
+      let(:init_command)       { double class: init_command_class }
+
+      let(:command) { ['init'] }
+      let(:options) { [] }
+      let(:argv) { command.concat(options) }
+
+      let(:default_allows) do
+        allow(subject_class).to receive(:command_key_is_included?).and_return(true)
+        allow(subject_class).to receive(:new_command_instance).and_return(init_command)
+      end
+
+      let(:setup_allows) { allow(init_command_class).to receive(:help) }
+
+      before do
+        default_allows
+        setup_allows
+        Chid::Command.run(argv)
+      end
+
+      context 'When is a single command' do
+
+        let(:setup_allows) { allow(init_command).to receive(:run) }
+
+        it 'Command key should be :init' do
+          expect(subject_class).to have_received(:command_key_is_included?).with(:init)
+        end
+      end
+
+      context 'When is a compost command' do
+        let(:command) { ['init', 'chid']  }
+
+        let(:setup_allows) { allow(init_command).to receive(:run) }
+
+        it 'Command key should be :"init chid"' do
+          expect(subject_class).to have_received(:command_key_is_included?).with(:'init chid')
+        end
+      end
+
+      # @TODO: Extract that context to shared examples
+      context 'When pass :help options' do
+        let(:options) { ['-h'] }
+
+        it 'Command should call :help method' do
+          expect(init_command_class).to have_received(:help)
+        end
+      end
+
+      context 'When pass invalid options' do
+        let(:options) { ['-ah', 'some', 'value'] }
+
+        it 'Should call :help method' do
+          expect(init_command_class).to have_received(:help)
+        end
+      end
+
+      context 'When pass valid options' do
+        let(:options) { ['-some_valid_option', 'some', 'value'] }
+
+        let(:setup_allows) do
+          allow(init_command).to receive(:run)
+          allow(subject_class).to receive(:has_valid_arguments?).and_return(true)
+        end
+
+        it 'Command should call :new method with :options' do
+          expected_options = {
+            '-some_valid_option' => ['some', 'value']
+          }
+          expect(subject_class).to have_received(:new_command_instance).with(:init, expected_options)
+        end
+
+        it 'Command should call :run method' do
+          expect(init_command).to have_received(:run)
+        end
+
+      end
+
+      context 'When no pass any options' do
+        let(:options) { [] }
+
+        let(:setup_allows) do
+          allow(init_command).to receive(:run)
+          allow(subject_class).to receive(:has_valid_arguments?).and_return(false)
+        end
+
+        it 'Command should call :new method with :options' do
+          expected_options = {}
+          expect(subject_class).to have_received(:new_command_instance).with(:init, expected_options)
+        end
+
+        it 'Command should call :run method' do
+          expect(init_command).to have_received(:run)
+        end
+
+      end
+
+    end
+  end
+end

data/spec/lib/chid/commands/init_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Chid::Commands::Init do
+
+  let(:argv) { {} }
+  subject { Chid::Commands::Init.new(argv) }
+
+  # @TODO: Extract for a shared context test
+  describe 'Documentations classes attributes' do
+    it('summary should not be nil') { expect(subject.class.summary).not_to be_nil }
+    it('description should not be nil') { expect(subject.class.description).not_to be_nil }
+    it('arguments should be empty') { expect(subject.class.arguments).to be_empty }
+  end
+
+  describe '#run' do
+    let(:chid_config_path)            { File.join(File.dirname(__FILE__), '.chid.config') }
+    let(:file_content_configurations) { YAML.load_file(chid_config_path) }
+
+    let(:default_allows) do
+      allow(subject).to receive(:chid_config_path).and_return(chid_config_path)
+    end
+
+    let(:setup) {}
+
+    before do
+      default_allows
+      setup
+      subject.run
+    end
+
+    after do
+      File.delete(chid_config_path) if File.exist?(chid_config_path)
+    end
+
+    context 'When does not exist .chid.config file' do
+      let(:base_configuration) do
+        {
+          chid: {
+            workstations: {}
+          }
+        }
+      end
+
+      it 'Should contains the base configuration' do
+        expect(file_content_configurations).to eq base_configuration
+      end
+    end
+
+    context 'When does exist .chid.config file with some configuration' do
+      let(:existent_configurations) do
+        {
+          chid: {
+            workstations: {
+              base: 'vim'
+            }
+          }
+        }
+      end
+
+      let(:setup) do
+        File.open(chid_config_path, 'w') do |file|
+          YAML.dump(existent_configurations, file)
+        end
+      end
+
+      it 'Should remains the existent configuration' do
+        expect(file_content_configurations).to eq existent_configurations
+      end
+    end
+
+  end
+
+end

data/spec/lib/chid/commands/workstation/open_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Chid::Commands::Workstation::Open, tt:true do
+
+  subject { Chid::Commands::Workstation::Open.new(options) }
+
+  describe '#run' do
+    let(:options) { {} }
+    let(:setup) {  }
+
+    before do
+      allow(subject).to receive(:open_apps)
+
+      setup
+      subject.run
+    end
+
+    context 'when no pass any argument' do
+      let(:expected_workstation_name) { 'none' }
+
+      let(:setup) do
+        allow(subject).to receive(:select_workstation).and_return expected_workstation_name
+      end
+
+      it 'should call :select_workstation method' do
+        expect(subject).to have_received(:select_workstation).once
+      end
+
+      it 'should call :open_apps method' do
+        expect(subject).to have_received(:open_apps).with(expected_workstation_name).once
+      end
+
+    end
+
+    context 'when pass -name as argument' do
+      let(:options) { {'-name' => ['base', 'two']} }
+      let(:expected_workstation_name) { 'base two' }
+
+      let(:setup) do
+
+      end
+
+      it 'should call :open_apps method' do
+        expect(subject).to have_received(:open_apps).with(expected_workstation_name).once
+      end
+
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'chid'
+
+RSpec.configure do |config|
+
+end

data/tasks/tmux/config_windows.rake

@@ -1,21 +1,8 @@
 desc 'Configure default windows for development'
-task :tmux_config, [:name] do |t, args|
-  name = args.fetch(:name, 'development')
-  if name == 'development'
-    system("tmux rename-window bash")
-    system("tmux new-window -n app")
-    system("tmux new-window -n server")
-  elsif name == 'stant-api'
-    system("tmux rename-window app")
-    system("tmux new-window -n tests")
-    system("tmux new-window -n server")
-    system("tmux new-window -n bash")
-  elsif name == 'stant-traceability'
-    system("tmux rename-window ios-traceability")
-    system("tmux new-window -n ios-infrastructure")
-    system("tmux new-window -n ios-core")
-    system("tmux new-window -n bash")
-  end
+task :tmux_config do
+  system("tmux rename-window bash")
+  system("tmux new-window -n app")
+  system("tmux new-window -n server")
 end
 
 

data/tasks/tmux/new_session.rake

@@ -1,9 +1,8 @@
 desc 'Open or Create the new session for development key'
-task :tmux, [:name] do |t, args|
-  name = args.fetch(:name, 'development')
-  session = system("tmux attach -t #{name}")
+task :tmux do
+  session = system('tmux attach -t development')
   unless session
-    system("tmux new -s #{name}")
+    system('tmux new -s development')
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chid
 version: !ruby/object:Gem::Version
-  version: 0.1.4.pre.beta
+  version: 0.1.4
 platform: ruby
 authors:
 - Rachid Calazans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-17 00:00:00.000000000 Z
+date: 2017-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -100,11 +114,16 @@ files:
 - etc/img/stack.png
 - lib/chid.rb
 - lib/chid/chid_config.rb
+- lib/chid/command.rb
+- lib/chid/commands/gitflow/commit.rb
+- lib/chid/commands/init.rb
 - lib/chid/commands/install.rb
 - lib/chid/commands/installs/dotfile.rb
 - lib/chid/commands/installs/node.rb
 - lib/chid/commands/installs/postgres.rb
 - lib/chid/commands/installs/rvm.rb
+- lib/chid/commands/workstation/list.rb
+- lib/chid/commands/workstation/open.rb
 - lib/chid/currency_api.rb
 - lib/chid/github_api.rb
 - lib/chid/main.rb
@@ -113,6 +132,10 @@ files:
 - lib/chid/stack_overflow_api.rb
 - lib/chid/version.rb
 - lib/chid/yandex_translate_api.rb
+- spec/lib/chid/command_spec.rb
+- spec/lib/chid/commands/init_spec.rb
+- spec/lib/chid/commands/workstation/open_spec.rb
+- spec/spec_helper.rb
 - tasks/chid/config.rake
 - tasks/chid/init.rake
 - tasks/chid/install.rake
@@ -155,9 +178,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.6.6