swedish-pin 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bb6a746d0ef33cae631f59b11006ee17a98cc38af65b69b35a0f025a22beeae1
+  data.tar.gz: c9e0ca8008e77aab92808afee2e619bf6a7ed8d9461319449a304128a50237d5
+SHA512:
+  metadata.gz: cd9f5e5328d76e4d709a4d0b8e688b3e13fd186fb57c66eb82a8793215e01231cb1799d41a4e16a75b306d1d37c9cb3d7a2c1cb98a0ae79dec18ea5bc9cf554e
+  data.tar.gz: 4b7ed29721a100dc98515d181748f47d0c3957d677a19fb93a6ee287837a270dd845ccdaf20ec504735d7e20ad4d03629dc48cdb052d112380fafb3315ced81a

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+before_script:
+  bundle install
+rvm:
+  - 2.5
+  - 2.6
+  - 2.7
+sudo: false

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [1.0.0] - 2020-09-09
+
+Initial release.
+
+[Unreleased]: https://github.com/Mange/swedish-pin-ruby/compare/v1.0.0...HEAD
+[1.0.0]: https://github.com/Mange/swedish-pin-ruby/releases/tag/v1.0.0

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,47 @@
+PATH
+  remote: .
+  specs:
+    swedish-pin (1.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.1)
+    minitest (5.14.2)
+    parallel (1.19.2)
+    parser (2.7.1.4)
+      ast (~> 2.4.1)
+    rainbow (3.0.0)
+    rake (13.0.1)
+    regexp_parser (1.7.1)
+    rexml (3.2.4)
+    rubocop (0.90.0)
+      parallel (~> 1.10)
+      parser (>= 2.7.1.1)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.7)
+      rexml
+      rubocop-ast (>= 0.3.0, < 1.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 2.0)
+    rubocop-ast (0.3.0)
+      parser (>= 2.7.1.4)
+    rubocop-performance (1.8.0)
+      rubocop (>= 0.87.0)
+    ruby-progressbar (1.10.1)
+    standard (0.6.0)
+      rubocop (~> 0.90)
+      rubocop-performance (~> 1.8.0)
+    unicode-display_width (1.7.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  minitest
+  rake
+  standard
+  swedish-pin!
+
+BUNDLED WITH
+   2.1.4

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-2020 - Personnummer, Magnus Bergmark and Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,60 @@
+# swedish-pin
+
+[![Build Status](https://secure.travis-ci.org/Mange/swedish-pin-ruby.png?branch=master)](http://travis-ci.org/Mange/swedish-pin-ruby) [![Inline docs](http://inch-ci.org/github/Mange/swedish-pin-ruby.svg?branch=master)](http://inch-ci.org/github/Mange/swedish-pin-ruby)
+
+Validate, parse, and generate [Swedish Personal Identity
+Numbers](https://en.wikipedia.org/wiki/Personal_identity_number_(Sweden))
+("PINs", or *Personnummer*).
+
+[API documentation](https://www.rubydoc.info/gems/swedish-pin)
+
+## Installation
+
+Add this to your `Gemfile`
+
+```ruby
+gem 'swedish-pin'
+```
+
+Then run `bundle install`.
+
+## Usage
+
+```ruby
+require "swedish_pin"
+
+# Validate strings
+SwedishPIN.valid?("8507099805") # => true
+SwedishPIN.valid?("8507099804") # => false
+
+# Parse numbers to get more information about them, or to normalize display of
+# them.
+pin = SwedishPIN.parse("8507099805") # => #<SwedishPIN::Personnummer …>
+pin.year # => 1985
+pin.birthdate # => #<Date: 1985-07-09>
+
+# The 10-digit variant also knows about century separators.
+pin.to_s     # => "850709-9805"
+pin.to_s(10) # => "850709-9805"
+pin.format_short(Date.civil(2025, 12, 1)) # => "850709-9805"
+pin.format_short(Date.civil(2085, 12, 1)) # => "850709+9805"
+
+# Use unofficial 12-digit format for a stable string that doesn't change
+# depending on today's date when storing it.
+pin.to_s(12)    # => "19850709-9805"
+pin.format_long # => "19850709-9805"
+
+# You can also generate numbers to use as example data
+fake1 = SwedishPIN.generate
+fake2 = SwedishPIN.generate(user.birthday)
+```
+
+## License
+
+MIT. See `LICENSE` file for more details.
+
+This project started out as a fork of
+[personnummer/ruby](https://github.com/personnummer/ruby), but has since been
+almost completely rewritten.
+Despite this, the original authors retains most of the copyright since this is
+derivative work.

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task default: :test

data/lib/swedish-pin.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "swedish_pin"

data/lib/swedish_pin.rb

@@ -0,0 +1,107 @@
+require "date"
+
+# Validate, parse, and generate Swedish Personal Identity Numbers.
+#
+# In Swedish these are called _Personnummer_. There is also a variant called
+# "coordination number" (_Samordningsnummer_). Both of these are supported
+# using the same API; see {SwedishPIN::Personnummer#coordination_number?}.
+#
+# To get started, look at {SwedishPIN.valid?} and {SwedishPIN.parse}.
+module SwedishPIN
+  autoload :Generator, "swedish_pin/generator"
+  autoload :Parser, "swedish_pin/parser"
+  autoload :Personnummer, "swedish_pin/personnummer"
+  autoload :VERSION, "swedish_pin/version"
+
+  autoload :ParseError, "swedish_pin/errors"
+  autoload :InvalidFormat, "swedish_pin/errors"
+  autoload :InvalidDate, "swedish_pin/errors"
+  autoload :InvalidChecksum, "swedish_pin/errors"
+
+  # Parses a string of a personnummer and returns a
+  # {SwedishPIN::Personnummer} or raises an error.
+  #
+  # Some numbers will have to relate to the current time in order to be parsed
+  # correctly. For example, the PIN +201231-…+ could be in many different
+  # years, including 1820, 1920, 2020, and so on.
+  # This library will guess that the year is in the most recent guess that are
+  # in the past. So during the year 2020 it would guess 2020, and in 2019 it
+  # will guess 1920.
+  #
+  # @param [String] string The number to parse.
+  # @param [Time] now Provide a different "parse time" context.
+  # @return [SwedishPIN::Personnummer] The parsed PIN
+  # @raise {SwedishPIN::ParseError} When the provided string was not valid.
+  # @raise {ArgumentError} When the provided value was not a +String+.
+  def self.parse(string, now = Time.now)
+    result = Parser.new(string, now).parse
+    Personnummer.new(
+      year: result.fetch(:year),
+      month: result.fetch(:month),
+      day: result.fetch(:day),
+      sequence_number: result.fetch(:sequence_number),
+      control_digit: result.fetch(:control_digit)
+    )
+  end
+
+  # Checks if a provided string is a valid _Personnummer_.
+  #
+  # @param [String] string The number to parse.
+  # @param [Time] now Provide a different "parse time" context. See {.parse}.
+  # @return [true, false] if the string was valid
+  def self.valid?(string, now = Time.now)
+    Parser.new(string, now).valid?
+  rescue ArgumentError
+    false
+  end
+
+  # Generates a valid _Personnummer_ given certain inputs. Inputs not provided
+  # will be randomized.
+  #
+  # This is mainly useful in order to generate test data or "Lorem Ipsum"-like
+  # values for use in demonstrations. Note that valid PINs might actually
+  # correspond to a real person, so don't use these generated PINs for anything
+  # that has a real effect.
+  #
+  # @example FactoryBot sequence
+  #   FactoryBot.define do
+  #     sequence(:swedish_pin) do |n|
+  #       # Will generate every PIN for a full day, then flip over to the next
+  #       # day and start the sequence over.
+  #       sequence_number = n % 1000
+  #       date = Date.civil(1950, 1, 1) + (n / 1000)
+  #       SwedishPIN.generate(date, sequence_number)
+  #     end
+  #   end
+  #
+  # @example Test data
+  #   user = User.new(name: "Jane Doe", pin: SwedishPIN.generate)
+  #
+  # @raise [ArgumentError] if given numbers are outside of the valid range.
+  # @param [Date, Time, nil] birthday The birthday of the person the PIN identifies, or +nil+ for a random date in the past.
+  # @param [String, Integer, nil] sequence_number The sequence number that correspond to the three digits after the birthday, or +nil+ to pick a random one.
+  def self.generate(birthday = nil, sequence_number = nil)
+    Generator.new(birthday).generate(sequence_number)
+  end
+
+  # @api private
+  #
+  # Implementation of Luhn algorithm.
+  #
+  # @param [String] digits String of digits to calculate a control digit for.
+  # @return [Integer] Control digit.
+  def self.luhn(digits)
+    sum = 0
+
+    (0...digits.length).each do |i|
+      v = digits[i].to_i
+      v *= 2 - (i % 2)
+      if v > 9
+        v -= 9
+      end
+      sum += v
+    end
+
+    ((sum.to_f / 10).ceil * 10 - sum.to_f).to_i
+  end
+end

data/lib/swedish_pin/errors.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SwedishPIN
+  # Error that represents a problem that occurred while parsing a
+  # _Personnummer_.
+  #
+  # You can inspect both the {input} attribute and check the subclass to build
+  # more helpful error messages for your users.
+  class ParseError < RuntimeError
+    # The input string that caused the error.
+    #
+    # @example
+    #   error.input # => "112233@4455"
+    attr_reader :input
+
+    # Create a new instance of this error.
+    #
+    # @param [String] message The error message.
+    # @param [String] input The input string that could not be parsed.
+    def initialize(message, input)
+      super(message)
+      @input = input
+    end
+  end
+
+  # The format of the input string does not look like a _Personnummer_. This
+  # could happen because the string has the wrong length, or because extra
+  # characters are placed inside of it.
+  class InvalidFormat < ParseError
+  end
+
+  # The date embedded in the input string is not a valid date.
+  class InvalidDate < ParseError
+  end
+
+  # The control digit at the end does not match the rest of the input. This
+  # could mean that the input has a typo.
+  class InvalidChecksum < ParseError
+  end
+end

data/lib/swedish_pin/generator.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "date"
+
+module SwedishPIN
+  # @private
+  # @api private
+  #
+  # Generator for PINs.
+  class Generator
+    # The date all generated PINs will be based on.
+    attr_reader :date
+
+    # Creates a new generator for a particular date.
+    def initialize(date)
+      @date = date || random_date
+    end
+
+    # Generate a {Personnummer} with the given sequence number.
+    def generate(sequence_number)
+      sequence_number ||= random_sequence_number
+      Personnummer.new(
+        year: date.year,
+        month: date.month,
+        day: date.day,
+        sequence_number: sequence_number,
+        control_digit: control_digit(sequence_number)
+      )
+    end
+
+    private
+
+    def random_date
+      Date.today - Random.rand(0..(110 * 365))
+    end
+
+    def random_sequence_number
+      Random.rand(0..999)
+    end
+
+    def control_digit(sequence_number)
+      padded = ("%03d" % sequence_number)
+      SwedishPIN.luhn("#{date.strftime("%y%m%d")}#{padded}")
+    end
+  end
+end

data/lib/swedish_pin/parser.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module SwedishPIN
+  # @api private
+  #
+  # Parser for _Personnummer_.
+  #
+  # Please use {SwedishPIN.parse} or {SwedishPIN.valid?} instead.
+  class Parser
+    MATCHER = /
+      \A
+      (?<century>\d{2})?
+      (?<year>\d{2})
+      (?<month>\d{2})
+      (?<day>\d{2})
+      (?<separator>[+\- ]?)
+      (?<sequence_number>\d{3})
+      (?<control_digit>\d)
+      \z
+    /x.freeze
+    private_constant :MATCHER
+
+    # Setup a new parser.
+    def initialize(input, now = Time.now)
+      unless input.is_a?(String)
+        raise ArgumentError, "Expected String, got #{input.inspect}"
+      end
+
+      @input = input
+      @now = now
+      @matches = MATCHER.match(input.strip)
+    end
+
+    # Raise {ParseError} if anything in the input isn't valid.
+    def validate
+      validate_match
+      validate_luhn
+      validate_date
+    end
+
+    # Check validity without raising.
+    def valid?
+      validate
+      true
+    rescue
+      false
+    end
+
+    # Return +Hash+ of parsed values to be used with {SwedishPIN::Personnummer#initialize}.
+    def parse
+      validate
+
+      {
+        year: full_year,
+        month: month,
+        day: day,
+        sequence_number: sequence_number,
+        control_digit: control_digit
+      }
+    end
+
+    private
+
+    attr_reader :now
+
+    def full_year
+      century * 100 + year
+    end
+
+    def century
+      if @matches["century"]
+        Integer(@matches["century"], 10)
+      else
+        guess_century
+      end
+    end
+
+    def year
+      Integer(@matches["year"], 10)
+    end
+
+    def month
+      @month ||= Integer(@matches["month"], 10)
+    end
+
+    def day
+      @day ||= Integer(@matches["day"], 10)
+    end
+
+    # Day, but adjusted for coordination numbers being possible.
+    def real_day
+      if day > 60
+        day - 60
+      else
+        day
+      end
+    end
+
+    def sequence_number
+      Integer(@matches["sequence_number"], 10)
+    end
+
+    def control_digit
+      Integer(@matches["control_digit"], 10)
+    end
+
+    def guess_century
+      guessed_year = (now.year / 100) * 100 + year
+
+      # Don't guess future dates; skip back a century when that happens.
+      if Time.new(guessed_year, month, real_day) > now
+        guessed_year -= 100
+      end
+
+      # The "+" separator means another century back.
+      if @matches["separator"] == "+"
+        guessed_year -= 100
+      end
+
+      guessed_year / 100
+    end
+
+    def validate_match
+      unless @matches
+        raise InvalidFormat.new("Input did not match expected format", @input)
+      end
+    end
+
+    def validate_luhn
+      comparator = [
+        @matches["year"],
+        @matches["month"],
+        @matches["day"],
+        @matches["sequence_number"]
+      ].join("")
+
+      if SwedishPIN.luhn(comparator) != control_digit
+        raise InvalidChecksum.new("Control digit did not match expected value", @input)
+      end
+    end
+
+    def validate_date
+      raise InvalidDate.new("#{month} is not a valid month", @input) unless (1..12).cover?(month)
+      raise InvalidDate.new("#{day} is not a valid day", @input) unless (1..31).cover?(real_day)
+
+      unless Date.valid_date?(full_year, month, real_day)
+        raise InvalidDate.new("Input had invalid date", @input)
+      end
+    end
+  end
+end

data/lib/swedish_pin/personnummer.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module SwedishPIN
+  # Represents a parsed and valid _Personnummer_ or _Samordningsnummer_ for a
+  # particular individual.
+  #
+  # Determine if this is a _Personnummer_ or a _Samordningsnummer_ using {coordination_number?}.
+  #
+  # @see https://en.wikipedia.org/wiki/Personal_identity_number_(Sweden) Personnummer on Wikipedia.
+  class Personnummer
+    attr_reader :year, :month, :day, :sequence_number, :control_digit
+    # @!attribute [r] year
+    #   The full year of the _personnummer_. For example +1989+.
+    #   @return [Integer]
+    # @!attribute [r] month
+    #   The month digit of the _personnummer_. 1 for January up until 12 for December.
+    #   @return [Integer]
+    # @!attribute [r] day
+    #   The day of the month of the _personnummer_. This will be for the real
+    #   day, even for coordination numbers.
+    #   @see #coordination_number?
+    #   @return [Integer]
+    # @!attribute [r] sequence_number
+    #   The number after the separator.
+    #   A common reason to access this is to check the sex of the person. You
+    #   might want to look at {#male?} and {#female?} instead.
+    #   @note This attribute returns an +Integer+, but this sequence needs to
+    #     be zero-padded up to three characters if you intend to display it (i.e.
+    #     +3+ is +"003"+).
+    #   @return [Integer]
+    # @!attribute [r] control_digit
+    #   The last digit of the _personnummer_. It acts as a checksum of the
+    #   previous numbers.
+    #   @return [Integer]
+
+    # @api private
+    # @private
+    #
+    # Initializes a new instance from specific values. Please consider using
+    # {SwedishPIN.generate} instead of you want custom instances.
+    def initialize(year:, month:, day:, sequence_number:, control_digit:)
+      @year = year
+      @month = month
+      @coordination_number = day > 60
+      @day = (day > 60 ? day - 60 : day)
+      @sequence_number = sequence_number
+      @control_digit = control_digit
+    end
+
+    # Return the birthday for the person that is represented by this
+    # _Personnummer_.
+    #
+    # @return [Date] the date of birth
+    def birthday
+      Date.civil(year, month, day)
+    end
+
+    # Returns +true+ if this number is a _Samordningsnummer_ (coordination
+    # number). This is a number that is granted to non-Swedish citizens until
+    # the time that they become citizens.
+    #
+    # Coordination numbers are identical to a PIN, except that the "day"
+    # component has +60+ added to it (i.e. <code>28+60=88</code>).
+    #
+    # @note The {day} attribute will still return a valid date day, even for coordination numbers.
+    # @see https://sv.wikipedia.org/wiki/Samordningsnummer Samordningsnummer on Wikipedia (Swedish)
+    def coordination_number?
+      @coordination_number
+    end
+
+    # Formats the PIN in the official "10-digit" format. This is the "real"
+    # _Personnummer_ string.
+    #
+    # *Format:* +yymmdd-nnnn+ or <code>yymmdd+nnnn</code>
+    #
+    # The _Personnummer_ specification says that starting from the year of a
+    # person's 100th birthday, the separator in their _personnummer_ will
+    # change from a <code>-</code> into a <code>+</code>.
+    #
+    # That means that every time you display a _personnummer_ you also must
+    # consider the time of this action. Something that was read on date A and
+    # outputted on date B might not use the same string representation.
+    #
+    # For this reason, the real _personnummer_ is usually not what you want to
+    # store, only what you want to display in some cases.
+    #
+    # This library recommends that you use {format_long} for storage.
+    #
+    # @param [Time, Date] now The time when this personnummer is supposed to be displayed.
+    # @return [String] the formatted number
+    # @see #format_long
+    def format_short(now = Time.now)
+      [
+        format_date(false),
+        short_separator(now),
+        "%03d" % sequence_number,
+        control_digit
+      ].join("")
+    end
+
+    # Formats the _personnummer_ in the unofficial "12-digit" format that
+    # includes the century and doesn't change separator depending on when the
+    # number is supposed to be shown.
+    #
+    # This format is being adopted in a lot of places in favor of the
+    # "10-digit" format ({format_short}), but as of 2020 it remains an
+    # unofficial format.
+    #
+    # *Format:* +yyyymmdd-nnnn+
+    #
+    # @see #format_short
+    def format_long
+      [
+        format_date(true),
+        "-",
+        "%03d" % sequence_number,
+        control_digit
+      ].join("")
+    end
+
+    # Formats the PIN into a +String+.
+    #
+    # You can provide the desired length to get different formats.
+    #
+    # @note The length isn't how long the resulting string will be as the
+    #   resulting string will also have a separator included. The formats are
+    #   colloquially called "10-digit" and "12-digit", which is why they are
+    #   referred to as "length" here.
+    #
+    # +10+ or +nil+:: {format_short}
+    # +12+:: {format_long}
+    #
+    # @param [Integer, nil] length The desired format.
+    # @param [Time, Date] now The current time. Only used by {format_short}.
+    # @raise [ArgumentError] If not provided a valid length.
+    # @return [String]
+    # @see #format_short
+    # @see #format_long
+    def to_s(length = 10, now = Time.now)
+      case length
+      when 10 then format_short(now)
+      when 12 then format_long
+      else raise ArgumentError, "The only supported lengths are 10 or 12."
+      end
+    end
+
+    # Returns the age of the person this _personnummer_ represents, as an
+    # integer of years since birth.
+    #
+    # Swedish age could be defined as such: A person will be +0+ years old when
+    # born, and +1+ 12 months after that, on the same day or the day after in
+    # the case of leap years. This is the same way most western countries count
+    # age.
+    #
+    # If the {birthday} is in the future, then +0+ will be returned.
+    #
+    # @param [Time, Date] now The current time.
+    # @return [Integer] Number of 12 month periods that have passed since the birthdate; +0+ or more.
+    def age(now = Time.now)
+      age = now.year - year - (birthday_passed_this_year?(now) ? 0 : 1)
+      [0, age].max
+    end
+
+    # Returns +true+ if the _personnummer_ represents a person that is legally
+    # identified as +male+.
+    # @return [true, false]
+    def male?
+      sequence_number.odd?
+    end
+
+    # Returns +true+ if the _personnummer_ represents a person that is legally
+    # identified as +female+.
+    # @return [true, false]
+    def female?
+      sequence_number.even?
+    end
+
+    private
+
+    def short_separator(now)
+      if year <= (now.year - 100)
+        "+"
+      else
+        "-"
+      end
+    end
+
+    def format_date(include_century)
+      [
+        (include_century ? pad(year / 100) : nil),
+        pad(year % 100),
+        pad(month),
+        pad(coordination_number? ? day + 60 : day)
+      ].join("")
+    end
+
+    def pad(num)
+      "%02d" % num
+    end
+
+    def birthday_passed_this_year?(now)
+      now.month > month || (now.month == month && now.day >= day)
+    end
+  end
+end

data/lib/swedish_pin/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module SwedishPIN
+  # The version number of this library.
+  VERSION = "1.0.0"
+end

data/personnummer.gemspec

@@ -0,0 +1,28 @@
+require_relative "lib/swedish_pin/version"
+
+Gem::Specification.new do |s|
+  s.name = "swedish-pin"
+  s.version = SwedishPIN::VERSION
+  s.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
+
+  s.license = "MIT"
+  s.summary = "Work with Swedish PINs (Personnummer)"
+  s.description = "Parse, validate, and generate Swedish Personal Identity Numbers (PINs / Personnummer)"
+  s.homepage = "https://github.com/Mange/swedish-pin-ruby"
+
+  s.authors = ["Magnus Bergmark", "Jack Millard", "Fredrik Forsmo"]
+  s.email = ["me@mange.dev", "millard64@hotmail.co.uk", "fredrik.forsmo@gmail.com"]
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  s.files = Dir.chdir(File.expand_path("..", __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  s.bindir = "exe"
+  s.executables = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "minitest"
+  s.add_development_dependency "standard"
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: swedish-pin
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Magnus Bergmark
+- Jack Millard
+- Fredrik Forsmo
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2020-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Parse, validate, and generate Swedish Personal Identity Numbers (PINs
+  / Personnummer)
+email:
+- me@mange.dev
+- millard64@hotmail.co.uk
+- fredrik.forsmo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/swedish-pin.rb
+- lib/swedish_pin.rb
+- lib/swedish_pin/errors.rb
+- lib/swedish_pin/generator.rb
+- lib/swedish_pin/parser.rb
+- lib/swedish_pin/personnummer.rb
+- lib/swedish_pin/version.rb
+- personnummer.gemspec
+homepage: https://github.com/Mange/swedish-pin-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.8
+signing_key:
+specification_version: 4
+summary: Work with Swedish PINs (Personnummer)
+test_files: []