rutty 2.2.0 → 2.3.1

data/.yardopts

@@ -0,0 +1,3 @@
+--private
+--default-return void
+--exclude tag_query*

data/Gemfile

@@ -5,6 +5,7 @@ gem "terminal-table", '~> 1.4.2'
 gem "net-ssh", '~> 2.0.23'
 gem "net-scp", '~> 1.0.4'
 gem "builder", '~> 2.1.2'
+gem "treetop", '~> 1.4.8'
 
 group :development do
   gem "jeweler", '~> 1.4.0'

data/Gemfile.lock

@@ -16,10 +16,13 @@ GEM
     net-scp (1.0.4)
       net-ssh (>= 1.99.1)
     net-ssh (2.0.23)
+    polyglot (0.3.1)
     rubyforge (2.0.4)
       json_pure (>= 1.1.7)
     terminal-table (1.4.2)
     thoughtbot-shoulda (2.11.1)
+    treetop (1.4.8)
+      polyglot (>= 0.3.1)
     xml-simple (1.0.12)
 
 PLATFORMS
@@ -33,4 +36,5 @@ DEPENDENCIES
   net-ssh (~> 2.0.23)
   terminal-table (~> 1.4.2)
   thoughtbot-shoulda
+  treetop (~> 1.4.8)
   xml-simple (~> 1.0.12)

data/README.md

@@ -79,7 +79,6 @@ TODO
 ----
 
 * Cleanup dsh action code
-* Expand the tag searching semantics to allow for AND and/or OR queries
 * Implement delete_node command
 
 Copyright

data/Rakefile

@@ -23,6 +23,7 @@ begin
     gem.add_dependency "net-ssh", ">= 2.0.23"
     gem.add_dependency "net-scp", ">= 1.0.4"
     gem.add_dependency "builder", ">= 2.1.2"
+    gem.add_dependency "treetop", ">= 1.4.8"
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError

data/VERSION

@@ -1 +1 @@
-2.2.0
+2.3.1

data/bin/rutty

@@ -16,7 +16,7 @@ add_filter_options = lambda { |c|
 }
 
 add_remote_options = lambda { |c|
-  c.option('-t', '--tags TAG1[,TAG2,...]', Array, 'Comma-separated list of tags to run the command on')
+  c.option('-t', '--tags TAG1[,TAG2,...]', String, 'Comma-separated list of tags to run the command on')
   c.option('-a', 'Run the command on ALL nodes')
   c.option('-d', '--debug', 'Enable debug output')
 }

data/lib/rutty/errors.rb

@@ -19,4 +19,12 @@ module Rutty
   # @author Josh Lindsey
   # @since 2.1.4
   class InvalidOutputFormat < StandardError; end
+  
+  ##
+  # Raised by {Rutty::Helpers#get_tag_query_filter} if the Treetop
+  # parser is unable to parse the tag query string.
+  #
+  # @author Josh Lindsey
+  # @since 2.3.0
+  class InvalidTagQueryString < StandardError; end
 end

data/lib/rutty/nodes.rb

@@ -2,7 +2,7 @@ require 'rutty/node'
 require 'rutty/consts'
 
 module Rutty
-  
+
   ##
   # Simple container class for {Rutty::Node} instances. Contains methods to load node data from file,
   # write data back to the file, and filter nodes based on user-supplied criteria.
@@ -22,7 +22,7 @@ module Rutty
         Rutty::Nodes.new YAML.load(File.open(File.join(dir, Rutty::Consts::NODES_CONF_FILE)).read)
       end
     end
-    
+
     ##
     # Filters out the {Rutty::Node} objects contained in this instance based on user-defined criteria.
     #
@@ -30,21 +30,38 @@ module Rutty
     # @option opts [String] :keypath (nil) The path to the private key
     # @option opts [String] :user (nil) The user to login as
     # @option opts [Integer] :port (nil) The port to connect to
-    # @option opts [Array<String>] :tags (nil) The tags to filter by
-    # @return [Array] An Array containing the {Rutty::Node} objects after filtering
+    # @option opts [String] :tags (nil) The tags to filter by
+    # @return [Rutty::Nodes] A duplicate of this object, but containing the {Rutty::Node} objects after filtering.
     def filter opts = {}
-      return self if opts[:all]
-      
-      ary = Array.new self
-      
-      ary.reject! { |n| n.keypath != opts[:keypath] } unless opts[:keypath].nil?
-      ary.reject! { |n| n.user != opts[:user] } unless opts[:user].nil?
-      ary.reject! { |n| n.port != opts[:port] } unless opts[:port].nil?
-      ary.reject! { |n| (n.tags & opts[:tags]).empty? } unless opts[:tags].nil?
+      return self if opts.all
+
+      ary = self.dup
+
+      ary.delete_if { |n| n.keypath != opts.keypath } unless opts.keypath.nil?
+      ary.delete_if { |n| n.user != opts.user } unless opts.user.nil?
+      ary.delete_if { |n| n.port != opts.port } unless opts.port.nil?
+      ary.delete_if &get_tag_query_filter(opts.tags) unless opts.tags.nil? 
       
       ary
     end
     
+    ##
+    # Same as {#filter}, but destructive on this object instead of a duplicate.
+    #
+    # @param (see #filter)
+    # @option (see #filter)
+    # @return [Rutty::Nodes] This object with the requested nodes filtered out.
+    def filter! opts = {}
+      return self if opts.all
+
+      self.delete_if { |n| n.keypath != opts.keypath } unless opts.keypath.nil?
+      self.delete_if { |n| n.user != opts.user } unless opts.user.nil?
+      self.delete_if { |n| n.port != opts.port } unless opts.port.nil?
+      self.delete_if &get_tag_query_filter(opts.tags) unless opts.tags.nil?
+      
+      self
+    end
+
     ##
     # Writes the updated nodes config back into the nodes.yaml file in the specified dir.
     #
@@ -55,5 +72,99 @@ module Rutty
         YAML.dump(self, f)
       end
     end
+
+    private
+
+    ##
+    # Builds and returns a <tt>Proc</tt> for {#filter}. The Proc
+    # should be passed a {Rutty::Node} object when called. The Proc calls
+    # {Rutty::Node#has_tag?} on the passed in object to determine tag inclusion.
+    #
+    # In other words, the Proc returned by this should be suitable for passing to 
+    # Array#reject!, as that's what {#filter} calls.
+    #
+    # @param [String] query_str The string passed in by the user via the <tt>--tags</tt> option
+    # @return [Proc] The generated filter Proc
+    #
+    # @see #recursive_build_query_proc_string
+    # @see Rutty::Nodes#filter
+    # @since 2.3.0
+    def get_tag_query_filter query_str
+      require 'rutty/proc_classes'
+
+      filter = nil
+
+      if query_str =~ /^\w$/
+        # Single tag query, no need to fire up the parser
+        filter = Procs::SingleTagQuery.new { |n| n.has_tag? "#{$1}" }
+      elsif query_str =~ /^(?:\w,?)+$/
+        # Old-style comma-separated tag query. Still no
+        # need to fire up the parser, just additively compare.
+        tags = query_str.split(',')
+        filter = Procs::MultipleTagQuery.new { |n| (n.tags & tags).empty? }
+      else
+        # New sql-like tag query. Need the parser for this.
+        require 'treetop'
+        require 'rutty/treetop/syntax_nodes'
+        require 'rutty/treetop/tag_query'
+               
+        parser = TagQueryGrammarParser.new
+
+        parsed_syntax_tree = parser.parse(query_str)
+
+        raise InvalidTagQueryString.new "error: Unable to parse tag query string" if parsed_syntax_tree.nil?
+        
+        proc_str = recursive_build_query_proc_string parsed_syntax_tree.elements
+        proc_str = proc_str.rstrip << ') }'
+
+        filter = eval(proc_str)
+      end
+
+      filter
+    end
+
+
+    ##
+    # Builds a string to be <tt>eval</tt>'d into a Proc by {#get_tag_query_filter}. Recursively
+    # walks a Treetop parsed syntax tree, building the string as it goes. The string is not actually
+    # evaluated into a Proc object in this method; that happens in {#get_tag_query_filter}.
+    #
+    # @param [Array<Treetop::Runtime::SyntaxNode>] elems A multidimensional array ultimately 
+    #   consisting of Treetop SyntaxNodes or children thereof.
+    # @param [String] str The string to build on. Passed around over recursions.
+    # @return [String] The completed string to evaluate into a Proc.
+    #
+    # @see #get_tag_query_filter
+    # @since 2.3.0
+    def recursive_build_query_proc_string elems, str = ''
+      return str if elems.nil? or elems.empty?
+
+      str = 'Procs::SqlLikeTagQuery.new { |n| !(' if str.empty?
+
+      elem = elems.shift
+
+      case elem.class.to_s
+      when 'TagQueryGrammar::Tag'
+        str << "n.has_tag?(#{elem.text_value}) "
+      when 'TagQueryGrammar::AndLiteral'
+        str << "&& "
+      when 'TagQueryGrammar::OrLiteral'
+        str << "|| "
+      when 'TagQueryGrammar::GroupStart'
+        str << '('
+      when 'TagQueryGrammar::GroupEnd'
+        str.rstrip!
+        str << ')'
+      when 'TagQueryGrammar::QueryGroup'
+        str = recursive_build_query_proc_string elem.elements, str
+        # For some reason, Treetop won't let me assign a class to the "query" rule,
+        # so it defaults to this class. This should be the only parsed rule that evaluates
+        # to this generic class.
+      when 'Treetop::Runtime::SyntaxNode'
+        str = recursive_build_query_proc_string elem.elements, str
+      end
+
+      recursive_build_query_proc_string elems, str
+    end
   end
 end

data/lib/rutty/proc_classes.rb

@@ -0,0 +1,18 @@
+module Rutty
+  
+  ##
+  # The classes defined in here are used by {Rutty::Nodes#get_tag_query_filter} and 
+  # {Rutty::Nodes#recursive_build_query_proc_string}. Mostly they exist to simplify unit
+  # tests, to ensure that the correct logic paths are reached in those methods for differing
+  # query strings.
+  # 
+  # @author Josh Lindsey
+  # @since 2.3.0
+  module Procs
+    class SingleTagQuery < Proc; end
+
+    class MultipleTagQuery < Proc; end
+
+    class SqlLikeTagQuery < Proc; end
+  end
+end

data/lib/rutty/treetop/syntax_nodes.rb

@@ -0,0 +1,24 @@
+##
+# Extensions to the TagQueryGrammar module, generated by Treetop. The classes
+# contained in this module are applied to the nodes of the parsed syntax tree
+# for easier interpretation later.
+#
+# @see http://treetop.rubyforge.org/
+#
+# @author Josh Lindsey
+# @since 2.3.0
+module TagQueryGrammar
+  class Tag < Treetop::Runtime::SyntaxNode; end
+
+  class Whitespace < Treetop::Runtime::SyntaxNode; end
+
+  class QueryGroup < Treetop::Runtime::SyntaxNode; end
+
+  class GroupStart < Treetop::Runtime::SyntaxNode; end
+
+  class GroupEnd < Treetop::Runtime::SyntaxNode; end
+
+  class AndLiteral < Treetop::Runtime::SyntaxNode; end
+
+  class OrLiteral < Treetop::Runtime::SyntaxNode; end
+end

data/lib/rutty/treetop/tag_query.rb

@@ -0,0 +1,382 @@
+# Autogenerated from a Treetop grammar. Edits may be lost.
+
+
+module TagQueryGrammar
+  include Treetop::Runtime
+
+  def root
+    @root ||= :query
+  end
+
+  module Query0
+    def tag
+      elements[0]
+    end
+
+    def space1
+      elements[1]
+    end
+
+    def boolean
+      elements[2]
+    end
+
+    def space2
+      elements[3]
+    end
+
+  end
+
+  def _nt_query
+    start_index = index
+    if node_cache[:query].has_key?(index)
+      cached = node_cache[:query][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    i1, s1 = index, []
+    r2 = _nt_tag
+    s1 << r2
+    if r2
+      r3 = _nt_space
+      s1 << r3
+      if r3
+        r4 = _nt_boolean
+        s1 << r4
+        if r4
+          r5 = _nt_space
+          s1 << r5
+          if r5
+            i6 = index
+            r7 = _nt_query
+            if r7
+              r6 = r7
+            else
+              r8 = _nt_group
+              if r8
+                r6 = r8
+              else
+                @index = i6
+                r6 = nil
+              end
+            end
+            s1 << r6
+          end
+        end
+      end
+    end
+    if s1.last
+      r1 = instantiate_node(SyntaxNode,input, i1...index, s1)
+      r1.extend(Query0)
+    else
+      @index = i1
+      r1 = nil
+    end
+    if r1
+      r0 = r1
+    else
+      r9 = _nt_tag
+      if r9
+        r0 = r9
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:query][start_index] = r0
+
+    r0
+  end
+
+  module Tag0
+  end
+
+  def _nt_tag
+    start_index = index
+    if node_cache[:tag].has_key?(index)
+      cached = node_cache[:tag][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    if has_terminal?('\G["|\']', true, index)
+      r1 = true
+      @index += 1
+    else
+      r1 = nil
+    end
+    s0 << r1
+    if r1
+      s2, i2 = [], index
+      loop do
+        if has_terminal?('\G[\\w-]', true, index)
+          r3 = true
+          @index += 1
+        else
+          r3 = nil
+        end
+        if r3
+          s2 << r3
+        else
+          break
+        end
+      end
+      if s2.empty?
+        @index = i2
+        r2 = nil
+      else
+        r2 = instantiate_node(SyntaxNode,input, i2...index, s2)
+      end
+      s0 << r2
+      if r2
+        if has_terminal?('\G["|\']', true, index)
+          r4 = true
+          @index += 1
+        else
+          r4 = nil
+        end
+        s0 << r4
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(Tag,input, i0...index, s0)
+      r0.extend(Tag0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:tag][start_index] = r0
+
+    r0
+  end
+
+  module Group0
+    def group_start
+      elements[0]
+    end
+
+    def query
+      elements[1]
+    end
+
+    def group_end
+      elements[2]
+    end
+  end
+
+  def _nt_group
+    start_index = index
+    if node_cache[:group].has_key?(index)
+      cached = node_cache[:group][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0, s0 = index, []
+    r1 = _nt_group_start
+    s0 << r1
+    if r1
+      r2 = _nt_query
+      s0 << r2
+      if r2
+        r3 = _nt_group_end
+        s0 << r3
+      end
+    end
+    if s0.last
+      r0 = instantiate_node(QueryGroup,input, i0...index, s0)
+      r0.extend(Group0)
+    else
+      @index = i0
+      r0 = nil
+    end
+
+    node_cache[:group][start_index] = r0
+
+    r0
+  end
+
+  def _nt_boolean
+    start_index = index
+    if node_cache[:boolean].has_key?(index)
+      cached = node_cache[:boolean][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    i0 = index
+    r1 = _nt_AND
+    if r1
+      r0 = r1
+    else
+      r2 = _nt_OR
+      if r2
+        r0 = r2
+      else
+        @index = i0
+        r0 = nil
+      end
+    end
+
+    node_cache[:boolean][start_index] = r0
+
+    r0
+  end
+
+  def _nt_space
+    start_index = index
+    if node_cache[:space].has_key?(index)
+      cached = node_cache[:space][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    s0, i0 = [], index
+    loop do
+      if has_terminal?('\G[\\s]', true, index)
+        r1 = true
+        @index += 1
+      else
+        r1 = nil
+      end
+      if r1
+        s0 << r1
+      else
+        break
+      end
+    end
+    if s0.empty?
+      @index = i0
+      r0 = nil
+    else
+      r0 = instantiate_node(Whitespace,input, i0...index, s0)
+    end
+
+    node_cache[:space][start_index] = r0
+
+    r0
+  end
+
+  def _nt_group_start
+    start_index = index
+    if node_cache[:group_start].has_key?(index)
+      cached = node_cache[:group_start][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if has_terminal?('(', false, index)
+      r0 = instantiate_node(GroupStart,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure('(')
+      r0 = nil
+    end
+
+    node_cache[:group_start][start_index] = r0
+
+    r0
+  end
+
+  def _nt_group_end
+    start_index = index
+    if node_cache[:group_end].has_key?(index)
+      cached = node_cache[:group_end][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if has_terminal?(')', false, index)
+      r0 = instantiate_node(GroupEnd,input, index...(index + 1))
+      @index += 1
+    else
+      terminal_parse_failure(')')
+      r0 = nil
+    end
+
+    node_cache[:group_end][start_index] = r0
+
+    r0
+  end
+
+  def _nt_AND
+    start_index = index
+    if node_cache[:AND].has_key?(index)
+      cached = node_cache[:AND][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if has_terminal?('AND', false, index)
+      r0 = instantiate_node(AndLiteral,input, index...(index + 3))
+      @index += 3
+    else
+      terminal_parse_failure('AND')
+      r0 = nil
+    end
+
+    node_cache[:AND][start_index] = r0
+
+    r0
+  end
+
+  def _nt_OR
+    start_index = index
+    if node_cache[:OR].has_key?(index)
+      cached = node_cache[:OR][index]
+      if cached
+        cached = SyntaxNode.new(input, index...(index + 1)) if cached == true
+        @index = cached.interval.end
+      end
+      return cached
+    end
+
+    if has_terminal?('OR', false, index)
+      r0 = instantiate_node(OrLiteral,input, index...(index + 2))
+      @index += 2
+    else
+      terminal_parse_failure('OR')
+      r0 = nil
+    end
+
+    node_cache[:OR][start_index] = r0
+
+    r0
+  end
+
+end
+
+class TagQueryGrammarParser < Treetop::Runtime::CompiledParser
+  include TagQueryGrammar
+end
+
+

data/lib/rutty/treetop/tag_query.treetop

@@ -0,0 +1,38 @@
+grammar TagQueryGrammar
+  rule query
+    tag space boolean space (query / group) / tag
+  end
+
+  rule tag
+    ["|'] [\w-]+ ["|'] <Tag>
+  end
+
+  rule group
+    group_start query group_end <QueryGroup>
+  end
+  
+  rule boolean
+    AND / OR
+  end
+  
+  rule space
+    [\s]+ <Whitespace>
+  end
+
+  rule group_start
+    '(' <GroupStart>
+  end
+
+  rule group_end
+    ')' <GroupEnd>
+  end
+
+  rule AND
+    'AND' <AndLiteral>
+  end
+
+  rule OR
+    'OR' <OrLiteral>
+  end
+end
+

data/lib/rutty/version.rb

@@ -8,8 +8,8 @@ module Rutty
   # @see http://semver.org
   module Version
     MAJOR = 2
-    MINOR = 2
-    PATCH = 0
+    MINOR = 3
+    PATCH = 1
     BUILD = nil
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.')

data/rutty.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rutty}
-  s.version = "2.2.0"
+  s.version = "2.3.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Josh Lindsey"]
-  s.date = %q{2010-11-13}
+  s.date = %q{2010-11-15}
   s.default_executable = %q{rutty}
   s.description = %q{
       RuTTY is a DSH (distributed / dancer's shell) written in Ruby. It's used to run commands 
@@ -24,6 +24,7 @@ Gem::Specification.new do |s|
   ]
   s.files = [
     ".gitignore",
+     ".yardopts",
      "Gemfile",
      "Gemfile.lock",
      "LICENSE",
@@ -39,6 +40,10 @@ Gem::Specification.new do |s|
      "lib/rutty/helpers.rb",
      "lib/rutty/node.rb",
      "lib/rutty/nodes.rb",
+     "lib/rutty/proc_classes.rb",
+     "lib/rutty/treetop/syntax_nodes.rb",
+     "lib/rutty/treetop/tag_query.rb",
+     "lib/rutty/treetop/tag_query.treetop",
      "lib/rutty/version.rb",
      "rutty.gemspec",
      "test/helper.rb",
@@ -88,6 +93,7 @@ Gem::Specification.new do |s|
       s.add_runtime_dependency(%q<net-ssh>, [">= 2.0.23"])
       s.add_runtime_dependency(%q<net-scp>, [">= 1.0.4"])
       s.add_runtime_dependency(%q<builder>, [">= 2.1.2"])
+      s.add_runtime_dependency(%q<treetop>, [">= 1.4.8"])
     else
       s.add_dependency(%q<bundler>, [">= 1.0.0"])
       s.add_dependency(%q<jeweler>, [">= 1.4.0"])
@@ -98,6 +104,7 @@ Gem::Specification.new do |s|
       s.add_dependency(%q<net-ssh>, [">= 2.0.23"])
       s.add_dependency(%q<net-scp>, [">= 1.0.4"])
       s.add_dependency(%q<builder>, [">= 2.1.2"])
+      s.add_dependency(%q<treetop>, [">= 1.4.8"])
     end
   else
     s.add_dependency(%q<bundler>, [">= 1.0.0"])
@@ -109,6 +116,7 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<net-ssh>, [">= 2.0.23"])
     s.add_dependency(%q<net-scp>, [">= 1.0.4"])
     s.add_dependency(%q<builder>, [">= 2.1.2"])
+    s.add_dependency(%q<treetop>, [">= 1.4.8"])
   end
 end
 

data/test/test_nodes.rb

@@ -1,4 +1,5 @@
 require 'helper'
+require 'ostruct'
 
 class TestNodes < Test::Unit::TestCase
   context "The Rutty::Nodes class" do
@@ -33,13 +34,18 @@ class TestNodes < Test::Unit::TestCase
                                :port => 22,
                                :user => 'root',
                                :keypath => '/dev/null',
-                               :tags => %w(localhost test)
+                               :tags => %w(localhost fake test)
       @node2 = Rutty::Node.new :host => 'google.com',
                                :port => 22,
                                :user => 'google',
                                :keypath => '/home/user/.ssh/id_rsa',
                                :tags => %w(google fake test)
-      @nodes = Rutty::Nodes.new [@node1, @node2]
+      @node3 = Rutty::Node.new :host => 'example.com',
+                               :port => 22333,
+                               :user => 'example',
+                               :keypath => '/home/example/.ssh/id_rsa.pem',
+                               :tags => %w(broken test example)
+      @nodes = Rutty::Nodes.new [@node1, @node2, @node3]
     end
     
     teardown { clean_test_config! }
@@ -49,10 +55,47 @@ class TestNodes < Test::Unit::TestCase
     end
     
     should "filter out nodes matching provided criteria" do
-      assert_equal [@node1], @nodes.filter(:tags => %w(localhost))
-      assert_equal [@node1, @node2], @nodes.filter(:port => 22)
-      assert_equal [@node2], @nodes.filter(:user => 'google')
-      assert_equal [@node2], @nodes.filter(:keypath => '/home/user/.ssh/id_rsa')
+      assert_equal [@node1, @node2], @nodes.filter(OpenStruct.new :port => 22)
+      assert_equal [@node2], @nodes.filter(OpenStruct.new :user => 'google')
+      assert_equal [@node2], @nodes.filter(OpenStruct.new :keypath => '/home/user/.ssh/id_rsa')
+    end
+    
+    should "correctly filter on a single tag and return the correct node(s)" do
+      filtered = @nodes.filter(OpenStruct.new :tags => 'test')
+      assert_equal 3, filtered.length
+      assert_equal [@node1, @node2, @node3], filtered
+      
+      filtered = @nodes.filter(OpenStruct.new :tags => 'fake')
+      assert_equal 2, filtered.length
+      assert_equal [@node1, @node2], filtered
+    end
+    
+    should "correctly filter on a comma-separated list of tags and return the correct node(s)" do
+      filtered = @nodes.filter(OpenStruct.new :tags => 'broken,example')
+      assert_equal 1, filtered.length
+      assert_equal [@node3], filtered
+      
+      filtered = @nodes.filter(OpenStruct.new :tags => 'test,fake')
+      assert_equal 3, filtered.length
+      assert_equal [@node1, @node2, @node3], filtered
+      
+      filtered = @nodes.filter(OpenStruct.new :tags => 'localhost,example')
+      assert_equal 2, filtered.length
+      assert_equal [@node1, @node3], filtered
+    end
+    
+    should "correctly filter on a SQL-like tag query and return the correct node(s)" do
+      filtered = @nodes.filter(OpenStruct.new :tags => "'test' AND 'localhost'")
+      assert_equal 1, filtered.length
+      assert_equal [@node1], filtered
+      
+      filtered = @nodes.filter(OpenStruct.new :tags => "'example' OR 'localhost'")
+      assert_equal 2, filtered.length
+      assert_equal [@node1, @node3], filtered
+      
+      filtered = @nodes.filter(OpenStruct.new :tags => "'localhost' AND 'test' OR ('google')")
+      assert_equal 2, filtered.length
+      assert_equal [@node1, @node2], filtered
     end
     
     should "correctly write out a node config" do

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rutty
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 1
   prerelease: false
   segments: 
   - 2
-  - 2
-  - 0
-  version: 2.2.0
+  - 3
+  - 1
+  version: 2.3.1
 platform: ruby
 authors: 
 - Josh Lindsey
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-13 00:00:00 -05:00
+date: 2010-11-15 00:00:00 -05:00
 default_executable: rutty
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -160,6 +160,22 @@ dependencies:
         version: 2.1.2
   type: :runtime
   version_requirements: *id009
+- !ruby/object:Gem::Dependency 
+  name: treetop
+  prerelease: false
+  requirement: &id010 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 4
+        - 8
+        version: 1.4.8
+  type: :runtime
+  version_requirements: *id010
 description: "\n      RuTTY is a DSH (distributed / dancer's shell) written in Ruby. It's used to run commands \n      on multiple remote servers at once, based on a tagging system. Also allows for multiple\n      SCP-style uploads.\n    "
 email: josh@cloudspace.com
 executables: 
@@ -171,6 +187,7 @@ extra_rdoc_files:
 - README.md
 files: 
 - .gitignore
+- .yardopts
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -186,6 +203,10 @@ files:
 - lib/rutty/helpers.rb
 - lib/rutty/node.rb
 - lib/rutty/nodes.rb
+- lib/rutty/proc_classes.rb
+- lib/rutty/treetop/syntax_nodes.rb
+- lib/rutty/treetop/tag_query.rb
+- lib/rutty/treetop/tag_query.treetop
 - lib/rutty/version.rb
 - rutty.gemspec
 - test/helper.rb