warp-dir 1.1.0

data/lib/warp/dir/command/ls.rb

@@ -0,0 +1,31 @@
+require 'warp/dir/command'
+module Warp
+  module Dir
+    class Command
+      class LS < Warp::Dir::Command
+        description %q(List directory contents of a Warp Point)
+        needs_a_point? true
+        aliases :dir
+
+        # @param [Object] args
+        def run(opts, *flags)
+          point         = store.find_point(point_name)
+          STDERR.puts "FLAGS: [#{flags}]".bold.green if config.debug
+
+          command_flags = if flags && !flags.empty?
+                            flags
+                          else
+                            ['-al']
+                          end
+          command = "ls #{command_flags.join(' ')} #{point.path}/"
+          STDERR.puts 'Command: '.yellow + command.bold.green if config.debug
+          ls_output     = `#{command}`
+          STDERR.puts 'Output:  '.yellow + ls_output.bold.blue if config.debug
+          on :success do
+            message ls_output.bold
+          end
+        end
+      end
+    end
+  end
+end

data/lib/warp/dir/command/remove.rb

@@ -0,0 +1,16 @@
+require 'warp/dir/command'
+class Warp::Dir::Command
+  class Remove < Warp::Dir::Command
+    description %q(Removes a given warp point from the database)
+    needs_a_point? true
+    aliases :rm, :delete
+
+    def run(*args)
+      point_name = self.point_name
+      store.remove point_name: point_name
+      on :success do
+        message "Warp point #{point_name.to_s.yellow} has been removed."
+      end
+    end
+  end
+end

data/lib/warp/dir/command/warp.rb

@@ -0,0 +1,24 @@
+require 'warp/dir/command'
+
+require 'colored'
+module Warp
+  module Dir
+    class Command
+      class Warp < Warp::Dir::Command
+        description %q(Jumps to the pre-defined warp point (command optional))
+        needs_a_point? true
+
+        def run(*args)
+          if point.nil? && point_name
+            self.point = store[point_name]
+          end
+          raise ::Warp::Dir::Errors::PointNotFound.new(point) unless point
+          p = point
+          on :shell do
+            message "cd #{p.absolute_path}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/warp/dir/commander.rb

@@ -0,0 +1,71 @@
+require 'set'
+require 'warp/dir/errors'
+require 'warp/dir/formatter'
+require 'singleton'
+module Warp
+  module Dir
+    class Commander
+      include Singleton
+
+      attr_reader :commands
+      attr_accessor :command_map
+
+      def initialize
+        @commands ||= Set.new # a pre-caution, normally it would already by defined by now
+        @command_map   = {}
+      end
+
+      def register(command)
+        @commands << command if command
+        self
+      end
+
+      def installed_commands
+        @commands.map(&:command_name)
+      end
+
+      def lookup(command_name)
+        reindex!
+        command_map[command_name]
+      end
+
+      def find(command_name)
+        command = lookup(command_name)
+        if command.nil?
+          raise ::Warp::Dir::Errors::InvalidCommand.new(command_name)
+        end
+        command
+      end
+
+      def run(command_name, *args)
+        cmd = find command_name
+        raise ::Warp::Dir::Errors::InvalidCommand.new(command_name) unless cmd.is_a?(warp::Dir::Command)
+        cmd.new(*args).run
+      end
+
+      def reindex!
+        commands.each do |command|
+          if command.respond_to?(:aliases)
+            command.aliases.each do |an_alias|
+              if self.command_map[an_alias] && !self.command_map[an_alias] == command
+                raise Warp::Dir::Errors::InvalidCommand.new("Duplicate alias for command #{command}")
+              end
+              self.command_map[an_alias] = command
+            end
+          end
+          self.command_map[command.command_name] = command
+        end
+        self
+      end
+
+      def validate!
+        self.commands.delete_if do |subclass|
+          if !subclass.respond_to?(:abstract_class?) && !subclass.method_defined?(:run)
+            raise ::Warp::Dir::Errors::InvalidCommand.new(subclass)
+          end
+          subclass.respond_to?(:abstract_class?) || !subclass.method_defined?(:run)
+        end
+      end
+    end
+  end
+end

data/lib/warp/dir/config.rb

@@ -0,0 +1,87 @@
+require 'forwardable'
+
+module Warp
+  module Dir
+    class Config
+
+      DEFAULTS = {
+        warprc: ENV['HOME'] + '/.warprc',
+        shell: false,
+        force: false,
+        debug: false
+      }
+
+      attr_accessor :variables
+
+      extend ::Forwardable
+      def_delegators :@variables, :size, :<<, :map, :each
+      def initialize(opts = {})
+        configure(opts)
+      end
+
+      def configure(opts = {})
+        options = DEFAULTS.merge(opts)
+
+        # Move :config hash key->value to :warprc that is expected by the Config
+        if options[:config]
+          options[:warprc] = options[:config]
+          options.delete(:config)
+        end
+
+        self.variables = []
+
+        # OK. I concede. This is very likely a total overkill :O
+        # The thing is: I just really like calling hash members via
+        # methods, and I didn't want to load HashieMash because
+        # it's big. Real big.
+        #
+        # IRB Session that explains it all:
+        #
+        # c = Config.new({ foo: "bar", bar: "foo"})
+        # => #<Warp::Dir::Config:0x007ff8e39531f0 @variables=[:config, :foo, :bar], @config="/Users/kigster/.warprc", @foo="bar", @bar="foo">
+        #  > c.foo              # => "bar"
+        #  > c.bar              # => "foo"
+        #  > c.bar?             # => true
+        #  > c.config           # => "/Users/kigster/.warprc"
+        #  > c.color = "red"    # => "red"
+        #  > c.color            # => "red"
+        #  > c.color?           # => true
+
+        options.each_pair do |variable_name, value|
+          self.variables << add_config_variable(variable_name, value)
+        end
+      end
+
+      # allow syntax @config[:warprc]
+      def [](key)
+        self.send(key)
+      end
+
+      # Dispatches redis operations to master/slaves.
+      def method_missing(method, *args, &block)
+        if method =~ /=$/
+          add_config_variable(method.to_s.gsub(/=$/, ''), *args)
+        else
+          super
+        end
+      end
+
+      private
+
+      def add_config_variable(variable_name, value)
+        reader   = variable_name.to_sym
+        writer   = "#{reader}=".to_sym
+        boolean  = "#{reader}?"
+        variable = "@#{reader}".to_sym
+        # set this value on the the instance of config class
+        instance_variable_set(variable, value)
+        # add the reader and the writer to this key
+        define_singleton_method(reader) { instance_variable_get(variable) }
+        define_singleton_method(writer) { |new_value| instance_variable_set(variable, new_value) }
+        define_singleton_method(boolean){ !instance_variable_get(variable).nil? }
+        reader
+      end
+
+    end
+  end
+end

data/lib/warp/dir/errors.rb

@@ -0,0 +1,60 @@
+module Warp
+  module Dir
+    module Errors
+      class Runtime < RuntimeError;
+      end
+
+      class StoreFormatError < Warp::Dir::Errors::Runtime
+        attr_reader :line
+        def initialize(msg, line)
+          @line = line
+          super msg
+        end
+      end
+
+      class StoreUninitialized < Warp::Dir::Errors::Runtime; end
+      class StoreAlreadyInitialized < Warp::Dir::Errors::Runtime; end
+
+      # This is a generic Exception that wraps an object passed to the
+      # initializer and assumed to be the reason for the failure.
+      # Message is optional, but each concrete exception should provide
+      # it's own concrete message
+      class InstanceError < Warp::Dir::Errors::Runtime
+        attr_accessor :instance
+        def initialize(message = nil)
+          super message ? message : "#{self.class.name}->[#{instance}]"
+        end
+
+        def name
+          super.gsub(%r{#{self.class.name}}, '')
+        end
+
+        def color_error instance_type, instance, result
+          instance_type.red.bold +
+            instance.to_s.yellow.bold +
+            result.red.bold
+        end
+      end
+
+      class InvalidCommand < ::Warp::Dir::Errors::InstanceError
+        def initialize(instance = nil)
+          self.instance = instance
+          super instance.is_a?(Symbol) ? color_error('Command ', instance, ' is invalid.') : instance
+        end
+      end
+
+      class PointNotFound < ::Warp::Dir::Errors::InstanceError
+        def initialize(point)
+          self.instance = point
+          super color_error('Point ', point.to_s, ' was not found.')
+        end
+      end
+      class PointAlreadyExists < ::Warp::Dir::Errors::InstanceError
+        def initialize(point)
+          self.instance = point
+          super color_error('Point ', point.to_s, ' already exists. Pass --force to overwrite.')
+        end
+      end
+    end
+  end
+end

data/lib/warp/dir/formatter.rb

@@ -0,0 +1,77 @@
+require 'warp/dir'
+require 'warp/dir/errors'
+require 'colored'
+require 'thread'
+module Warp
+  module Dir
+    class Formatter
+      DEFAULT_FORMAT = :ascii
+
+      attr_accessor :store
+
+      def initialize(store)
+        @store  = store
+        @config = store.config
+      end
+
+      def unhappy(exception: nil, message: nil)
+        out = 'Whoops! – '.white
+        out << "#{exception.message} ".red if exception && !message
+        out << "#{message} ".red if !exception && message
+        out << "#{exception.message}:\n#{message}".red if message && exception
+        out << "\n"
+        print ? STDERR.printf(out) : out
+      end
+
+      def format_point(point, *args)
+        PointFormatter.new(point).format(*args)
+      end
+
+      def format_store(*args)
+        StoreFormatter.new(store).format(*args)
+      end
+
+      def happy(message: nil)
+        STDOUT.printf(message.blue.bold)
+      end
+
+      private
+
+      class PointFormatter
+        attr_accessor :point
+
+        def initialize(point)
+          @point = point
+        end
+
+        def format(type = DEFAULT_FORMAT, width = 0)
+          case type
+            when :ascii
+              point.to_s(width)
+            else
+              raise ArgumentError.new("Type #{type} is not recognized.")
+          end
+        end
+      end
+
+      class StoreFormatter
+        attr_accessor :store
+
+        def initialize(store)
+          @store = store
+        end
+
+        # find the widest warp point name, and indent them all based on that.
+        # make it easy to extend to other types, and allow the caller to
+        # sort by one of the fields.
+        def format(type = DEFAULT_FORMAT, sort_field = :name)
+          longest_key_length = store.points.map(&:name).map(&:length).sort.last
+          Warp::Dir.sort_by(store.points, sort_field).map do |point|
+            PointFormatter.new(point).format(type, longest_key_length)
+          end.join("\n")
+        end
+      end
+    end
+  end
+end
+

data/lib/warp/dir/point.rb

@@ -0,0 +1,53 @@
+require 'forwardable'
+require 'digest'
+module Warp
+  module Dir
+    class Point
+      attr_accessor :full_path, :name
+
+      def initialize(name, full_path)
+        raise ArgumentError.new ':name is required' if name.nil?
+        raise ArgumentError.new ':full_path is required' if full_path.nil?
+        @full_path = Warp::Dir.absolute full_path
+        @name      = name.to_sym
+      end
+
+      def absolute_path
+        full_path
+      end
+
+      def relative_path
+        Warp::Dir.relative full_path
+      end
+
+      def path
+        absolute_path
+      end
+
+      def inspect
+        sprintf("(#{object_id})[name: '%s', path: '%s']", name, relative_path)
+      end
+
+      def to_s(width = 0)
+        sprintf("%#{width}s  ->  %s", name, relative_path)
+      end
+
+      def hash
+        Digest::SHA1.base64digest("#{full_path.hash}#{name.hash}").hash
+      end
+
+      def <=>(other)
+        name <=> other.name
+      end
+
+      def eql?(another)
+        return false unless another.is_a?(Warp::Dir::Point)
+        %i(name full_path).each do |attribute|
+          return false unless send(attribute) == another.send(attribute)
+        end
+        true
+      end
+
+    end
+  end
+end

data/lib/warp/dir/serializer.rb

@@ -0,0 +1,14 @@
+module Warp
+  module Dir
+    SERIALIZERS = {}
+    module Serializer
+      def self.default
+        SERIALIZERS.values.first
+      end
+    end
+  end
+end
+
+Warp::Dir.require_all_from '/dir/serializer'
+
+raise 'No concrete serializer implementations were found' if Warp::Dir::SERIALIZERS.empty?