mtgdecksort 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6d44b74ed7c8516f48b9f4581149eb81dbd53101
+  data.tar.gz: d014fcbf79f252ded342441394f88b4df0d65a11
+SHA512:
+  metadata.gz: 09f0c9d44408ef524fd901ed66d8606e4ae30a921eb7d08623ffc42b7ac1ad0aa9be7706c0af9124beab1dd1d8274e0b160707de2fec67102806e7c7312eab9b
+  data.tar.gz: 3ee170435d16e2f0f48213b16f13ecd7c568ee03278f05121f15f1485f0273fc245b90f66083a5d1353ac561a47acbcbd08dbcca988c368ffb9815acfaff3b10

data/bin/mtgdecksort

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+
+require 'mtgdecksort'
+
+MtgDecksort.execute

data/lib/mtgdecksort.rb

@@ -0,0 +1,240 @@
+# coding:utf-8
+
+require 'optparse'
+require 'json'
+
+module MtgDecksort
+  Card = Struct.new(:name, :cmc, :type, :quantity)
+
+  def MtgDecksort.execute
+    options = {}
+
+    OptionParser.new do |opts|
+      opts.banner = "Usage: mtgdecksort [options]"
+        opts.on("-p", "--path STR", "Decklist file") do |p|
+          options[:file] = p
+        end
+        opts.on("-f", "--format STR", "Output format") do |f|
+          options[:format] = f
+        end
+    end.parse!
+
+    unless options == {}
+      sortDeck(options[:file], options[:format])
+    end
+  end
+
+  # Private: Sort a deck list.
+  #
+  # path - The path to the file containing the deck list to be sorted, as a
+  #        String.
+  # format - A String detailing the order of output categories.
+  #
+  # Returns nothing.
+  def MtgDecksort.sortDeck(path, format)
+    deck = parseDeck(path)
+
+    separated_deck = separateTypes(deck)
+
+    deck = rebuildDeck(separated_deck, format)
+
+    puts deck
+  end
+
+  # Private: Parses a file containing a deck list.
+  #
+  # f - The path to the file containing the deck list to be parsed, as a String.
+  #
+  # Returns an Array of Cards containing the parsed deck.
+  def MtgDecksort.parseDeck(f)
+    deck = []
+
+    File.open(f).each do |cardname|
+      deck << getCardInfo(cardname)
+    end
+
+    return deck
+  end
+
+  # Private: Gets the information for a specific card
+  # using tutor (https://github.com/davidchambers/tutor).
+  #
+  # cardname - The name of the card to retrieve information for, as a String.
+  #
+  # Returns a Card containing the relevant card information.
+  def MtgDecksort.getCardInfo(cardname)
+    # ignore lines beginning with //
+    unless /(\/\/).*$/.match(cardname)
+      # Only do the split if the cardname has a quantity in front
+      if /[0-9]+\s.+$/.match(cardname)
+        quantity, cardname = cardname.split(" ", 2)
+      else
+        quantity = 1
+      end
+
+      cardname = cardname.strip
+
+      puts "Parsing " + cardname + "..."
+      info = 'tutor card \'' + cardname + '\' --format json'
+      info = %x[ #{info} ]
+
+      info_parsed = JSON.parse(info)
+
+      card = Card.new(cardname, info_parsed["converted_mana_cost"],
+                      info_parsed["types"], quantity)
+
+      return card
+    end
+  end
+
+  # Private: Separates a deck Array into a Hash, with card type represented as
+  #          a Symbol as the key.
+  #
+  # deck - The deck to separate.
+  #
+  # Returns a Hash with Cards as values and card types represented as Symbols as
+  #   keys.
+  def MtgDecksort.separateTypes(deck)
+    cards = {
+      :artifacts => [],
+      :creatures => [],
+      :enchantments => [],
+      :instants => [],
+      :lands => [],
+      :planeswalkers => [],
+      :sorceries => []
+    }
+
+    deck.each do |card|
+      case card.type
+      when ["Artifact", "Creature"]
+        cards[:creatures] << card
+      when ["Enchantment", "Creature"]
+        cards[:creatures] << card
+      when ["Creature"]
+        cards[:creatures] << card
+      when ["Instant"]
+        cards[:instants] << card
+      when ["Land"]
+        cards[:lands] << card
+      when ["Planeswalker"]
+        cards[:planeswalkers] << card
+      when ["Sorcery"]
+        cards[:sorceries] << card
+      when ["Artifact"]
+        cards[:artifacts]<< card
+      when ["Enchantment", "Artifact"]
+        cards[:artifacts] << card
+      when ["Enchantment"]
+        cards[:enchantments] << card
+      end
+    end
+
+    cards.delete_if do |k, v|
+      v.empty?
+    end
+
+    return cards
+  end
+
+  # Private: Sorts an Array of cards by their converted mana cost, then name.
+  #
+  # list - The Array of cards to sort.
+  #
+  # Returns nothing.
+  def MtgDecksort.sortList!(list)
+    list.sort_by! do |card|
+      [card.cmc, card.name]
+    end
+  end
+
+  # Private: builds an Array of Strings to populate a decklist file based on the
+  #          provided Hash of Cards, with Symbols representing card type as
+  #          keys.
+  #
+  # deck - The deck to build the strings from, as a Hash with Cards as values
+  #        and Symbols representing card types as keys.
+  #
+  # format - A String representing the order to place the card types in. Card
+  #          card types should be represented by their first character. Any card
+  #          type not represented will be placed in the general 'Spells'
+  #          category.
+  #
+  # Returns the array of strings.
+  def MtgDecksort.rebuildDeck(deck, format)
+    deck_strings = []
+
+    format = format.split("")
+
+    format.each do |type|
+      case type
+      when 'a'
+        deck_strings << "// Artifacts"
+        deck_strings << extractCardType(deck, :artifacts)
+      when 'c'
+        deck_strings << "// Creatures"
+        deck_strings << extractCardType(deck, :creatures)
+      when 'e'
+        deck_strings << "// Enchantments"
+        deck_strings << extractCardType(deck, :enchantments)
+      when 'i'
+        deck_strings << "// Instants"
+        deck_strings << extractCardType(deck, :instants)
+      when 'l'
+        deck_strings << "// Lands"
+        deck_strings << extractCardType(deck, :lands)
+      when 'p'
+        deck_strings << "// Planeswalkers"
+        deck_strings << extractCardType(deck, :planeswalkers)
+      when 's'
+        deck_strings << "// Sorceries"
+        deck_strings << extractCardType(deck, :sorceries)
+      end
+    end
+
+    deck_strings << "// Spells"
+    leftover_cards = []
+    deck.each do |type, list|
+      list.each do |card|
+        leftover_cards << card
+      end
+    end
+
+    sortList!(leftover_cards)
+    deck_strings << cardArrayToString(leftover_cards)
+    return deck_strings
+  end
+
+  # Private: Removes one card type Array from the deck, sorts it, and returns it
+  #          as an Array of Strings.
+  #
+  # deck - The deck to extract the card type Array from, as a Hash.
+  #
+  # type - The card type to extract, represented as a Symbol.
+  #
+  # Returns a sorted Array of Strings representing the Cards in the extracted
+  #   Array.
+  def MtgDecksort.extractCardType(deck, type)
+    sortList!(deck[type])
+    deck_strings = cardArrayToString(deck[type])
+    deck.delete(type)
+    deck_strings << "\n"
+
+    return deck_strings
+  end
+
+  # Private: Converts an array of Cards to an array of Strings representing the
+  #          Cards.
+  #
+  # array - The Array of Cards to convert.
+  #
+  # Returns an Array of Strings representing the Array of Cards passed in.
+  def MtgDecksort.cardArrayToString(array)
+    return_strings = []
+    array.each do |card|
+      return_strings << card.quantity.to_s + " " + card.name
+    end
+
+    return return_strings
+  end
+end

metadata

@@ -0,0 +1,46 @@
+--- !ruby/object:Gem::Specification
+name: mtgdecksort
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- James Noble
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-01-12 00:00:00.000000000 Z
+dependencies: []
+description: 'A utility for sorting Magic: The Gathering decklists'
+email: james@jamwillinob.com
+executables:
+- mtgdecksort
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/mtgdecksort
+- lib/mtgdecksort.rb
+homepage: http://jamwillinob.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: 'Magic: The Gathering deck sorting utility'
+test_files: []