cue 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c3e67b30c304c9b38c0b750b943c045b8f5ccd20
+  data.tar.gz: 1f4757388541654942e0adee30d1aadc051f5bc4
+SHA512:
+  metadata.gz: 0c64eede657d74523a8390aced2eefc1f0a7ede4f02e55c3268c34f7decedcb105b4fde9d069d4f7f8c6533e9cbf64dd7a0778e1d8e79784477b3f2c81946b7c
+  data.tar.gz: 2922380a75b9823bec5a02ab0bc730c00f1b672c6937531d02f5b5deff50121f07edf5c70a36d591c87cbaa9a418dfc47962ff5d18d74a6b1f5bd4f181e4fc59

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) arcsum42@gmail.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1 @@
+# cue

data/bin/cue

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+args       = ARGV.dup
+subcommand = args.first
+
+if subcommand.nil?
+  system('cue-list')
+elsif subcommand == 'rm'
+  args.shift
+  system('cue-delete', *args)
+elsif ['add', 'clear', 'delete', 'list', 'show', 'toggle'].include?(subcommand)
+  args.shift
+  system("cue-#{subcommand}", *args)
+else
+  abort "cue: #{subcommand} is not a cue command."
+end

data/bin/cue-add

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$:.unshift File.join(__dir__, '..', 'lib')
+require 'cue/command/add'
+Cue::Command::Add.new(ARGV).execute

data/bin/cue-clear

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$:.unshift File.join(__dir__, '..', 'lib')
+require 'cue/command/clear'
+Cue::Command::Clear.new(ARGV).execute

data/bin/cue-delete

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$:.unshift File.join(__dir__, '..', 'lib')
+require 'cue/command/delete'
+Cue::Command::Delete.new(ARGV).execute

data/bin/cue-list

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$:.unshift File.join(__dir__, '..', 'lib')
+require 'cue/command/list'
+Cue::Command::List.new(ARGV).execute

data/bin/cue-show

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$:.unshift File.join(__dir__, '..', 'lib')
+require 'cue/command/show'
+Cue::Command::Show.new(ARGV).execute

data/bin/cue-toggle

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$:.unshift File.join(__dir__, '..', 'lib')
+require 'cue/command/toggle'
+Cue::Command::Toggle.new(ARGV).execute

data/lib/colorfool.rb

@@ -0,0 +1,25 @@
+module ColorFool
+  COLORS = %i(green red)
+  
+  CODES = {
+    black:   30,
+    red:     31,
+    green:   32,
+    yellow:  33,
+    blue:    34,
+    magenta: 35,
+    cyan:    36,
+    white:   37
+  }
+  
+  def code(color)
+    CODES[color]
+  end
+  
+  def colorize(color, &block)
+    code    = code(color)
+    content = block.call.to_s
+    
+    "\e[#{code}m#{content}\e[0m"
+  end
+end

data/lib/cue.rb

@@ -0,0 +1,2 @@
+module Cue
+end

data/lib/cue/command/add.rb

@@ -0,0 +1,27 @@
+require 'cue/command/base'
+require 'cue/command/utils/editor'
+
+module Cue
+  module Command
+    class Add < Base
+      def initialize(args)
+        super(args)
+        
+        if @args.size == 1
+          @content = @args.first
+        else
+          @content = Utils::Editor.new.read
+        end
+      end
+      
+      def execute
+        item = Cue::Item.new(@content)
+        item.save(options.store)
+      end
+      
+      def nargs
+        (0..1)
+      end
+    end
+  end
+end

data/lib/cue/command/base.rb

@@ -0,0 +1,98 @@
+require 'cue/store/redis'
+require 'json'
+require 'ostruct'
+require 'optparse'
+
+module Cue
+  module Command
+    class Base
+      attr_reader :options
+      
+      def initialize(args)
+        @options = OpenStruct.new.tap do |opts|
+          opts.store = Cue::Store::Redis.new
+        end
+        
+        @args = parser.parse(args)
+        configure_store
+        check_num_arguments
+      end
+      
+      def find_key(key_prefix)
+        keys     = options.store.keys
+        item_ids = keys.select { |id| id.start_with?(key_prefix) }
+        
+        if item_ids.size > 1
+          parser.abort "#{key_prefix} is too ambiguous."
+        end
+        
+        item_id = item_ids.first
+        
+        parser.abort("Couldn't find item #{key_prefix}.") unless item_id
+        item_id
+      end
+      
+      def find_item(key_prefix)
+        options.store.read(find_key(key_prefix))
+      end
+      
+      def nargs
+        0
+      end
+      
+      def parser
+        @parser ||= OptionParser.new do |opts|
+          opts.banner = "Usage: #{File.basename($0)} [options]"
+          
+          opts.on('-s', '--store [STORE]', 'Specify the store adapter') do |store|
+            begin
+              require "cue/store/#{store}"
+              klass = store.split('_').map(&:capitalize).join
+              options.store = Cue.const_get("Store::#{klass}").new
+            rescue LoadError
+              opts.abort "Couldn't find the store adapter \"#{store}\"."
+            end
+          end
+        end
+      end
+      
+      private
+      
+      def check_num_arguments
+        case nargs
+        when Range
+          parser.abort('Invalid number of arguments.') unless nargs.cover?(@args.size)
+        else
+          parser.abort('Invalid number of arguments.') if @args.size != nargs
+        end
+      end
+      
+      def config_path
+        File.join(ENV['HOME'], '.cue', 'config.json')
+      end
+      
+      def configure_redis
+        get_config(:redis) do |config|
+          Cue::Store::Redis.configure do |rconfig|
+            opts = config.select { |k,_| [:host, :port, :password].include?(k) }
+            rconfig.redis = Redis.new(opts)
+          end
+        end
+      end
+      
+      def configure_store
+        case options.store
+        when Cue::Store::Redis
+          configure_redis
+        end
+      end
+      
+      def get_config(key=nil, &block)
+        return unless File.exists?(config_path)
+        
+        json = JSON.parse(File.read(config_path), symbolize_names: true)
+        key.nil? ? yield(json) : yield(json[key])
+      end
+    end
+  end
+end

data/lib/cue/command/clear.rb

@@ -0,0 +1,11 @@
+require 'cue/command/base'
+
+module Cue
+  module Command
+    class Clear < Base      
+      def execute
+        options.store.clear
+      end
+    end
+  end
+end

data/lib/cue/command/delete.rb

@@ -0,0 +1,21 @@
+require 'cue/command/base'
+
+module Cue
+  module Command
+    class Delete < Base
+      def initialize(args)
+        super(args)
+        @sha = @args.first
+      end
+      
+      def execute
+        item_key = find_key(@sha)
+        options.store.delete(item_key)
+      end
+      
+      def nargs
+        1
+      end
+    end
+  end
+end

data/lib/cue/command/list.rb

@@ -0,0 +1,12 @@
+require 'cue'
+require 'cue/command/base'
+
+module Cue
+  module Command
+    class List < Base
+      def execute
+        options.store.each(&method(:puts))
+      end
+    end
+  end
+end

data/lib/cue/command/show.rb

@@ -0,0 +1,21 @@
+require 'cue/command/base'
+
+module Cue
+  module Command
+    class Show < Base
+      def initialize(args)
+        super(args)
+        @sha = @args.first
+      end
+      
+      def execute
+        item = find_item(@sha)
+        puts item
+      end
+      
+      def nargs
+        1
+      end
+    end
+  end
+end

data/lib/cue/command/toggle.rb

@@ -0,0 +1,23 @@
+require 'cue/command/base'
+
+module Cue
+  module Command
+    class Toggle < Base
+      def initialize(args)
+        super(args)
+        @sha = @args.first
+      end
+      
+      def execute
+        find_item(@sha).tap do |item|
+          item.toggle!
+          item.save(options.store)
+        end
+      end
+      
+      def nargs
+        1
+      end
+    end
+  end
+end

data/lib/cue/command/utils/editor.rb

@@ -0,0 +1,40 @@
+require 'tempfile'
+
+module Cue
+  module Command
+    module Utils
+      class Editor
+        def basename
+          'cue'
+        end
+        
+        def command
+          ENV['EDITOR'] || default_editor
+        end
+        
+        def read
+          Process.wait(spawn([command, path].join(' ')))
+          content = File.read(path)
+          
+          File.delete(path)
+          
+          content
+        end
+        
+        def dir
+          '/tmp'
+        end
+        
+        def path
+          @path ||= File.expand_path(Dir::Tmpname::make_tmpname(basename, nil), dir)
+        end
+        
+        private
+        
+        def default_editor
+          'vi'
+        end
+      end
+    end
+  end
+end

data/lib/cue/group.rb

@@ -0,0 +1,17 @@
+require 'forwardable'
+
+module Cue
+  class Group
+    extend Forwardable
+    
+    def_delegators :items, :<<, :[], :each, :size
+    
+    def items
+      @items ||= []
+    end
+    
+    def to_s
+      items.map(&:to_s).join("\n")
+    end
+  end
+end

data/lib/cue/indicator.rb

@@ -0,0 +1,39 @@
+require 'colorfool'
+
+module Cue
+  class Indicator
+    include ColorFool
+    
+    attr_reader :state
+    
+    def initialize(state)
+      @state = state
+    end
+    
+    def color
+      case state
+      when :complete
+        :green
+      when :incomplete
+        :red
+      else
+        :none
+      end
+    end
+    
+    def symbol
+      case state
+      when :complete
+        '✓'
+      when :incomplete
+        '✗'
+      else
+        '?'
+      end
+    end
+    
+    def to_s
+      colorize(color) { symbol }
+    end
+  end
+end

data/lib/cue/item.rb

@@ -0,0 +1,79 @@
+require 'colorfool'
+require 'cue/indicator'
+require 'digest'
+
+module Cue
+  class Item
+    include ColorFool
+    include Comparable
+    
+    attr_accessor :content
+    attr_reader   :created_at, :state
+    
+    def initialize(content, attrs={})
+      self.content = content
+      
+      attrs.each do |k, v|
+        setter = "#{k}="
+        if respond_to?(setter, true)
+          send(setter, v)
+        end
+      end
+      
+      self.state = self.state || :incomplete
+    end
+    
+    def <=>(other)
+      created_at <=> other.created_at
+    end
+    
+    def ==(other)
+      content == other.content
+    end
+    
+    def complete!
+      self.state = :complete
+    end
+    
+    def complete?
+      self.state == :complete
+    end
+    
+    def hash
+      Digest::SHA1.hexdigest(content)
+    end
+    
+    def in_store?(store)
+      !store.read(hash).nil?
+    end
+    
+    def incomplete!
+      self.state = :incomplete
+    end
+    
+    def incomplete?
+      self.state == :incomplete
+    end
+    
+    def save(store)
+      self.created_at = Time.now unless in_store?(store)
+      store.write(hash, self)
+      true
+    end
+    
+    def to_s
+      i = Indicator.new(state)
+      h = colorize(:cyan) { hash[0..6] }
+      "#{h} #{i} #{content}"
+    end
+    
+    def toggle!
+      complete? ? incomplete! : complete!
+      self
+    end
+    
+    private
+    
+    attr_writer :created_at, :state
+  end
+end

data/lib/cue/store/file.rb

@@ -0,0 +1,129 @@
+require 'cue/item'
+require 'fileutils'
+require 'zlib'
+
+module Cue
+  module Store
+    class File
+      include Enumerable
+      
+      def initialize(root_path=nil)
+        @root_path = root_path
+        FileUtils.mkdir_p(items_path)
+      end
+      
+      def clear
+        keys.each { |key| delete(key) }
+      end
+      
+      def delete(key)
+        FileUtils.rm_r(item_path(key))
+        key_dir = dir_for(key)
+        FileUtils.rm_r(key_dir) if Dir[::File.join(key_dir, '*')].empty?
+      end
+      
+      def each
+        items = keys.map(&method(:read)).sort
+        yield(items)
+      end
+      
+      def keys
+        keys = []
+        
+        Dir.glob(::File.join(items_path, '*')).each do |prefix_dir|
+          prefix = ::File.basename(prefix_dir)
+          Dir.glob(::File.join(prefix_dir, '*')).each do |suffix_file|
+            suffix = ::File.basename(suffix_file)
+            keys << (prefix + suffix)
+          end
+        end
+        
+        keys
+      end
+      
+      def read(key)
+        return nil unless ::File.exists?(item_path(key))
+        
+        data = nil
+        file_for_reading(item_path(key)) do |file|
+          data = uncompress(file.read)
+        end
+        return data if data.nil?
+        
+        deserialize(data)
+      end
+      
+      def write(key, item)
+        FileUtils.mkdir_p(dir_for(key))
+        file_for_writing(item_path(key)) do |file|
+          data = compress(serialize(item))
+          file.write(data)
+        end
+      end
+      
+      private
+      
+      def root_path
+        @root_path ||= ::File.join(ENV['HOME'], '.cue')
+      end
+      
+      def compress(data)
+        Zlib::Deflate.deflate(data)
+      end
+      
+      def deserialize(data)
+        created_at, state, content = data.unpack('Z*Z*Z*')
+        Cue::Item.new(content, created_at: created_at, state: state.to_sym)
+      end
+      
+      def dir_for(key)
+        ::File.join(items_path, prefix(key))
+      end
+      
+      def file_for_writing(path, &block)
+        ::File.open(path, mode_for_writing) { |file| yield(file) }
+      end
+      
+      def file_for_reading(path, &block)
+        ::File.open(path, mode_for_reading) { |file| yield(file) }
+      end
+      
+      def item_path(key)
+        ::File.join(dir_for(key), suffix(key))
+      end
+      
+      def items_path
+        @items_path ||= ::File.join(root_path, 'items')
+      end
+      
+      def keys_path
+        @keys_path ||= ::File.join(root_path, 'keys')
+      end
+      
+      def mode_for_reading
+        ::File::RDONLY
+      end
+      
+      def mode_for_writing
+        ::File::CREAT | ::File::WRONLY | ::File::TRUNC
+      end
+      
+      def prefix(key)
+        key[0..1]
+      end
+      
+      def serialize(item)
+        data = [item.created_at.to_i.to_s, item.state.to_s, item.content.to_s]
+        data.pack('Z*Z*Z*')
+      end
+      
+      def suffix(key)
+        key[2...(key.size)]
+      end
+      
+      def uncompress(data)
+        Zlib::Inflate.inflate(data)
+      end
+    end
+  end
+end

data/lib/cue/store/memory.rb

@@ -0,0 +1,38 @@
+module Cue
+  module Store
+    class Memory
+      include Enumerable
+      
+      def clear
+        @store = {}
+      end
+      
+      def delete(key)
+        store.delete(key)
+      end
+      
+      def each
+        items = keys.map(&method(:read)).sort
+        yield(items)
+      end
+      
+      def keys
+        store.keys
+      end
+      
+      def read(key)
+        store[key]
+      end
+      
+      def write(key, item)
+        store[key] = item.dup
+      end
+      
+      private
+      
+      def store
+        @store ||= {}
+      end
+    end
+  end
+end

data/lib/cue/store/redis.rb

@@ -0,0 +1,110 @@
+require 'cue/item'
+require 'redis'
+require 'time'
+
+module Cue
+  module Store
+    class Redis
+      include Enumerable
+      
+      class << self
+        attr_writer :namespace, :redis
+        
+        def configure(&block)
+          self.tap { |klass| yield(klass) }
+        end
+        
+        def namespace
+          @namespace ||= 'cue'
+        end
+        
+        def redis
+          @redis ||= ::Redis.new
+        end
+      end
+      
+      def clear
+        item_keys = redis.smembers(redis_key('keys'))
+        keys_key  = redis_key('keys')
+        
+        redis.del(item_keys, keys_key)
+      end
+      
+      def delete(key)
+        item_key = item_key(key)
+        
+        redis.del(item_key)
+        redis.srem(redis_key('keys'), item_key)
+      end
+      
+      def each
+        items = keys.map(&method(:read)).sort
+        yield(items)
+      end
+      
+      def keys
+        redis.smembers(redis_key('keys')).map do |redis_key|
+          redis_key.split(':').last
+        end
+      end
+      
+      def read(key)
+        item_hash = redis.hgetall(item_key(key))
+        return nil if item_hash.empty?
+        
+        deserialize(item_hash)
+      end
+      
+      def write(key, item)
+        add_key(key)
+        add_item(key, item)
+      end
+      
+      private
+      
+      def add_item(key, item)
+        redis.mapped_hmset(item_key(key), serialize(item))
+      end
+      
+      def add_key(key)
+        redis.sadd(redis_key('keys'), item_key(key))
+      end
+      
+      def deserialize(item_hash)
+        content    = item_hash['content']
+        created_at = Time.parse(item_hash['created_at']) if item_hash['created_at']
+        state      = item_hash['state'].to_sym
+        
+        Cue::Item.new(content, created_at: created_at, state: state)
+      end
+      
+      def item_key(key)
+        redis_key('item', key)
+      end
+      
+      def namespace
+        self.class.namespace
+      end
+      
+      def redis
+        self.class.redis
+      end
+      
+      def redis_key(*components)
+        key = *components
+        key.unshift(namespace)
+        
+        key.join(':')
+      end
+      
+      def serialize(item)
+        {
+          'state'      => item.state.to_s,
+          'content'    => item.content
+        }.tap do |hash|
+          hash['created_at'] = item.created_at.to_s if item.created_at
+        end
+      end
+    end
+  end
+end

data/lib/cue/version.rb

@@ -0,0 +1,3 @@
+module Cue
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: cue
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- John Doe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.4
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Cue is a simple command line tool for keeping track of stuff.
+email: arcsum42@gmail.com
+executables:
+- cue
+- cue-add
+- cue-clear
+- cue-delete
+- cue-list
+- cue-show
+- cue-toggle
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- LICENSE.md
+- lib/colorfool.rb
+- lib/cue/command/add.rb
+- lib/cue/command/base.rb
+- lib/cue/command/clear.rb
+- lib/cue/command/delete.rb
+- lib/cue/command/list.rb
+- lib/cue/command/show.rb
+- lib/cue/command/toggle.rb
+- lib/cue/command/utils/editor.rb
+- lib/cue/group.rb
+- lib/cue/indicator.rb
+- lib/cue/item.rb
+- lib/cue/store/file.rb
+- lib/cue/store/memory.rb
+- lib/cue/store/redis.rb
+- lib/cue/version.rb
+- lib/cue.rb
+- bin/cue
+- bin/cue-add
+- bin/cue-clear
+- bin/cue-delete
+- bin/cue-list
+- bin/cue-show
+- bin/cue-toggle
+homepage: https://github.com/arcsum/cue
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: keep track of stuff
+test_files: []