luigi 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 31f72e1bb7c69d75d612950916f95e58fa4400aa
-  data.tar.gz: 5ef3d3525cc4fed1a18e116f2a181b0404345824
+  metadata.gz: 361fa53ceb381c724adade28d8810a8395751c24
+  data.tar.gz: 10505b06c45cf12b465e8d75af6e013ebebafb7b
 SHA512:
-  metadata.gz: 36b695ae7932032f603148293248e81783306009f32fcf88aa9c0bc151987cb84cfb635114e8b5fb4129d55b920c3beb97543f5a14139770dc4803bbfea22073
-  data.tar.gz: 5a90dce275ef2342a929b19c05387d581f5b51e171e336efc2c9ff7e7c386bfbaed2106b3a6a4ef7602935d58924ae693035a4f0f87027335389e7da6ae5fb5f
+  metadata.gz: dcdfd3563d55f51a638abcf1b1c0afdd9ff7865356f6f990aa1c9ab8ecd02c0a3a10d6534fe2dd5f4addf8b9b0ad81991af3e4fff8dfe39344e02c8056c7438c
+  data.tar.gz: b90f219db6687ca7919d5c5a9f128f99efe1820f53f282b1889d7c42e71766b285d91dcf626e01456ac79e5dd8ed309365edf9c5e7c7e216c8936388d4b61f32

data/lib/luigi.rb

@@ -1,63 +1,39 @@
 # encoding: utf-8
 require 'fileutils'
 require 'logger'
+require 'hashr'
 
+require File.join File.dirname(__FILE__), "luigi_internal"
+require File.join File.dirname(__FILE__), "luigi_project"
+require File.join File.dirname(__FILE__), "luigi_projects_list"
 require File.join File.dirname(__FILE__), "luigi/gitplumber"
 require File.join File.dirname(__FILE__), "luigi/ShellSanitizer"
 
 ## requires a project_class
 # project_class must implement: name, date
-class Luigi
+# TODO
+class Luigi < LuigiInternal
 
   attr_reader :dirs,
-    :opened_projects,
     :project_paths,
-    :opened_paths,
     :opened_sort,
-    :opened_dir
+    :templates,
+    :settings
 
-  attr_writer :project_class
+  #attr_writer :project_class
 
   include GitPlumber
 
-
   def initialize(settings, project_class = nil)
-    @settings        = settings
-    @opened_projects = []
+    @settings        = Hashr.new settings
     @project_class   = project_class
     @file_extension  = settings['project_file_extension']
+    @file_extension  ||= ".yml"
     @using_git       = settings['use_git']
 
-    @logger = Logger.new(STDERR)
-    @logger.level = Logger::ERROR
-    @logger.error "need a project_class" if project_class.nil?
-    @logger.progname = "LUIGI"
-
-    @dirs            = {}
-    # TODO allow for multiple templates
-    @dirs[:template] = File.expand_path File.join @settings['script_path'], @settings['templates']['project']
-    @dirs[:storage]  = File.expand_path File.join @settings['path'], @settings['dirs']['storage']
-    @dirs[:working]  = File.join @dirs[:storage], @settings['dirs']['working']
-    @dirs[:archive]  = File.join @dirs[:storage], @settings['dirs']['archive']
-
-
-  end
-
-  ##
-  # Checks the existens of one of the three basic dirs.
-  # dir can be either :storage, :working or :archive
-  # and also :template
-  def check_dir(dir)
-    File.exists? "#{@dirs[dir]}"
-  end
-
-  ##
-  # Checks the existens of every thing required
-  def check_dirs
-    check_dir :storage and
-    check_dir :working and
-    check_dir :archive and
-    check_dir :template
+    init_logger()
+    init_dirs()
+    load_templates()
   end
 
   ##
@@ -66,67 +42,43 @@ class Luigi
   def create_dir(dir)
     unless check_dir(dir)
       if dir == :storage or check_dir :storage
-        FileUtils.mkdir "#{@dirs[dir]}"
+        FileUtils.mkdir @dirs[dir]
         @logger.info "Created \"#{dir.to_s}\" Directory (#{@dirs[dir]})"
         return true
       end
-      @logger.error "no storage dir"
+      @logger.error "No storage dir."
     end
     return false
   end
  
-  ##
-  # creates new project_dir and project_file
-  def _new_project_folder(name)
-    unless check_dir(:working)
-      @logger.info(File.exists? @dirs[:working])
-      @logger.info "missing working directory!"
-      return false
-    end
-
-    #  check of existing project with the same name
-    folder = get_project_folder(name, :working)
-    unless folder
-      FileUtils.mkdir File.join @dirs[:working], name
-      return get_project_folder(name, :working)
-    else
-      @logger.info "#{folder} already exists"
-      return false
-    end
-  end
 
   ##
   # creates new project_dir and project_file
   # returns project object
-  def new_project(_name)
+  def new_project(_name, template = :default, data = {})
     _name = ShellSanitizer.process _name
     name = ShellSanitizer.clean_path _name
 
-    project_name   = _name
-    settings       = @settings
-    defaults       = @settings['defaults']
-    defaults       = {}
-
-    filename = @dirs[:template]
+    load_templates()
 
-    ## Approach A ( Thomas Kühn )
-    engine=ERB.new(File.read(filename),nil,'<>')
-    result = engine.result(binding)
+    template_path = @templates[template]
+    raise "No such template." unless @templates.keys.include? template
+    raise "Template file does not exists." unless File.exists? template_path
+    data[:project_name] = name
 
-    # copy template_file to project_dir
+    # create project folder
     folder = _new_project_folder(name)
+
     if folder
       target = File.join folder, name+@file_extension
+      # project will load template and 
+      project = @project_class.new({
+        :path          => target,
+        :settings      => @settings,
+        :template_path => template_path,
+        :data          => data }
+                                  )
 
-      #puts "writing into #{target}"
-      file = File.new target, "w"
-      result.lines.each do |line|
-        file.write line
-      end
-      file.close
-
-      @logger.info "#{folder} created"
-      return @project_class.new target
     else
       return false
     end
@@ -140,105 +92,81 @@ class Luigi
   # output of (foobar must be comparable)
   #
   # untested
-  def open_projects(dir=:working, year=Date.today.year, sort = :date)
+  def _open_projects(dir=:working, sort = :date, year=Date.today.year)
+    #TODO perhaps cache projects
     if dir==:all
-      @opened_paths    = list_projects_all
+      opened_paths    = list_project_files_all
     else
-      @opened_paths    = list_projects dir, year 
+      opened_paths    = list_project_files dir, year 
     end
 
-    @opened_dir      = dir
-    @project_paths   = {}
-    @opened_paths.each {|path|
-      project = @project_class.new path
-      if project.STATUS == :ok
-        @opened_projects = @opened_projects + [ project ]
-      end
-      @project_paths[project.name] = path
+    projects = []
+    opened_paths.each {|path|
+      project = open_project_from_path(path)
+      projects <<  project if project.status == :ok
     }
-    sort_projects(sort)
-    return true
+    projects = LuigiProjectsList.new sort_projects(projects, sort)
+    return projects
   end
 
-  def open_project project
-    if project.class == String
-      project = ShellSanitizer.process    project
-      project = ShellSanitizer.clean_path project
-      open_projects()
-      project = lookup(project)
-    end
-    return project if project.class == @project_class
-    return false
+  # sorts array of project_class
+  def sort_projects(projects, sort = :date)
+      raise "sort must be a Symbol, not a #{sort.class} (#{sort})" unless sort.class == Symbol
+      if @project_class.method_defined? sort
+          projects.sort_by! {|project| project.method(sort).call}
+          return projects
+      else raise "#{@project_class} does not implement #{sort}()"
+      end
+      return false
   end
 
 
-  ##
-  # produces an Array of @project_class objects
-  #
-  # untested
   def open_projects_all(sort = :date)
-    @opened_paths    = list_projects_all
-    open_projects :all, year=nil, sort
+    _open_projects :all , sort, Date.today.year
   end
 
-  def [] name
-    lookup name
+  def open_projects_working(sort = :date)
+    _open_projects :working, sort, Date.today.year
   end
 
-  def lookup_path(name, sort = nil)
-    p = lookup(name)
-    return @project_paths[p.name] unless p.nil?
-    @logger.error "there is no project #{name}"
-    return false
+  def open_projects_archive(year,sort = :date)
+    _open_projects :archive, sort, year
   end
-  
-  
-  def lookup(name, sort = nil)
-    sort_projects sort unless sort == nil or @opened_sort == sort
-    name = name.to_i - 1 if name =~ /^\d*$/
-    if name.class == String
-      name_map = {}
-      @opened_projects.each {|project| name_map[project.name] = project}
-      project = name_map[name]
-      @logger.error "there is no project \"#{name}\"" if project.nil?
-    elsif name.class == Fixnum
-      project =  @opened_projects[name]
-      @logger.error "there is no project ##{name+1}" if project.nil?
-    end
+
+
+  # returns project path
+  def lookup_path_by_name(name, dir = :working, year = Date.today.year)
+    projects = map_project_files(dir, year)
+    matches = projects.keys.select{|k| k.downcase.include? name.downcase}
+    return matches.each{|match|
+      projects[match]
+    }
+  end
+
+  # returns opened project
+  # needs to open projects in order to sort
+  def lookup_by_num(num, dir= :working, sort=:date, year= Date.today.year)
+    projects =  _open_projects(dir, sort, year) 
+    projects.each{|p| puts "#{p.date}: #{p.name}" }
+    #num = num.to_i - 1 if num.class == String and num =~ /^\d*$/
+    num = num.to_i - 1
+    project =  projects[num]
+    @logger.error "there is no project ##{num+1}" if project.nil?
     return project
   end
   
-  
-  def sort_projects(sort = :date)
-      fail "sort must be a Symbol" unless sort.class == Symbol
-      if @project_class.method_defined? sort
-          @opened_projects.sort_by! {|project| project.method(sort).call}
-      else fail "#{@project_class} does not implement #{sort}()"
-      end
-      return true
+  # opens a project from name
+  # TODO implement archive lookup
+  def open_project_from_name project_name
+    return false unless project_name.class == String
+    project_name = ShellSanitizer.process    project_name
+    project_name = ShellSanitizer.clean_path project_name
+    path = get_project_file_path project_name
+    return open_project_from_path path if path
+    @logger.error "Patherror: #{project_name}"
   end
-  
-  ##
-  # path to project file
-  # there may only be one @file_extension file per project folder
-  #
-  # untested
-  def get_project_file_path(name, dir=:working, year=Date.today.year)
-      name = ShellSanitizer.process    name
-      name = ShellSanitizer.clean_path name
-      
-    folder = get_project_folder(name, dir, year)
-    if folder
-      files = Dir.glob File.join folder, "*#{@file_extension}"
-      warn "ambiguous amount of #{@file_extension} files in #{folder}" if files.length > 1
-      warn "no #{@file_extension} files in #{folder}" if files.length < 1
-      return files[0]
-    end
-    @logger.info "NO FOLDER get_project_folder(name = #{name}, dir = #{dir}, year = #{year})"
-    return false
-  end
-
 
+  
   ##
   # Path to project folder
   # If the folder exists
@@ -261,67 +189,32 @@ class Luigi
   def list_project_names(dir = :working, year=Date.today.year)
     return unless check_dir(dir)
     if dir == :working
-      paths = Dir.glob File.join @dirs[dir], "/*"
-      names = paths.map {|path| File.basename path }
+      return map_project_files_working().keys()
     elsif dir == :archive
-      paths = Dir.glob File.join @dirs[dir], year.to_s, "/*"
-      names = paths.map {|path|
-        file_path = get_project_file_path (File.basename path), :archive, year
-        name = File.basename file_path, @file_extension
-      }
-      return names
+      return map_project_files_archive(year).keys()
     else
       @logger.error "unknown path #{dir}"
     end
   end
 
   ##
-  # list projects
   # lists project files
-  # (names actually contains paths)
-  def list_projects(dir = :working, year=Date.today.year)
+  def list_project_files(dir = :working, year=Date.today.year)
     return unless check_dir(dir)
     if dir == :working
-      folders = Dir.glob File.join @dirs[dir], "/*"
-      paths = folders.map {|path| get_project_file_path File.basename path }
+      return list_project_files_working()
     elsif dir == :archive
-      folders = Dir.glob File.join @dirs[dir], year.to_s, "/*"
-      paths = folders.map {|path| get_project_file_path (File.basename path), :archive, year }
+      return list_project_files_archive(year)
     else
       @logger.error "unknown path #{dir}"
+      return []
     end
-
-    puts "WARNING! one folder is not correct" if paths.include? false
-    paths.keep_if{|v| v}
   end
 
-  ##
-  # list projects
-  # lists project files
-  # (names actually contains paths)
-  def list_projects_all
-    names = []
-
-    #first all archived projects, ever :D
-    archives = Dir.glob File.join @dirs[:archive], "/*"
-    archives.sort!
-    archives.each do |a|
-      paths = Dir.glob File.join a, "/*"
-      year = File.basename a
-      names += paths.map { |path|
-        get_project_file_path (File.basename path), :archive, year
-      }
-    end
-
-    #then all working projects
-    names += list_projects :working
 
-    return names
-  end
-
-  def filter_by hash
+  def filter_by projects, hash
     filtered_projets = []
-    @opened_projects.each{|project|
+    projects.each{|project|
       hash.each{|key,value|
         field = project.data(key)
         if field and field.to_s.downcase.include? value
@@ -338,7 +231,6 @@ class Luigi
   #  @name 
   ## Luigi.archive_project should use ShellSanitizer
   def archive_project(project, year = nil, prefix = '')
-    project = open_project project
     return false unless project.class == @project_class
     
     year ||= project.date.year
@@ -369,17 +261,15 @@ class Luigi
   ##
   #  Move to archive directory
   def unarchive_project(project, year = Date.today.year)
-    project = open_project project
     return false unless project.class == @project_class
 
-    name         = project.name
     path         = project.path
     cleaned_name = File.basename(path,@file_extension)
-    source       = get_project_folder name, :archive, year
+    source       = get_project_folder project.name, :archive, year
     target       = File.join @dirs[:working], cleaned_name
+    return false unless source
 
     @logger.info "moving #{source} to #{target}"
-    return false unless source
 
     unless get_project_folder cleaned_name
       FileUtils.mv source, target

data/lib/luigi/ShellSanitizer.rb

@@ -22,7 +22,7 @@ class ShellSanitizer
     return string
   end
 
-## TODO somebody find my a gem that works and I'll replace this
+## TODO somebody find me a gem that works and I'll replace this
   def self.deumlautify(string)
     REPLACE_HASH.each{|k,v| string = string.gsub k, v }
     string.each_char.to_a.keep_if {|c| c.ascii_only?}

data/lib/luigi/version.rb

@@ -1,3 +1,3 @@
 module Luigi
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/lib/luigi_internal.rb

@@ -0,0 +1,184 @@
+# encoding: utf-8
+require 'fileutils'
+require 'logger'
+require 'hashr'
+
+require File.join File.dirname(__FILE__), "luigi/gitplumber"
+require File.join File.dirname(__FILE__), "luigi/ShellSanitizer"
+
+## requires a project_class
+# project_class must implement: name, date, index
+
+# implements everything not exposed to the outside
+# TODO: make this all private
+class LuigiInternal
+  def init_logger
+    @logger = Logger.new(STDERR)
+    @logger.level = Logger::ERROR
+    @logger.error "need a project_class" if @project_class.nil?
+    @logger.progname = "LUIGI"
+  end
+
+  def init_dirs
+    @dirs = {}
+    @dirs[:storage]   = File.expand_path(File.join(@settings['path'], @settings['dirs']['storage']))
+    @dirs[:working]   = File.join @dirs[:storage], @settings['dirs']['working']
+    @dirs[:archive]   = File.join @dirs[:storage], @settings['dirs']['archive']
+    @dirs[:templates] = File.join @dirs[:storage], @settings['dirs']['templates']
+  end
+
+  ##
+  # Checks the existens of one of the three basic dirs.
+  # dir can be either :storage, :working or :archive
+  # and also :templates
+  def check_dir(dir)
+    File.exists? @dirs[dir]
+  end
+
+  ##
+  # Checks the existens of every thing required
+  def check_dirs
+    check_dir :storage and
+    check_dir :working and
+    check_dir :archive and
+    check_dir :templates
+  end
+
+  # read the templates directory and cache paths
+  def load_templates
+    return false unless check_dir :templates
+    #files = Dir.glob File.join @dirs[:templates] , ?*
+    files = Dir.glob File.join(@dirs[:templates], "*{#{@file_extension}.erb,#{@file_extension}}")
+    @templates =  {}
+    files.each{|file|
+      name = File.basename file.split(?.)[0]
+      @templates[name.to_sym] = file
+    }
+    return true
+  end
+
+  ##
+  # creates new project_dir and project_file
+  def _new_project_folder(name)
+    unless check_dir(:working)
+      @logger.info(File.exists? @dirs[:working])
+      @logger.info "missing working directory!"
+      return false
+    end
+
+    #  check of existing project with the same name
+    folder = get_project_folder(name, :working)
+    unless folder
+      FileUtils.mkdir File.join @dirs[:working], name
+      return get_project_folder(name, :working)
+    else
+      @logger.info "#{folder} already exists"
+      return false
+    end
+  end
+
+  ##
+  # derives path to project file from name
+  # there may only be one @file_extension file per project folder
+  #
+  # untested
+  def get_project_file_path(name, dir=:working, year=Date.today.year)
+    name = ShellSanitizer.process    name
+    name = ShellSanitizer.clean_path name
+
+    folder = get_project_folder(name, dir, year)
+    if folder
+      files = Dir.glob File.join folder, "*#{@file_extension}"
+      warn "ambiguous amount of #{@file_extension} files in #{folder}" if files.length > 1
+      warn "no #{@file_extension} files in #{folder}" if files.length < 1
+      return files[0]
+    end
+    @logger.info "NO FOLDER get_project_folder(name = #{name}, dir = #{dir}, year = #{year})"
+    return false
+  end
+
+  # opens a project from path
+  def open_project_from_path path
+    project = @project_class.new({
+      :path          => path,
+      :settings      => @settings})
+    return project if project.class == @project_class
+    return false
+  end
+
+
+
+
+  ##
+  # maps project names to files from working dir
+  def map_project_files_working()
+    map = {}
+    folders = Dir.glob File.join @dirs[:working], "/*"
+    paths = folders.map {|path| get_project_file_path File.basename path }
+    paths.select!{|path| path} # removing faulty paths
+    paths.each   {|path| map[File.basename path, @file_extension] = path }
+    return map
+  end
+
+  ##
+  # maps project names to files from working dir
+  def map_project_files_archive(year = Date.today.year)
+    map={}
+    paths = Dir.glob File.join @dirs[:archive], year.to_s, "/*"
+    names = paths.map {|path|
+      file_path = get_project_file_path (File.basename path), :archive, year
+      name = File.basename file_path, @file_extension
+      map[name] = file_path
+    }
+    return map
+  end
+
+  ##
+  # maps project names to files 
+  def map_project_files(dir = :working, year=Date.today.year)
+    return unless check_dir(dir)
+    if dir == :working
+      return map_project_files_working()
+    elsif dir == :archive
+      return map_project_files_archive year
+    else
+      @logger.error "unknown path #{dir}"
+    end
+  end
+
+  ##
+  # returns map of years to archive folders
+  def map_archive_years
+    map = {}
+    Dir.glob(File.join @dirs[:archive], "/*").each{|path|
+      map[File.basename path] = path
+    }
+    return map
+  end
+
+
+
+
+  ##
+  # lists project files from working directory
+  def list_project_files_working()
+    map_project_files_working.values
+  end
+
+  # lists project files from archive directory
+  def list_project_files_archive(year = Date.today.year)
+    map_project_files_archive(year).values
+  end
+
+  ##
+  # list projects
+  # lists project files
+  def list_project_files_all
+    working = list_project_files_working
+    archive = []
+    map_archive_years.keys.each{|year|
+      archive += list_project_files_archive(year)
+    }
+    return ( archive + working )
+  end
+end

data/lib/luigi_project.rb

@@ -0,0 +1,90 @@
+require 'date'
+require 'logger'
+
+
+class LuigiProject
+
+  attr_reader :status, :using_erb
+
+  # initializes the project
+  # opens project from :path.
+  # if :template_path is given it will create a fresh project from template first
+  # and store it in path
+  def initialize hash
+    @path          = hash[:path]
+    @settings      = hash[:settings]
+    @template_path = hash[:template_path]
+    @data          = hash[:data]
+    @data        ||= {}
+
+    @logger = Logger.new STDOUT
+    @logger.progname = "LuigiProject"
+
+    unless @template_path.nil?
+      create @template_path
+    end
+
+    open @path
+  end
+
+  # attempting to fill erb if template ends in .erb
+  # filling with @settings[:defaults]
+  def create(template_path)
+    @using_erb = File.extname(@template_path) == ".erb"
+
+    template_basename = File.basename @template_path
+    template_basename = File.basename @template_path, ".erb" if using_erb
+
+    raise "Project file extension error!" unless File.extname(@path) == @settings['project_file_extension']
+    raise "Template file extension error!" unless File.extname(template_basename) == @settings['project_file_extension']
+    raise "Template does not exist!" unless File.exists? @template_path
+    raise "Project file already exists! (#{@path})" if File.exists? @path
+
+    if @using_erb
+      create_with_erb(template_path)
+    else
+      FileUtils.cp @template_path, @path
+    end
+  end
+
+  def fill_template
+    return binding
+  end
+
+  def create_with_erb template_path
+    engine=ERB.new(File.read(template_path),nil,'<>')
+    b = fill_template()
+    result = engine.result(b)
+
+    file = File.new @path, "w"
+    result.lines.each do |line|
+      file.write line
+    end
+    file.close
+  end
+
+  # opens project form path
+  def open path
+    @path = path
+  end
+
+  # returns path
+  def path
+    @path
+  end
+
+  # returns name
+  def name
+    File.basename @path, ".yml"
+  end
+
+  # returns index
+  def index
+    123
+  end
+
+  def date
+    return Date.today
+  end
+
+end

data/lib/luigi_projects_list.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+require 'fileutils'
+require 'logger'
+require 'hashr'
+
+require File.join File.dirname(__FILE__), "luigi"
+require File.join File.dirname(__FILE__), "luigi_project"
+
+class LuigiProjectsList < Array
+
+
+  def lookup_by_anything thing, value
+    project_class = self[0].class
+    raise "#{project_class} does not implement #{thing.to_s}()" unless project_class.instance_methods.include? thing
+    raise "#{thing}" unless [:name, :date, :index].include? thing
+
+    selection = self.map{|project| 
+      project if project.method(thing).call.to_s.downcase.include? value.to_s.downcase
+    }
+    selection.select{|p|p}
+
+  end
+
+  def lookup_by_index index
+    self.lookup_by_anything :index, index
+  end
+
+  def lookup_by_date date
+    self.lookup_by_anything :date, date
+  end
+
+  def lookup_by_name name
+    self.lookup_by_anything :name, name
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: luigi
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Hendrik Sollich
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-14 00:00:00.000000000 Z
+date: 2014-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -77,6 +77,9 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.0.1
   type: :runtime
@@ -84,19 +87,46 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - ">="
       - !ruby/object:Gem::Version
         version: 0.0.1
-description: ''
+- !ruby/object:Gem::Dependency
+  name: hashr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.22
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.22
+description: |-
+  A project manager that keeps track of a working directory, archive and template files.
+    Used in commandline tools like ascii-invoicer.
 email: hendrik@hoodie.de
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/PlumberProject.rb
 - lib/luigi.rb
 - lib/luigi/ShellSanitizer.rb
 - lib/luigi/gitplumber.rb
 - lib/luigi/version.rb
+- lib/luigi_internal.rb
+- lib/luigi_project.rb
+- lib/luigi_projects_list.rb
 homepage: https://github.com/hoodie/luigi
 licenses:
 - GPL

data/lib/PlumberProject.rb

@@ -1,34 +0,0 @@
-require 'date'
-
-#interface
-class PlumberProject
-
-  def initialize path
-    open path
-  end
-
-  def open path
-    @path = path
-  end
-
-  def path
-    @path
-  end
-
-  def name
-    File.basename @path, ".yml"
-  end
-
-  def index
-    123
-  end
-
-  def STATUS
-    :ok # at least :ok or anything else
-  end
-
-  def date
-    return Date.today
-
-  end
-end