mtg_search_parser 0.0.1

data/lib/mtg_search_parser/or_group.rb

@@ -0,0 +1,13 @@
+module MtgSearchParser
+  class OrGroup
+    attr_reader :tokens
+
+    def initialize(tokens)
+      @tokens = tokens
+    end
+
+    def ==(o)
+      o.class == self.class && o.tokens == tokens
+    end
+  end
+end

data/lib/mtg_search_parser/parsed/any_color.rb

@@ -0,0 +1,7 @@
+module MtgSearchParser
+  module Parsed
+    class AnyColor < Base
+
+    end
+  end
+end

data/lib/mtg_search_parser/parsed/artist.rb

@@ -0,0 +1,7 @@
+module MtgSearchParser
+  module Parsed
+    class Artist < Base
+
+    end
+  end
+end

data/lib/mtg_search_parser/parsed/banned.rb

@@ -0,0 +1,7 @@
+module MtgSearchParser
+  module Parsed
+    class Banned < Base
+
+    end
+  end
+end

data/lib/mtg_search_parser/parsed/base.rb

@@ -0,0 +1,15 @@
+module MtgSearchParser
+  module Parsed
+    class Base
+      attr_reader :contents
+
+      def initialize(contents)
+        @contents = contents
+      end
+
+      def ==(o)
+        o.class == self.class && o.contents == contents
+      end
+    end
+  end
+end

data/lib/mtg_search_parser/parsed/card_type.rb

@@ -0,0 +1,7 @@
+module MtgSearchParser
+  module Parsed
+    class CardType < Base
+
+    end
+  end
+end

data/lib/mtg_search_parser/parsed/color_identity.rb

@@ -0,0 +1,7 @@
+module MtgSearchParser
+  module Parsed
+    class ColorIdentity < Base
+
+    end
+  end
+end

data/lib/mtg_search_parser/parsed/edition.rb

@@ -0,0 +1,7 @@
+module MtgSearchParser
+  module Parsed
+    class Edition < Base
+
+    end
+  end
+end

data/lib/mtg_search_parser/parsed/exact_color.rb

@@ -0,0 +1,7 @@
+module MtgSearchParser
+  module Parsed
+    class ExactColor < Base
+
+    end
+  end
+end

data/lib/mtg_search_parser/parsed/exact_name.rb

@@ -0,0 +1,7 @@
+module MtgSearchParser
+  module Parsed
+    class ExactName < Base
+
+    end
+  end
+end

data/lib/mtg_search_parser/parsed/language.rb

@@ -0,0 +1,7 @@
+module MtgSearchParser
+  module Parsed
+    class Language < Base
+
+    end
+  end
+end

data/lib/mtg_search_parser/parsed/legal.rb

@@ -0,0 +1,7 @@
+module MtgSearchParser
+  module Parsed
+    class Legal < Base
+
+    end
+  end
+end

data/lib/mtg_search_parser/parsed/mana_cost.rb

@@ -0,0 +1,18 @@
+module MtgSearchParser
+  module Parsed
+    class ManaCost < Base
+      attr_reader :operator, :mana_cost
+
+      def initialize(operator, mana_cost)
+        @operator = operator
+        @mana_cost = mana_cost
+      end
+
+      def ==(o)
+        o.class == self.class &&
+          o.operator == operator &&
+          o.mana_cost == mana_cost
+      end
+    end
+  end
+end

data/lib/mtg_search_parser/parsed/name.rb

@@ -0,0 +1,7 @@
+module MtgSearchParser
+  module Parsed
+    class Name < Base
+
+    end
+  end
+end

data/lib/mtg_search_parser/parsed/power_tough_compare.rb

@@ -0,0 +1,20 @@
+module MtgSearchParser
+  module Parsed
+    class PowerToughCompare < Base
+      attr_reader :left, :op, :right
+
+      def initialize(left, op, right)
+        @left = left
+        @op = op
+        @right = right
+      end
+
+      def ==(o)
+        o.class == self.class &&
+          o.left == left &&
+          o.op == op &&
+          o.right == right
+      end
+    end
+  end
+end

data/lib/mtg_search_parser/parsed/quality.rb

@@ -0,0 +1,7 @@
+module MtgSearchParser
+  module Parsed
+    class Quality < Base
+
+    end
+  end
+end

data/lib/mtg_search_parser/parsed/rarity.rb

@@ -0,0 +1,7 @@
+module MtgSearchParser
+  module Parsed
+    class Rarity < Base
+
+    end
+  end
+end

data/lib/mtg_search_parser/parsed/release_year.rb

@@ -0,0 +1,18 @@
+module MtgSearchParser
+  module Parsed
+    class ReleaseYear < Base
+      attr_reader :operator, :year
+
+      def initialize(operator, year)
+        @operator = operator
+        @year = year
+      end
+
+      def ==(o)
+        o.class == self.class &&
+          o.operator == operator &&
+          o.year == year
+      end
+    end
+  end
+end

data/lib/mtg_search_parser/parsed/rules_text.rb

@@ -0,0 +1,7 @@
+module MtgSearchParser
+  module Parsed
+    class RulesText < Base
+
+    end
+  end
+end

data/lib/mtg_search_parser/parser.rb

@@ -0,0 +1,60 @@
+module MtgSearchParser
+  class Parser
+    def parse(contents)
+      case contents
+
+      when /\Ac!([wubrgmlc]+)\z/i
+        MtgSearchParser::Parsed::ExactColor.new($1)
+
+      when /\Ac:([wubrgmlc]+)\z/i
+        MtgSearchParser::Parsed::AnyColor.new($1)
+
+      when /\Aci:([wubrgmlc]+)\z/i
+        MtgSearchParser::Parsed::ColorIdentity.new($1)
+
+      when /\At:"([^"]+)"\z/i, /\At:(.+)\z/i
+        MtgSearchParser::Parsed::CardType.new($1)
+
+      when /\Ao:"?([^"]+)"?\z/i
+        MtgSearchParser::Parsed::RulesText.new($1)
+
+      when /\Amana(=|>=|<=|>|<)(.+)\z/i
+        MtgSearchParser::Parsed::ManaCost.new($1, $2)
+
+      when /\A(pow|tou|cmc)(=|>=|<=|>|<)(pow|tou|cmc|\*|[0-9]+)\z/i
+        MtgSearchParser::Parsed::PowerToughCompare.new($1, $2, $3)
+
+      when /\Ar:(mythic|uncommon|common|rare|promo)\z/i
+        MtgSearchParser::Parsed::Rarity.new($1)
+
+      when /\Aa:"(.+)"\z/i, /\Aa:(.+)\z/i
+        MtgSearchParser::Parsed::Artist.new($1)
+
+      when /\Af:(standard|block|extended|vintage|classic|legacy|modern|commander)\z/i
+        MtgSearchParser::Parsed::Legal.new($1)
+
+      when /\Abanned:(standard|block|extended|vintage|classic|legacy|modern|commander)\z/i
+        MtgSearchParser::Parsed::Banned.new($1)
+
+      when /\Ae:(.+)\z/i
+        MtgSearchParser::Parsed::Edition.new($1)
+
+      when /\Al:(.+)\z/i
+        MtgSearchParser::Parsed::Language.new($1)
+
+      when /\Ayear(=|>=|<=|>|<)(.+)\z/i
+        MtgSearchParser::Parsed::ReleaseYear.new($1, $2)
+
+      when /\Ais:(.+)\z/i
+        MtgSearchParser::Parsed::Quality.new($1)
+
+      when /\A!(.+)\z/
+        MtgSearchParser::Parsed::ExactName.new($1)
+      when /\A"([^"]+)"\z/
+        MtgSearchParser::Parsed::Name.new($1)
+      else
+        MtgSearchParser::Parsed::Name.new(contents)
+      end
+    end
+  end
+end

data/lib/mtg_search_parser/version.rb

@@ -0,0 +1,3 @@
+module MtgSearchParser
+  VERSION = "0.0.1"
+end

data/mtg_search_parser.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mtg_search_parser/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mtg_search_parser"
+  spec.version       = MtgSearchParser::VERSION
+  spec.authors       = ["Donald Plummer"]
+  spec.email         = ["donald.plummer@gmail.com"]
+  spec.summary       = %q{A ruby implementation of a MTG search string parser.}
+  spec.homepage      = "https://github.com/dplummer/mtg_search_parser"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/lexer_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+module MtgSearchParser
+  describe Lexer do
+    it "lexes a word" do
+      expect(subject.lex("word")).to eq([Nodes::Query.new("word")])
+    end
+
+    it "splits two words" do
+      expect(subject.lex("word foo")).
+        to eq([Nodes::Query.new("word"), Nodes::Query.new("foo")])
+    end
+
+    it "keeps characters in words" do
+      expect(subject.lex("foo-bar cat")).
+        to eq([Nodes::Query.new("foo-bar"), Nodes::Query.new("cat")])
+    end
+
+    it "allows apostrophes" do
+      expect(subject.lex("foo's bar")).
+        to eq([Nodes::Query.new("foo's"), Nodes::Query.new("bar")])
+    end
+
+    it "keeps : in the word" do
+      expect(subject.lex("foo:bar cat")).
+        to eq([Nodes::Query.new("foo:bar"), Nodes::Query.new("cat")])
+    end
+
+    it "keeps ! in the word" do
+      expect(subject.lex("foo!bar cat")).
+        to eq([Nodes::Query.new("foo!bar"), Nodes::Query.new("cat")])
+    end
+
+    it "keeps it all together if the word starts with a bang" do
+      expect(subject.lex("!foo bar baz")).
+        to eq([Nodes::Query.new("!foo bar baz")])
+    end
+
+    it "keeps tokens together with quotes" do
+      expect(subject.lex('"foo bar" baz')).
+        to eq([Nodes::Query.new('"foo bar"'), Nodes::Query.new("baz")])
+    end
+
+    it "allows quotes in the middle of the term" do
+      expect(subject.lex('o:"foo bar" baz')).
+        to eq([Nodes::Query.new('o:"foo bar"'), Nodes::Query.new("baz")])
+    end
+
+    it "recognizes left and right parens" do
+      expect(subject.lex("(foo)")).
+        to eq([Nodes::LeftParen.new, Nodes::Query.new("foo"), Nodes::RightParen.new])
+    end
+
+    it "recognizes left and right parens ignoring spaces" do
+      expect(subject.lex(" ( foo ) ")).
+        to eq([Nodes::LeftParen.new, Nodes::Query.new("foo"), Nodes::RightParen.new])
+    end
+
+    it "parses AND as an AndNode" do
+      expect(subject.lex("foo AND bar")).
+        to eq([Nodes::Query.new("foo"), Nodes::And.new, Nodes::Query.new("bar")])
+    end
+
+    it "parses and as an AndNode" do
+      expect(subject.lex("foo and bar")).
+        to eq([Nodes::Query.new("foo"), Nodes::And.new, Nodes::Query.new("bar")])
+    end
+
+    it "parses OR as an OrNode" do
+      expect(subject.lex("foo OR bar")).
+        to eq([Nodes::Query.new("foo"), Nodes::Or.new, Nodes::Query.new("bar")])
+    end
+
+    it "parses or as an OrNode" do
+      expect(subject.lex("foo or bar")).
+        to eq([Nodes::Query.new("foo"), Nodes::Or.new, Nodes::Query.new("bar")])
+    end
+
+    it "parses NOT as an NotNode" do
+      expect(subject.lex("foo NOT bar")).
+        to eq([Nodes::Query.new("foo"), Nodes::Not.new, Nodes::Query.new("bar")])
+    end
+
+    it "parses not as an NotNode" do
+      expect(subject.lex("foo not bar")).
+        to eq([Nodes::Query.new("foo"), Nodes::Not.new, Nodes::Query.new("bar")])
+    end
+
+    it "parses - as an NotNode" do
+      expect(subject.lex("foo -bar")).
+        to eq([Nodes::Query.new("foo"), Nodes::Not.new, Nodes::Query.new("bar")])
+    end
+  end
+end

data/spec/mtg_search_parser_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe MtgSearchParser do
+  describe ".parse" do
+    it "parses a big long string of lots of tokens" do
+      expect(MtgSearchParser.parse("\"Foo Bar\" o:Rule t:Type c:WU mana>=3G "\
+                                  "pow<=10 tou=5 cmc>2 f:Modern a:\"Hank Hill\" "\
+                                  "e:avr year=1999")).
+        to eq([
+          MtgSearchParser::Parsed::Name.new("Foo Bar"),
+          MtgSearchParser::Parsed::RulesText.new("Rule"),
+          MtgSearchParser::Parsed::CardType.new("Type"),
+          MtgSearchParser::Parsed::AnyColor.new("WU"),
+          MtgSearchParser::Parsed::ManaCost.new(">=", "3G"),
+          MtgSearchParser::Parsed::PowerToughCompare.new("pow", "<=", "10"),
+          MtgSearchParser::Parsed::PowerToughCompare.new("tou", "=", "5"),
+          MtgSearchParser::Parsed::PowerToughCompare.new("cmc", ">", "2"),
+          MtgSearchParser::Parsed::Legal.new("Modern"),
+          MtgSearchParser::Parsed::Artist.new("Hank Hill"),
+          MtgSearchParser::Parsed::Edition.new("avr"),
+          MtgSearchParser::Parsed::ReleaseYear.new("=", "1999"),
+      ])
+    end
+
+    it "groups items OR'd" do
+      expect(MtgSearchParser.parse("t:angel OR t:demon")).
+        to eq([
+          MtgSearchParser::OrGroup.new([
+            MtgSearchParser::Parsed::CardType.new("angel"),
+            MtgSearchParser::Parsed::CardType.new("demon"),
+          ])
+        ])
+    end
+
+    it "not" do
+      expect(MtgSearchParser.parse("NOT t:angel -t:demon")).
+        to eq([
+          MtgSearchParser::NotGroup.new(
+            [MtgSearchParser::Parsed::CardType.new("angel")]),
+          MtgSearchParser::NotGroup.new(
+            [MtgSearchParser::Parsed::CardType.new("demon")])
+        ])
+    end
+
+    it "parenthesis" do
+      expect(MtgSearchParser.parse("t:demon NOT (t:legendary t:artifact)")).
+        to eq([
+          MtgSearchParser::Parsed::CardType.new("demon"),
+          MtgSearchParser::NotGroup.new([MtgSearchParser::Parsed::CardType.new("legendary"),
+                                         MtgSearchParser::Parsed::CardType.new("artifact")]),
+        ])
+    end
+
+    it "strips unneccessary parenthesis" do
+      expect(MtgSearchParser.parse("(((t:legendary t:artifact)))")).
+        to eq([
+          MtgSearchParser::Parsed::CardType.new("legendary"),
+          MtgSearchParser::Parsed::CardType.new("artifact")
+        ])
+    end
+  end
+end