slimtimercli 0.1.2 → 0.1.3

data/History.txt

@@ -1,3 +1,7 @@
+== 0.1.3 2008-04-07
+* fixed bug that allows starting a nonexisting task
+* refactored options to start slimtimer
+
 == 0.1.2 2008-04-06
 * time recording can only be stopped if a task was started
 * time recording can only be started if no other task was started

data/bin/slimtimer

@@ -4,9 +4,7 @@ require 'rubygems'
 gem 'slimtimercli'
 require 'slimtimercli'
 
-# Run
-if ARGV.size == 0
-  Slimtimercli.__send__(:help)  
-else
-  Slimtimercli.__send__(ARGV[0].to_sym)  
-end
+include Slimtimercli
+
+c = CommandLine.new(ARGV)
+c.run

data/lib/slimtimercli.rb

@@ -6,7 +6,9 @@ require 'net/http'
 require 'rubygems'
 require 'active_record'
 require 'active_support'
-require 'yaml'    
+require 'yaml'             
+require 'optparse'
+require 'ostruct'
 
 require "slimtimercli/entities"
 require "slimtimercli/slim_timer"
@@ -14,7 +16,7 @@ require "slimtimercli/version"
 
 module Slimtimercli
   module Helper
-    def self.login
+    def login
       config = Helper::load_config
       st = SlimTimer.new(config["email"], config["password"],
         config["api_key"])
@@ -23,23 +25,23 @@ module Slimtimercli
       st  
     end
 
-    def self.root
+    def root
       File.join(ENV["HOME"], ".slimtimer")
     end
 
-    def self.config_file
+    def config_file
       File.join(root, "config.yml")
     end
 
-    def self.tasks_file
+    def tasks_file
       File.join(root, "tasks.yml")
     end
 
-    def self.current_file
+    def current_file
       File.join(root, "current.yml")
     end
 
-    def self.check_and_create_dir
+    def check_and_create_dir
       raise "Home DIR not set!" unless ENV["HOME"]
 
       unless File.directory?(root)
@@ -47,7 +49,7 @@ module Slimtimercli
       end
     end
 
-    def self.load_config
+    def load_config
       check_and_create_dir
 
       unless File.exists?(File.join(root, "config.yml"))
@@ -58,89 +60,76 @@ module Slimtimercli
       load_file("config.yml")
     end
 
-    def self.save_config(config)
+    def save_config(config)
       dump_to_file(config, "config.yml")
     end
 
-    def self.load_file(file)
+    def load_file(file)
       File.open( File.join(root, file) ) { |yf| YAML::load( yf ) }
     end
 
-    def self.dump_to_file(object, file)
+    def dump_to_file(object, file)
       check_and_create_dir
       File.open( File.join(root, file), 'w' ) do |out|
         YAML.dump(object, out )
       end
     end
-  end
-    
-  def self.create_task
-    name = ARGV[1]
-
-    st = Helper::login
-    if st.create_task(name)                    
-      Helper::dump_to_file(st.tasks, "tasks.yml")
-      puts "Task #{name} successfully created."
-    end            
-  end
-
-  def self.tasks(show= true)
-    config = Helper::load_config
-    st = SlimTimer.new(config["email"], config["password"],
-      config["api_key"])
-
-    if !File.exists?(Helper::tasks_file) ||
-       File.mtime(Helper::tasks_file) < (Time.now - 60 * 60 *24)
-
-      st.login
-      Helper::dump_to_file(st.tasks, "tasks.yml")
-    end
 
-    tasks = Helper::load_file("tasks.yml")
-
-    return tasks unless show
-
-    tasks.each do |t|
-      puts t.name
-    end
-  end
-
-  def self.force_reload
-    config = Helper::load_config
-    st = SlimTimer.new(config["email"], config["password"],
-      config["api_key"])
-
-    st.login
-    Helper::dump_to_file(st.tasks, "tasks.yml")
-    tasks = Helper::load_file("tasks.yml")
-
-    tasks.each do |t|
-      puts t.name
+    def rm_current
+      FileUtils.rm(current_file) if
+        File.exists?(current_file)
     end
-  end
 
-  # This method stores the credentials in the necessary directoyr
-  def self.setup
-    config = Helper::load_config
-
-    puts "Slimtimer Login Credentials\n"
-    print "E-Mail: "
-    config["email"] = STDIN.gets.gsub("\n", "")
-
-    print "Password: "
-    config["password"] = STDIN.gets.gsub("\n", "")
-
-    print "API Key: "
-    config["api_key"] = STDIN.gets.gsub("\n", "")
-
-    Helper::save_config(config)
-
-    # clear the screen
-    system("clear")
-  end
-
-  def self.help
-    puts <<-HELP
+    def parse(args)  
+      
+      if !args || args.empty?
+        raise "Need to specify arguments, run slimtimer -h for help"
+        
+      end
+      
+      options = OpenStruct.new
+      options.force = false
+      
+      opts = OptionParser.new do |opts|
+        
+        opts.banner = "Usage: slimtimer [options]"
+        
+        opts.on("-s TASK", "--start TASK", 
+          "Start a TASK given by the task name") do |t|
+            
+          options.run = "start"
+          options.task_name = t
+        end 
+        
+        opts.on("-c TASK", "--create TASK", 
+          "Create a ne task by the given name") do |t|
+          options.run = "create"
+          options.task_name = t
+        end
+        
+        opts.on("-e", "--end" ,"Stops time recording for the given task") do
+          options.run = "stop"
+        end       
+        
+        opts.on("-t", "--tasks", "Prints all available tasks") do
+          options.run = "tasks"
+        end
+        
+        opts.on("-f", "--force", "Force deletion of tasks") do
+          options.force = true
+        end     
+        
+        opts.on("--setup", "Setup your account") do
+          options.run = "setup"
+        end
+        
+        opts.on_tail("-h", "Shows this note") do
+          puts opts
+          exit
+        end
+        
+        opts.on("--help", "Show verbose help") do
+          @out.puts <<-HELP
 SlimTimer is a tool to record your time spend on a
 task. SlimTimer CLI allows you to controll your 
 SlimTimer directly from where you spend most of your
@@ -174,53 +163,166 @@ Finally you can run
 
 To show all your tasks available.
 HELP
+          exit
+        end
+      end   
+      
+      begin
+        opts.parse!(args)
+      rescue
+        puts $!.message
+        exit
+      end
+      options
+    end
   end
 
-  def self.start    
-    if ARGV.empty?
-      puts "Need to specify a task as argument"
-      return false
+  class CommandLine
+                  
+    # Include Helper module
+    include Helper
+    
+    def initialize(args, output = $stdout)
+      @args = args
+      @out = output       
+      
+      deprecated_calls
+      
+      @options = parse(args)
     end
-                    
-    if File.exists?(Helper::current_file)
-      puts "Need to stop the other task first"
-      return false                     
+                                          
+    def create      
+      st = login
+      if st.create_task(@options.task_name)                    
+        dump_to_file(st.tasks, "tasks.yml")
+        @out.puts "Task #{name} successfully created."
+      end
     end
     
-    info = {"task" =>  ARGV[1],
-      "start_time" => Time.now}
-
-    # dum curent task to file
-    Helper::dump_to_file(info, "current.yml")
-    return true
-  end
+    def tasks(show = true)
+      tasks = load_tasks
+      return tasks unless show
 
-  def self.end 
-    begin
-    info = Helper::load_file("current.yml")
-    rescue                                 
-      puts "You must start a task before you finish it"
-      return false
+      tasks.each do |t|
+        @out.puts t.name
+      end
     end
+    
+    def setup
+      config = load_config
+
+      @out.puts "Slimtimer Login Credentials\n"
+      @out.print "E-Mail: "
+      config["email"] = STDIN.gets.gsub("\n", "")
+
+      @out.print "Password: "
+      config["password"] = STDIN.gets.gsub("\n", "")
 
+      @out.print "API Key: "
+      config["api_key"] = STDIN.gets.gsub("\n", "")
 
-    #Find task in tasks yml
-    t = tasks(false).find {|t| t.name == info["task"]}
+      save_config(config)
 
-    raise "Task not found in list. Reload List?" unless t
+      # clear the screen
+      system("clear")
+    end
+    
+    def start                      
+      if File.exists?(current_file)
+        @out.puts "Need to stop the other task first"
+        return false                     
+      end
+      
+      info = {"task" =>  @options.task_name,
+        "start_time" => Time.now}
+      
+      #Find task in tasks yml
+      t = load_tasks.find {|t| t.name == info["task"]}
+      unless t
+        @out.puts "Task not found in list. Reload List?"
+        return false
+      end
 
-    st = Helper::login
-    result = st.create_time_entry(t, info["start_time"],
-      (Time.now - info["start_time"]).to_i)
+      dump_to_file(info, "current.yml")
+      return true
+    end
+    
+    def stop   
 
-    # Delete yml file
-    if result
-      FileUtils.rm(Helper::current_file)
-    end                            
+      if @options.force
+        rm_current 
+        @out.puts "Forced ending of task, no entry to slimtimer.com written"
+        return true
+      end
+      
+      
+      begin
+        info = load_file("current.yml")
+      rescue                                 
+        puts "You must start a task before you finish it"
+        return false
+      end
 
-    # Output
-    puts "Wrote new Entry for #{t.name}, duration #{result["duration_in_seconds"] / 60}m"
-    return true
+      #Find task in tasks yml
+      t = load_tasks.find {|t| t.name == info["task"]}
+      unless t
+        @out.puts "Task not found in list. Reload List?"
+        return false
+      end
+      raise  unless t
+
+      st = login
+      result = st.create_time_entry(t, info["start_time"],
+        (Time.now - info["start_time"]).to_i)
+
+      # Delete yml file
+      if result
+        rm_current
+        
+        # Output
+        @out.puts "Wrote new Entry for #{t.name}, duration #{result["duration_in_seconds"] / 60}m"
+        return true
+      else          
+        @out.puts "Coult not write new entry, please try again"
+        return false
+      end                            
+    end
+    
+    def run
+      send(@options.run.to_sym)
+    end
+    
+    alias_method :end, :stop
+    
+    private
+    
+    # This method checks if the first parameter in args needs to
+    # be transformed to the new one
+    def deprecated_calls
+      case @args[0]
+      when "start": @args[0] = "-s"
+      when "end": @args[0] = "-e"
+      when "create_task": @args[0] = "-c"
+      when "tasks": @args[0] = "-t"
+      when "setup": @args[0] = "--setup"  
+      end
+    end
+    
+    def load_tasks(force = false)
+      config = load_config
+      st = SlimTimer.new(config["email"], config["password"],
+        config["api_key"])
+
+      tasks = []
+      if !File.exists?(tasks_file) ||
+         File.mtime(tasks_file) < (Time.now - 60 * 60 *24) || force
+        st.login
+        tasks = st.tasks
+        dump_to_file(tasks, "tasks.yml")
+      else
+        tasks = load_file("tasks.yml")
+      end
+      tasks
+    end
   end
-     
 end         

data/lib/slimtimercli/version.rb

@@ -2,7 +2,7 @@ module Slimtimercli #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 1
-    TINY  = 2
+    TINY  = 3
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/spec/slimtimercli_spec.rb

@@ -1,5 +1,6 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
+require File.dirname(__FILE__) + '/spec_helper.rb'    
 
+include Slimtimercli::Helper
 # Time to add your specs!
 # http://rspec.rubyforge.org/
 describe "SlimTimer" do
@@ -7,8 +8,11 @@ describe "SlimTimer" do
   describe "Helper" do
 
     it "should return the path to the config files" do
-      Slimtimercli::Helper::config_file.should =~ /.slimtimer\/config.yml/
-      Slimtimercli::Helper::tasks_file.should =~ /.slimtimer\/tasks.yml/
+      
+      st = Slimtimercli::CommandLine.new(["-e"])
+      
+      st.config_file.should =~ /.slimtimer\/config.yml/
+      st.tasks_file.should =~ /.slimtimer\/tasks.yml/
     end
 
   end
@@ -49,44 +53,92 @@ describe "SlimTimer" do
   describe "command line interface" do
                          
     before  do
-      Slimtimercli::Helper.stub!(:root).and_return(File.dirname(__FILE__))
+      Slimtimercli::CommandLine.
+        any_instance.stubs(:root).returns(File.dirname(__FILE__))
       
       @c = File.join(File.dirname(__FILE__), "current.yml")
       FileUtils.rm(@c) if File.exists?(@c)
       
       @d = File.join(File.dirname(__FILE__), "config.yml")
       FileUtils.rm(@d) if File.exists?(@d)
+      
     end                         
                                                   
     it "should start a task" do
- 
-      # Manipulate ARGV
-      Slimtimercli.start
+      # Manipulate ARGV                     
+      
+      lambda { Slimtimercli::CommandLine.new([]) }.should
+        raise_error(RuntimeError)
       File.exists?(@c).should be_false
-       
+      
+      Slimtimercli::CommandLine.
+        any_instance.stubs(:load_tasks).
+        returns(stub("task", :find => stub("task", :name => "test")))   
+        
       # Set a task
       ARGV[1] = "test"
-      Slimtimercli.start              
+      
+      st = Slimtimercli::CommandLine.new(ARGV)
+      st.start              
       File.exists?(@c).should be_true
                   
       # no double start                               
-      Slimtimercli.start.should be_false
-      
-      
+      st.start.should be_false
     end
 
     it "should stop a task" do
-      Slimtimercli.stub!(:tasks).and_return(stub("task", :find => stub("task", :name => "test")))
-      Slimtimercli::Helper.stub!(:login).
-        and_return(stub("slimtimer", :create_time_entry => {"duration_in_seconds" => 10}))
+      Slimtimercli::CommandLine.
+        any_instance.stubs(:load_tasks).
+        returns(stub("task", :find => stub("task", :name => "test")))
+        
+      Slimtimercli::CommandLine.any_instance.stubs(:login).
+        returns(stub("slimtimer", 
+          :create_time_entry => {"duration_in_seconds" => 10}))
       
-      ARGV[1] = "test"
-      Slimtimercli.start.should be_true
-      Slimtimercli.end.should be_true
+      ARGV[1] = "test"                         
+      st = Slimtimercli::CommandLine.new(ARGV)
+      st.start.should be_true
+      st.end.should be_true
+      
+      File.exists?(@c).should be_false
     end          
     
     it "should not stop a task if none is running" do
-      Slimtimercli.end.should be_false
+      st = Slimtimercli::CommandLine.new(["-e"])
+      st.end.should be_false
+    end
+    
+    it "should not start a task that does not exist" do
+      Slimtimercli::CommandLine.any_instance.
+        stubs(:load_tasks).returns(stub("task", :find => nil))
+      
+      ARGV[1] = "not exisiting task"
+      st = Slimtimercli::CommandLine.new(ARGV)
+      st.start.should be_false     
+      
+    end
+                                                   
+    it "should allow to force the deletion of the current task" do
+      st = Slimtimercli::CommandLine.new(["-e"])
+      st.end.should be_false
+      ARGV[0] = "-e"
+      ARGV[1] = "--force" || "-f"              
+      st = Slimtimercli::CommandLine.new(ARGV)
+      st.end.should be_true
+    end
+    
+  end
+
+  describe "option parser" do
+    
+    it "should parse the start part correctly" do
+
+      args = ["--start", "my_task"]
+      options = parse(args)
+      
+      options.run.should == "start"
+      options.task_name.should == "my_task"
+      
     end
     
   end

data/spec/spec_helper.rb

@@ -1,10 +1,20 @@
 begin
+  
   require 'spec'
+  require 'mocha'
+  
 rescue LoadError
   require 'rubygems'
   gem 'rspec'
-  require 'spec'
+  require 'spec'         
+  
+  gem 'mocha'
+  require 'mocha'
 end
-
+                
 $:.unshift(File.dirname(__FILE__) + '/../lib')
-require 'slimtimercli'
+require 'slimtimercli'                                          
+
+Spec::Runner.configure do |config|
+  config.mock_with :mocha
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: slimtimercli
 version: !ruby/object:Gem::Version 
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors: 
 - Martin Grund
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-04-06 00:00:00 +02:00
+date: 2008-04-07 00:00:00 +02:00
 default_executable: 
 dependencies: []