pokepaste 0.0 → 0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6d17c57c81b0801cd9628e74eb0a1632fbf0be50fa2a2cec58b3b0bdd10492e4
-  data.tar.gz: d6b16c078757ff881a8e87341330f10e8c7ac94c36aac2da960ae53db32882fb
+  metadata.gz: 00dd0a7de40dd35ecfea44b68923d6670038e9975fea57031d344686eab5be8e
+  data.tar.gz: 1dd51398eaa67e92e7c4be23007c3ef551a4ad59be205978404f47f243d6fea3
 SHA512:
-  metadata.gz: 142c409f1da71ff043710f94f48a03953fdf26682079a7abc54e3f9a6395e1d43b2164156b6c556f8627904e837ebea114304407af8f78d279b68aecf033fd51
-  data.tar.gz: b5bd9cb65f42d138aec7b22d8bb496ce8b4980cdda65ae5cff2963357109680a7e156da3040588545aba1e43df723129dc3f48385dbae1ebd08a266b12fe558f
+  metadata.gz: 8d373e26fb2be699c0b083ffa5acfda5543514c5373077b762d35cdc2611cfb7effcea61066cb8719e00fba1dfee4bfe5387ccc77726dd186975ab98bc078ca7
+  data.tar.gz: 4cdae218a9a99a2294085c1a5aafcdab28615c66e87a810952562e12f8946e32bb1b636653a146519bdba63dd1d90292141b41a77c99026c5523ee4e9312796d

data/README.md

@@ -5,7 +5,7 @@ by Pokémon Showdown and various teambuilders.
 
 ## Installation
 
-Install with RubyGems:
+Install with [RubyGems](https://rubygems.org/gems/pokepaste):
 
 ```bash
 gem install pokepaste
@@ -40,17 +40,17 @@ team = PokePaste::fetch("https://pokepast.es/5c46f9ec443664cb")
 team = PokePaste::fetch("5c46f9ec443664cb") # full URL optional
 ```
 
-Once you have it parsed, you have an instance of `PokePaste::Team`, an
-Enumerable containing an instance of `PokePaste::Pokemon` for each Pokémon on
+These methods return an instance of `PokePaste::Team`, an Enumerable
+containing an instance of `PokePaste::Pokemon` for each Pokémon on
 the team. You can loop over the team as with any Enumerable, and access the
 data like so:
 
 ```ruby
 team.each do |pkmn|
   pkmn.species # required
-  pkmn.nickname # default null
-  pkmn.gender # default null
-  pkmn.item # default null
+  pkmn.nickname # default nil
+  pkmn.gender # default nil
+  pkmn.item # default nil
 
   # EVs and IVs are hashes with the stat as the key
   # (:hp, :atk, :def, :spa, :spd, or :spe)
@@ -58,7 +58,8 @@ team.each do |pkmn|
   pkmn.ivs[:spa] # default 31
 
   pkmn.shiny? # default is false
-  pkmn.ability # default is null
+  pkmn.ability # default is nil
+  pkmn.tera_type # default is nil
   pkmn.level # default is 50
   pkmn.happiness # default is 255
   pkmn.nature # default is :hardy (neutral nature)
@@ -87,6 +88,7 @@ team << PokePaste::Pokemon.new(
   species: "Bulbasaur",
   nickname: "Bud",
   ivs: {atk: 0},
+  shiny: true,
   moves: %w[Tackle Growl]
 )
 
@@ -100,9 +102,18 @@ a paste on [pokepast.es](https://pokepast.es/), you could:
 raw_paste = PokePaste.fetch(url_or_id).to_s
 ```
 
+This library is purely a parser for the PokéPaste format, it does not contain
+any data about the Pokémon, whether or not the moves are valid, their
+abilities, anything like that. You could enter nonsense into any of the given
+fields and they will be parsed to and from the PokéPaste format happily.
+Validating anything beyond the syntax of the PokéPaste is left up to the user.
+
 ## License
 
 This library is released under the MIT license. See the
-[`LICENSE.md`](https://github.com/vinnydiehl/pokepaste-ruby/blob/master/LICENSE.md)
+[`LICENSE.md`](https://github.com/vinnydiehl/pokepaste-ruby/blob/develop/LICENSE.md)
 file included with this code or
 [the official page on OSI](http://opensource.org/licenses/MIT) for more information.
+
+I am not affiliated with Nintendo, Game Freak, The Pokémon Company, or any of
+their subsidiaries. This is a free fan-made project. Pokémon is © and ™ Nintendo.

data/VERSION

@@ -1 +1 @@
-0.0
+0.1

data/lib/pokepaste/pokemon.rb

@@ -1,9 +1,136 @@
 module PokePaste
   class Pokemon
-    def initialize
+    attr_accessor *%i[species nickname gender item evs ivs shiny
+                      ability tera_type level happiness nature moves]
+
+    @gender_abbrs = {m: :male, f: :female}
+    class << self
+      attr_accessor :gender_abbrs
+    end
+
+    def initialize(**attrs)
+      unless attrs[:species]
+        raise ArgumentError, "species required to initialize a PokePaste::Pokemon"
+      end
+
+      # Check types for things expected to be other than strings... everything else will
+      # at worst get coverted with #to_s and so will be allowed. It is not the job of
+      # this library to enforce legality, only to parse the PokéPaste format
+      [[:evs, Hash],
+       [:ivs, Hash],
+       [:level, Integer],
+       [:happiness, Integer],
+       [:moves, Array]].each do |attr, type|
+        unless attrs[attr].nil? || attrs[attr].is_a?(type)
+          raise TypeError, "expected type #{type} for :#{attr}, received #{attrs[attr].class}"
+        end
+      end
+
+      unless attrs[:shiny].nil? || [true, false].include?(attrs[:shiny])
+        raise TypeError, "expected (true|false|nil) for :shiny, received #{attrs[:shiny]}"
+      end
+
+      # Process and set defaults for EVs and IVs
+      %i[evs ivs].each do |attr|
+        # Pluck the relevant value out of the attrs Hash if there is one
+        input_attr = attrs.delete(attr) || {}
+
+        # Error if this isn't a Hash
+        unless input_attr.is_a?(Hash)
+          raise ArgumentError, "expected a Hash for :#{attr}, received #{input_attr.class}"
+        end
+
+        stats = %i[hp atk def spa spd spe]
+
+        # Error if an invalid stat is specified
+        input_attr.each do |key, value|
+          unless stats.include?(key)
+            raise ArgumentError, "invalid :#{attr} key :#{key}, expected one of #{stats.keys}"
+          end
+        end
+
+        # Set default for any stat that hasn't been specified
+        stats.each do |stat|
+          input_attr[stat] ||= attr == :evs ? 0 : 31
+        end
+
+        send "#{attr}=", input_attr
+      end
+
+      # Copy the attributes from the constructor to instance variables
+      attrs.each { |key, value| send "#{key}=", value }
+
+      # Both first letter and full word, string and symbol are supported for gender
+      if attrs[:gender]
+        gender = attrs[:gender].downcase.to_sym
+        if self.class.gender_abbrs.flatten.include?(gender)
+          # Either it's the key, or the value; this will find the value either way
+          @gender = self.class.gender_abbrs[gender] || gender
+        else
+          raise TypeError,
+            "expected nil or one of #{self.class.gender_abbrs.flatten} for :gender, received #{attrs[:gender]}"
+        end
+      end
+
+      if attrs[:nature]
+        begin
+          @nature = attrs[:nature].is_a?(Integer) ? attrs[:nature] : attrs[:nature].downcase.to_sym
+        rescue NoMethodError
+          raise TypeError,
+            "expected a (String|Symbol|Integer) for :nature, received #{attrs[:nature].class}"
+        end
+      end
+
+      @shiny ||= false
+      @level ||= 50
+      @happiness ||= 255
+      @nature ||= :hardy
+      @moves ||= []
     end
 
     def to_s
+      # Build first line
+      str = @nickname ? "#{@nickname} (#{@species})" : @species.dup
+      str << " (#{@gender.to_s[0].upcase})" if @gender
+      str << " @ #{@item}" if @item
+
+      str << "\nAbility: #{@ability}" if @ability
+      str << "\nLevel: #{@level}" if @level != 50
+      str << "\nShiny: Yes" if @shiny
+      str << "\nTera Type: #{@tera_type.to_s.capitalize}" if @tera_type
+      str << "\nEVs: #{stat_string @evs, 0}" if @evs.any? { |_, value| value != 0 }
+      # Don't print neutral natures
+      unless %i[hardy docile serious bashful quirky].include? @nature
+        str << "\n#{@nature.to_s.capitalize} Nature"
+      end
+      str << "\nIVs: #{stat_string @ivs, 31}" if @ivs.any? { |_, value| value != 31 }
+      str << "\nHappiness: #{@happiness}" if @happiness != 255
+
+      @moves.each do |move|
+        str << "\n- #{move.is_a?(Array) ? move.join(" / ") : move}"
+      end
+
+      str
+    end
+
+    def shiny?
+      @shiny
+    end
+
+    private
+
+    @@stat_inflections = {
+      hp: "HP",
+      atk: "Atk",
+      def: "Def",
+      spa: "SpA",
+      spd: "SpD",
+      spe: "Spe"
+    }
+
+    def stat_string(stats, default)
+      stats.select { |_, value| value != default}
+              .map { |stat, value| "#{value} #{@@stat_inflections[stat]}" }.join(' / ')
     end
   end
 end

data/lib/pokepaste/{paste.rb → team.rb}

@@ -1,10 +1,12 @@
+require "forwardable"
+
 module PokePaste
   class Team
     include Enumerable
     extend Forwardable
     def_delegators :@team, *%i[size length [] empty? last index]
 
-    def initialize(paste)
+    def initialize
       @team = []
     end
 
@@ -13,6 +15,15 @@ module PokePaste
     end
 
     def to_s
+      map(&:to_s).join("\n\n")
+    end
+
+    def <<(pkmn)
+      if pkmn.is_a? PokePaste::Pokemon
+        @team << pkmn
+      else
+        raise TypeError, "invalid type, PokePaste::Pokemon expected"
+      end
     end
   end
 end

data/lib/pokepaste.rb

@@ -1,10 +1,112 @@
-require "pokepaste/paste"
 require "pokepaste/pokemon"
+require "pokepaste/team"
+
+require "open-uri"
 
 module PokePaste
-  def parse(paste)
+  def self.parse(paste)
+    # Each paragraph is a Pokémon (separated by 1 or more blank lines)
+    paragraphs = paste.strip.split(/\n\s*\n/).map { |p| p.split("\n").map &:strip }
+
+    team = PokePaste::Team.new
+
+    paragraphs.each do |paragraph|
+      # Line 1 can contain species, nickname, gender, and item in format like:
+      #   Bud (Bulbasaur) (M) @ Life Orb
+      # Only the species is required, however
+      line1 = paragraph.shift
+      before_at, item = line1.split /\s+@\s+/
+
+      # Now work from right to left, parsing off the parts in parens
+
+      # Set the gender to nil, :male, or :female
+      if gender = before_at.slice!(/\s*\((m(ale)?|f(emale)?)\)$/i)
+        # Get rid of the parens
+        [/^\s*\(/, /\)$/].each { |regex| gender.slice! regex }
+        gender = PokePaste::Pokemon.gender_abbrs[gender.downcase[0].to_sym]
+      end
+
+      # This regex requires a space between the nickname and opening paren
+      if species = before_at.slice!(/\s+\([^\)]+\)$/i)
+        # We found the species inside parens, which means a nickname is present
+        [/^\s*\(/, /\)$/].each { |regex| species.slice! regex }
+        nickname = before_at
+      else
+        # Otherwise all that remains is the species, and there is no nickname
+        species = before_at
+        nickname = nil
+      end
+
+      pkmn = PokePaste::Pokemon.new species: species, nickname: nickname,
+                                    item: item, gender: gender
+
+      # Pull the moves out
+      pkmn.moves, paragraph = paragraph.partition { |line| line =~ /^\s*-/ }
+      if pkmn.moves.any?
+        pkmn.moves.map! do |line|
+          move_slot = line.sub /^\s*-\s*/, ""
+          move_slot.include?("/") ? move_slot.split(/\s*\/\s*/) : move_slot
+        end
+      end
+
+      # Pull the nature out. If there are multiple, the first is used
+      nature_line, paragraph = paragraph.partition { |line| line =~ /nature\s*$/i }
+      if nature_line.any?
+        pkmn.nature = nature_line.first.sub(/\s*nature\s*$/i, "").downcase.to_sym
+      end
+
+      # All that we're left with at this point are attributes that are denoted with
+      # the syntax "Attribute: Value". Let's loop over them and parse the attribute
+      paragraph.each do |line|
+        attribute, value = line.split /\s*:\s*/, 2
+        attribute = attribute.downcase.gsub(/\s+/, "_").to_sym
+
+        # At this point attribute will be a symbol with the snake_case approximation
+        # of whatever was before the first ":" in the string. If we know what it does,
+        # we can manipulate it as desired, otherwise just let it through as a string.
+        # This is intended to be a flexible format.
+        if %i[evs ivs].include?(attribute)
+          data = value.split /\s*\/\s*/
+          data.map { |d| d.split /\s+/, 2 }.each do |value, stat|
+            current_value = pkmn.send attribute
+            current_value[stat.downcase.to_sym] = value.to_i
+            pkmn.send "#{attribute}=", current_value
+          end
+        elsif %i[level happiness].include?(attribute)
+          pkmn.send "#{attribute}=", value.to_i
+        elsif attribute == :shiny
+          pkmn.shiny = %w[yes true].include?(value.downcase)
+        else
+          pkmn.send "#{attribute}=", value
+        end
+      end
+
+      team << pkmn
+    end
+
+    team
   end
 
-  def fetch(str)
+  def self.fetch(str)
+    input_url = URI.parse(str)
+    unless [nil, "pokepast.es"].include? input_url.host
+      raise ArgumentError, "invalid URL; must be valid pokepast.es URL or path, received '#{str}'"
+    end
+
+    path = (input_url.host ? input_url.path : str).gsub /^\//, ""
+    if path.empty?
+      raise ArgumentError, "invalid URL; no paste ID found in '#{str}'"
+    end
+
+    # The paste is in <article> tags
+    paste_content = URI.open("https://pokepast.es/#{path}").read.
+                        slice(/(?<=\<article\>)[\S\s]*(?=\<\/article\>)/)
+
+    unless paste_content
+      raise OpenURI::HTTPError.new "no paste found at '#{str}'", 404
+    end
+
+    # Removing all HTML tags is sufficient to pass the string to the parser
+    parse paste_content.gsub(/\<\/?[^\>]+\>/, "")
   end
 end

data/spec/pokepaste/parser_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+describe PokePaste do
+  let(:paste) { PokePaste::parse TEST_PASTE }
+
+  describe "#parse" do
+    TEST_DATA.each_with_index do |attrs, i|
+      attrs.each do |attr, value|
+        it "processes :#{attr}#{attr == :shiny ? '?' : ''} correctly" do
+          attr = (attr.to_s + "?").to_sym if attr == :shiny
+          expect(paste[i].send attr).to eq value
+        end
+      end
+    end
+  end
+
+  describe "#fetch" do
+    before :each do
+      # stub a PokéPaste request
+    end
+
+    it "works with a full URL" do
+      fetch = PokePaste::fetch TEST_PASTE_URL
+
+      test_paste_equality paste, fetch
+    end
+
+    it "works with a path" do
+      fetch = PokePaste::fetch "/#{TEST_PASTE_ID}"
+
+      test_paste_equality paste, fetch
+    end
+
+    it "works with an ID" do
+      fetch = PokePaste::fetch TEST_PASTE_ID
+
+      test_paste_equality paste, fetch
+    end
+
+    it "fails with an invalid host or no path" do
+      ["https://google.com/",
+       "https://pokepast.es",
+       "http://localhost/test"].each do |input|
+        expect { PokePaste::fetch input }.to raise_error ArgumentError
+      end
+    end
+
+    it "fails with an invalid input" do
+      ["https://pokepast.es/nobodyhome",
+       "somerandomtext",
+       "https://pokepast.es/syntax.html",
+       "syntax.html"].each do |input|
+        expect { PokePaste::fetch input }.to raise_error OpenURI::HTTPError
+      end
+    end
+  end
+end

data/spec/pokepaste/pokemon_spec.rb

@@ -0,0 +1,92 @@
+require "spec_helper"
+
+# For most of these the species doesn't matter, here's a shortcut
+def init_pkmn(**args)
+  PokePaste::Pokemon.new species: "Bulbasaur", **args
+end
+
+GENDERS = {m: :male, f: :female}
+
+describe PokePaste::Pokemon do
+  context "when initialized with no species" do
+    it "throws an ArgumentError" do
+      expect { PokePaste::Pokemon.new }.to raise_error ArgumentError
+    end
+  end
+
+  %i[evs ivs shiny level happiness moves].each do |attr|
+    context "when initiaized with an invalid type for :#{attr}" do
+      it "throws a TypeError" do
+        expect { init_pkmn attr => "string" }.to raise_error TypeError
+      end
+    end
+  end
+
+  GENDERS.each do |shorthand, gender|
+    context "when gender :#{shorthand} is used" do
+      it "expands it to :#{gender}" do
+        expect(init_pkmn(gender: shorthand).gender).to eq gender
+      end
+    end
+
+    context "when a string '#{gender}' is used" do
+      it "changes it to a symbol" do
+        expect(init_pkmn(gender: gender.to_s).gender).to eq gender
+      end
+    end
+
+    context "when a string '#{shorthand}' is used" do
+      it "changes it to the symbol :#{gender}" do
+        expect(init_pkmn(gender: shorthand.to_s).gender).to eq gender
+      end
+    end
+  end
+
+  context "when a gender unavailable in the Pokémon games is used" do
+    it "raises a typeerror" do
+      expect { init_pkmn gender: :test }.to raise_error TypeError
+    end
+  end
+
+  it "downcases the gender" do
+    expect(init_pkmn(gender: "Male").gender).to eq :male
+  end
+
+  context "when you try to pass in a boolean for the nature" do
+    it "raises a typeerror" do
+      expect { init_pkmn nature: true }.to raise_error TypeError
+    end
+  end
+
+  context "when you pass a string in for the nature" do
+    it "converts it to a lowercase symbol" do
+      expect(init_pkmn(nature: "Bold").nature).to eq :bold
+    end
+  end
+
+  %i[evs ivs].each do |attr|
+    # n is the default
+    n = attr == :evs ? 0 : 31
+    attr_title = attr.to_s.chop.upcase
+
+    context "when given a single #{attr_title}" do
+      it "keeps the rest of the #{attr_title}s at their defaults" do
+        expect(init_pkmn(attr => {hp: 10}).send attr).to eq({
+          hp: 10, atk: n, def: n, spa: n, spd: n, spe: n
+        })
+      end
+    end
+  end
+
+  context "when initialized with only a species" do
+    let(:pkmn) { PokePaste::Pokemon.new(species: "Armarouge") }
+
+    # The second 'mon in the test data is an Armarouge with
+    # all default values, nothing set except the species.
+    TEST_DATA[1].each do |attr, value|
+      it "sets the :#{attr} attribute correctly" do
+        expect(pkmn.send attr).to eq value
+      end
+    end
+  end
+end

data/spec/pokepaste/team_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+
+describe PokePaste::Team do
+  let :team do
+    team = PokePaste::Team.new
+    TEST_DATA.each { |pkmn| team << PokePaste::Pokemon.new(**pkmn) }
+    team
+  end
+
+  describe "#to_s" do
+    it "produces the correct PokéPaste" do
+      expect(team.to_s).to eq TEST_PASTE
+    end
+  end
+
+  describe "#<<" do
+    context "when given a PokePaste::Pokemon" do
+      it "adds it to the team" do
+        orig_size = team.size
+        team << PokePaste::Pokemon.new(species: (test_species = "Bulbasaur"))
+
+        expect(team.size).to eq (orig_size + 1)
+        expect(team.last.species).to eq test_species
+      end
+    end
+
+    context "when given a string" do
+      it "throws a TypeError" do
+        expect { team << "string" }.to raise_error TypeError
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,7 +1,13 @@
+require "pokepaste"
+
 # Include all files in spec/support
 Dir[File.expand_path("../support/**/*.rb", __FILE__)].each { |f| require f }
 
 RSpec.configure do |config|
+  # Add `focus: true` hash parameter to a describe/context/it block
+  # to only run the specs in that block
+  config.filter_run_when_matching :focus
+
   # Fuubar
   config.add_formatter "Fuubar"
   config.fuubar_progress_bar_options = { format: "  %c/%C |%b>%i|%e " }

data/spec/support/paste_equality.rb

@@ -0,0 +1,8 @@
+def test_paste_equality(a, b)
+  %w[species nickname gender item evs ivs shiny?
+     ability tera_type level happiness nature moves].each do |attr|
+    a.each_with_index do |pkmn, index|
+      expect(pkmn.send attr).to eq b[index].send(attr)
+    end
+  end
+end

data/spec/support/test_paste.rb

@@ -0,0 +1,126 @@
+# These aren't intended to be realistic or legal setups; this is merely to
+# broadly test the features of the parser.
+
+TEST_PASTE = <<~EOS.strip
+  Mr. Mime-Galar (M) @ Heavy-Duty Boots
+  Ability: Vital Spirit
+  Modest Nature
+  IVs: 0 Atk / 0 Spe
+  - Hidden Power [Dark]
+  - Freeze-Dry
+  - Dragon Hammer
+  - Acid
+
+  Armarouge
+
+  Manny (Great Tusk)
+  Ability: Protosynthesis
+  Level: 85
+  Shiny: Yes
+  Tera Type: Ground
+  EVs: 1 HP / 2 Atk / 3 Def / 4 SpA / 5 SpD / 6 Spe
+  Jolly Nature
+  IVs: 1 HP / 2 Atk / 3 Def / 4 SpA / 5 SpD / 6 Spe
+  Happiness: 100
+  - Headlong Rush
+  - Earthquake
+
+  Wo-Chien @ Rocky Helmet
+  Ability: Tablets of Ruin
+  Tera Type: Dark
+  - Ruination
+  - Zen Headbutt
+
+  Glimmora (F)
+  Shiny: Yes
+  EVs: 4 Atk / 252 SpA / 252 Spe
+  Naive Nature
+  IVs: 0 Atk
+  - Dazzling Gleam
+  - Flash Cannon
+  - Mortal Spin
+  - Power Gem / Protect
+EOS
+
+# Identical to TEST_PASTE, uploaded to pokepast.es:
+TEST_PASTE_URL = "https://pokepast.es/a979ce56c2109382"
+TEST_PASTE_ID = "a979ce56c2109382"
+
+# This paste is expected to be parsed into this data:
+TEST_DATA = [
+  {
+    species: "Mr. Mime-Galar",
+    nickname: nil,
+    gender: :male,
+    item: "Heavy-Duty Boots",
+    evs: {hp: 0, atk: 0, def: 0, spa: 0, spd: 0, spe: 0},
+    ivs: {hp: 31, atk: 0, def: 31, spa: 31, spd: 31, spe: 0},
+    shiny: false,
+    ability: "Vital Spirit",
+    tera_type: nil,
+    level: 50,
+    happiness: 255,
+    nature: :modest,
+    moves: ["Hidden Power [Dark]", "Freeze-Dry", "Dragon Hammer", "Acid"]
+  },
+  {
+    species: "Armarouge",
+    nickname: nil,
+    gender: nil,
+    item: nil,
+    evs: {hp: 0, atk: 0, def: 0, spa: 0, spd: 0, spe: 0},
+    ivs: {hp: 31, atk: 31, def: 31, spa: 31, spd: 31, spe: 31},
+    shiny: false,
+    ability: nil,
+    tera_type: nil,
+    level: 50,
+    happiness: 255,
+    nature: :hardy,
+    moves: []
+  },
+  {
+    species: "Great Tusk",
+    nickname: "Manny",
+    gender: nil,
+    item: nil,
+    evs: {hp: 1, atk: 2, def: 3, spa: 4, spd: 5, spe: 6},
+    ivs: {hp: 1, atk: 2, def: 3, spa: 4, spd: 5, spe: 6},
+    shiny: true,
+    ability: "Protosynthesis",
+    tera_type: "Ground",
+    level: 85,
+    happiness: 100,
+    nature: :jolly,
+    moves: ["Headlong Rush", "Earthquake"]
+  },
+  {
+    species: "Wo-Chien",
+    nickname: nil,
+    gender: nil,
+    item: "Rocky Helmet",
+    evs: {hp: 0, atk: 0, def: 0, spa: 0, spd: 0, spe: 0},
+    ivs: {hp: 31, atk: 31, def: 31, spa: 31, spd: 31, spe: 31},
+    shiny: false,
+    ability: "Tablets of Ruin",
+    tera_type: "Dark",
+    level: 50,
+    happiness: 255,
+    nature: :hardy,
+    moves: ["Ruination", "Zen Headbutt"]
+  },
+  {
+    species: "Glimmora",
+    nickname: nil,
+    gender: :female,
+    item: nil,
+    evs: {hp: 0, atk: 4, def: 0, spa: 252, spd: 0, spe: 252},
+    ivs: {hp: 31, atk: 0, def: 31, spa: 31, spd: 31, spe: 31},
+    shiny: true,
+    ability: nil,
+    tera_type: nil,
+    level: 50,
+    happiness: 255,
+    nature: :naive,
+    moves: ["Dazzling Gleam", "Flash Cannon", "Mortal Spin", ["Power Gem", "Protect"]]
+  }
+]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pokepaste
 version: !ruby/object:Gem::Version
-  version: '0.0'
+  version: '0.1'
 platform: ruby
 authors:
 - Vinny Diehl
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-04 00:00:00.000000000 Z
+date: 2023-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -77,10 +77,15 @@ files:
 - Rakefile
 - VERSION
 - lib/pokepaste.rb
-- lib/pokepaste/paste.rb
 - lib/pokepaste/pokemon.rb
+- lib/pokepaste/team.rb
 - pokepaste.gemspec
+- spec/pokepaste/parser_spec.rb
+- spec/pokepaste/pokemon_spec.rb
+- spec/pokepaste/team_spec.rb
 - spec/spec_helper.rb
+- spec/support/paste_equality.rb
+- spec/support/test_paste.rb
 homepage: https://github.com/vinnydiehl/pokepaste-ruby
 licenses:
 - MIT
@@ -105,4 +110,9 @@ signing_key:
 specification_version: 4
 summary: PokéPaste parser for Ruby
 test_files:
+- spec/pokepaste/parser_spec.rb
+- spec/pokepaste/pokemon_spec.rb
+- spec/pokepaste/team_spec.rb
 - spec/spec_helper.rb
+- spec/support/paste_equality.rb
+- spec/support/test_paste.rb