magnet 1.0.0

data/lib/magnet.rb

@@ -0,0 +1,5 @@
+module Magnet
+  require "magnet/card"
+  require "magnet/parser"
+  require "magnet/version"
+end

data/lib/magnet/card.rb

@@ -0,0 +1,144 @@
+module Magnet
+  class Card
+    ALLOWED_SERVICES = {
+      0..1 => :no_restrictions,
+      2 => :goods_and_services_only,
+      3 => :atm_only,
+      4 => :cash_only,
+      5 => :goods_and_services_only,
+      6 => :no_restrictions,
+      7 => :goods_and_services_only
+    }.freeze
+
+    AUTHORIZATION_PROCESSING = {
+      0 => :normal,
+      2 => :by_issuer,
+      4 => :by_issuer_unless_explicit_agreement
+    }.freeze
+
+    FORMAT = {
+      "A" => :reserved,
+      "B" => :bank,
+      "C".."M" => :reserved,
+      "N".."Z" => :available
+    }.freeze
+
+    INTERCHANGE = {
+      1..2 => :international,
+      5..6 => :national,
+      7 => :private,
+      9 => :test
+    }.freeze
+
+    PIN_REQUIREMENTS = {
+      0 => :pin_required,
+      3 => :pin_required,
+      5 => :pin_required,
+      6..7 => :prompt_for_pin_if_ped_present
+    }.freeze
+
+    TECHNOLOGY = {
+      2 => :integrated_circuit_card,
+      6 => :integrated_circuit_card
+    }.freeze
+
+    attr_accessor :allowed_services, :authorization_processing, :discretionary_data, :expiration_year, :expiration_month, :first_name, :format, :initial, :interchange, :last_name, :number, :pin_requirements, :technology, :title
+
+    class << self
+      def parse(track_data, parser = Parser.new(:auto))
+        attributes = parser.parse(track_data)
+        position1, position2, position3 = (attributes[:service_code] || "").scan(/\d/).map(&:to_i)
+        year, month = (attributes[:expiration] || "").scan(/\d\d/).map(&:to_i)
+        title, first_name, initial, last_name = parse_name(attributes[:name].rstrip)
+
+        card = new
+        card.allowed_services = hash_lookup(ALLOWED_SERVICES, position3)
+        card.authorization_processing = hash_lookup(AUTHORIZATION_PROCESSING, position2)
+        card.discretionary_data = attributes[:discretionary_data]
+        card.expiration_month = month
+        card.expiration_year = year
+        card.first_name = first_name
+        card.format = hash_lookup(FORMAT, attributes[:format])
+        card.initial = initial
+        card.interchange = hash_lookup(INTERCHANGE, position1)
+        card.last_name = last_name
+        card.number = attributes[:pan]
+        card.pin_requirements = hash_lookup(PIN_REQUIREMENTS, position3)
+        card.technology = hash_lookup(TECHNOLOGY, position1)
+        card.title = title
+        card
+      end
+
+      private
+      def hash_lookup(hash, key)
+        hash.each do |k, v|
+          return v if k === key
+        end
+        nil
+      end
+
+      def parse_name(name)
+        last, first = name.split("/", 2)
+        first, initial = first.split(" ", 2) if first
+        initial, title = initial.split(".", 2) if initial
+        [title, first, initial, last]
+      end
+    end
+
+    def atm_only?
+      allowed_services == :atm_only
+    end
+
+    def cash_only?
+      allowed_services == :cash_only
+    end
+
+    def goods_and_services_only?
+      allowed_services == :goods_and_services_only
+    end
+
+    def integrated_circuit_card?
+      technology == :integrated_circuit_card
+    end
+
+    def international?
+      interchange == :international
+    end
+
+    def national?
+      interchange == :national
+    end
+
+    def no_service_restrictions?
+      allowed_services = :no_restrictions
+    end
+
+    def pin_required?
+      pin_requirements == :pin_required
+    end
+
+    def private?
+      interchange == :private
+    end
+
+    def process_by_issuer?
+      authorization_processing == :by_issuer
+    end
+
+    def process_by_issuer_unless_explicit_agreement?
+      authorization_processing == :by_issuer_unless_explicit_agreement
+    end
+
+    def process_normally?
+      authorization_processing == :normal
+    end
+
+    def prompt_for_pin_if_ped_present?
+      pin_requirements == :prompt_for_pin_if_ped_present
+    end
+
+    def test?
+      interchange == :test
+    end
+  end
+end

data/lib/magnet/parser.rb

@@ -0,0 +1,34 @@
+module Magnet
+  class Parser
+    TRACKS = {
+      1 => /\A%(?<format>[A-Z])(?<pan>[0-9]{1,19})\^(?<name>[A-Za-z.\/ ]{2,26})\^(?<expiration>\d{4}|\^)(?<service_code>\d{3}|\^)(?<discretionary_data>[^\?]+)\?\Z/,
+      2 => /\A;(?<format>[A-Z])(?<pan>[0-9]{1,19})=(?<expiration>\d{4}|=)(?<service_code>\d{3}|=)(?<discretionary_data>[^\?]+)\?\Z/
+    }.freeze
+
+    def initialize(track = :auto)
+      @track = :auto
+    end
+
+    def parse(track_data)
+      tracks = @track == :auto ? TRACKS.values : [TRACKS[@track]]
+
+      tracks.each do |track|
+        if m = track.match(track_data)
+          attributes = {}
+          attributes[:format] = m[:format]
+          attributes[:pan] = m[:pan]
+          attributes[:name] = m[:name]
+          attributes[:expiration] = m[:expiration] == "^" ? nil : m[:expiration]
+          attributes[:service_code] = m[:service_code] == "^" ? nil : m[:service_code]
+          attributes[:discretionary_data] = m[:discretionary_data]
+          return attributes
+        end
+      end
+
+      raise InvalidDataError, "track data is not valid"
+    end
+
+    class InvalidDataError < StandardError
+    end
+  end
+end

data/lib/magnet/version.rb

@@ -0,0 +1,3 @@
+module Magnet
+  VERSION = "1.0.0"
+end

data/test/magnet/card_test.rb

@@ -0,0 +1,55 @@
+require "test_helper"
+
+describe Magnet::Card do
+  describe "Parse" do
+    before do
+      @attributes = { :format => "B", :pan => "5452300551227189", :name => "HOGAN/PAUL      ", :expiration => "0804", :service_code => "321", :discretionary_data => "0000000725000000" }
+      @parser = stub()
+      @track_data = stub()
+      @parser.stubs(:parse).with(@track_data).returns(@attributes)
+    end
+
+    it "should parse basic attributes" do
+      card = Magnet::Card.parse(@track_data, @parser)
+
+      assert_equal :no_restrictions, card.allowed_services
+      assert_equal :by_issuer, card.authorization_processing
+      assert_equal "0000000725000000", card.discretionary_data
+      assert_equal 8, card.expiration_year
+      assert_equal 4, card.expiration_month
+      assert_equal "PAUL", card.first_name
+      assert_equal :bank, card.format
+      assert_equal nil, card.initial
+      assert_equal nil, card.interchange
+      assert_equal "HOGAN", card.last_name
+      assert_equal "5452300551227189", card.number
+      assert_equal nil, card.pin_requirements
+      assert_equal nil, card.technology
+      assert_equal nil, card.title
+    end
+
+    it "should parse an initial" do
+      @attributes = { :format => "B", :pan => "5452300551227189", :name => "HOGAN/PAUL A    ", :expiration => "0804", :service_code => "321", :discretionary_data => "0000000725000000" }
+      @parser.stubs(:parse).with(@track_data).returns(@attributes)
+
+      card = Magnet::Card.parse(@track_data, @parser)
+
+      assert_equal "PAUL", card.first_name
+      assert_equal "A", card.initial
+      assert_equal "HOGAN", card.last_name
+      assert_equal nil, card.title
+    end
+
+    it "should parse a title" do
+      @attributes = { :format => "B", :pan => "5452300551227189", :name => "HOGAN/PAUL A.DR ", :expiration => "0804", :service_code => "321", :discretionary_data => "0000000725000000" }
+      @parser.stubs(:parse).with(@track_data).returns(@attributes)
+
+      card = Magnet::Card.parse(@track_data, @parser)
+
+      assert_equal "PAUL", card.first_name
+      assert_equal "A", card.initial
+      assert_equal "HOGAN", card.last_name
+      assert_equal "DR", card.title
+    end
+  end
+end

data/test/magnet/parser_test.rb

@@ -0,0 +1,42 @@
+require "test_helper"
+
+describe Magnet::Parser do
+  describe "Track 1" do
+    before do
+      @parser = Magnet::Parser.new(1)
+    end
+
+    it "should parse sample #1" do
+      attributes = @parser.parse("%B6011898748579348^DOE/ JOHN              ^37829821000123456789?")
+
+      assert_equal "B", attributes[:format]
+      assert_equal "6011898748579348", attributes[:pan]
+      assert_equal "DOE/ JOHN              ", attributes[:name]
+      assert_equal "3782", attributes[:expiration]
+      assert_equal "982", attributes[:service_code]
+      assert_equal "1000123456789", attributes[:discretionary_data]
+    end
+
+    it "should parse sample #2" do
+      attributes = @parser.parse("%B6011785948493759^DOE/JOHN L                ^^^0000000      00998000000?")
+
+      assert_equal "B", attributes[:format]
+      assert_equal "6011785948493759", attributes[:pan]
+      assert_equal "DOE/JOHN L                ", attributes[:name]
+      assert_equal nil, attributes[:expiration]
+      assert_equal nil, attributes[:service_code]
+      assert_equal "0000000      00998000000", attributes[:discretionary_data]
+    end
+
+    it "should parse sample #3" do
+      attributes = @parser.parse("%B5452300551227189^HOGAN/PAUL      ^08043210000000725000000?")
+
+      assert_equal "B", attributes[:format]
+      assert_equal "5452300551227189", attributes[:pan]
+      assert_equal "HOGAN/PAUL      ", attributes[:name]
+      assert_equal "0804", attributes[:expiration]
+      assert_equal "321", attributes[:service_code]
+      assert_equal "0000000725000000", attributes[:discretionary_data]
+    end
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: magnet
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Samuel Kadolph
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.13.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.13.2
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.3
+description: magnet lets you parse track data from magnetic stripe cards. Currently
+  supports tracks 1 & 2 from bank cards.
+email:
+- samuel@kadolph.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/magnet/card.rb
+- lib/magnet/parser.rb
+- lib/magnet/version.rb
+- lib/magnet.rb
+- test/magnet/card_test.rb
+- test/magnet/parser_test.rb
+homepage: http://samuelkadolph.github.com/magnet/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: magnet is a library for decoding the track data on magnetic stripe cards.
+test_files:
+- test/magnet/card_test.rb
+- test/magnet/parser_test.rb