telepath 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b38bc8a0619f00d35224b7e2586a0d193074f7a3
-  data.tar.gz: 81772bf8131f737c3071e2566158559f576edaa7
+  metadata.gz: 9157b212267be8ba4d41ed1cd42f5b4eefdb1c1d
+  data.tar.gz: a661c2d3028ebbf03b7470c6c95a82b6066963e9
 SHA512:
-  metadata.gz: a32bab376cf4b20156be53dceb4c5e567a103f4dc4174664dc16a99d746eabd8582cbb34329266d7eb79444c231205629071b501b1556ebff4a98258b340f07a
-  data.tar.gz: 16b7370de869fc20fb802bdea9ca45516c1ddb0b70dd8d947b9a2ef2fd522c68bca4eb252771afe5096bab41fb08a2d0811ee65ba4e3fb5edc2dab06d28e4ea6
+  metadata.gz: f7c8c46a8a91a9e7cf25ea59efcfb35a5b4a6a38b3ff1a8f67fbf65a3e856672b1ea687c1c15b727f1d4555b90de1541c1232f7fb9d70187a5cd2d0019944704
+  data.tar.gz: aab5d675ed50d4273308bb0ad1143b84349545d9a5ad6b10a95e08be3f1e3860d7e7c5f9f7d93aff2e5610f167acfe14e23c61f70b9986c50f31df1a31c0a9ec

data/README.markdown

@@ -66,12 +66,13 @@ Subcommands:
     ?, lookup                     Look up item by pattern
     $, last                       Get most recent item
     @, index                      Get item from (reverse) index
+    list                          List known containers and contents
 
 Options:
-    -q, --quiet                   Only output when absolutely necessary. (default: $TELEPORT_QUIET, or false)
-    -f, --file FILE               Filename of the Teleport store file. (default: $TELEPORT_FILE, or ".telepath.db")
-    -p, --path PATH               Path where the the Teleport store file is located. (default: $TELEPORT_PATH, or "~")
     -h, --help                    print help
+    -q, --quiet                   Only output when absolutely necessary. (default: $TELEPATH_QUIET, or false)
+    -f, --file FILE               Filename of the Teleport store file. (default: $TELEPATH_FILE, or ".telepath.db")
+    -p, --path PATH               Path where the the Teleport store file is located. (default: $TELEPATH_PATH, or "~")
 ```
 
 Example

data/bin/tel

@@ -2,5 +2,5 @@
 
 require_relative '../lib/telepath'
 
-Telepath::Command.run
+Telepath::CommandLine::Main.run
 

data/lib/telepath/command.rb

@@ -1,97 +1,137 @@
 require 'clamp'
 
 module Telepath
-  class Command < ::Clamp::Command
+  class CommandLine
+    class Command < Clamp::Command
 
-    option ['-q', '--quiet'], :flag, 'Only output when absolutely necessary.',
-      environment_variable: 'TELEPORT_QUIET', default: false
+      # GLOBAL OPTIONS
 
-    option ['-f', '--file'], 'FILE', 'Filename of the Teleport store file.',
-      environment_variable: 'TELEPORT_FILE', default: Telepath::Storage::DEFAULT_FILE
+      option ['-q', '--quiet'], :flag, 'Only output when absolutely necessary.',
+        environment_variable: 'TELEPATH_QUIET', default: false
 
-    option ['-p', '--path'], 'PATH', 'Path where the the Teleport store file is located.',
-      environment_variable: 'TELEPORT_PATH', default: Telepath::Storage::DEFAULT_PATH
+      option ['-f', '--file'], 'FILE', 'Filename of the Teleport store file.',
+        environment_variable: 'TELEPATH_FILE', default: Telepath::Storage::DEFAULT_FILE
 
-    subcommand ['+', 'add'], 'Add item' do
-      parameter '[VALUE] ...', 'value to add', attribute_name: 'values'
+      option ['-p', '--path'], 'PATH', 'Path where the the Teleport store file is located.',
+        environment_variable: 'TELEPATH_PATH', default: Telepath::Storage::DEFAULT_PATH
 
-      def execute
-        handler = Telepath::Handler.new self
-        values = self.values || Array.new
+      # HELPERS
+
+      def setup_environment
+        # quiet
+        # timeout
+        # file
+        # path
+      end
+
+      def handler
+        @handler ||= Telepath::Handler.new self
+      end
 
-        unless $stdin.tty? then
-          buffered = IO.select([$stdin], [], [], 1)
-          values << $stdin.read.strip if buffered && buffered.first && buffered.first.first
+      def data_out value, failure_message
+        if value then
+          Out.data value
+        else
+          Out.error self, failure_message
         end
+      end
+
+    end
+
+    class Add < Command
+      parameter '[ITEM] ...', 'item to add', attribute_name: 'items'
+
+      option ['-t', '--timeout'], 'TIMEOUT', 'How long to wait for stdin (in seconds).',
+        environment_variable: 'TELEPATH_TIMEOUT', default: 1
+
+      def execute
+        container = 'stack'
+        values    = self.items || Array.new
+
+        values << read_stdin if stdin?
 
         Out.error self, "No values supplied!" if values.empty?
 
-        results = values.map do |value|
-          handler.add value
+        values.each do |value|
+          handler.add value, container
+          # check that value was added correctly, individually?
         end
 
-        success = results.all?{|r|r.first}
-        name    = results.first.last
+        info values, container
+      end
 
-        if success then
-          Out.info "Added [#{values.map(&:inspect).join ', '}] to `#{name}'!"
-        else
-          failures = values.reject.with_index{|_, i| results[i].first}
-          Out.error self, "Could not add [#{failures.map().join ', '}] to `#{name}'!"
+      def info values, container
+        value_text = values.length == 1 ? values.first : "[#{values.join ', '}]"
+        Out.info "Added #{value_text} to #{container}!"
+      end
+
+      def read_stdin
+        $stdin.read.strip if stdin?
+      end
+
+      def stdin?
+        if not $stdin.tty? then
+          buffered = IO.select([$stdin], [], [], timeout)
+          buffered && buffered.first && buffered.first.first
         end
       end
+
+      # check that values were added, as a group?
+      #def verify_values_added values
+      #  failures = values.reject.with_index{|_, i| results[i].first}
+      #  Out.error self, "Could not add [#{failures.map().join ', '}] to `#{container}'!"
+      #end
     end
 
-    subcommand ['?', 'lookup'], 'Look up item by pattern' do
+    class Lookup < Command
       parameter '[PATTERN]', 'pattern to find'
 
       def execute
-        handler = Telepath::Handler.new self
-        value = handler.lookup pattern
-
-        if value && !value.empty? then
-          Out.data value
-        else
-          Out.error self, "Pattern `#{pattern}' not matched."
-        end
+        data_out handler.lookup(pattern),
+          "Pattern `#{pattern}' not matched."
       end
     end
 
-    subcommand ['$', 'last'], 'Get most recent item' do
-      def execute
-        handler = Telepath::Handler.new self
-        value = handler.last
-
-        if value && !value.empty? then
-          Out.data value
-        else
-          Out.error self, "Telepath is empty, is your storage location configured properly?"
+    class Last < Command
+      parameter '[COUNT]', 'number of most recent items to get',
+        default: 1 do |c|
+          Integer c
         end
+
+      def execute
+        data_out handler.last(count),
+          "Telepath is empty, is your storage location configured properly?"
       end
     end
 
-    subcommand ['@', 'index'], 'Get item from (reverse) index' do
+    class Index < Command
       parameter 'INDEX ...', 'index of item, starting from most recent (0)',
         attribute_name: :indicies do |i|
-          Integer(i)
+          Integer i
         end
 
       def execute
-        handler = Telepath::Handler.new self
-        index = indicies.first
-        value = handler.index index
-
-        if value && !value.to_s.empty? then
-          Out.data value
-        else
-          Out.error self, "Hmm, couldn't find anything at that index."
-        end
+        data_out handler.index(*indicies),
+          "Hmm, couldn't find anything at that index."
       end
     end
 
-    def execute
-      exit 1
+    class List < Command
+      parameter '[CONTAINER] ...', 'container to list contents of',
+        attribute_name: :containers
+
+      def execute
+        data_out handler.list(*containers),
+          "Container empty (or no container with that name)."
+      end
     end
 
+    class Main < Command
+      subcommand ['+', 'add'], 'Add item', Add
+      subcommand ['?', 'lookup'], 'Look up item by pattern', Lookup
+      subcommand ['$', 'last'], 'Get most recent item', Last
+      subcommand ['@', 'index'], 'Get item from (reverse) index', Index
+      subcommand ['list'], 'List known containers and contents', List
+    end
   end
 end

data/lib/telepath/handler.rb

@@ -4,45 +4,47 @@ module Telepath
       @command = command
     end
 
-    def add value
-      name = 'stack'
-
+    def add value, name = 'stack'
       with_store name do |container|
         container << value
       end
-
-      [true, name]
     end
 
-    def last
+    def last count = nil
       with_store 'stack' do |container|
-        container.last
+        if count.nil? then
+          container.last
+        else
+          container.last count
+        end
       end
     end
 
     def lookup pattern
       with_store 'stack' do |container|
-
-        if pattern && !pattern.empty? then
-          if container.include? pattern.to_s then
-            pattern.to_s
-          else
-            container.find do |element|
-              /#{pattern}/ =~ element.to_s
-            end
-          end
-        else
-          container.last
+        container.find do |element|
+          /#{pattern}/ =~ element.to_s
         end
-
       end
     end
 
     def index *indicies
-      index = indicies.first
-
       with_store 'stack' do |container|
-        container[-(index.to_i + 1)]
+        indicies.map do |index|
+          container[-(index.to_i + 1)]
+        end
+      end
+    end
+
+    def list *containers
+      c = containers.first
+
+      if c then
+        with_store c do |container|
+          rev_array container
+        end
+      else
+        rev_array storage.store.adapter.backend.keys
       end
     end
 
@@ -56,15 +58,23 @@ module Telepath
 
     protected
 
+    def rev_array list_of_things
+      Array(list_of_things).reverse
+    end
+
     def with_store name = 'stack'
       container = storage.store[name] || Array.new
 
       result = yield container
 
-      storage.store[name] = container
+      storage.store[name] = container if present? container
       result
     ensure
       storage.store.close
     end
+
+    def present? value
+      !!value && ((value.respond_to?(:empty?) || true) && !value.empty?)
+    end
   end
 end

data/lib/telepath/version.rb

@@ -1,3 +1,3 @@
 module Telepath
-  VERSION = '0.0.3'
+  VERSION = '0.1.0'
 end

data/spec/exe_spec.rb

@@ -5,6 +5,10 @@ describe 'Telepath Executable' do
   let(:status){ exe.status }
   let(:stdout){ exe.stdout.strip }
 
+  let(:handler){ Telepath::Handler.new double(Clamp::Command) }
+  let(:value){ '12' }
+  let(:next_value){ 'Boo yah!' }
+
   # override these in context
   let(:command){ '' }
   let(:args){ [] }
@@ -39,19 +43,31 @@ describe 'Telepath Executable' do
       specify { expect(status).to be_success }
 
       it 'adds the value to the stack' do
-        expect(stdout).to eq("Added [\"12\"] to `stack'!")
+        expect(stdout).to eq("Added 12 to stack!")
       end
 
       it 'should have no error output' do
         expect(exe.stderr).to eq ''
       end
     end
+
+    context 'with multiple values' do
+      let(:args){ ['12', 'foo/bar'] }
+
+      it 'adds the value to the stack' do
+        expect(stdout).to eq("Added [12, foo/bar] to stack!")
+      end
+    end
+
+    context 'redirected input' do
+      xit 'reads and stores stdin' do
+        # how to test?
+      end
+    end
   end
 
   describe '? lookup' do
     let(:command){ '?' }
-    let(:handler){ Telepath::Handler.new double(Clamp::Command) }
-    let(:value){ '12' }
 
     before do
       handler.add value
@@ -59,7 +75,6 @@ describe 'Telepath Executable' do
 
     context 'without parameters' do
       context 'with values in telepath' do
-
         specify { expect(status).to be_success }
         specify { expect(stdout).to eq value }
       end
@@ -72,4 +87,91 @@ describe 'Telepath Executable' do
       specify { expect(stdout).to eq value }
     end
   end
+
+  describe '@ index' do
+    let(:command){ '@' }
+
+    before do
+      handler.add value
+      handler.add next_value
+    end
+
+    context 'with single index' do
+      let(:args){ [1] }
+
+      it 'returns only that item' do
+        expect(stdout).to eq value
+      end
+    end
+
+    context 'with indicies' do
+      let(:args){ [0, 1] }
+
+      it 'returns each index on a new line' do
+        expect(stdout).to eq %Q{Boo yah!\n12}
+      end
+    end
+  end
+
+  describe '$ last' do
+    let(:command){ '$' }
+
+    before do
+      handler.add value
+      handler.add next_value
+    end
+
+    context 'without parameters' do
+      context 'with values in telepath' do
+        specify { expect(status).to be_success }
+        specify { expect(stdout).to eq next_value }
+      end
+    end
+
+    context 'with parameters' do
+      let(:args){ ['2'] }
+
+      specify { expect(status).to be_success }
+
+      it 'returns each most recent item on a new line' do
+        expect(stdout).to eq %Q{12\nBoo yah!}
+      end
+    end
+  end
+
+  describe 'list' do
+    let(:command){ 'list' }
+
+    before do
+      handler.add value
+      handler.add next_value
+      handler.add 'something else', 'another container'
+    end
+
+    context 'without parameters' do
+      it 'lists known containers, most recent first' do
+        expect(stdout).to eq "another container\nstack"
+      end
+    end
+
+    context 'with contaienr specified' do
+      let(:args){ ['"another container"'] }
+
+      it 'lists the contents of the specified container' do
+        expect(stdout).to eq 'something else'
+      end
+    end
+
+    context 'with nonexistant container' do
+      let(:args){ ['"totally does not exist"'] }
+      let(:container_list_exe){ run './bin/tel list' }
+      let(:container_list){ container_list_exe.stdout.strip }
+
+      it 'does not create listed containers' do
+        expect(stdout).to eq ''
+        expect(container_list).to eq "another container\nstack"
+      end
+    end
+  end
+
 end

data/spec/handler_spec.rb

@@ -8,9 +8,12 @@ describe Telepath::Handler do
 
   let(:storage){ Telepath::Storage.new }
   let(:value){ 'whatever' }
+  let(:next_value){ 'all your bass' }
+  let(:default_container){ 'stack' }
 
   before do
     handler.add value
+    handler.add next_value
   end
 
   it 'exists' do
@@ -22,11 +25,12 @@ describe Telepath::Handler do
   end
 
   describe '#add' do
+
     it 'adds 1 item' do
       expect{ handler.add 'something' }.to change{
         storage.store.adapter.backend.sunrise
         storage.stack.length
-      }.from(1).to(2)
+      }.from(2).to(3)
     end
 
     it 'adds the right item' do
@@ -34,52 +38,64 @@ describe Telepath::Handler do
       expect(storage.stack).to include('something')
     end
 
-    context 'redirected input' do
-      xit 'reads and stores stdin' do
+    context 'with container specified' do
+      let(:container){ 'keepsafe' }
+      let(:not_in_stack){ 'are belong to us' }
+
+      before do
+        handler.add not_in_stack, container
+      end
+
+      it do
+        expect(handler.list container).to include not_in_stack
+      end
+
+      it do
+        expect(handler.list).not_to include not_in_stack
       end
     end
+
   end
 
   describe '#last' do
     it 'returns the last value' do
-      expect(handler.last).to eq(value)
+      expect(handler.last).to eq(next_value)
     end
 
     it 'does not delete the item' do
-      expect{ handler.last }.to change{
-        storage.store.adapter.backend.sunrise
-        storage.stack.length
-      }.by(0)
+      store_unchanged { handler.last }
     end
-  end
 
-  describe '#index' do
-    before do
-      handler.add 'blah'
+    context 'with a count' do
+      it 'returns the count last items' do
+        expect(handler.last 2).to eq ["whatever", "all your bass"]
+      end
     end
+  end
 
+  describe '#index' do
     it 'returns the item at the specified reverse index (1)' do
-      expect(handler.index 1).to eq(value)
+      expect(handler.index 1).to eq [value]
     end
 
     it 'returns the item at the specified reverse index (0)' do
-      expect(handler.index 0).to eq('blah')
+      expect(handler.index 0).to eq [next_value]
     end
 
     it 'does not delete the item' do
-      expect{ handler.index value }.to change{
-        storage.store.adapter.backend.sunrise
-        storage.stack.length
-      }.by(0)
+      store_unchanged { handler.index 1 }
+    end
+
+    context 'multiple indicies' do
+      it 'should return the items in the same order specified' do
+        expect(handler.index 0, 1).to eq [next_value, value]
+      end
     end
   end
 
   describe '#lookup' do
     it 'does not delete the item' do
-      expect{ handler.lookup value }.to change{
-        storage.store.adapter.backend.sunrise
-        storage.stack.length
-      }.by(0)
+      store_unchanged { handler.lookup value }
     end
 
     context 'pattern matching' do
@@ -96,4 +112,29 @@ describe Telepath::Handler do
       end
     end
   end
+
+  describe '#list' do
+
+    let(:other_container){ 'keepsafe' }
+
+    before do
+      handler.add 'not_in_stack', other_container
+    end
+
+    it 'does not alter the store' do
+      store_unchanged { handler.list; handler.list default_container }
+    end
+
+    context 'without specifying a container' do
+      it do
+        expect(handler.list).to eq([other_container, default_container])
+      end
+    end
+
+    context 'with container specified' do
+      it do
+        expect(handler.list default_container).to eq ['all your bass', 'whatever']
+      end
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -28,6 +28,13 @@ module SpecHelpers
   def unassign_test_path; ENV[path_env_var] = nil; end
   def pre_test_setup; assign_test_path; cleanup_db; end
   def post_test_teardown; unassign_test_path; cleanup_db; end
+
+  def store_unchanged
+    expect{ yield }.to change{
+      storage.store.adapter.backend.sunrise
+      storage.stack.length
+    }.by(0)
+  end
 end
 
 RSpec.configure do |c|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: telepath
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - Anthony Cook
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-01 00:00:00.000000000 Z
+date: 2013-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: moneta