mite.cmd 0.1.10

data/lib/mite_cmd/autocomplete.rb

@@ -0,0 +1,48 @@
+require 'shellwords'
+
+module MiteCmd
+  class Autocomplete
+    include Shellwords
+    
+    attr_accessor :completion_table
+    attr_reader :calling_script
+    
+    def initialize(calling_script)
+      @calling_script = calling_script
+    end
+    
+    def bash_line
+      ENV['COMP_LINE'].to_s
+    end
+  
+    def argument_string
+      bash_line.sub(/^(.*)#{File.basename calling_script}\s*/, '').close_unmatched_quotes
+    end
+  
+    def partial_argument_string
+      bash_line[0..cursor_position+1].sub(/^(.*)#{File.basename calling_script}\s*/, '').close_unmatched_quotes
+    end
+  
+    def current_word
+      return nil if argument_string =~ /\s$/ && bash_line.length == cursor_position
+      shellwords(partial_argument_string).last
+    end
+  
+    def current_argument_index
+      return args.size if argument_string =~ /\s$/ && bash_line.length == cursor_position
+      args.index(current_word) || 0
+    end
+  
+    def cursor_position
+      ENV['COMP_POINT'].to_i
+    end
+  
+    def args
+      shellwords(argument_string)
+    end
+  
+    def suggestions
+      completion_table[current_argument_index] ? completion_table[current_argument_index].select {|s| s =~ /^#{current_word}/i} : []
+    end
+  end
+end

data/lib/mite_ext.rb

@@ -0,0 +1,53 @@
+Mite.class_eval do
+  def self.account_url
+    host_format % [protocol, domain_format % account, (port.blank? ? '' : ":#{port}")]
+  end
+end
+
+Mite::TimeEntry.class_eval do
+  # I need the full class path, otherwise there will be LoadErrors
+  def service
+    @service ||= Mite::Service.find(service_id) unless service_id.blank?
+  end
+  
+  # I need the full class path, otherwise there will be LoadErrors
+  def project
+    @project ||= Mite::Project.find(project_id) unless project_id.blank?
+  end
+
+  def inspect
+    output = []
+    output << formatted_time.colorize(tracking? ? :lightyellow : :lightred)
+    output << formatted_revenue.colorize(:lightgreen) if revenue
+    output << "\tdoing #{service.name}" if service
+    output << "\tfor #{project.name}" if project
+    output << "\n\t\t|_ #{note}" unless note.blank?
+    output.join(' ')
+  end
+  
+  def formatted_revenue
+    revenue.nil? ? '' : "%.2f $" % (revenue / 100.0)
+  end
+    
+  def formatted_time
+    minutes = tracking? ? tracker.minutes : self.minutes
+    if minutes > 59
+      h = minutes/60
+      m = minutes-h*60
+      "#{h}:%.2d" % m
+    else
+      "0:%.2d" % minutes
+    end
+  end
+
+end
+
+Mite::Tracker.class_eval do
+  def time_entry
+    @time_entry ||= Mite::TimeEntry.find(id)
+  end
+
+  def inspect
+    time_entry.inspect
+  end
+end

data/lib/string_ext.rb

@@ -0,0 +1,50 @@
+String.class_eval do
+  def quote(q="\"")
+    "#{q}#{self}#{q}"
+  end
+  
+  def quote_if_spaced(q="\"")
+    self =~ /\s/ ? self.quote : self
+  end
+  
+  def close_unmatched_quotes(q="\"")
+    (self.scan(/"/).size % 2) != 0 ? self+q : self
+  end
+  
+  BASH_COLOR = {
+    :black => 30,
+    :red => 31,
+    :green => 32,
+    :yellow => 33,
+    :blue => 34,
+    :magenta => 35,
+    :cyan => 36,
+    :white => 37,
+    :default => 39
+  }
+  BASH_EFFECT = {
+    :none => 0,
+    :bright => 1,
+    :underline => 4,
+    :blink => 5,
+    :exchange => 7,
+    :hidden => 8
+  }
+  def colorize(options={})
+    return '' if self == ''
+    options = {:color => options} if options.is_a?(Symbol)
+    options[:color] = :default unless options[:color]
+    if options[:color] != :default && options[:color].to_s =~ /^(light|bright)/
+      options[:color] = options[:color].to_s.sub(/^(light|bright)/, '').to_sym
+      options[:effect] = :bright 
+    end
+    options[:background] = :default unless options[:background]
+    options[:effect] = :none unless options[:effect]
+    
+    effect_code = "#{BASH_EFFECT[options[:effect]]}"
+    background_code = "#{BASH_COLOR[options[:background]]+10}m"
+    color_code = "#{BASH_COLOR[options[:color]]}"
+    reset_code = "\e[0m"
+    "\e[#{effect_code};#{color_code};#{background_code}#{self}#{reset_code}"
+  end
+end

data/mite.cmd.gemspec

@@ -0,0 +1,75 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{mite.cmd}
+  s.version = "0.1.10"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Lukas Rieder"]
+  s.date = %q{2010-02-11}
+  s.default_executable = %q{mite}
+  s.description = %q{A simple command line interface for mite, a sleek time tracking webapp.}
+  s.email = %q{l.rieder@gmail.com}
+  s.executables = ["mite"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.textile"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.textile",
+     "Rakefile",
+     "TODO",
+     "VERSION",
+     "bin/mite",
+     "lib/mite_cmd.rb",
+     "lib/mite_cmd/application.rb",
+     "lib/mite_cmd/autocomplete.rb",
+     "lib/mite_ext.rb",
+     "lib/string_ext.rb",
+     "mite.cmd.gemspec",
+     "spec/mite_cmd/application_spec.rb",
+     "spec/mite_cmd/autocomplete_spec.rb",
+     "spec/mite_cmd_spec.rb",
+     "spec/mite_ext_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/string_ext_spec.rb",
+     "vendor/yolk-mite-rb-0.0.3/CHANGES.txt",
+     "vendor/yolk-mite-rb-0.0.3/LICENSE",
+     "vendor/yolk-mite-rb-0.0.3/README.textile",
+     "vendor/yolk-mite-rb-0.0.3/Rakefile",
+     "vendor/yolk-mite-rb-0.0.3/VERSION.yml",
+     "vendor/yolk-mite-rb-0.0.3/lib/mite-rb.rb",
+     "vendor/yolk-mite-rb-0.0.3/lib/mite/customer.rb",
+     "vendor/yolk-mite-rb-0.0.3/lib/mite/project.rb",
+     "vendor/yolk-mite-rb-0.0.3/lib/mite/service.rb",
+     "vendor/yolk-mite-rb-0.0.3/lib/mite/time_entry.rb",
+     "vendor/yolk-mite-rb-0.0.3/lib/mite/time_entry_group.rb",
+     "vendor/yolk-mite-rb-0.0.3/lib/mite/tracker.rb",
+     "vendor/yolk-mite-rb-0.0.3/lib/mite/user.rb"
+  ]
+  s.homepage = %q{http://github.com/Overbryd/mite.cmd}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{A simple command line interface for basic mite tasks.}
+  s.test_files = [
+    "spec/mite_cmd/application_spec.rb",
+     "spec/mite_cmd/autocomplete_spec.rb",
+     "spec/mite_cmd_spec.rb",
+     "spec/mite_ext_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/string_ext_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/spec/mite_cmd/application_spec.rb

@@ -0,0 +1,532 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe MiteCmd::Application, 'new' do
+  it "should load the configuration for MiteCmd" do
+    MiteCmd.should_receive(:load_configuration)
+    MiteCmd::Application.new []
+  end
+  
+  it "should not load the configuration if the first argument is 'configure'" do
+    MiteCmd.should_not_receive(:load_configuration)
+    MiteCmd::Application.new ['configure']
+  end
+  
+  it "should set arguments" do
+    MiteCmd.stub!(:load_configuration)
+    MiteCmd::Application.new(['1', '2', '3']).instance_variable_get('@arguments').should == ['1', '2', '3']
+  end
+end
+
+describe MiteCmd::Application, 'run' do
+  before(:each) do
+    MiteCmd.stub!(:load_configuration)
+  end
+  
+  describe 'no argument' do
+    before(:each) do
+      @application = MiteCmd::Application.new []
+      @application.stub!(:say)
+      @application.stub!(:flirt).and_return 'Your beautiful eyes touch my heart.'
+    end
+        
+    it "should tell the inspection of the current tracker if there is one" do    
+      tracker = stub('tracker', :inspect => 'I am the inspection of this tracker')
+      Mite::Tracker.stub!(:current).and_return tracker
+      @application.should_receive(:tell).with 'I am the inspection of this tracker'
+      @application.run
+    end
+    
+    it "should tell something romantic if there is no current tracker" do
+      Mite::Tracker.stub!(:current).and_return nil
+      @application.should_receive(:tell).with 'Your beautiful eyes touch my heart.'
+      @application.run
+    end
+  end
+  
+  describe 'the open argument' do
+    it "should try to open the account url or at least echo it" do
+      Mite.stub!(:account_url).and_return 'http://demo.mite.yo.lk'
+      application = MiteCmd::Application.new ['open']
+      application.should_receive(:exec).with "open 'http://demo.mite.yo.lk' || echo 'http://demo.mite.yo.lk'"
+      application.run
+    end
+  end
+  
+  describe 'the help argument' do
+    it "should try to open the github repository of mighty mite or at least echo it" do
+      application = MiteCmd::Application.new ['help']
+      application.should_receive(:exec).with "open 'http://github.com/Overbryd/mite.cmd' || echo 'http://github.com/Overbryd/mite.cmd'"
+      application.run
+    end
+  end
+  
+  describe 'the configure argument' do
+    before(:each) do
+      @application = MiteCmd::Application.new ['configure', 'demo', '123']
+      @application.stub!(:tell)
+      File.stub!(:chmod)
+    end
+    
+    it "should generate a yaml formatted file in ~/.mite.yml with the account and the apikey" do
+      File.stub!(:expand_path).and_return '/tmp/.mite.yml'
+      File.should_receive(:open).with('/tmp/.mite.yml', 'w').and_yield :file_handle
+      YAML.should_receive(:dump).with({:account => 'demo', :apikey => '123'}, :file_handle)
+      @application.run
+    end
+    
+    it "should tell something nice if the bash completion setup fails" do
+      @application.stub!(:try_to_setup_bash_completion).and_return false
+      @application.should_receive(:tell).with "Couldn't set up bash completion. I'm terribly frustrated. Maybe 'mite help' helps out."
+      
+      File.stub!(:open) # prevents the yml file to be written
+      @application.run
+    end
+    
+    it "should not tell something nice if bash completion is already set up or was ok" do
+      @application.stub!(:try_to_setup_bash_completion).and_return true
+      @application.should_not_receive(:tell)
+      
+      File.stub!(:open) # prevents the yml file to be written
+      @application.run      
+    end
+    
+    it "should chmod the configuration file to 0600" do
+      File.stub!(:expand_path).and_return '/tmp/.mite.yml'
+      File.stub!(:file?).and_return true
+      File.should_receive(:chmod).with(0600, '/tmp/.mite.yml')
+      @application.run
+    end
+        
+    describe 'and setup bash completion' do
+      it "should append the bash completion call for mite to ~/.bash_completion if it is a regular file and exists and return true" do
+        File.stub!(:expand_path).and_return '/tmp/.bash_completion'
+        File.should_receive(:file?).with('/tmp/.bash_completion').and_return true
+        file_handle = stub('file_handle')
+        File.should_receive(:open).with('/tmp/.bash_completion', 'a').and_yield file_handle
+        file_handle.should_receive(:puts).with("\n\ncomplete -C \"mite auto-complete\" mite")
+        
+        File.stub!(:read).and_return ''
+        @application.send(:try_to_setup_bash_completion).should == true
+      end
+      
+      it "should try '~/.bash_completion', '~/.bash_profile', '~/.bash_login', '~/.bashrc'" do
+        files = ['~/.bash_completion', '~/.bash_profile', '~/.bash_login', '~/.bashrc']
+        files_regexp = files.map {|f| Regexp.escape(f)}.join('|')
+        File.should_receive(:expand_path).with(
+          Regexp.new(files_regexp)
+        ).exactly(files.size).times
+        
+        File.stub!(:file?).and_return false
+        @application.send :try_to_setup_bash_completion
+      end
+      
+      it "should not open a file handle if the file does not exist" do
+        File.stub!(:file?).and_return false
+        File.should_not_receive(:open)
+        @application.send :try_to_setup_bash_completion
+      end
+      
+      it "should not append the bash completion call twice" do
+        File.stub!(:read).and_return "\n\ncomplete -C \"mite auto-complete\" mite"
+        File.should_not_receive(:open)
+        @application.send :try_to_setup_bash_completion
+      end
+      
+      it "should return false if the bash completion could not be set up" do
+        File.stub!(:file?).and_return false
+        @application.send(:try_to_setup_bash_completion).should == false
+      end      
+    end
+    
+    it "should raise an error if one of the last two arguments is missing" do
+      application = MiteCmd::Application.new ['configure', 'faildemo']
+      lambda {
+        application.run
+      }.should raise_error(MiteCmd::Exception)
+    end
+  end
+  
+  describe 'the auto-complete argument' do
+    before(:each) do
+      @application = MiteCmd::Application.new ['auto-complete']
+      @application.stub!(:tell)
+      
+      @autocomplete = stub('autocomplete', :completion_table => {}, :completion_table= => nil, :suggestions => [])
+      MiteCmd::Autocomplete.stub!(:new).and_return @autocomplete
+    end
+    
+    it "should create a new instance of MiteCmd::Autocomplete setting the calling_script" do
+      MiteCmd.stub!(:calling_script).and_return '/usr/local/bin/mite'
+      MiteCmd::Autocomplete.should_receive(:new).with '/usr/local/bin/mite'
+      @application.run
+    end
+
+    it "should unmarshal the cached completion table from ~/.mite.cache if it exists" do
+      File.stub!(:exist?).and_return true
+      File.should_receive(:read).and_return :marshal_data
+      Marshal.should_receive(:load).and_return :cached_completion_table
+      @autocomplete.should_receive(:completion_table=).with :cached_completion_table
+      @autocomplete.stub!(:suggestions).and_return []
+      @application.run
+    end
+    
+    it "should tell each suggestion from MiteCmd::Autocomplete" do
+      File.stub!(:exist?).and_return true
+      File.stub!(:read)
+      Marshal.stub!(:load)
+      @autocomplete.stub!(:suggestions).and_return ['Heinz', 'Peter']
+      @application.should_receive(:tell).with(/Heinz|Peter/).exactly(2).times
+      @application.run
+    end
+    
+    it "should wrap suggestions inside quotes if they are spaced" do
+      File.stub!(:exist?).and_return true
+      File.stub!(:read)
+      Marshal.stub!(:load)
+      @autocomplete.stub!(:suggestions).and_return ['I need quotes', 'MeNot']
+      @application.should_receive(:tell).with(/"I need quotes"|MeNot/).exactly(2).times
+      @application.run
+    end
+
+    shared_examples_for 'an uncached completion table' do
+      before(:each) do
+        File.stub!(:exist?).and_return false
+        
+        Mite::Project.stub!(:all).and_return [stub('project', :name => 'Demo Project')]
+        Mite::Service.stub!(:all).and_return [stub('service', :name => 'late night programming')]
+        Mite::TimeEntry.stub!(:all).and_return [stub('time entry', :note => 'shit 02:13 is really late')]
+        
+        File.stub!(:open)
+        File.stub!(:chmod)
+        Marshal.stub!(:dump)
+        
+        @completion_table = {
+          0 => ['Demo Project'],
+          1 => ['late night programming'],
+          2 => ['"0:05"', '"0:05+"', '"0:15"', '"0:15+"', '"0:30"', '"0:30+"', '"1:00"', '"1:00+"'],
+          3 => ['shit 02:13 is really late']
+        }
+      end
+
+      it "should create a new completion table" do
+        @application.send(:rebuild_completion_table).should == @completion_table
+      end
+
+      it "should save the new completion table to ~/.mite.cache" do
+        File.stub!(:expand_path).and_return '/tmp/.mite.cache'
+        File.should_receive(:open).with('/tmp/.mite.cache', 'w').and_yield :file_handle
+        Marshal.should_receive(:dump).with(@completion_table, :file_handle)
+        @application.run
+      end
+    end
+    
+    describe 'and the completion table is not cached' do
+      it_should_behave_like 'an uncached completion table'
+    end
+    
+  end
+
+  describe 'the rebuild-cache argument' do
+    before(:each) do
+      @application = MiteCmd::Application.new ['rebuild-cache']
+      @application.stub!(:tell)
+      File.stub!(:delete)
+      File.stub!(:chmod)
+    end
+    
+    it "should delete the file at ~/.mite.cache if it exists" do
+      File.stub!(:exist?).and_return true
+      File.stub!(:expand_path).and_return '/tmp/.mite.cache'
+      File.should_receive(:delete).with '/tmp/.mite.cache'
+      @application.run
+    end
+    
+    it "should not call delete on File if ~/.mite.cache does not exist" do
+      File.stub!(:exist?).and_return false
+      File.should_not_receive(:delete)
+      @application.run
+    end
+    
+    it "should tell something nice if the cache has been rebuild" do
+      @application.should_receive(:tell).with 'The rebuilding of the cache has been done, Master. Your wish is my command.'
+      @application.run
+    end
+    
+    it "should chmod the cache file to 0600" do
+      File.stub!(:expand_path).and_return '/tmp/.mite.cache'
+      File.stub!(:exist?).and_return true
+      File.should_receive(:chmod).with(0600, '/tmp/.mite.cache')
+      @application.run
+    end
+    
+    it_should_behave_like 'an uncached completion table'
+  end
+  
+  describe 'the simple report argument' do
+    shared_examples_for 'a simple report' do
+      before(:each) do
+        @application = MiteCmd::Application.new [@argument]
+        @application.stub!(:tell)
+
+        @time_entry = stub('time_entry', :inspect => 'I am a time entry.', :revenue => 1200, :minutes => 120)
+        @time_entry_with_nil_revenue = stub('time_entry_without_revenue', :inspect => 'I am a time entry.', :revenue => nil, :minutes => 18)
+        @time_entry_with_nil_revenue.stub!(:revenue).and_return nil
+        Mite::TimeEntry.stub!(:all).and_return [@time_entry, @time_entry, @time_entry_with_nil_revenue]
+      end
+
+      it "should tell an inspection of each time entry" do
+        Mite::TimeEntry.should_receive(:all).with(:params => hash_including(:at => @argument))
+        @time_entry.should_receive(:inspect).exactly(2).times
+        @time_entry_with_nil_revenue.should_receive(:inspect).at_least(:once)
+        @application.should_receive(:tell).with('I am a time entry.').exactly(3).times
+        @application.run
+      end
+      
+      it "should only output the time entries of the current user" do
+        Mite::TimeEntry.should_receive(:all).with(:params => hash_including(:user_id => 'current'))
+        @application.run
+      end
+      
+      it "should tell #{@argument}'s revenue, nicely formatted and colorized in lightgreen" do
+        @application.should_receive(:tell).with(/#{Regexp.escape "\e[1;32;49m24.00 $\e[0m"}/).at_least(:once)
+        @application.run
+      end
+      
+      it "should tell #{@argument}'s total time, nicely formatted and colorized in red" do
+        @application.should_receive(:tell).with(/#{Regexp.escape "\e[1;31;49m4:18\e[0m"}/).at_least(:once)
+        @application.run
+      end
+    end
+    
+    ['today', 'yesterday', 'this_week', 'last_week', 'this_month', 'last_month'].each do |argument|
+      describe argument do
+        before(:each) { @argument = argument }
+        it_should_behave_like 'a simple report'
+      end
+    end
+  end
+  
+  describe 'the stop argument' do
+    before(:each) do
+      @application = MiteCmd::Application.new ['stop']
+      @application.stub!(:tell)
+      
+      time_entry = stub('time_entry', :inspect => 'hey there.')
+      @current_tracker = stub('tracker', :time_entry => time_entry)
+      @current_tracker.stub!(:stop).and_return @current_tracker
+      Mite::Tracker.stub!(:current).and_return @current_tracker
+    end
+    
+    it "should call stop on the current tracker" do
+      @current_tracker.should_receive :stop
+      @application.run
+    end
+    
+    it "should do nothing if there is no current tracker" do
+      Mite::Tracker.stub!(:current).and_return nil
+      @application.run
+    end
+    
+    it "should tell the inspection of the tracker's time entry if it has been stopped" do
+      @application.should_receive(:tell).with 'hey there.'
+      @application.run
+    end
+  end
+
+  describe 'the start argument' do
+    before(:each) do
+      @application = MiteCmd::Application.new ['start']
+      @application.stub!(:tell)
+      
+      @time_entry = stub('time_entry', :start_tracker => nil, :inspect => 'I was started.')
+      Mite::TimeEntry.stub!(:first).and_return @time_entry
+    end
+  
+    it "should call start_tracker on the last time entry of today" do
+      # last time entry by time = first by list order
+      Mite::TimeEntry.should_receive(:first).with(:params => {:at => 'today'})
+      @time_entry.should_receive(:start_tracker)
+      @application.run
+    end
+    
+    it "should tell an inspection of the last time entry if it has been started" do
+      @application.should_receive(:tell).with 'I was started.'
+      @application.run
+    end
+    
+    it "should tell something nice if there is no time entry to start" do
+      Mite::TimeEntry.stub!(:first).and_return nil
+      @application.should_receive(:tell).with "Oh my dear! I tried hard, but I could'nt find any time entry for today."
+      @application.run
+    end
+  end
+
+end
+
+describe MiteCmd::Application, 'dynamic time entry creation' do
+  before(:each) do
+    MiteCmd.stub!(:load_configuration)
+    
+    @time_entry = stub('time_entry', :start_tracker => nil, :inspect => '')
+    Mite::TimeEntry.stub!(:create).and_return @time_entry
+    Mite::Project.stub! :first
+    Mite::Project.stub! :create
+    Mite::Service.stub! :first
+    Mite::Service.stub! :create
+  end
+  
+  def new_application(args=[])
+    application = MiteCmd::Application.new args
+    application.stub!(:tell)
+    application
+  end
+  
+  it "should tell an inspection of the time entry" do
+    @time_entry.stub!(:inspect).and_return 'My name is entry, time entry.'
+    application = new_application(['Project', 'Service', 'Note'])
+    application.should_receive(:tell).with 'My name is entry, time entry.'
+    application.run
+  end
+  
+  describe 'the + argument' do
+    it "should create and start a new time entry" do
+      time_entry = stub('time_entry')
+      Mite::TimeEntry.should_receive(:create).with(:minutes => 0).and_return time_entry
+      time_entry.should_receive :start_tracker
+      new_application(['+']).run
+    end
+  end
+  
+  describe 'with a time given' do
+    it "should parse minutes as integer out of h:mm(+)?" do
+      new_application.send(:parse_minutes, '1:18').should == 78
+      new_application.send(:parse_minutes, '72:00').should == 4320
+      new_application.send(:parse_minutes, '0:01+').should == 1
+    end
+    
+    it "should parse minutes as integer out of h(:)?(+)?" do
+      new_application.send(:parse_minutes, '3').should == 180
+      new_application.send(:parse_minutes, '2:').should == 120
+      new_application.send(:parse_minutes, '1.5').should == 90
+      new_application.send(:parse_minutes, '2.5+').should == 150
+      new_application.send(:parse_minutes, '5:').should == 300
+      new_application.send(:parse_minutes, '1:+').should == 60
+      new_application.send(:parse_minutes, '0.5:').should == 30
+    end
+    
+    it "should parse minutes as 0 out of +" do
+      new_application.send(:parse_minutes, '+').should == 0
+    end
+    
+    it "should add the parsed minutes to the attributes" do
+      Mite::TimeEntry.should_receive(:create).with hash_including(:minutes => 78)
+      new_application(['ARG1', 'ARG2', '1:18', 'ARG4']).run
+    end
+    
+    it "should start the tracker for the time entry if the attributes is suffixed with '+'" do
+      @time_entry.should_receive(:start_tracker)
+      new_application(['ARG1', 'ARG2', '1:18+', 'ARG4']).run
+    end
+  end
+  
+  describe 'with a project name given' do
+    before(:each) do
+      @project = stub('project', :id => 1)
+      Mite::Project.stub!(:first).and_return @project
+    end
+    
+    it "should try if the first argument is an existing project" do
+      Mite::Project.should_receive(:first).with(:params => {:name => 'Project No1'})
+      new_application(['Project No1']).run
+    end
+    
+    it "should add the project id to the attributes if a project was found" do
+      Mite::TimeEntry.should_receive(:create).with hash_including(:project_id => 1)
+      new_application(['Project No1']).run
+    end
+    
+    it "should create a new project unless a project was found" do
+      Mite::Project.stub!(:first).and_return nil
+      @project.stub!(:id).and_return 1234
+      Mite::Project.should_receive(:create).with(:name => 'I do not exist').and_return @project
+      new_application(['I do not exist']).run
+    end
+    
+    it "should not create a new project if the first argument is a time argument" do
+      Mite::Project.stub!(:first).and_return nil
+      Mite::Project.should_not_receive(:create)
+      new_application(['1:11+']).run
+    end
+  end
+  
+  describe "with a service name given" do
+    before(:each) do
+      @service = stub('service', :id => 2)
+      Mite::Service.stub!(:first).and_return @service
+    end
+    
+    it "should try if the second argument is an existing service" do
+      Mite::Service.should_receive(:first).with(:params => {:name => 'Carwashing'})
+      new_application(['1', 'Carwashing']).run
+    end
+    
+    it "should add the service id to the attributes if a service was found" do
+      Mite::TimeEntry.should_receive(:create).with hash_including(:service_id => 2)
+      new_application(['1', 'Read a book']).run
+    end
+    
+    it "should create a new service unless a service was found" do
+      Mite::Service.stub!(:first).and_return nil
+      @service.stub!(:id).and_return 15
+      Mite::Service.should_receive(:create).with(:name => 'I do not exist yet').and_return @service
+      new_application(['1', 'I do not exist yet']).run
+    end
+    
+    it "should not create a new service if the second argument is a time argument" do
+      Mite::Service.stub!(:first).and_return nil
+      Mite::Service.should_not_receive(:create)
+      new_application(['1', '0:18']).run
+    end
+    
+    it "should do nothing on services if there is no second argument" do
+      application = new_application(['1'])
+      application.should_not_receive :find_or_create_service
+      application.run
+    end
+  end
+  
+  describe "with a note given" do
+    it "should parse the note out of the arguments" do
+      new_application.send(:parse_note, ['0:12', 'gnarr gnarr'], '0:12').should == 'gnarr gnarr'
+      new_application.send(:parse_note, ['1', '1:30+', 'bla bla'], '1:30+').should == 'bla bla'
+      new_application.send(:parse_note, ['Project', 'Service', 'NOTE!'], nil).should == 'NOTE!'
+    end
+    
+    it "should add the note to the attributes if the fourth argument is given" do
+      Mite::TimeEntry.should_receive(:create).with hash_including(:note => 'Reminder')
+      new_application(['ARG1', 'ARG2', '3+', 'Reminder']).run
+    end
+    
+    it "should add the note to the attributes if it is third argument and no time is given" do
+      Mite::TimeEntry.should_receive(:create).with hash_including(:note => 'bla bla')
+      new_application(['ARG1', 'ARG2', 'bla bla']).run
+    end
+    
+    it "should add the note to the attributes if a time argument is followed by a note" do
+      Mite::TimeEntry.should_receive(:create).with hash_including(:note => 'gnarr gnarr')
+      new_application(['1:02', 'gnarr gnarr']).run
+      Mite::TimeEntry.should_receive(:create).with hash_including(:note => 'glubb glubb')
+      new_application(['ARG1', '3:04', 'glubb glubb']).run
+    end
+  end
+end
+
+describe MiteCmd::Application, 'flirt' do
+  before(:each) do
+    MiteCmd.stub!(:load_configuration)
+  end
+  
+  it "should return a random flirt as string" do
+    MiteCmd::Application.new.flirt.should be_kind_of(String)
+  end
+end