melon 0.1.0

data/.gitignore

@@ -0,0 +1,8 @@
+tmp
+*.swo
+*~
+*.swp
+pkg
+coverage
+*.db
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/History.txt

@@ -0,0 +1,6 @@
+=== 0.1.0 2011-01-25
+
+* Initial release, basic functionality present:
+  * Add files to database (add)
+  * query database about file (check)
+

data/README.textile

@@ -0,0 +1,29 @@
+h1. Melon
+
+A media file cataloging tool.
+
+h2. Synopsis
+
+Melon is a tool for tracking files based on content, aiming
+to scale to arbitrarily large files without slowing down.  It uses
+a sparse hashing algorithm to generate a digest without having to
+read the whole file, allowing it to go much faster than disk would
+ordinarily allow.
+
+h2. Installation
+
+<pre>
+gem install melon
+</pre>
+
+h2. Usage
+
+TODO
+
+h2. Motivation
+
+"Is this file copied onto my media drive yet?"
+
+h2. Author
+
+Copyright 2010 Andrew Roberts

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'cucumber'
+require 'cucumber/rake/task'
+require 'rake/gempackagetask'
+
+desc 'Default: run the cucumber features.'
+task :default => :features
+
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "features --format pretty"
+end
+
+eval("$specification = begin; #{IO.read('melon.gemspec')}; end")
+Rake::GemPackageTask.new($specification) do |package|
+  package.need_zip = true
+  package.need_tar = true
+end
+

data/TODO

@@ -0,0 +1,15 @@
+Command line parsing:
+* melon [<opts>] <cmd> <cmd-params> [<cmd-opts>]
+* pivot on <cmd>, melon opts come before cmd, cmd-opts come after
+* this may make it hard to guess at unrecognized commands
+* commands don't have a dash
+
+Testing:
+* fix rcov rake world
+
+Commands:
+* a command helper that
+  * dynamically makes the collection "commands" from files in commands/*
+  * figures out the padding for the banner
+
+  * google "ruby get all classes declared in a directory"

data/bin/melon

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+lib_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(lib_dir) unless $LOAD_PATH.include?(lib_dir)
+
+require 'melon'
+Melon::CLI.execute(ARGV)
+

data/features/basic.feature

@@ -0,0 +1,33 @@
+Feature: Basic usage
+
+  Background:
+    Given a file named "test_file" with:
+    """
+    This file is a test file
+    """
+
+  Scenario: Adding files to a melon database
+    When I run "melon -d test.db add test_file"
+    Then the output should contain a hash
+    And the output should contain "test_file"
+
+  Scenario: Adding a file that already exists
+    When I run "melon -d test.db add test_file"
+    And I run "melon -d test.db add test_file"
+    Then the output should contain:
+    """
+    melon: path already present in database
+    """
+    And the exit status should not be 0
+
+  Scenario: Checking a file that is not in the database
+    When I run "melon -d test.db check test_file"
+    Then the output should contain "test_file"
+    And the output should start with "/"
+
+  Scenario: Adding a directory
+    Given a directory named "testo"
+    When I run "melon -d test.db add testo"
+    Then the output should contain "directory"
+    And the exit status should not be 0
+

data/features/edges.feature

@@ -0,0 +1,13 @@
+Feature: Edge cases
+
+  Scenario: Adding two files with the identical contents
+    Given a file named "test_file" with:
+    """
+    This file is a test file
+    """
+    When I run "cp test_file test_file_2"
+    And I run "melon -d test.db add test_file test_file_2"
+    Then the stderr should contain:
+    """
+    melon: file exists elsewhere in the database
+    """

data/features/step_definitions/basic_steps.rb

@@ -0,0 +1,15 @@
+require 'aruba/api'
+
+Then /^the output should be empty$/ do
+  all_output.should match(/^$/)
+end
+
+Then /^the output should start with "([^"]*)"$/ do |arg1|
+  all_output.should match(/^#{arg1}/)
+end
+
+Then /^the output should contain a hash$/ do
+  all_output.should match(/[a-fA-F0-9]{20}/)
+end
+
+

data/features/support/env.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'aruba/cucumber'
+
+Before do
+  @aruba_timeout_seconds = 2
+end
+

data/lib/melon.rb

@@ -0,0 +1 @@
+require 'melon/cli'

data/lib/melon/cli.rb

@@ -0,0 +1,121 @@
+require 'ostruct'
+require 'optparse'
+
+require 'melon/version'
+require 'melon/commands'
+
+module Melon
+  class CLI
+
+    def self.execute(arguments=[])
+      new(arguments).run
+    end
+
+    attr_accessor :arguments
+
+    def initialize(arguments)
+      self.arguments = arguments
+    end
+
+    def self.default_options
+      options = OpenStruct.new
+      options.database_path = "#{ENV['HOME']}/.melondb"
+      options
+    end    
+
+    def run
+      options = parse_options
+      options.database = PStore.new(File.expand_path(options.database_path))
+
+      # prepare db
+      options.database.transaction do
+        options.database[:by_hash] ||= {}
+        options.database[:by_path] ||= {}
+      end
+
+      unless arguments.empty?
+        run_command(options)
+      end
+    end
+
+    def run_command(options)
+      # look for command class in args.shift
+      command_name = arguments.shift
+      begin
+        command = Commands.const_get(command_name.capitalize)
+        command.new(arguments, options).run
+      # rescue NameError
+      #   CLI.error "unrecognized command: #{command_name}"
+      end
+    end
+
+    def parse_options
+      options = CLI.default_options
+
+      parser = OptionParser.new do |p|
+        p.banner = "Usage: melon [options] COMMAND [command-options] [ARGS]"
+
+        p.separator ""
+        p.separator "Commands:"
+        p.separator ""
+
+        %w(add check).each do |command|
+          cls = Commands.const_get(command.capitalize)
+          p.separator format_command(command, cls.description)
+        end
+
+        p.separator ""
+        p.separator "Options:"
+        p.separator ""
+
+        p.on("-d", "--database PATH",
+             "Path to database file (#{options.database_path})") do |database|
+          options.database_path = database
+             end
+
+        p.on_tail("-v", "--version", "Show version") do
+          puts Melon.version_string
+          exit 0
+        end
+
+        p.on_tail("-h", "--help", "This is it") do
+          puts p
+          exit 0
+        end
+
+      end
+
+      begin
+        parser.order!(arguments)
+      rescue OptionParser::ParseError => e
+        CLI.error e
+      end
+
+      options
+    end
+
+    def format_command(name, desc, margin = 4, width = 22, wrapdesc = 80)
+      pad = "\n" + ' ' * width
+      desc = wrap_text(desc, wrapdesc - width).split("\n").join(pad)
+
+      ' ' * margin + "#{name.ljust(width-margin)}#{desc}"
+    end
+
+    def wrap_text(txt, col = 80)
+      txt.gsub(/(.{1,#{col}})( +|$\n?)|(.{1,#{col}})/,
+               "\\1\\3\n") 
+    end
+    
+    
+    def self.error(error_obj_or_str, code = 1)
+      if error_obj_or_str.respond_to?('to_s')
+        error_str = error_obj_or_str.to_s
+      else
+        error_str = error_obj_or_str.inspect
+      end
+
+      $stderr.puts "melon: #{error_str}"
+      exit code
+    end
+  end
+end

data/lib/melon/commands.rb

@@ -0,0 +1,122 @@
+require 'pstore'
+require 'ftools'
+
+require 'melon/hasher'
+require 'melon/cli'
+
+# TODO: in commands, parse arguments with parse!  in CLI, parse with order!
+
+module Melon
+  module Commands
+    # needs a 'verify' command to check integrity of database
+    # needs a 'remove' command, or some way to deal with deletes/renames
+    class Base
+      attr_accessor :args, :options
+      attr_reader :description
+
+      def initialize(args, options)
+        self.args = args
+        self.options = options
+      end
+
+      def parser
+        raise
+      end
+
+      def self.description
+        raise
+      end
+
+      def parse_options!
+        begin
+          parser.parse!(args)
+        rescue OptionParser::ParseError => e
+          CLI.error "#{self.class.to_s.split("::").last.downcase}: #{e}"
+        end
+      end
+
+    end
+
+    class Add < Base
+
+      def self.description
+        "Add files to the melon database"
+      end
+
+      def parser
+        @parser ||= OptionParser.new do |p|
+          p.banner = "Usage: melon add [options] file [file [file ...]]"
+          p.separator ""
+          p.separator Add.description
+
+          p.separator ""
+          p.separator "Options:"
+          p.separator ""
+
+          # p.on("-f", "--force",
+          #      "Force the recalculation of the path that",
+          #      " already exists in the database") do
+          #   options.force = true
+          #      end
+        end
+      end
+
+      def run
+        parse_options!
+
+        options.database.transaction do
+          args.each do |arg|
+            filename = File.expand_path(arg)
+
+            if File.directory?(filename)
+              CLI.error "argument is a directory: #{arg}"
+            end
+
+            if options.database[:by_path][filename]# and !options.force
+              CLI.error "path already present in database: #{arg}"
+            end
+
+            # hash strategy should be encapsulated, ergo indirection here
+            hash = Hasher.digest(filename)
+
+            if options.database[:by_hash][hash]
+              CLI.error "file exists elsewhere in the database: #{arg}"
+            end
+
+
+            options.database[:by_hash][hash] = filename
+            options.database[:by_path][filename] = hash
+            puts "#{hash}:#{filename}"
+          end
+        end
+      end
+    end
+
+    class Check < Base
+      def self.description
+        "Determine whether or not a copy of a file resides in the database"
+      end
+
+      def parser
+        @parser ||= OptionParser.new do |p|
+          p.banner = "Usage: melon check file [file [file ...]]"
+          p.separator ""
+          p.separator Check.description
+        end
+      end
+
+      def run
+        parse_options!
+
+        options.database.transaction do
+          args.each do |filename|
+            hash = Hasher.digest(filename)
+            unless options.database[:by_hash][hash]
+              puts File.expand_path(filename)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/melon/commands/add.rb

@@ -0,0 +1,10 @@
+module Melon
+  module Commands
+    class Add
+      extend BasicCommand
+
+
+    end
+  end
+end
+

data/lib/melon/commands/basic_command.rb

@@ -0,0 +1,19 @@
+module Melon
+  module Commands
+    module BasicCommand
+
+      def execute(arguments, options)
+        new(arguments, options).run
+      end
+
+      # returns name {padding} description, for usage"
+      def short_usage(padding="   ")
+        name = Melon::Commands.translate_command(self)
+        extra_spaces = Melon::Commands.commands.collect do |c|
+          c.length
+        end.max - name.length
+        "#{name}#{padding}#{' ' * extra_spaces}#{self.description}"
+      end
+    end
+  end
+end

data/lib/melon/commands/help.rb

@@ -0,0 +1,51 @@
+require 'melon/commands/basic_command'
+
+module Melon
+  module Commands
+    class Help
+      # Help is a basic command that also ties itself in to cli#usage, so
+      # it's a little bit unconventional.  Retrospectively, I should not
+      # have written it first.  
+      extend BasicCommand
+
+      def self.description
+        "Get help with a specific command, or with Melon in general"
+      end
+
+      attr_accessor :arguments
+
+      def initialize(arguments, options)
+        self.arguments = arguments
+      end
+      
+      def parser
+        @parser ||= OptionParser.new do |opts|
+          Melon::Commands.command_hash.each do |name, command|
+            next if command == self.class
+            # TODO help banner: gem help help
+            # TODO flesh out parsing - give short_usage for each command
+            opts.on(name) { command.parser }
+          end
+        end
+      end
+
+      def run
+        begin
+          parser.parse!(arguments)
+        rescue OptionParser::InvalidOption => e
+          puts "melon: #{e.to_s}"
+          exit 1
+        end
+
+        if arguments == ['help']
+          puts parser
+          exit
+        end
+        
+        # if arguments are empty, we handled it in CLI
+        puts "melon: '#{arguments.join(' ')}' is not a recognized command."
+        exit 1
+      end
+    end
+  end
+end

data/lib/melon/example.rb

@@ -0,0 +1,68 @@
+require 'rubygems'
+require 'subcommand'
+
+require 'melon/version'
+
+module Melon
+  class CLI
+    def self.execute(arguments=[])
+      new(arguments).run
+    end
+
+    attr_accessor :arguments
+
+    def initialize(arguments)
+      self.arguments = arguments
+    end
+
+    def run
+      # command may be nil, if no command is given
+      command = parser.parse!(arguments)
+    end
+
+    def parser
+      @parser ||= OptionParser.new do |opts|
+        opts.banner = "Example of what option parsing should look like"
+
+        opts.on("-d", "--database=PATH", String,
+                "Path to Melon's sqlite database.",
+                "  (default ~/.melon/melon.db)") do |arg|
+          self.options[:database] = arg
+                end
+    
+        opts.on("-v", "--version",
+                "Display the program version.") { puts "0.0.0" }
+        opts.on("-h", "--help",
+                "Show this help message.") { puts parser }
+        opts.separator ""
+
+        opts.command :create, "description text" do |subopts|
+          subopts.banner "create: create a directory, somewhere"
+
+          subopts.on("-f" "--force",
+                     "Force creation.") { self.options[:force] = true }
+        end
+
+
+        opts.separator "To see a list of commands, use 'melon help commands'."
+        opts.separator "To get help with a specific command," +
+          " use 'melon help COMMAND'."
+      end
+
+      # OptionParser#command adds lazy option parsers to an array
+      # of subcommands
+      #
+      # melon help COMMAND prints the appropriate option
+      #
+      # PARSING:
+      # the option parser knows what the commands are at parse time
+      # so, scan the parse!() argument for the first command and pivot on
+      # it
+      #
+      # pre-cmd goes to the main option_parser.parse
+      # cmd goes into a string, is returned
+      # post-cmd goes to cmd parser.parse!()
+      #
+      # possibly implement that behavior for order! as well 
+  end
+end

data/lib/melon/hasher.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'digestif/hasher'
+
+module Melon
+  class Hasher
+    def self.digest(filename)
+      hasher = Digestif::Hasher.new(filename)
+      hasher.options.read_size = 40000
+      hasher.options.seek_size = 80000000
+      hasher.digest
+    end
+  end
+end

data/lib/melon/version.rb

@@ -0,0 +1,10 @@
+module Melon
+  def self.version
+    "0.1.0"
+  end
+
+  def self.version_string
+    "melon version #{self.version}"
+  end
+end
+

data/melon.gemspec

@@ -0,0 +1,32 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+require 'melon/version'
+
+Gem::Specification.new do |s|
+    s.name        = %q{melon}
+    s.version     = Melon.version
+    s.summary     = %q{A media catalog}
+    s.description = %q{A tool for tracking files based on content, aiming to scale to arbitrarily large files without slowing down}
+
+    s.files         = `git ls-files`.split("\n")
+    s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+    s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+    s.default_executable = 'melon'
+
+    s.require_path = 'lib'
+
+    s.has_rdoc = false
+
+    s.authors = ["Andrew Roberts"]
+    s.email   = %q{adroberts@gmail.com}
+    s.homepage = "http://github.com/aroberts/melon"
+
+    s.add_dependency("digestif", ">=1.0.4")
+
+    s.add_development_dependency('cucumber')
+    s.add_development_dependency('aruba')
+
+    s.platform = Gem::Platform::RUBY
+    s.rubygems_version = %q{1.2.0}
+end
+

data/script/console

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+libs <<  " -r irb/ext/save-history"
+
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/melon.rb'}"
+puts "Loading melon gem"
+exec "#{irb} #{libs} --simple-prompt"

data/spec/melon/cli_spec.rb

@@ -0,0 +1,8 @@
+require 'melon/cli'
+
+describe Melon::CLI do
+  before do
+    @cli = Melon::CLI
+  end
+  
+end

data/spec/melon/database_spec.rb

@@ -0,0 +1,32 @@
+require 'melon/database'
+
+describe Melon::Database, "when passing a file that doesn't exist" do
+  before do
+    @database = Melon::Database.new(nonexistant_database_file)
+  end
+
+  after do
+    FileUtils.rm_rf(@database.path)
+  end
+  
+  it "should be created" do
+    File.exist?(@database.path).should be_true
+  end
+  
+end
+
+describe Melon::Database, "when passing a file that is not a database" do
+  before do
+    @file = non_database_file
+  end
+
+  after do
+    FileUtils.rm_rf(@file)
+  end
+
+  it "should throw an exception" do
+    lambda {
+      @database = Melon::Database.new(non_database_file)
+    }.should raise_error(ActiveRecord::StatementInvalid)
+  end
+end

data/spec/melon/fingerprint_spec.rb

@@ -0,0 +1,30 @@
+require 'melon/fingerprint'
+require 'melon/database' # may need to reverse the order of these
+
+
+describe Fingerprint, "when creating with just a file" do
+  before do
+    File.stub!(:exist?) { true }
+
+    @database = Database.new(nonexistant_database_file)
+    @fingerprint = Fingerprint.new(:file => small_media_file)
+    @fingerprint.save!
+  end
+
+  after do
+    FileUtils.rm_rf(@database.path)
+  end
+  
+  it "should resolve the path" do
+    @fingerprint.file.should match(/^\//)
+  end
+
+  it "should be valid" do
+    @fingerprint.should be_valid
+  end
+
+  it "should set the digest field" do
+    @fingerprint.digest.should_not be_nil
+  end
+  
+end

data/spec/melon/parsed_arguments_spec.rb

@@ -0,0 +1,77 @@
+require 'melon/parsed_arguments'
+
+describe Melon::ParsedArguments, "when splitting valid arguments" do
+  before do
+    @args = Melon::ParsedArguments.new(%w(-t -b help plate /path/to/file -t 5))
+  end
+  
+  it "should correctly find the program arguments" do
+    @args.program_arguments.should include("-t", "-b")
+    @args.program_arguments.length.should == 2
+  end
+
+  it "should correctly find the command" do
+    @args.command.should == "help"
+  end
+
+  it "should correctly find the command arguments" do
+    @args.command_arguments.should include("plate", "/path/to/file", "-t", "5")
+    @args.command_arguments.length.should == 4
+  end
+end
+
+describe Melon::ParsedArguments, "when splitting argument-less commands" do
+  before do
+    @args = Melon::ParsedArguments.new(%w(help))
+  end
+  
+  it "should correctly find the program arguments" do
+    @args.program_arguments.should be_empty
+  end
+
+  it "should correctly find the command" do
+    @args.command.should == "help"
+  end
+
+  it "should correctly find the command arguments" do
+    @args.command_arguments.should be_empty
+  end
+end
+
+describe Melon::ParsedArguments, "when splitting command-less arguments" do
+  before do
+    @args = Melon::ParsedArguments.new(%w(--help))
+  end
+
+  it "should set the program arguments" do
+    @args.program_arguments.should include("--help")
+    @args.program_arguments.length.should == 1
+  end
+
+  it "shound not set a command" do
+    @args.command.should be_nil
+  end
+  
+  it "should not set any command arguments" do
+    @args.command_arguments.should be_nil
+  end
+end
+
+describe Melon::ParsedArguments, "when splitting invalid commands" do
+  before do
+    @args = Melon::ParsedArguments.new(%w(fizzle))
+  end
+
+  it "should not set a command" do
+    @args.command.should be_nil
+  end
+
+  it "should treat the invalid command as a program argument" do
+    @args.program_arguments.should include("fizzle")
+    @args.program_arguments.length.should == 1
+  end
+
+  it "should not set command arguments" do
+    @args.command_arguments.should be_nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,61 @@
+begin
+  require 'rspec'
+rescue LoadError
+  require 'rubygems' unless ENV['NO_RUBYGEMS']
+  gem 'rspec'
+  require 'rspec'
+end
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'melon'
+include Melon
+
+
+def nonexistant_database_file
+  'tmp/' + (0..8).map{ ('a'..'z').to_a[rand(26)] }.join + '.db'
+end
+
+def non_database_file
+  name = nonexistant_database_file
+  File.open(name, 'w') {|f| f.write("bad") }
+  name
+end
+
+def small_media_file
+  name = nonexistant_database_file
+  File.open(name, 'w') do |f|
+    f.write(<<EOS
+<p>
+It is included in the Ruby standard library.
+</p>
+<h2>Description</h2>
+<p>
+ftools adds several (class, not instance) methods to the <a
+href="File.html">File</a> class, for copying, moving, deleting, installing,
+and comparing files, as well as creating a directory <a
+href="File.html#M002554">path</a>. See the <a href="File.html">File</a>
+class for details.
+</p>
+<p>
+<a href="FileUtils.html">FileUtils</a> contains all or nearly all the same
+functionality and more, and is a recommended option over ftools
+</p>
+<p>
+When you
+</p>
+<pre>
+  require 'ftools'
+</pre>
+<p>
+then the <a href="File.html">File</a> class aquires some utility methods
+for copying, moving, and deleting files, and more.
+</p>
+<p>
+See the method descriptions below, and consider using <a
+href="FileUtils.html">FileUtils</a> as it is more comprehensive.
+</p>
+EOS
+           )
+  end
+  name
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification 
+name: melon
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Andrew Roberts
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-25 00:00:00 -05:00
+default_executable: melon
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: digestif
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 31
+        segments: 
+        - 1
+        - 0
+        - 4
+        version: 1.0.4
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: aruba
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: A tool for tracking files based on content, aiming to scale to arbitrarily large files without slowing down
+email: adroberts@gmail.com
+executables: 
+- melon
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- History.txt
+- README.textile
+- Rakefile
+- TODO
+- bin/melon
+- features/basic.feature
+- features/edges.feature
+- features/step_definitions/basic_steps.rb
+- features/support/env.rb
+- lib/melon.rb
+- lib/melon/cli.rb
+- lib/melon/commands.rb
+- lib/melon/commands/add.rb
+- lib/melon/commands/basic_command.rb
+- lib/melon/commands/help.rb
+- lib/melon/example.rb
+- lib/melon/hasher.rb
+- lib/melon/version.rb
+- melon.gemspec
+- script/console
+- spec/melon/cli_spec.rb
+- spec/melon/database_spec.rb
+- spec/melon/fingerprint_spec.rb
+- spec/melon/parsed_arguments_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/aroberts/melon
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A media catalog
+test_files: 
+- features/basic.feature
+- features/edges.feature
+- features/step_definitions/basic_steps.rb
+- features/support/env.rb
+- spec/melon/cli_spec.rb
+- spec/melon/database_spec.rb
+- spec/melon/fingerprint_spec.rb
+- spec/melon/parsed_arguments_spec.rb
+- spec/spec_helper.rb