serienmover 0.0.1 → 0.1.0

data/Rakefile

@@ -1,2 +1,10 @@
 #!/usr/bin/env rake
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs = ["lib"]
+  t.warning = false
+  t.verbose = true
+  t.test_files = FileList['spec/*_spec.rb']
+end

data/bin/serienmover

@@ -0,0 +1,207 @@
+#!/usr/bin/env ruby
+# -*- ruby -*-
+# encoding: UTF-8
+
+$LOAD_PATH << File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'serienmover'
+require 'serienrenamer'
+require 'fileutils'
+require 'hashconfig'
+require 'optparse'
+require 'highline/import'
+require "highline/system_extensions"
+include HighLine::SystemExtensions
+
+# create program configuration dirs/files
+CONFIG_DIR  = File.join( File.expand_path("~"), ".serienmover" )
+CONFIG_FILE = File.join( CONFIG_DIR, "config.yml" )
+FileUtils.mkdir(CONFIG_DIR) unless File.directory?(CONFIG_DIR)
+
+###
+# configuration
+STANDARD_CONFIG = {
+  :default_directory    => File.join(File.expand_path("~"), "Downloads"),
+  :series_directories   => [],
+  :read_episode_info    => false,
+  :store_path           => '',
+  :byte_count_for_md5   => 2048,
+  :collective_directory => '',
+}
+
+config = STANDARD_CONFIG.merge_with_serialized(CONFIG_FILE)
+
+###
+# option definition and handling
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{File.basename($PROGRAM_NAME)} [DIR]"
+
+  opts.separator("")
+  opts.separator("Tool that moves series episodes into a specific")
+  opts.separator("directory structure.")
+  opts.separator("")
+  opts.separator("  Options:")
+
+  opts.on( "-s", "--seriesdir=DIR", String,
+           "Directory that contains series data (multiple allowed)") do |dirs|
+    dirs = [ dirs ] if dirs.is_a? String
+
+    dirs.each do |d|
+      if File.directory?(d)
+        config[:series_directories] << d
+      end
+    end
+  end
+
+  opts.on( "-i", "--ignore-seriesinfo",
+           "do not use the information from the infostore") do |opt|
+    config[:read_episode_info] = false
+  end
+
+  opts.on( "-v", "--version",
+           "Outputs the version number.") do |opt|
+    puts Serienmover::VERSION
+    exit
+  end
+
+  opts.separator("")
+  opts.separator("  Arguments:")
+  opts.separator("     DIR      The path that includes the episodes")
+  opts.separator("              defaults to ~/Downloads")
+  opts.separator("")
+
+end.parse!
+
+###
+# change into DIR
+episode_directory = ARGV.pop || config[:default_directory]
+
+fail "'#{episode_directory}' does not exist or is not a directory" unless
+    Dir.exists?(episode_directory)
+
+Dir.chdir(episode_directory)
+
+###
+# instantiate the series_store
+store = Serienmover::SeriesStore.new(config[:series_directories])
+
+###
+# instantiate information store
+info_store = Serienrenamer::InformationStore.new(
+    config[:store_path], config[:byte_count_for_md5])
+
+###
+# iterate through all episode files
+episode_actions = []
+
+Dir.new('.').to_a.sort.each do |file|
+
+  next if file.match(/^\./)
+  next unless File.file? file
+  next unless Serienrenamer::Episode.determine_video_file(file)
+
+  p file
+
+  episode = Serienrenamer::Episode.new(file)
+
+  # get seriesname from the informationstore which is used by
+  # serienrenamer to store the seriesname when it renames files
+  md5 = episode.md5sum(config[:byte_count_for_md5])
+  series = info_store.episode_hash[md5]
+
+  options = {}
+  if config[:read_episode_info] && series && series.match(/\w+/)
+    options[:series] = series
+  end
+
+  targets = store.find_suitable_target(episode, options)
+  selected_target = nil
+
+  ###
+  # process the targets
+  case targets.size
+  when 0
+    puts "No suitable target found\n"
+    next
+  when 1
+    selected_target = targets[0]
+  else
+
+    begin
+      puts "Available targets:"
+      choose do |menu|
+        menu.prompt = "Choose the right target: "
+
+        targets.each do |t|
+          menu.choice t.series do lambda { selected_target = t }.call end
+        end
+      end
+    rescue Interrupt
+      puts ""
+    end
+
+  end
+
+  if selected_target
+    puts ">> '%s'" % selected_target
+    episode.target = selected_target
+
+    ###
+    # ask for the action (copy/move)
+    print "What should be done ( [c]opy (*) , [m]ove ): "
+    char = get_character
+    print char.chr unless char.chr.match(/\r/)
+
+    unless char.chr.match(/[kcmv\r]/i)
+      puts "\nwill be skipped ...\n\n"
+      next
+    end
+
+    if char.chr.match(/[kc\r]/i)
+      episode.set_action(copy: true)
+      print " ... copy"
+    else
+      episode.set_action(move: true)
+      print " ... move"
+    end
+
+    ###
+    # save the episode and set the target as used
+    store.set_target_to_used(episode, selected_target)
+
+    episode_actions << episode
+  end
+
+  puts "\n\n"
+end
+
+exit if episode_actions.empty?
+
+####
+# Process the actions on the episodes
+print "Start processing the episodes ? [yJ]"
+char = get_character
+print char.chr
+
+unless char.chr.match(/[jy\r]/i)
+  puts "\nwill exit ...\n\n"
+  exit
+end
+
+puts "\nEpisodes will be processed now"
+episode_actions.each do |episode|
+  puts "%s '%s' to '%s'" % [episode.action.capitalize, episode, episode.target]
+
+  episode.process_action
+
+  # move copied file into a collective_directory if needed
+  if config[:collective_directory] &&
+    File.directory?(config[:collective_directory]) &&
+      episode.action.match(/copy/i)
+
+    remote_file = File.join(config[:collective_directory],
+                            File.basename(episode.episodepath))
+    FileUtils.mv(episode.episodepath, remote_file)
+  end
+end

data/lib/serienmover/episode.rb

@@ -0,0 +1,39 @@
+require 'serienrenamer'
+
+class ::Serienrenamer::Episode
+  attr_accessor :target, :action
+
+  # Public: Sets the action that should be processed on this episode
+  #
+  # options  - generale options (default: {copy: false, move: false})
+  #            :copy - if true than the file will be copied (higher priority)
+  #            :move - if true than the file wille be moved
+  def set_action(options = {})
+    opt = {move: false, copy: false}.merge(options)
+
+    if opt[:copy]
+      @action = 'copy'
+    elsif opt[:move]
+      @action = 'move'
+    end
+  end
+
+  # Public: Move/Copy the file to the target directory
+  def process_action
+    raise ArgumentError, "target needed" unless self.target
+    raise ArgumentError, "action needed" unless
+      self.action.match(/(move|copy)/i)
+
+    FileUtils.mkdir_p(self.target.targetdir) unless
+      File.directory?(self.target.targetdir)
+
+    remote_file = File.join(self.target.targetdir,
+      File.basename(self.episodepath))
+
+    if self.action.match(/copy/i)
+      FileUtils.cp(self.episodepath, self.target.targetdir)
+    elsif self.action.match(/move/i)
+      FileUtils.mv(self.episodepath, remote_file)
+    end
+  end
+end

data/lib/serienmover/series_store.rb

@@ -0,0 +1,239 @@
+require 'find'
+require 'serienrenamer'
+
+module Serienmover
+
+  # Public: holds information from the series directories and is able to
+  #         search for possible targets for an supplied episode
+  class SeriesStore
+
+    attr_reader :series_data, :series_dirs
+    alias_method :series, :series_data
+
+    # Public: Initialize a SeriesStore
+    #
+    # series_directories - array of Strings that contains the
+    #                      series_directories
+    def initialize(series_directories)
+
+      @series_data = {}
+      @series_dirs = []
+
+      series_directories.each do |series_directory|
+        next unless File.directory? series_directory
+        @series_dirs << series_directory
+
+        Dir.new(series_directory).each do |series|
+          next if series.match(/^\.*$/)
+
+          seriesdir = File.join(series_directory, series)
+
+          episodes = {}
+          Find.find(seriesdir) do |file|
+            next unless File.file?(file)
+
+            infos = Serienrenamer::Episode.extract_episode_information(
+              File.basename(file))
+
+            if infos
+              index = SeriesStore.build_index(infos[:season], infos[:episode])
+              episodes[index] = file
+            end
+          end
+
+          series_data[series] = episodes
+        end
+      end
+    end
+
+    # Public: finds a suitable target in the store
+    #
+    # episode  - Serienrenamer::Episode instance
+    # options  - optional arguments (default: {):}
+    #            :series  - if this option is set than it returns only targets
+    #                       where the series matches the supplied arguments
+    #
+    # Returns an array of EpisodeTargets
+    def find_suitable_target(episode, options = {})
+      raise ArgumentError, "Serienrenamer::Episode needed" unless
+          episode.is_a? Serienrenamer::Episode
+
+      targets = []
+      current = SeriesStore.build_index(episode.season, episode.episode)
+      before  = SeriesStore.build_index(episode.season, episode.episode-1)
+
+      series_data.each do |series, episodes|
+
+        # restrict series to the supplied seriesname and skip otherwise
+        if options.include?(:series) && options[:series].match(/\w+/)
+          next unless SeriesStore.does_match_series?(series, options[:series])
+        end
+
+        target_directory = nil
+
+        if episode.episode <= 1
+          # find possible targets for a new season
+          current_season = episodes.select do |e|
+            ! e.match(/^#{episode.season.to_s}_/).nil?
+          end
+          before_season = episodes.select do |e|
+            ! e.match(/^#{(episode.season-1).to_s}_/).nil?
+          end
+
+          if current_season.empty? && ! before_season.empty?
+            season_before_dir = File.dirname(before_season.values[0])
+
+            dir_part = File.basename(season_before_dir)
+            dir_part.gsub!(/#{(episode.season-1).to_s }/, episode.season.to_s)
+
+            # let 'Staffel 010' be 'Staffel 10' as a side effect of
+            # the regex before
+            dir_part.gsub!(/010/, '10')
+
+            target_directory =
+              File.join( File.dirname(season_before_dir), dir_part )
+          end
+
+        elsif episodes.include?(before) && ! episodes.include?(current)
+          # look for the episode before the current which
+          # should be not existant and which hash no seasons afterwards
+
+          # check for seasons that follows the current
+          episodes_of_following_seasons =
+            episodes.select { |e| e.match(/#{(episode.season + 1).to_s}_/) }
+
+          if episodes_of_following_seasons.empty?
+            target_directory = File.dirname(episodes[before])
+          end
+
+        elsif ! episodes.include?(before) && ! episodes.include?(current)
+          # look for episodes that are released out of order so that
+          # S05E10 is released before S05E07, for which we are searching
+          # for a target
+          episode.episode.upto(50).each do |e|
+            index = SeriesStore.build_index(episode.season, e)
+            if episodes.include?(index)
+              target_directory = File.dirname(episodes[index])
+            end
+          end
+        end
+
+        # build up target instance
+        if target_directory
+          target = EpisodeTarget.new(series, target_directory)
+          targets << target
+        end
+      end
+
+      targets
+    end
+
+
+    # Public: set the supplied target as used so that it is not
+    #         available for future searches
+    #
+    # episode - Serienrenamer::Episode instcnace
+    # target  - EpisodeTarget instance
+    #
+    # Returns nothing
+    def set_target_to_used(episode, target)
+      raise ArgumentError, "Serienrenamer::Episode needed" unless
+          episode.is_a? Serienrenamer::Episode
+      raise ArgumentError, "Serienmover::EpisodeTarget needed" unless
+          target.is_a? Serienmover::EpisodeTarget
+
+      index = SeriesStore.build_index(episode.season, episode.episode)
+      @series_data[target.series][index] =
+          File.join(target.targetdir, episode.to_s)
+    end
+
+    class << self
+
+      # Public: tries to match the suppplied seriesname pattern
+      #         agains the series
+      #
+      # seriesname     - the seriesname that comes from the series_directory
+      # series_pattern - the series_name that has to be checked
+      #                  agains the seriesname
+      #
+      # Returns true if it matches otherwise false
+      def does_match_series?(seriesname, series_pattern)
+
+        if seriesname.match(/#{series_pattern}/i)
+          # if pattern matches the series directly
+          return true
+
+        else
+          # start with a pattern that includes all words from
+          # series_pattern and if this does not match, it cuts
+          # off the first word and tries to match again
+          #
+          # if the pattern contains one word and if this
+          # still not match, the last word is splitted
+          # characterwise, so that:
+          #  crmi ==> Criminal Minds
+          name_words = series_pattern.split(/ /)
+          word_splitted = false
+
+          while ! name_words.empty?
+
+            pattern = name_words.join('.*')
+            return true if seriesname.match(/#{pattern}/i)
+
+            # split characterwise if last word does not match
+            if name_words.length == 1 && ! word_splitted
+              name_words = pattern.split(//)
+              word_splitted = true
+              next
+            end
+
+            # if last word was splitted and does not match than break
+            # and return empty resultset
+            break if word_splitted
+
+            name_words.delete_at(0)
+          end
+        end
+
+        false
+      end
+
+      # Public: builds up an index 'd_d' where the d's are the supplied args
+      #
+      # season - Number that is the first part of the 'd_d'
+      # season - Number that is the second part of 'd_d'
+      #
+      # Examples
+      #
+      #   build_index('09', '12')
+      #   # => '9_12'
+      #
+      # Returns the index
+      def build_index(season, episode)
+        return '%d_%d' % [ season.to_i, episode.to_i ]
+      end
+
+    end
+  end
+
+  # Public: holds information about suitable target directories
+  #
+  # Examples
+  #
+  #   target = EpisodeTarget.new('Chuck', '/path/to/series')
+  #   target.series
+  #   # => "Chuck"
+  #
+  class EpisodeTarget
+    attr_accessor :series, :targetdir
+
+    def initialize(seriesname, targetdir)
+      @series = seriesname
+      @targetdir = targetdir
+    end
+
+    def to_s
+      @series
+    end
+  end
+end

data/lib/serienmover/version.rb

@@ -1,3 +1,3 @@
 module Serienmover
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/serienmover.rb

@@ -1,5 +1,8 @@
-require "serienmover/version"
+require "serienmover/series_store.rb"
+require "serienmover/episode.rb"
+require "serienmover/version.rb"
+require "serienrenamer"
 
 module Serienmover
-  # Your code goes here...
+
 end

data/spec/episode_spec.rb

@@ -0,0 +1,51 @@
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+require 'serienrenamer'
+
+describe Serienrenamer::Episode do
+
+  before(:each) do
+    @episodes = TestData.create
+
+    @store = Serienmover::SeriesStore.new([ TestHelper::SERIES_STORAGE_DIR ])
+  end
+
+  after(:each) do
+    TestData.clean
+  end
+
+  it "should copy the episode properly" do
+    episode = @episodes[:crmi]
+
+    results = @store.find_suitable_target(episode, series: "Criminal Minds")
+    results.size.should be == 1
+    results[0].series.should eq "Criminal Minds"
+
+    target = results[0]
+    episode.target = target
+    episode.set_action(copy: true)
+    episode.process_action
+
+    File.file?(episode.episodepath).should be_true
+
+    remote_path = File.join(target.targetdir, File.basename(episode.episodepath))
+    File.file?(remote_path).should be_true
+  end
+
+  it "should move the episode properly" do
+    episode = @episodes[:crmi]
+
+    results = @store.find_suitable_target(episode, series: "Criminal Minds")
+    results.size.should be == 1
+    results[0].series.should eq "Criminal Minds"
+
+    target = results[0]
+    episode.target = target
+    episode.set_action(move: true)
+    episode.process_action
+
+    File.file?(episode.episodepath).should_not be_true
+
+    remote_path = File.join(target.targetdir, File.basename(episode.episodepath))
+    File.file?(remote_path).should be_true
+  end
+end

data/spec/serienmover_spec.rb

@@ -1,17 +1,23 @@
-require 'spec_helper'
-
-require File.dirname(__FILE__) + '/../lib/serienmover'
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+require 'serienrenamer'
 
 describe Serienmover do
 
-  before(:all) do
+
+  before(:each) do
+    @episodes = TestData.create
+  end
+
+  after(:each) do
+    TestData.clean
   end
 
-  after(:all) do
+  it "should build up Episode instances successfully" do
+    @episodes[:tbbt].should_not be_nil
   end
 
-  it "should be true" do
-    true.should be_true
+  it "should extract the right information from the files" do
+    @episodes[:crmi].episode.should eq 4
   end
 end
 

data/spec/series_store_spec.rb

@@ -0,0 +1,110 @@
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+
+describe Serienmover::SeriesStore do
+
+  before(:each) do
+    @episodes = TestData.create
+
+    @store = Serienmover::SeriesStore.new([ TestHelper::SERIES_STORAGE_DIR ])
+  end
+
+  after(:each) do
+    TestData.clean
+  end
+
+  it "should be possible to instantiate the store" do
+    @store.should_not be_nil
+  end
+
+  it "should process the series directories" do
+    @store.series_dirs.size > 0
+  end
+
+  it "should build up a hash for series with all episodes" do
+    @store.series["Chuck"].size > 0
+  end
+
+  it "should return the right target for 'Chuck'" do
+    episode = @episodes[:chuck]
+    results = @store.find_suitable_target(episode)
+    results.select { |t| t.series == "Chuck" }.size.should be >= 1
+  end
+
+  it "should return the right target for 'Criminal Minds'" do
+    episode = @episodes[:crmi]
+    results = @store.find_suitable_target(episode)
+    results.select { |t| t.series == "Criminal Minds" }.size.should be >= 1
+  end
+
+  it "should only return the Criminal Minds target if a name is supplied" do
+    episode = @episodes[:crmi]
+
+    results = @store.find_suitable_target(episode, series: "Criminal Minds")
+    results.size.should be == 1
+    results[0].series.should eq "Criminal Minds"
+
+    results = @store.find_suitable_target(episode, series: "crmi")
+    results.size.should be == 1
+    results[0].series.should eq "Criminal Minds"
+
+    results = @store.find_suitable_target(episode, series: "sof criminal minds")
+    results.size.should be == 1
+    results[0].series.should eq "Criminal Minds"
+  end
+
+  it "should return the right target for 'The Big Bang Theory'" do
+    episode = @episodes[:tbbt]
+    results = @store.find_suitable_target(episode)
+    results.select { |t| t.series == "The Big Bang Theory" }.size.should be >= 1
+  end
+
+
+  it "should only return the Criminal Minds target if a name is supplied" do
+    episode = @episodes[:tbbt]
+
+    results = @store.find_suitable_target(episode, series: "sof tbbt")
+    results.size.should be == 1
+    results[0].series.should eq "The Big Bang Theory"
+  end
+
+  it "should return the right target for 'Dr House' (first epi of season)" do
+    episode = @episodes[:drhou]
+    results = @store.find_suitable_target(episode)
+    results.select { |t| t.series == "Dr House" }.size.should be >= 1
+  end
+
+  it "should build up the right path for an episode of a new season" do
+    episode = @episodes[:drhou]
+    results = @store.find_suitable_target(episode, series: 'Dr House')
+    results.size.should == 1
+
+    results[0].targetdir.should match(/House.*Staffel.05/i)
+  end
+
+  it "should build up the right path for an episode S10E01" do
+    episode = @episodes[:spook]
+    results = @store.find_suitable_target(episode, series: 'Spooks')
+    results.size.should == 1
+
+    results[0].targetdir.should match(/Spooks.*Staffel.10/i)
+  end
+
+  it "should exclude season of series where more season exists" do
+    episode = @episodes[:numbe]
+    results = @store.find_suitable_target(episode)
+    results.size.should == 1
+  end
+
+  it "should set target to used and skipped this target in future searches" do
+    episode = @episodes[:crmi]
+    results = @store.find_suitable_target(episode)
+    results.size.should be == 2
+
+    crmi_target = results.select { |t| t.series == "Criminal Minds" }[0]
+    @store.set_target_to_used(episode, crmi_target)
+
+    episode = @episodes[:seap]
+    less_results = @store.find_suitable_target(episode)
+    less_results.size.should be 1
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,92 @@
 require 'bundler/setup'
 require 'fileutils'
+require 'rspec'
+
+require File.dirname(__FILE__) + '/../lib/serienmover'
+require File.join(File.dirname(__FILE__), "spec_testdata.rb")
 
 RSpec.configure do |config|
 end
+
+class TestHelper
+
+  TESTFILE_DIRECTORY = File.join(File.dirname(__FILE__), 'testfiles')
+  SERIES_STORAGE_DIR = File.join(TESTFILE_DIRECTORY, 'series')
+
+  class << self
+
+    # create the supplied Files in the testfiles directory
+    def create_test_files(files)
+      _create_directories
+
+      files.each do |f|
+        FileUtils.touch File.join(TESTFILE_DIRECTORY, f)
+      end
+    end
+
+    # this method creates a directory structure for a given
+    # series with the opportunity to exclude some episodes
+    def create_series(seriesname, options={})
+      default = { :from => '1_0', :to => '1_0',
+                  :max => 30, :exclude => [] }
+      options = default.merge(options)
+
+      series_dir = File.join(SERIES_STORAGE_DIR, seriesname)
+      _create_dir(series_dir)
+
+      from = _split_entry(options[:from])
+      to   = _split_entry(options[:to])
+
+      for season in from[0]..to[0]
+
+        season_dir = File.join(series_dir, "Staffel %02d" % season)
+        _create_dir(season_dir)
+
+        episodes = (season == to[0]) ? to[1] : options[:max]
+
+        for episode in 1..episodes.to_i
+
+          # check for excludes
+          definition = "%d_%d" % [ season, episode ]
+          next if options[:exclude].include? definition
+
+          # build and create file
+          file = "S%02dE%02d - Epi%02d.avi" % [ season, episode,episode ]
+          episode_file = File.join(season_dir, file)
+          _create_file(episode_file)
+        end
+      end
+
+
+    end
+
+    # returns the absolute path to the given file
+    def path(element)
+      File.absolute_path(File.join(TESTFILE_DIRECTORY, element))
+    end
+
+    # remove testfile directory
+    def clean
+      if File.directory?(TESTFILE_DIRECTORY)
+        FileUtils.remove_dir(TESTFILE_DIRECTORY)
+      end
+    end
+
+    def _split_entry(definition)
+      definition.split(/_/)
+    end
+
+    def _create_directories
+      _create_dir TESTFILE_DIRECTORY
+      _create_dir SERIES_STORAGE_DIR
+    end
+
+    def _create_dir(dir)
+      FileUtils.mkdir(dir) unless File.directory?(dir)
+    end
+
+    def _create_file(file)
+      FileUtils.touch(file) unless File.file?(file)
+    end
+  end
+end

data/spec/spec_testdata.rb

@@ -0,0 +1,62 @@
+require File.join(File.dirname(__FILE__), "spec_helper.rb")
+
+class TestData
+
+  EPISODES = {
+    :chuck => { :filename => "S04E11 - Pilot.avi",
+                :series => "Chuck",
+                :data => { :from => '1_1', :to => '4_10' }
+    },
+    :tbbt  => { :filename => "S05E06 - Pilot.avi",
+                :series => "The Big Bang Theory",
+                :data => { :from => '1_1', :to => '5_9',
+                           :exclude => ['5_5', '5_6', '5_7', '5_8', ] }
+    },
+    :crmi  => { :filename => "S01E04 - Pilot.avi",
+                :series => "Criminal Minds",
+                :data => { :from => '1_1', :to => '1_3' }
+    },
+    :seap  => { :filename => "S01E04 - Pilot.avi",
+                :series => "Sea Patrol",
+                :data => { :from => '1_1', :to => '1_3' }
+    },
+    :drhou => { :filename => "S05E01 - First Episode.avi",
+                :series => "Dr House",
+                :data => { :from => '1_1', :to => '4_20' }
+    },
+    :spook => { :filename => "S10E01 - First Episode.avi",
+                :series => "Spooks",
+                :data => { :from => '1_1', :to => '9_20' }
+    },
+    :numbe => { :filename => "S04E31 - High Episode.avi",
+                :series => "Numb3rs",
+                :data => { :from => '1_1', :to => '4_30' }
+    },
+  }
+
+  # create test data
+  def self.create
+    episodes = Hash.new
+
+    EPISODES.each do |key,value|
+      TestHelper.create_test_files([ value[:filename] ])
+      TestHelper.create_series(value[:series], value[:data])
+
+      path = TestHelper.path(value[:filename])
+      episode = Serienrenamer::Episode.new(path)
+
+      episodes[key] = episode
+    end
+    return episodes
+  end
+
+  # remove files
+  def self.clean
+    TestHelper.clean
+  end
+
+  def self.get(key)
+    EPISODES[key]
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: serienmover
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-23 00:00:00.000000000 Z
+date: 2012-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: serienrenamer
@@ -30,7 +30,8 @@ dependencies:
 description: Tool that moves your episodes into a specific directory structure
 email:
 - philipp@i77i.de
-executables: []
+executables:
+- serienmover
 extensions: []
 extra_rdoc_files: []
 files:
@@ -40,11 +41,17 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- bin/serienmover
 - lib/serienmover.rb
+- lib/serienmover/episode.rb
+- lib/serienmover/series_store.rb
 - lib/serienmover/version.rb
 - serienmover.gemspec
+- spec/episode_spec.rb
 - spec/serienmover_spec.rb
+- spec/series_store_spec.rb
 - spec/spec_helper.rb
+- spec/spec_testdata.rb
 homepage: http://github.com/pboehm/serienmover
 licenses: []
 post_install_message: 
@@ -70,5 +77,8 @@ signing_key:
 specification_version: 3
 summary: Tool that moves your episodes into a specific directory structure
 test_files:
+- spec/episode_spec.rb
 - spec/serienmover_spec.rb
+- spec/series_store_spec.rb
 - spec/spec_helper.rb
+- spec/spec_testdata.rb