peanut 0.1

data/README.rdoc

@@ -0,0 +1,22 @@
+= Peanut
+
+Peanut is a key/value store kind of similar to BOOM. Instead of managing lists, we store everything in 1 key value store to keep things simple.
+
+== Usage
+
+Usage is pretty straight forward:
+
+  peanut help                 show a quick help overview
+  peanut <key> <value>    		adds the key/value pair to your bucket
+  peanut rm <key>         		removes the key/value pair where key matches
+  peanut <key>            		copies the value of key to your clipboard
+	peanut <key> v							adds the value of your clipboard to key
+  peanut list                 shows everything currently in your bucket
+
+== Installation
+
+gem install zap
+
+== Requirements
+
+Peanut should function on Linux, BSD (assuming you run X), or Mac OS X. There are currently a few bugs on some Linux systems I've tested. xclip seems to hang, although it actually functions. I'm working on that!

data/bin/peanut

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'rubygems' rescue LoadError
+$:.unshift File.dirname(__FILE__) + '/../lib/'
+require 'peanut'
+
+Peanut::Command.run(*ARGV)

data/lib/peanut/clipboard.rb

@@ -0,0 +1,24 @@
+module Peanut
+  class Clipboard
+    class << self
+
+      def copy(string)
+        cmd = if RUBY_PLATFORM =~ /linux/
+          "xclip -selection clipboard"
+        else
+          "pbcopy"
+        end
+        
+        `echo #{string} | tr -d "\n" | #{cmd}`        
+      end
+      
+      def paste
+        if RUBY_PLATFORM =~ /linux/
+          `xclip -selection clipboard -o`
+        else
+          `pbpaste`
+        end
+      end
+    end
+  end
+end

data/lib/peanut/command.rb

@@ -0,0 +1,75 @@
+module Peanut
+  class Command
+    class << self
+            
+      def run(*args)
+        key = args.shift
+        value = args.join(' ') unless args.length == 0
+        
+        return help unless key
+        return send key, value if is_arged_keyword?(key)
+        return send key if is_keyword?(key)
+        return save key, value if key && value
+        return get key
+      end
+      
+      private
+      
+      def store
+        @store ||= Peanut::Store.new(ENV['HOME'] + '/.peanut')
+      end
+      
+      def list
+        puts "Your peanut bucket: \n#{'-' * 20}"
+        store.each_pair do |key, value|
+          puts "#{key}: #{value}"
+        end
+      end   
+      
+      def help
+        puts %{
+            #{executable} <key> <value>      sets the "key" value to "value"
+            #{executable} <key>              copies the value for "key" to the clipboard
+            #{executable} rm <foo>           removes the key/value pair where the key = foo
+            #{executable} <foo> v            stores your current clipboard value into foo
+            #{executable} list               shows all the values that are in your peanut bucket
+            #{executable} help               shows you this help document
+        }.gsub(/^ {10}/, '') # murderous villain of whitespace   
+      end
+    
+      def get(key)
+        if val = store[key]
+          Clipboard.copy(val)
+          puts "Copied '#{val}' to the clipboard!"
+        else
+          puts "No value stored with key '#{key}'"
+        end
+      end
+    
+      def save(key, val)
+        val = Clipboard.paste if val == 'v'
+        store[key.intern] = val
+        store.save
+        puts "Saved '#{val}' as '#{key}'"
+      end
+    
+      def executable
+        @executable ||= $0.split('/').pop
+      end
+    
+      def rm(key)
+        store[key] = nil
+        store.save
+        puts "Deleted the value with the key '#{key}'"
+      end
+    
+      def is_keyword?(word)
+        ['rm', 'list', 'help'].include? word
+      end
+    
+      def is_arged_keyword?(word)
+        ['rm'].include? word
+      end
+    end
+  end
+end

data/lib/peanut/store.rb

@@ -0,0 +1,47 @@
+module Peanut
+  class Store
+
+    attr_accessor :store, :file
+
+    def initialize(file)
+      self.file = file
+      
+      init_file unless File.exists?(file)
+      self.store = Yajl::Parser.parse(File.new(file, 'r'))
+    end
+
+    def to_json
+      Yajl::Encoder.encode(store)
+    end
+
+    def []=(key, val)
+      self.store[key] = val
+      self.store.delete(key) if val.nil?
+      return val
+    end
+
+    def [](key)
+      return store[key]
+    end
+    
+    def save
+      File.open(file, 'w') { |f| f.write(to_json) }
+    end
+    
+    def each_pair
+      store.each do |key, val|
+        yield key, val
+      end
+      
+      if store.empty?
+        yield "Bucket", "empty"
+      end
+    end
+    
+    private
+    
+    def init_file
+      File.open(file, 'w') { |f| f.write "{}" }
+    end
+  end
+end

data/lib/peanut/version.rb

@@ -0,0 +1,3 @@
+module Peanut
+  VERSION = "0.1"
+end

data/lib/peanut.rb

@@ -0,0 +1,10 @@
+require 'yajl'
+
+module Peanut
+  
+  require 'peanut/clipboard'
+  require 'peanut/store'
+  require 'peanut/command'
+
+end
+

data/peanut.gemspec

@@ -0,0 +1,21 @@
+require File.expand_path("../lib/peanut/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "peanut"
+  s.version     = Peanut::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['the_gastropod', 'chrisrhoden']
+  s.email       = []
+  s.homepage    = "http://rubygems.org/gems/peanut"
+  s.summary     = "Peanut is a friendly remake of BOOM, where we manage simple key/value stores instead of lists."
+  s.description = "Peanut is a simple command line clipboard manager similar to BOOM. We use key/value stores instead of lists, keeping things simple."
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "peanut"
+  
+  s.add_dependency 'yajl-ruby'
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+end

data/test/examples/test.json

@@ -0,0 +1 @@
+{"keya":"this is value a","keyb":"this is value b"}

data/test/helper.rb

@@ -0,0 +1,20 @@
+require 'test/unit'
+
+begin
+  require 'rubygems'
+  require 'redgreen' # We'd like to see pretty pass/fails!
+rescue LoadError
+end
+
+require 'mocha'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'peanut'
+
+def peanut_json(name)
+  #Peanut::Store.any_instance.stubs(:json_file).
+  #returns("test/examples/#{name}.json")
+  Peanut.stubs(:storage).returns(Peanut::Store.new("examples/#{name}.json"))
+end

data/test/test_command.rb

@@ -0,0 +1,31 @@
+require 'helper'
+
+# Dont Mind this
+# Just a little ghetto monkey patching
+# It lets us grab the STD I/O, and test it
+class Object
+  class << self
+    attr_accessor :output
+    def puts(s)
+      @output = s
+    end
+  end
+end
+
+class TestCommand < Test::Unit::TestCase
+  
+  def setup
+    peanut_json "test"
+  end
+  
+  def command(cmd)
+    cmd = cmd.split(' ') if cmd
+    Object.puts Peanut::Command.run(*cmd) 
+  end
+  
+  def test_adding_entry
+    assert_equal "Saved 'testing' as 'test'", command("test testing")
+  end
+  
+end
+  

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: peanut
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- the_gastropod
+- chrisrhoden
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-01-11 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Peanut is a simple command line clipboard manager similar to BOOM. We use key/value stores instead of lists, keeping things simple.
+email: []
+
+executables: 
+- peanut
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.rdoc
+- bin/peanut
+- lib/peanut.rb
+- lib/peanut/clipboard.rb
+- lib/peanut/command.rb
+- lib/peanut/store.rb
+- lib/peanut/version.rb
+- peanut.gemspec
+- test/examples/test.json
+- test/helper.rb
+- test/test_command.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/peanut
+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: 23
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: peanut
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: Peanut is a friendly remake of BOOM, where we manage simple key/value stores instead of lists.
+test_files: []
+