the_dude 0.0.2 → 0.0.3

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    the_dude (0.0.2)
+    the_dude (0.0.3)
       colored
       hirb
       nokogiri

data/README.md

@@ -13,16 +13,16 @@ For example:
     $ dude show me pictures of cool stuff # opens a browser with a google images search for 'cool stuff'
     $ dude wassup # starts top
 
-If this sounds like fancypants bash aliases, you'd be about right. So what's the point?
-
-Well, there's a few reasons
+How can this be useful?
 - a single dude command can trigger a bunch of other commands.  Sure you
   could write a shell script and run that using an alias but that assumes
   you're happy writing shell scripts.
 - for the command-line phobic, dude provides a friendly interface to the
   command line.
-- for those who are happy on the command line, there can still be a benefit
-  in reducing the cognitive overhead required to run scripts
+- for those who are at on the command line, there can still be a benefit
+  in reducing the cognitive overhead required to run scripts.
+- Commands can be bundled and shared using gems meaning that command line savvy
+  devs can set up simpler commands for other team members to use.
 
 ## Talking to The Dude
 

data/bin/dude

@@ -1,10 +1,11 @@
 #!/usr/bin/env ruby
 require 'the_dude'
 
-include TheDude::Dsl
+#include TheDude::Dsl
 
 DUDERC_PATH = "#{ENV['HOME']}/.duderc"
-load DUDERC_PATH if File.exists? DUDERC_PATH
+#load DUDERC_PATH if File.exists? DUDERC_PATH
+TheDude::Dsl.from_file DUDERC_PATH
 
 # Setup rlwrap for readline support
 if ARGV.include? '-i'

data/lib/the_dude/command.rb

@@ -1,7 +1,7 @@
 module TheDude
   class Command
-    # [String | Regexp] The question for this command
-    attr_reader :question
+    # [TheDude::Expression] The expression for this command
+    attr_reader :expression
 
     # [String | Proc | Block] The answer for this command
     attr_accessor :answer
@@ -23,12 +23,12 @@ module TheDude
     #     puts 'how are you?'
     #   end
     #
-    # @param [String | Regexp] question the question to ask
-    # @param [String | Proc]   answer   the answer to the question
+    # @param [String | Regexp] expression  the question to ask
+    # @param [String | Proc]   answer      the answer to the question
     #
     # @return [TheDude::Command]
-    def initialize question, answer=nil, &block_answer
-      @question = Expression.new(question).to_regex
+    def initialize expression, answer=nil, &block_answer
+      @expression = Expression.new(expression)
       @answer = block_answer || answer
 
       TheDude.register_command self
@@ -39,8 +39,8 @@ module TheDude
     # parameters.
     def ask *args
       begin
-        if answer.kind_of? Proc
-          instance_exec(*args, &answer)
+        if answer.kind_of?(Proc)
+          TheDude::Dsl.new.instance_exec(*args, &answer)
         else
           answer
         end

data/lib/the_dude/dsl.rb

@@ -1,7 +1,28 @@
 module TheDude
-  module Dsl
+  class Dsl
+    # Forwards the call on to {TheDude.ask}
+    def ask *args
+      TheDude.ask *args
+    end
+
+    # Forwards the call on to {TheDude::Command.new}
     def command *args, &block
       TheDude::Command.new *args, &block
     end
+
+    # Forwards the call on to {TheDude.say}
+    def say *args
+      TheDude.say *args
+    end
+
+    # Class methods
+    class << self
+      # Reads in a file and processes it using The Dude Dsl
+      #
+      # @param [String] path Path to the file to read
+      def from_file path
+        new.instance_eval File.read(path) if File.exists? path
+      end
+    end
   end
 end

data/lib/the_dude/expression.rb

@@ -1,6 +1,6 @@
 module TheDude
   class Expression
-    PLACEHOLDER_REGEX = /\s\:(\S+)/
+    PLACEHOLDER_REGEXP = /\s\:(\S+)/
 
     # [String | Regexp] The expression
     attr_reader :expression
@@ -12,6 +12,7 @@ module TheDude
     # @return [TheDude::Expression]
     def initialize expr
       @expression = expr
+      #to_regexp
     end
 
     # Converts the expression to a regex.
@@ -20,21 +21,24 @@ module TheDude
     # they are substituted for the associated regexs
     #
     # @return [Regexp]
-    def to_regex
+    def to_regexp
+      return @regexp unless @regexp.nil?
+
       # If we have a string, escape it turn it into a regex and send it back
-      return /^#{Regexp.quote @expression}$/ if @expression.kind_of? String
+      @regexp = /^#{Regexp.quote @expression}$/ and return @regexp if @expression.kind_of? String
+      @regexp = @expression
 
       substitute_all_variables
       check_for_undefined_variables
 
-      return @expression
+      return @regexp
     end
 
     private
 
     # @return [Boolean] Whether the expression contains the specified variable
     def contains_variable? var
-      @expression.source.match /\:#{var.name.to_s}/
+      @regexp.source.match /\:#{var.name.to_s}/
       #@expression.source.match PLACEHOLDER_REGEX
     end
 
@@ -42,16 +46,16 @@ module TheDude
     # @return [Boolean] True if there are undefined variables
     def check_for_undefined_variables
       return false if @expression.kind_of? String
-      vars = @expression.source.scan(PLACEHOLDER_REGEX)[0]
+      vars = @regexp.source.scan(PLACEHOLDER_REGEXP)[0]
       return false if vars.nil?
       vars = vars.map{|v| v.strip.to_sym}
-      raise TheDude::UndefinedVariableError if (vars - TheDude.variables.keys).any?
+      raise TheDude::UndefinedVariableError.new("Undefined variables : #{(vars - TheDude.variables.keys).join(' ')} in #{@expression}") if (vars - TheDude.variables.keys).any?
     end
 
     # [Regexp] Substitues the specified variable for its pattern and converts
     # the result back to a regex
     def substitute_variable var
-      subbed = @expression.source.gsub(/\:#{var.name}(\s|$)/, "(#{var.pattern.source}) ")
+      subbed = @regexp.source.gsub(/\:#{var.name}(\s|$)/, "(#{var.pattern.source}) ")
       subbed.strip! if subbed
       Regexp.new subbed
     end
@@ -59,7 +63,7 @@ module TheDude
     # Substitutes all variables in the expression for their pattern
     def substitute_all_variables
       TheDude.variables.each do |key, val|
-        @expression = substitute_variable(val) if contains_variable? val
+        @regexp = substitute_variable(val) if contains_variable? val
       end
     end
   end

data/lib/the_dude/plugin.rb

@@ -0,0 +1,34 @@
+module TheDude
+  # Plugins can contain additional commands or integrate other tools into the
+  # dude
+  class Plugin
+    # [String] The name of the plugin
+    attr_reader :name
+
+    # Intializes a new TheDude::Plugin instance
+    def initialize name
+      @name = name
+    end
+
+    def gem_name
+      @gem_name ||= "the_dude-#{name}"
+    end
+
+    class << self
+      # Returns all the plugins that are installed. This works by examining the
+      # installed gems. Any installed gem whose name begins with the_dude- is
+      # assumed to be a plugin for The Dude
+      def all
+        begin
+          Gem::Specification.latest_specs.   # Get all the installed gems
+            collect{|s| s.name}.     # Collect the names
+            grep(/the_dude\-/).     # Filter for those beginning with the_dude-
+            map{|s| TheDude::Plugin.new s[9..s.length]} #   Trim off the prefix
+                                                       # and convert to Plugin instance
+        rescue
+          []
+        end
+      end
+    end
+  end
+end

data/lib/the_dude/setup.rb

@@ -19,3 +19,5 @@ TheDude::Command.new /^show me pictures of (.*)/, ->(query){ `open "https://www.
 TheDude::Command.new /source for :url/, ->(url){ `curl #{url} | highlight --syntax html -O xterm256`  }
 TheDude::Command.new /headers for :url/, ->(url){ `curl -I #{url}`  }
 
+# Load plugins
+TheDude::Plugin.all.each {|r| require r.gem_name}

data/lib/the_dude/version.rb

@@ -1,3 +1,3 @@
 module TheDude
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/lib/the_dude.rb

@@ -9,6 +9,7 @@ require 'the_dude/config'
 require 'the_dude/dsl'
 require 'the_dude/expression'
 require 'the_dude/http'
+require 'the_dude/plugin'
 require 'the_dude/variable'
 require 'the_dude/version'
 
@@ -28,6 +29,22 @@ module TheDude
       command.ask *arguments
     end
 
+    # Returns the command registered with the specified question. This should
+    # be the expression before it is processed and parsed for variables
+    #
+    # @example
+    #
+    #   TheDude::Comand.new(/something :cool/)
+    #   TheDude.command(/something :cool) # returns the above command
+    #
+    # @param [String | Regex] expression A dude command
+    #
+    # @return [TheDude::Command | false]
+    def command expression
+      c = commands.select {|c, v| v.expression.expression == expression}
+      (c.any?) ? c.first[1] : false
+    end
+
     # @return [Hash] Returns the commands the dude knows about
     def commands
       @commands || {}
@@ -48,7 +65,7 @@ module TheDude
     # @param [TheDude::Command] command The command to register
     def register_command command
       @commands ||= {}
-      @commands[command.question] = command
+      @commands[command.expression.to_regexp] = command
     end
 
     # Registers a new variable with the dude
@@ -77,14 +94,14 @@ module TheDude
       string
     end
 
-    # Returns the arguments for a question based on the specified command
+    # Returns the arguments for an expression based on the specified command
     #
-    # @param [String]           question  The question
-    # @param [TheDude::Command] command   The command
+    # @param [String]           expression  The question or task
+    # @param [TheDude::Command] command     The command
     #
     # @return [Array] An array of arguments
-    def arguments_for question, command
-      question.scan(command.question)[0]
+    def arguments_for expression, command
+      expression.scan(command.expression.to_regexp)[0]
     end
 
     # @return [String] Applies dude formatting
@@ -92,18 +109,18 @@ module TheDude
       string
     end
 
-    # Returns the command for answering the specified question
+    # Returns the command for answering the specified expression
     #
-    # @param [String] question The question asked
+    # @param [String] expression The expression asked
     #
     # @return [TheDude::Command]
-    def find_command_for question
+    def find_command_for expression
       # if there's an exact match return that first
-      return commands[question] if commands[question]
+      return commands[expression] if commands[expression]
 
       commands.each do |key, val|
         if key.kind_of? Regexp
-          return val if key =~ question
+          return val if key =~ expression
         end
       end
 

data/spec/spec_helper.rb

@@ -1,7 +1,11 @@
-require 'the_dude'
-
 require 'fakeweb'
-require 'support/webmocks'
+require 'ostruct'
+
+Dir["#{Dir.pwd}/spec/support/**/*.rb"].each {|f| require f}
+
+include TestHelpers::Console
+
+require 'the_dude'
 
 RSpec.configure do |config|
   config.before :each do

data/spec/support/helpers/console.rb

@@ -0,0 +1,77 @@
+module TestHelpers
+  # Helpers to make life in the terminal a little more pleasant
+  # Include them in rspec by adding
+  #   include TestHelpers::Console
+  #
+  # to spec_helper.rb
+  module Console
+    # Colour handling functionality
+    module Colors
+      # Standard terminal color codes
+      COLORS = {
+        :reset => '0',
+        :bold => '1',
+        :red => '31',
+        :green => '32',
+        :yellow => '33',
+        :blue => '34',
+        :magenta => '35',
+        :cyan => '36',
+        :white => '37'
+      }
+
+      # Colours the specified text by prepending it with the standard terminal
+      # colour code for the specified colour. A reset code is appended in order
+      # to avoid accidentally colourising subsequent text.
+      #
+      # @param [String] text  The text to colourise
+      # @param [Symbol] color The colour to use
+      #
+      # @return [String] The colourised string
+      def color(text, color)
+        if COLORS[color]
+          "#{start_color color}#{text}#{reset_color}"
+        end
+      end
+
+      # The terminal reset code
+      #
+      # @return [String]
+      def reset_color
+        "\e[#{COLORS[:reset]}m"
+      end
+
+      # The code for the specified colour with the necessary escape characters
+      #
+      # @return [String]
+      def start_color color
+        "\e[#{COLORS[color]}m"
+      end
+    end
+
+    # Functions for outputting to the terminal
+    module Output
+      # Outputs the passed variable
+      #
+      # @param [Object] var    The variable to be output
+      # @param [Symbol] colour The colour to use
+      # @param [String] title  A descriptive title
+      def out var, colour=nil, title=''
+        #title ||= caller[0][/`([^']*)'/, 1]
+        loc = caller[0].scan(/[\s\/]`?([^\/:.']+)?/)[-2..-1].join(':')
+        title = " #{color(title, colour)} :" unless title == ''
+        out = var.inspect
+        out = "|> #{color(loc, colour)} :>#{title} #{color(out, colour)}"
+        puts color(out, colour)
+      end
+    end
+
+    def self.included base
+      base.send :include, Output
+      base.send :include, Colors
+    end
+
+  end
+end
+
+

data/spec/the_dude/command_spec.rb

@@ -38,6 +38,21 @@ describe TheDude::Command do
       end
     end
 
+    context 'when passed a string and a block param using Dsl shortcuts and full commands' do
+      before :each do
+        TheDude::Command.new 'test child', ->{'it worked'}
+        TheDude::Command.new /test child 2 (.*)/, ->(message){"the message says #{message}"}
+        TheDude::Command.new 'test block' do
+          message = ask 'test child'
+          TheDude.ask "test child 2 #{message}"
+        end
+      end
+
+      it 'should process both commands correctly and return the return value from the last' do
+        TheDude.ask('test block').should == "the message says it worked"
+      end
+    end
+
     context 'when passed an expression question containing a defined variable' do
       before :each do
         TheDude::Variable.new(:server, /\S+/).register
@@ -45,7 +60,7 @@ describe TheDude::Command do
       end
 
       it 'should convert the expression to a normal regex' do
-        @command.question.should == /connect to (\S+)/
+        @command.expression.to_regexp.should == /connect to (\S+)/
       end
     end
   end

data/spec/the_dude/dsl_spec.rb

@@ -5,6 +5,19 @@ describe TheDude::Dsl do
     include TheDude::Dsl
   end
 
+  describe '#ask' do
+    context 'when asked' do
+      context 'and the command exists' do
+        before :each do
+          Anony.new.command 'hey', 'what'
+        end
+        it 'should perform the requested command' do
+          Anony.new.ask('hey').should == 'what'
+        end
+      end
+    end
+  end
+
   describe '#command' do
     context 'when passed a question' do
       before :each do

data/spec/the_dude/expression_spec.rb

@@ -1,35 +1,45 @@
 require 'spec_helper'
 
 describe TheDude::Expression do
-  describe 'to_regex' do
+  describe '#expression' do
+    it 'should equal the original expression used to create the instance' do
+      TheDude::Expression.new('something :cool').expression.should == 'something :cool'
+      TheDude::Expression.new(/something :cool/).expression.should == /something :cool/
+    end
+  end
+
+  describe '#to_regexp' do
     context 'when the expression is created with a string' do
       before :each do
         @expr = TheDude::Expression.new 'some expression'
+        @expr.instance_variable_set(:@regexp, nil) # Clear out the cached regexp so that it gets rebuilt after we add variables
       end
 
       it 'should return a regex that exactly matches the string' do
-        @expr.to_regex.should == /^some\ expression$/
+        @expr.to_regexp.should == /^some\ expression$/
       end
     end
 
     context 'when the expression is created with a regex' do
       before :each do
         @expr = TheDude::Expression.new /a regex/
+        @expr.instance_variable_set(:@regexp, nil) # Clear out the cached regexp so that it gets rebuilt after we add variables
       end
 
       it 'should return the regex' do
-        @expr.to_regex.should == /a regex/
+        @expr.to_regexp.should == /a regex/
       end
     end
 
     context 'when the expression is created with a regex containing a variable' do
       before :each do
         @expr = TheDude::Expression.new /a :placeholder regex/
+        # @expr.instance_variable_set(:@regexp, nil) # Clear out the cached regexp so that it gets rebuilt after we add variables
       end
 
       context 'and the variable is not defined' do
         it 'should raise an error' do
-          expect{@expr.to_regex}.to raise_error TheDude::UndefinedVariableError
+          expect{@expr.to_regexp}.to raise_error TheDude::UndefinedVariableError
         end
       end
 
@@ -39,7 +49,7 @@ describe TheDude::Expression do
         end
 
         it 'should return the regex with the variable substituted' do
-          @expr.to_regex.should == /a (\S+) regex/
+          @expr.to_regexp.should == /a (\S+) regex/
         end
       end
     end
@@ -49,15 +59,19 @@ describe TheDude::Expression do
         @expr = TheDude::Expression.new /a :multiple :placeholder regex/
       end
 
-      context 'and neither variable is not defined' do
+      context 'and neither variable is defined' do
         it 'should raise an error' do
-          expect{@expr.to_regex}.to raise_error TheDude::UndefinedVariableError
+          expect{@expr.to_regexp}.to raise_error TheDude::UndefinedVariableError
         end
       end
 
       context 'and only one variable is defined' do
+        before :each do
+          TheDude::Variable.new(:multiple, /\d+/).register
+        end
+
         it 'should raise an error' do
-          expect{@expr.to_regex}.to raise_error TheDude::UndefinedVariableError
+          expect{@expr.to_regexp}.to raise_error TheDude::UndefinedVariableError
         end
       end
 
@@ -68,7 +82,7 @@ describe TheDude::Expression do
         end
 
         it 'should return the regex with the variable substituted' do
-          @expr.to_regex.should == /a (\d+) (\S+) regex/
+          @expr.to_regexp.should == /a (\d+) (\S+) regex/
         end
       end
     end

data/spec/the_dude/plugin_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe TheDude::Plugin do
+  describe '#gem_name' do
+    it 'should be the name of plugin prefixed with the_ruby-' do
+      TheDude::Plugin.new('plugin').gem_name.should == 'the_dude-plugin'
+    end
+  end
+
+  describe '.all' do
+    subject {TheDude::Plugin.all}
+
+    context 'when a gems are installed with the the_dude- prefix' do
+      before :each do
+        # Stub the call to Gem::Specification.latest_specs
+        Gem::Specification.stub(:latest_specs).and_return([
+          OpenStruct.new(name: 'the_dude-plugin'),
+          OpenStruct.new(name: 'the_dude-plugin2'),
+          OpenStruct.new(name: 'other-gem')
+        ])
+      end
+
+      its(:length) {should == 2}
+
+      describe '[0]' do
+        subject {TheDude::Plugin.all[0]}
+
+        it {should be_kind_of TheDude::Plugin}
+        its(:name) {should == 'plugin'}
+      end
+
+      describe '[1]' do
+        subject {TheDude::Plugin.all[1]}
+
+        it {should be_kind_of TheDude::Plugin}
+        its(:name) {should == 'plugin2'}
+      end
+    end
+  end
+end

data/spec/the_dude_spec.rb

@@ -15,6 +15,27 @@ describe TheDude do
     end
   end
 
+  describe '.command' do
+    context 'when passed a command' do
+      context 'that has not been registered' do
+        it 'should return false' do
+          TheDude.command(/duff/).should be_false
+        end
+      end
+
+      context 'that has been registered' do
+        before :each do
+          TheDude::Variable.new(:cool, /.*/).register
+          @command = TheDude::Command.new(/something :cool/)
+        end
+
+        it 'should return the command' do
+          TheDude.command(/something :cool/).should == @command
+        end
+      end
+    end
+  end
+
   describe '.register_command' do
     context 'when passed a command' do
       it 'should add the command to the commands collection' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: the_dude
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-14 00:00:00.000000000 Z
+date: 2013-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -164,10 +164,12 @@ files:
 - lib/the_dude/dsl.rb
 - lib/the_dude/expression.rb
 - lib/the_dude/http.rb
+- lib/the_dude/plugin.rb
 - lib/the_dude/setup.rb
 - lib/the_dude/variable.rb
 - lib/the_dude/version.rb
 - spec/spec_helper.rb
+- spec/support/helpers/console.rb
 - spec/support/webmocks.rb
 - spec/support/webmocks/google2.html
 - spec/the_dude/command_spec.rb
@@ -175,6 +177,7 @@ files:
 - spec/the_dude/dsl_spec.rb
 - spec/the_dude/expression_spec.rb
 - spec/the_dude/http_spec.rb
+- spec/the_dude/plugin_spec.rb
 - spec/the_dude/variable_spec.rb
 - spec/the_dude_spec.rb
 - the_dude.gemspec
@@ -193,7 +196,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1710943047893443555
+      hash: 4224877102825340562
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -202,7 +205,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1710943047893443555
+      hash: 4224877102825340562
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25