purse 0.1.0

data/lib/purse/note.rb

@@ -0,0 +1,62 @@
+module Purse
+  class Note
+    attr_reader :path, :name, :encrypted, :options 
+    attr_accessor :data
+    
+    def initialize(path, name, data, options = {})
+      Purse.check_for_parameter('path', path)
+      Purse.check_for_parameter('name', name)
+      @path = path
+      @name = name
+      @options = options
+      if options[:encrypted]
+        @encrypted = data
+      else
+        @data = data
+      end
+    end
+    
+    def self.load(path, name, options = {})
+      note = Note.new(path, name, nil)
+      raise MissingFile, "Tried to load #{note.file_path} but it does not exist" unless File.readable?(note.file_path)
+      encrypted_data = File.read(note.file_path)
+      Note.new(path, name, encrypted_data, options.merge(:encrypted => true))
+    end
+
+    def save(password)
+      Purse.check_for_parameter('password', password)
+      encrypt(password)
+      File.open(file_path, 'w') {|f| f << @encrypted }
+      self
+    end
+
+    def encrypt(password)
+      Purse.check_for_parameter('password', password)
+      blowfish = Crypt::Blowfish.new(password)
+      @encrypted = blowfish.encrypt_string(@data)
+    end
+
+    def decrypt(password)
+      Purse.check_for_parameter('password', password)
+      blowfish = Crypt::Blowfish.new(password)
+      @data = blowfish.decrypt_string(@encrypted)
+    end
+    
+    def encrypted?
+      @encrypted && (!@data || @data.blank?)
+    end
+    
+    def delete
+      File.unlink(file_path)
+    end
+    
+    def file_path
+      File.join(path, file_name)
+    end
+    
+    def file_name
+      "#{name}.note"
+    end
+    
+  end
+end

data/lib/purse/pocket.rb

@@ -0,0 +1,80 @@
+module Purse
+  class Pocket
+    attr_reader :path
+    
+    def initialize(path)
+      Purse.check_for_parameter('path', path)
+      @path = File.expand_path(path)
+    end
+    
+    def init
+      FileUtils.mkdir_p(@path) unless File.readable?(@path)
+      git
+    end
+    
+    def delete
+      FileUtils.rm_rf(@path)
+    end
+    
+    def find(name)
+      Purse.check_for_parameter('name', name)
+      note = notes.find {|note| note.name == name }
+      note ? note : raise(Purse::MissingFile, "Could note find the note named #{note}")
+    end
+    
+    def edit(name)
+      Purse.check_for_parameter('name', name)
+      begin
+        note = find(name)
+      rescue Purse::MissingFile
+        note = Note.new(path, name, nil)
+      end
+      yield(note)
+      @notes = load_notes
+    end
+    
+    def notes
+      @notes ||= load_notes
+    end
+    
+    def notes_paths
+      Dir[File.join(@path, '*.note')]
+    end
+    
+    def load_notes
+      notes_paths.collect {|note_path| Note.load(File.dirname(note_path), File.basename(note_path, '.note'))}
+    end
+    
+    def re_encrypt(password)
+      Purse.check_for_parameter('password', password)
+      notes.collect {|n| n.save(password) }
+    end
+    
+    def commit
+      git.add('.')
+      return if git.status.changed.empty?
+      git.commit_all("Changes via Purse #{Time.now}")
+    end
+    
+    def remote
+      git.remotes.first
+    end
+    
+    def set_remote(remote_url)
+      git.add_remote('origin', remote_url)
+    end
+    
+    def push
+      git.push('origin')
+    end
+    
+    def pull
+      git.pull('origin')
+    end
+    
+    protected
+    def git
+      @git ||= Git.init(@path)
+    end
+  end
+end

data/lib/purse/settings.rb

@@ -0,0 +1,57 @@
+module Purse
+  class Settings
+
+    class << self
+      def default_path
+        File.join(File.expand_path('~'), '.purse', 'settings.yml')
+      end
+
+      def path
+        @path ||= default_path
+      end
+
+      def path=(new_path)
+        raise MissingParameter unless new_path.is_a?(String)
+        @path = new_path
+        @loaded = false
+      end
+
+      def load
+        save unless File.readable?(path)
+        @settings = YAML.load_file(path)
+        @loaded = true
+      end
+
+      def loaded?
+        @loaded ||= false
+      end
+
+      def save
+        FileUtils.mkdir_p(File.dirname(path))
+        File.open(path, 'w') {|f| f << YAML::dump(settings) }
+      end
+
+      def get(key)
+        load unless loaded?
+        settings[key.to_s]
+      end
+
+      def set(key, value, should_save = true)
+        settings[key.to_s] = value
+        save if should_save
+      end
+
+      def settings
+        @settings ||= {}
+      end
+      
+      def settings=(new_settings)
+        return unless new_settings.is_a?(Hash)
+        new_settings.each do |k, v|
+          set(k, v, false)
+        end
+        save
+      end
+    end 
+  end
+end

data/lib/purse/version.rb

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

data/test/purse/test_cli.rb

@@ -0,0 +1,51 @@
+require 'test_helper.rb'
+
+class TestCli < Test::Unit::TestCase
+
+  context "Purse" do
+    context "Cli" do
+      context "run" do
+        setup do
+          HighLine.any_instance.stubs(:say)
+          @pocketname = 'test_purse_data'
+        end
+        
+        
+        # purse pursename #=> initialize or pull
+        context "purse pursename" do
+          should "call list" do
+            Cli.expects(:list).with(@pocketname).once
+            Cli.run([@pocketname])
+          end
+        end
+        
+        # purse pursename notename
+        context "purse pursename notename" do
+          
+          context "if the note exists" do
+            should "call init then call find and then display" do
+              notename = 'test123'
+              Cli.expects(:find).with(@pocketname,notename).once
+              Cli.run([@pocketname, notename])
+            end
+          end
+        end
+        
+        # purse pursename notename --edit #=> open in EDITOR save and push
+        context "purse pursename notename --edit" do
+          should "call init edit" do
+            notename = 'jagger'
+            Cli.expects(:edit).with(@pocketname,notename).once
+            Cli.run([@pocketname, notename, '--edit'])
+          end
+        end
+        
+        # purse pursename push
+        # purse pursename pull
+        # purse settings/ purse # rerun settings 
+        
+        
+      end
+    end
+  end
+end

data/test/purse/test_note.rb

@@ -0,0 +1,206 @@
+require 'test_helper.rb'
+
+class TestNote < Test::Unit::TestCase
+
+  context "Purse" do
+    context "Note" do
+
+      context "an instance" do        
+        setup do
+          @path = purse_path
+          @note = Note.new(@path, 'sander', 'Nonsense', :method => :blowfish, :store_as => :yaml)
+        end
+
+        context "new" do
+
+          should "require path" do
+            assert_raise(MissingParameter) do
+              Note.new(nil,'sander','Sander nonsense')
+            end
+          end
+
+          should "require name" do
+            assert_raise(MissingParameter) do
+              Note.new(purse_path, '', 'Sander nonsense')
+            end
+          end
+
+          context "initializing with regular data" do
+            should "set @path" do
+              assert_equal @path, @note.path
+            end
+
+            should "set @name" do
+              assert_equal 'sander', @note.name
+            end
+
+            should "set @data" do
+              assert_equal 'Nonsense', @note.data
+            end
+
+            should "save extra args as options" do
+              assert @note.options.is_a?(Hash)
+              assert_equal :blowfish, @note.options[:method]
+            end
+          end
+
+          context "initializing with encrypted data" do
+            setup do
+              @note = Note.new(purse_path, 'sander', 'ENCRYPTED DATA', :encrypted => true)
+            end
+
+            should "set @path" do
+              assert_equal purse_path, @note.path
+            end
+
+            should "set @name" do
+              assert_equal 'sander', @note.name
+            end
+
+            should "not set @data" do
+              assert_nil @note.data
+            end
+
+            should "set @encrypted" do
+              assert_equal 'ENCRYPTED DATA', @note.encrypted
+            end
+          end
+        end
+
+        context "file_name" do
+          should "return #name.note" do
+            assert_equal @note.name + '.note', @note.file_name
+          end
+        end
+
+        context "file_path" do
+          should "return path/name.note" do
+            assert_equal File.join(@note.path, @note.name + '.note'), @note.file_path
+          end
+        end
+
+        context "save" do
+
+          should "require password" do
+            assert_raise(MissingParameter) do
+              @note.save(nil)
+            end
+          end
+
+          context "with password" do
+            setup do
+              @password = '12345' 
+              Crypt::Blowfish.any_instance.expects(:encrypt_string).with(@note.data).returns('ENCRYPTED DATA')
+              @note.save(@password)
+            end
+
+            should "encrypt data and place in @encrypted" do
+              assert_equal 'ENCRYPTED DATA', @note.encrypted
+            end
+
+            should "write to file in path with #name" do
+              assert File.readable?(@note.file_path)
+              assert_equal @note.encrypted, File.read(@note.file_path)
+            end
+
+            # teardown do
+            #   File.unlink(purse_path, 'sander')
+            # end
+          end
+        end
+
+        context "encrypt" do
+          # blowfish = Crypt::Blowfish.new("A key up to 56 bytes long")
+          # plainBlock = "ABCD1234"
+          # encryptedBlock = blowfish.encrypt_block(plainBlock)
+          # decryptedBlock = blowfish.decrypt_block(encryptedBlock)
+
+          should "require password" do
+            assert_raise(MissingParameter) do
+              @note.encrypt(nil)
+            end
+          end
+          
+          context "with password" do
+            setup do
+              @password = 'Test123'
+              Crypt::Blowfish.any_instance.expects(:encrypt_string).with(@note.data).returns('ENCRYPTED DATA')
+              @note.encrypt(@password)
+            end
+
+            should "save encrypted data to encrypted" do
+              assert_equal 'ENCRYPTED DATA', @note.encrypted
+            end
+          end
+        end
+
+        context "decrypt" do
+          setup do
+            @note = Note.new(purse_path, 'sander', 'ENCRYPTED DATA', :encrypted => true)
+          end
+
+          should "require password" do
+            assert_raise(MissingParameter) do
+              @note.decrypt(nil)
+            end
+          end
+
+          context "with password" do
+            setup do
+              @password = 'Test123'
+              Crypt::Blowfish.any_instance.expects(:decrypt_string).with(@note.encrypted).returns('Nonsense')
+              @note.decrypt(@password)
+            end
+
+            should "save decrypted data to @data" do
+              assert_equal 'Nonsense', @note.data
+            end
+          end
+        end
+      end
+
+      context "on the class" do
+        context "load" do
+
+          should "require path" do
+            assert_raise(MissingParameter) do
+              Note.load(nil, 'sander')
+            end
+          end
+
+          should "name" do
+            assert_raise(MissingParameter) do
+              Note.load(nil, 'sander')
+            end
+          end
+
+          should "raise error if file can not be found" do
+            assert_raise(MissingFile) do
+              Note.load(purse_path, "file_#{rand(5)}")
+            end
+          end
+
+          context "with a saved encrypted file" do
+            setup do
+              # Crypt::Blowfish.any_instance.expects(:decrypt_block).with('ENCRYPTED DATA').returns('Nonsense')
+              @note = Note.load(purse_path, 'sander')
+            end
+
+            should "return Note" do
+              assert @note.is_a?(Note)
+            end
+
+            should "set @encrypted" do
+              assert_equal 'ENCRYPTED DATA', @note.encrypted
+            end
+
+            should "not set @data" do
+              assert_nil @note.data
+            end
+          end
+        end
+      end
+    end
+  end
+
+end