version_record 0.0.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9f5a7c0f67974ddb29bdaa5380a828cdd62eb777
-  data.tar.gz: bfdfa219024a406b781da423528bcd82b1e49d5d
+  metadata.gz: c085b6ca09746df9c01cb7895ed0f8cf7010a422
+  data.tar.gz: c468a447fe0c4046698c8281e90435b79e389c60
 SHA512:
-  metadata.gz: 8419cfdc04e5227f12d0ff10babd47f16ab7bc2ef769b572adac6c0b3d1bbd41010e6e1495fce989d89599fc73ad30b9099b63db8ec92e1bd165987587cc439a
-  data.tar.gz: 8b1fe56433425a4089708445e3633baf54e9c78aeddc41cbcc86aea8577ea3fd9093e60ffe58dd81a1e005bd827341454e2e1cd5c5a761151b8443c6489f32a4
+  metadata.gz: 96e263bf3b4cad106f37cec3ba5167ca533e6783413734097566f1b27df8c466f00ec15b454a7f1773990a12620b98a993f1c6022ebd76686ea607c29b610fa8
+  data.tar.gz: 9de8c9c1c270d4999112e8bcf9b129a9bdb9224d3787a8a3c412711fab40522fcf5520dd051b09a521040cc2341113ba92d6ee5e1f1f43daef7bed53e52b0a3c

data/lib/version_record.rb

@@ -0,0 +1,8 @@
+require 'version_record/finder'
+require 'version_record/macros'
+require 'version_record/prerelease'
+require 'version_record/version'
+require 'version_record/core_ext/string'
+require 'version_record/macros/versioned'
+require 'version_record/sorting/simple'
+require 'version_record/type/version'

data/lib/version_record/core_ext/string.rb

@@ -0,0 +1,5 @@
+class String
+  def to_version
+    VersionRecord::Version.new(to_s)
+  end
+end

data/lib/version_record/finder.rb

@@ -0,0 +1,18 @@
+module VersionRecord
+  class Finder
+    def initialize(klass, version_column)
+      @klass = klass
+      @version_column = version_column
+    end
+
+    def find_latest
+      by_version.last
+    end
+
+    private
+
+    def by_version
+      @klass.public_send("by_#{@version_column}")
+    end
+  end
+end

data/lib/version_record/gem_version.rb

@@ -1,3 +1,3 @@
 module VersionRecord
-  VERSION = '0.0.0'.freeze
+  VERSION = '1.0.0'.freeze
 end

data/lib/version_record/macros.rb

@@ -0,0 +1,17 @@
+module VersionRecord
+  module Macros
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def versioned(column_name: :version)
+        VersionRecord::Macros::Versioned.def_versioned(self, column_name)
+        VersionRecord::Macros::Versioned.def_by_version(self, column_name)
+        VersionRecord::Macros::Versioned.def_latest_version(self, column_name)
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load :active_record do
+  include VersionRecord::Macros
+end

data/lib/version_record/macros/versioned.rb

@@ -0,0 +1,25 @@
+module VersionRecord
+  module Macros
+    class Versioned
+
+      class << self
+
+        def def_versioned(klass, version_column)
+          klass.attribute version_column, :version
+        end
+
+        def def_by_version(klass, version_column)
+          klass.define_singleton_method("by_#{version_column}") do |direction = :asc|
+            Sorting::Simple.new(klass, version_column).by_version(direction)
+          end
+        end
+
+        def def_latest_version(klass, version_column)
+          klass.define_singleton_method("latest_#{version_column}") do
+            Finder.new(klass, version_column).find_latest
+          end
+        end
+      end
+    end
+  end
+end

data/lib/version_record/prerelease.rb

@@ -0,0 +1,69 @@
+module VersionRecord
+  class Prerelease
+    include Comparable
+
+    def self.build(string)
+      new(".#{string}") if string.present?
+    end
+
+    def initialize(string)
+      @string = string
+    end
+
+    def to_s
+      @string
+    end
+
+    def name
+      @string[1..-1]
+    end
+
+    def tail
+      @tail ||= self.class.build(at(1..-1).join('.'))
+    end
+
+    def first_segment
+      @first_segment ||= at(0)
+    end
+
+    def <=>(other)
+      return unless other.is_a?(Prerelease)
+
+      if first_segment == other.first_segment
+        compare_by_tail(other)
+      else
+        compare_by_first_segment(other)
+      end
+    end
+
+    private
+
+    def at(index)
+      to_a[index]
+    end
+
+    def to_a
+      name.split('.')
+    end
+
+    def compare_by_tail(other)
+      return  1 if self.tail && other.tail.nil?
+      return -1 if self.tail.nil? && other.tail
+      self.tail <=> other.tail
+    end
+
+    def compare_by_first_segment(other)
+      if int?(first_segment) && int?(other.first_segment)
+        first_segment.to_i <=> other.first_segment.to_i
+      else
+        first_segment <=> other.first_segment
+      end
+    end
+
+    def int?(str)
+      !!Integer(str)
+    rescue ArgumentError, TypeError
+      false
+    end
+  end
+end

data/lib/version_record/sorting/simple.rb

@@ -0,0 +1,34 @@
+module VersionRecord
+  module Sorting
+
+    # Handles sorting a collection of AR objects.
+    #
+    # This implementation uses in-memory sorting.
+    #
+    class Simple
+      def initialize(klass, version_column)
+        @klass = klass
+        @version_column = version_column
+      end
+
+      def by_version(direction = :asc)
+        collection = @klass.all
+        direction.to_sym == :asc ? sort_asc(collection) : sort_desc(collection)
+      end
+
+      private
+
+      def sort_asc(collection)
+        collection.sort_by { |object| version(object) }
+      end
+
+      def sort_desc(collection)
+        collection.sort { |obj_1, obj_2| version(obj_2) <=> version(obj_1) }
+      end
+
+      def version(object)
+        object.public_send(@version_column)
+      end
+    end
+  end
+end

data/lib/version_record/type/version.rb

@@ -0,0 +1,15 @@
+module VersionRecord
+  module Type
+    class Version < ActiveRecord::Type::String
+      def cast(value)
+        value.nil? ? super : value.to_version
+      end
+
+      def serialize(value)
+        value.nil? ? super : super(value.to_s)
+      end
+    end
+  end
+end
+
+ActiveRecord::Type.register(:version, VersionRecord::Type::Version)

data/lib/version_record/version.rb

@@ -0,0 +1,108 @@
+module VersionRecord
+  class Version
+    include Comparable
+
+    attr_accessor :major, :minor, :patch
+
+    def initialize(version)
+      @major, @minor, @patch, @prerelease = Parser.new(version.to_s).parse
+    end
+
+    def to_s
+      "#{@major}.#{@minor}.#{@patch}#{@prerelease}"
+    end
+
+    def to_version
+      self
+    end
+
+    def bump(segment = :minor)
+      send("bump_#{segment}") if [:major, :minor, :patch].include?(segment)
+      self
+    end
+
+    def prerelease
+      @prerelease.name if @prerelease
+    end
+
+    def <=>(other)
+      return unless other.respond_to?(:to_version)
+      other = other.to_version
+
+      if same_segments?(other, :major, :minor, :patch, :prerelease)
+        0
+      elsif same_segments?(other, :major, :minor, :patch)
+        compare_by(other, :prerelease)
+      elsif same_segments?(other, :major, :minor)
+        compare_by(other, :patch)
+      elsif same_segments?(other, :major)
+        compare_by(other, :minor)
+      else
+        compare_by(other, :major)
+      end
+    end
+
+    private
+
+    def bump_major
+      @major += 1
+      @minor = @patch = 0
+    end
+
+    def bump_minor
+      @minor += 1
+      @patch = 0
+    end
+
+    def bump_patch
+      @patch += 1
+    end
+
+    # Checks if all the segments in other are equal to the ones passed as a
+    # parameter.
+    #
+    # For example, calling same_segments?(other, :major, :minor) will check:
+    #
+    #    self.major == other.major && self.minor == other.minor
+    #
+    def same_segments?(other, *segments)
+      segments.all? { |segment| send(segment) == other.send(segment) }
+    end
+
+    def compare_by(other, segment)
+      if [:major, :minor, :patch].include?(segment)
+        send(segment) <=> other.send(segment)
+      else
+        compare_by_prerelease(other)
+      end
+    end
+
+    def compare_by_prerelease(other)
+      return  1 if @prerelease.nil? && other.prerelease
+      return -1 if @prerelease && other.prerelease.nil?
+
+      @prerelease <=> Prerelease.build(other.prerelease)
+    end
+
+    class Parser
+      VERSION_PATTERN = /^(\d+)\.(\d+)\.(\d+)(([\.-][0-9A-Za-z-]+)*)$/
+
+      def initialize(version)
+        @version = version
+      end
+
+      def parse
+        error! unless match = @version.match(VERSION_PATTERN)
+        prerelease = Prerelease.new(match[4]) if match[4].present?
+
+        [match[1].to_i, match[2].to_i, match[3].to_i, prerelease]
+      end
+
+      private
+
+      def error!
+        raise ArgumentError, "Malformed version number string #{@version}"
+      end
+    end
+  end
+end

data/spec/rails_helper.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+require 'rspec/rails'
+
+RSpec.configure do |config|
+  config.infer_spec_type_from_file_location!
+  config.filter_rails_from_backtrace!
+end

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+ENV['RAILS_ENV'] = 'test'
+ENV['DATABASE_URL'] = 'sqlite3://localhost/tmp/version_record_test'
+
+require 'bundler/setup'
+require 'rails'
+require 'byebug'
+if Rails.version.start_with?('5.0')
+  require 'support/apps/rails5_0'
+elsif Rails.version.start_with?('5.1')
+  require 'support/apps/rails5_1'
+end
+require 'support/model_spawner'
+require 'version_record'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  config.include VersionRecord::Testing::ModelSpawner
+
+  config.before :each do
+    @spawned_models = []
+  end
+
+  config.after :each do
+    @spawned_models.each do |model|
+      Object.instance_eval { remove_const model } if Object.const_defined?(model)
+    end
+  end
+end

data/spec/support/apps/rails5_0.rb

@@ -0,0 +1,48 @@
+require 'rails/all'
+
+module Rails50
+  class Application < Rails::Application
+    # The test environment is used exclusively to run your application's
+    # test suite. You never need to work with it otherwise. Remember that
+    # your test database is "scratch space" for the test suite and is wiped
+    # and recreated between test runs. Don't rely on the data there!
+    config.cache_classes = true
+
+    # Do not eager load code on boot. This avoids loading your whole application
+    # just for the purpose of running a single test. If you are using a tool that
+    # preloads Rails for running tests, you may have to set it to true.
+    config.eager_load = false
+
+    # Configure public file server for tests with Cache-Control for performance.
+    config.public_file_server.enabled = true
+    config.public_file_server.headers = {
+      'Cache-Control' => 'public, max-age=3600'
+    }
+
+    # Show full error reports and disable caching.
+    config.consider_all_requests_local       = true
+    config.action_controller.perform_caching = false
+
+    # Raise exceptions instead of rendering exception templates.
+    config.action_dispatch.show_exceptions = false
+
+    # Disable request forgery protection in test environment.
+    config.action_controller.allow_forgery_protection = false
+    config.action_mailer.perform_caching = false
+
+    # Tell Action Mailer not to deliver emails to the real world.
+    # The :test delivery method accumulates sent emails in the
+    # ActionMailer::Base.deliveries array.
+    config.action_mailer.delivery_method = :test
+
+    # Print deprecation notices to the stderr.
+    config.active_support.deprecation = :stderr
+
+    # Raises error for missing translations
+    # config.action_view.raise_on_missing_translations = true
+
+    config.secret_key_base = '49837489qkuweoiuoqwehisuakshdjksadhaisdy78o34y138974xyqp9rmye8yrpiokeuioqwzyoiuxftoyqiuxrhm3iou1hrzmjk'
+  end
+end
+
+Rails.application.initialize!

data/spec/support/apps/rails5_1.rb

@@ -0,0 +1,50 @@
+require 'rails/all'
+
+module Rails51
+  class Application < Rails::Application
+    # Settings specified here will take precedence over those in config/application.rb.
+
+    # The test environment is used exclusively to run your application's
+    # test suite. You never need to work with it otherwise. Remember that
+    # your test database is "scratch space" for the test suite and is wiped
+    # and recreated between test runs. Don't rely on the data there!
+    config.cache_classes = true
+
+    # Do not eager load code on boot. This avoids loading your whole application
+    # just for the purpose of running a single test. If you are using a tool that
+    # preloads Rails for running tests, you may have to set it to true.
+    config.eager_load = false
+
+    # Configure public file server for tests with Cache-Control for performance.
+    config.public_file_server.enabled = true
+    config.public_file_server.headers = {
+      'Cache-Control' => "public, max-age=#{1.hour.seconds.to_i}"
+    }
+
+    # Show full error reports and disable caching.
+    config.consider_all_requests_local       = true
+    config.action_controller.perform_caching = false
+
+    # Raise exceptions instead of rendering exception templates.
+    config.action_dispatch.show_exceptions = false
+
+    # Disable request forgery protection in test environment.
+    config.action_controller.allow_forgery_protection = false
+    config.action_mailer.perform_caching = false
+
+    # Tell Action Mailer not to deliver emails to the real world.
+    # The :test delivery method accumulates sent emails in the
+    # ActionMailer::Base.deliveries array.
+    config.action_mailer.delivery_method = :test
+
+    # Print deprecation notices to the stderr.
+    config.active_support.deprecation = :stderr
+
+    # Raises error for missing translations
+    # config.action_view.raise_on_missing_translations = true
+
+    config.secret_key_base = '49837489qkuweoiuoqwehisuakshdjksadhaisdy78o34y138974xyqp9rmye8yrpiokeuioqwzyoiuxftoyqiuxrhm3iou1hrzmjk'
+  end
+end
+
+Rails.application.initialize!

data/spec/support/model_spawner.rb

@@ -0,0 +1,22 @@
+module VersionRecord
+  module Testing
+    module ModelSpawner
+      def spawn_model(klass, &block)
+        Object.instance_eval { remove_const klass } if Object.const_defined?(klass)
+        Object.const_set klass, Class.new(ActiveRecord::Base)
+        Object.const_get(klass).class_eval(&block) if block_given?
+        @spawned_models << klass.to_sym
+      end
+
+      def create_table(table_name)
+        ActiveRecord::Migration.suppress_messages do
+          ActiveRecord::Schema.define do
+            create_table table_name, force: true do |t|
+              yield(t)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/version_record/finder_spec.rb

@@ -0,0 +1,30 @@
+describe VersionRecord::Finder do
+  describe "#find_latest" do
+    subject(:finder) { VersionRecord::Finder.new(Document, :version) }
+
+    before do
+      create_table(:documents) do |t|
+        t.string :title
+        t.string :version
+      end
+
+      spawn_model(:Document) do
+        versioned
+      end
+    end
+
+    context 'when data exists' do
+      before do
+        @document_1 = Document.create!(title: 'Title 1', version: '1.1.0')
+        @document_2 = Document.create!(title: 'Title 2', version: '1.0.0')
+        @document_3 = Document.create!(title: 'Title 3', version: '1.1.1')
+      end
+
+      it { expect(finder.find_latest).to eq @document_3 }
+    end
+
+    context 'with no data' do
+      it { expect(finder.find_latest).to be_nil }
+    end
+  end
+end

data/spec/version_record/macros/versioned_spec.rb

@@ -0,0 +1,230 @@
+describe VersionRecord::Macros::Versioned do
+
+  describe '#versioned' do
+    context 'with default options' do
+      before do
+        create_table(:documents) do |t|
+          t.string :title
+          t.string :version
+        end
+
+        spawn_model(:Document) do
+          versioned
+        end
+      end
+
+      context 'reading attribute' do
+        context 'when version column has values' do
+          let(:document) { Document.create!(title: 'Terms of service', version: '1.0.0') }
+          it { expect(document.version).to eq VersionRecord::Version.new('1.0.0') }
+        end
+
+        context 'when version column is nil' do
+          let(:document) { Document.create!(title: 'Terms of service', version: nil) }
+          it { expect(document.version).to be_nil }
+        end
+      end
+
+      context 'setting new values' do
+        context 'when version column has values' do
+          let(:document) { Document.create!(title: 'Terms of service', version: '1.0.0') }
+
+          it 'should accept a string' do
+            document.version = '1.1.0'
+            expect(document.version).to eq VersionRecord::Version.new('1.1.0')
+          end
+
+          it 'should accept a Version object' do
+            document.version = VersionRecord::Version.new('1.1.0')
+            expect(document.version).to eq VersionRecord::Version.new('1.1.0')
+          end
+
+          it 'should save to db with a string' do
+            document.update(version: '1.1.0')
+            expect(document.reload.version).to eq VersionRecord::Version.new('1.1.0')
+          end
+
+          it 'should save to db with a Version object' do
+            document.update(version: VersionRecord::Version.new('1.1.0'))
+            expect(document.reload.version).to eq VersionRecord::Version.new('1.1.0')
+          end
+
+          it 'should raise if malformed version' do
+            expect { document.update(version: '1.1.1.') }.to raise_error(ArgumentError)
+            expect(document.reload.version).to eq VersionRecord::Version.new('1.0.0')
+          end
+
+          it 'should allow setting the version to nil' do
+            document.version = nil
+            document.save!
+            expect(document.reload.version).to be_nil
+          end
+        end
+
+        context 'when version column is nil' do
+          let(:document) { Document.create!(title: 'Terms of service', version: nil) }
+
+          it 'should accept a string' do
+            document.version = '1.1.0'
+            expect(document.version).to eq VersionRecord::Version.new('1.1.0')
+          end
+
+          it 'should accept a Version object' do
+            document.version = VersionRecord::Version.new('1.1.0')
+            expect(document.version).to eq VersionRecord::Version.new('1.1.0')
+          end
+
+          it 'should save to db with a string' do
+            document.update(version: '1.1.0')
+            expect(document.reload.version).to eq VersionRecord::Version.new('1.1.0')
+          end
+
+          it 'should save to db with a Version object' do
+            document.update(version: VersionRecord::Version.new('1.1.0'))
+            expect(document.reload.version).to eq VersionRecord::Version.new('1.1.0')
+          end
+
+          it 'should raise if malformed version' do
+            expect { document.update(version: '1.1.1.') }.to raise_error(ArgumentError)
+            expect(document.reload.version).to be_nil
+          end
+
+          it 'should allow setting the version to nil' do
+            document.version = nil
+            document.save!
+            expect(document.reload.version).to be_nil
+          end
+        end
+      end
+
+      context 'querying' do
+        let!(:document_1) { Document.create!(title: 'Terms of service', version: '1.0.0') }
+        let!(:document_2) { Document.create!(title: 'Terms of service', version: '1.1.0') }
+        let!(:document_3) { Document.create!(title: 'Terms of service', version: '1.1.1') }
+        let!(:document_4) { Document.create!(title: 'Terms of service', version: nil) }
+
+        it { expect(Document.where(version: '1.1.1')).to eq [document_3] }
+        it { expect(Document.where(version: VersionRecord::Version.new('1.1.1'))).to eq [document_3] }
+        it { expect(Document.where(version: nil)).to eq [document_4] }
+      end
+    end
+
+    context 'with custom options' do
+      before do
+        create_table(:releases) do |t|
+          t.string :tag
+          t.string :semantic_version
+        end
+
+        spawn_model(:Release) do
+          versioned column_name: :semantic_version
+        end
+      end
+
+      context 'reading attribute' do
+        let(:release) { Release.create!(tag: 'jb23hj412', semantic_version: '1.0.0') }
+        it { expect(release.semantic_version).to eq VersionRecord::Version.new('1.0.0') }
+      end
+
+      context 'setting new values' do
+        context 'when version column has values' do
+          let(:release) { Release.create!(tag: 'jb23hj412', semantic_version: '1.0.0') }
+
+          it 'should save to db with a Version object' do
+            release.update(semantic_version: VersionRecord::Version.new('1.1.0'))
+            expect(release.reload.semantic_version).to eq VersionRecord::Version.new('1.1.0')
+          end
+
+          it 'should allow setting the version to nil' do
+            release.semantic_version = nil
+            release.save!
+            expect(release.reload.semantic_version).to be_nil
+          end
+        end
+      end
+
+      context 'querying' do
+        let!(:release_1) { Release.create!(tag: 'jb23hj412', semantic_version: '1.0.0') }
+        let!(:release_2) { Release.create!(tag: 'jb23hj412', semantic_version: '1.1.0') }
+        let!(:release_3) { Release.create!(tag: 'jb23hj412', semantic_version: '1.1.1') }
+        let!(:release_4) { Release.create!(tag: 'jb23hj412', semantic_version: nil) }
+
+        it { expect(Release.where(semantic_version: '1.1.1')).to eq [release_3] }
+        it { expect(Release.where(semantic_version: VersionRecord::Version.new('1.1.1'))).to eq [release_3] }
+        it { expect(Release.where(semantic_version: nil)).to eq [release_4] }
+      end
+    end
+  end
+
+  describe '#by_version' do
+    context 'with default options' do
+      before do
+        create_table(:documents) do |t|
+          t.string :title
+          t.string :version
+        end
+
+        spawn_model(:Document) do
+          versioned
+        end
+
+        @document = Document.create!(title: 'Title 1', version: '1.1.0')
+      end
+
+      it { expect(Document.by_version).to eq [@document] }
+    end
+
+    context 'with custom options' do
+      before do
+        create_table(:releases) do |t|
+          t.string :tag
+          t.string :semantic_version
+        end
+
+        spawn_model(:Release) do
+          versioned column_name: :semantic_version
+        end
+
+        @release = Release.create!(tag: 'jb23hj412', semantic_version: '1.0.0')
+      end
+
+      it { expect(Release.by_semantic_version).to eq [@release] }
+    end
+  end
+
+  describe '#latest_version' do
+    context 'with default options' do
+      before do
+        create_table(:documents) do |t|
+          t.string :title
+          t.string :version
+        end
+
+        spawn_model(:Document) do
+          versioned
+        end
+
+        @document = Document.create!(title: 'Title 1', version: '1.1.0')
+      end
+
+      it { expect(Document.latest_version).to eq @document }
+    end
+
+    context 'with custom options' do
+      before do
+        create_table(:releases) do |t|
+          t.string :tag
+          t.string :semantic_version
+        end
+
+        spawn_model(:Release) do
+          versioned column_name: :semantic_version
+        end
+
+        @release = Release.create!(tag: 'jb23hj412', semantic_version: '1.0.0')
+      end
+
+      it { expect(Release.latest_semantic_version).to eq @release }
+    end
+  end
+end

data/spec/version_record/prerelease_spec.rb

@@ -0,0 +1,49 @@
+describe VersionRecord::Prerelease do
+
+  subject(:prerelease) { VersionRecord::Prerelease.new('.beta') }
+
+  describe '.build' do
+    it { expect(VersionRecord::Prerelease.build('beta')).to eq VersionRecord::Prerelease.new('.beta') }
+  end
+
+  describe '#to_s' do
+    it { expect(prerelease.to_s).to eq '.beta' }
+  end
+
+  describe '#name' do
+    it { expect(prerelease.name).to eq 'beta' }
+  end
+
+  describe '#tail' do
+    it { expect(VersionRecord::Prerelease.new('.beta.1.alpha').tail).to eq VersionRecord::Prerelease.new('.1.alpha') }
+    it { expect(VersionRecord::Prerelease.new('.1.alpha').tail).to      eq VersionRecord::Prerelease.new('.alpha') }
+    it { expect(VersionRecord::Prerelease.new('.alpha').tail).to        be_nil }
+  end
+
+  describe '#first_segment' do
+    it { expect(VersionRecord::Prerelease.new('.beta.1.alpha').first_segment).to eq 'beta' }
+    it { expect(VersionRecord::Prerelease.new('.1.alpha').first_segment).to eq '1' }
+    it { expect(VersionRecord::Prerelease.new('.alpha').first_segment).to eq 'alpha' }
+  end
+
+  describe '#<=>' do
+    it { expect(VersionRecord::Prerelease.new('-alpha')).to      be <  VersionRecord::Prerelease.new('-alpha.1') }
+    it { expect(VersionRecord::Prerelease.new('-alpha.1')).to    be <  VersionRecord::Prerelease.new('-alpha.beta') }
+    it { expect(VersionRecord::Prerelease.new('-alpha.beta')).to be <  VersionRecord::Prerelease.new('-beta') }
+    it { expect(VersionRecord::Prerelease.new('-beta')).to       be <  VersionRecord::Prerelease.new('-beta.2') }
+    it { expect(VersionRecord::Prerelease.new('-beta.2')).to     be <  VersionRecord::Prerelease.new('-beta.11') }
+    it { expect(VersionRecord::Prerelease.new('-beta.11')).to    be <  VersionRecord::Prerelease.new('-rc.1') }
+    it { expect(VersionRecord::Prerelease.new('.beta.9')).to     be <  VersionRecord::Prerelease.new('.beta.10') }
+    it { expect(VersionRecord::Prerelease.new('.beta')).to       be <  VersionRecord::Prerelease.new('.beta.1') }
+    it { expect(VersionRecord::Prerelease.new('.beta')).to       eq    VersionRecord::Prerelease.new('.beta') }
+    it { expect(VersionRecord::Prerelease.new('.beta.1')).to     be >  VersionRecord::Prerelease.new('.beta') }
+    it { expect(VersionRecord::Prerelease.new('.beta.10')).to    be >  VersionRecord::Prerelease.new('.beta.9') }
+    it { expect(VersionRecord::Prerelease.new('-rc.1')).to       be >  VersionRecord::Prerelease.new('-beta.11') }
+    it { expect(VersionRecord::Prerelease.new('-beta.11')).to    be >  VersionRecord::Prerelease.new('-beta.2') }
+    it { expect(VersionRecord::Prerelease.new('-beta.2')).to     be >  VersionRecord::Prerelease.new('-beta') }
+    it { expect(VersionRecord::Prerelease.new('-beta')).to       be >  VersionRecord::Prerelease.new('-alpha.beta') }
+    it { expect(VersionRecord::Prerelease.new('-alpha.beta')).to be >  VersionRecord::Prerelease.new('-alpha.1') }
+    it { expect(VersionRecord::Prerelease.new('-alpha.1')).to    be >  VersionRecord::Prerelease.new('-alpha') }
+    it { expect(VersionRecord::Prerelease.new('-alpha.1')).not_to eq nil }
+  end
+end

data/spec/version_record/sorting/simple_spec.rb

@@ -0,0 +1,24 @@
+describe VersionRecord::Sorting::Simple do
+  describe "#by_version" do
+    subject(:sorting_strategy) { VersionRecord::Sorting::Simple.new(Document, :version) }
+
+    before do
+      create_table(:documents) do |t|
+        t.string :title
+        t.string :version
+      end
+
+      spawn_model(:Document) do
+        versioned
+      end
+
+      @document_1 = Document.create!(title: 'Title 1', version: '1.1.0')
+      @document_2 = Document.create!(title: 'Title 2', version: '1.0.0')
+      @document_3 = Document.create!(title: 'Title 3', version: '1.1.1')
+    end
+
+    it { expect(sorting_strategy.by_version).to        eq [@document_2, @document_1, @document_3] }
+    it { expect(sorting_strategy.by_version(:asc)).to  eq [@document_2, @document_1, @document_3] }
+    it { expect(sorting_strategy.by_version(:desc)).to eq [@document_3, @document_1, @document_2] }
+  end
+end

data/spec/version_record/string_spec.rb

@@ -0,0 +1,7 @@
+describe String do
+  describe '#to_version' do
+    it { expect('2.2.1'.to_version).to eq VersionRecord::Version.new('2.2.1') }
+    it { expect('2.2.1.beta'.to_version).to eq VersionRecord::Version.new('2.2.1.beta') }
+    it { expect { 'invalid_version'.to_version }.to raise_error(ArgumentError) }
+  end
+end

data/spec/version_record/type/version_spec.rb

@@ -0,0 +1,14 @@
+describe VersionRecord::Type::Version do
+  subject(:version_type) { VersionRecord::Type::Version.new }
+
+  it { is_expected.to be_an ActiveRecord::Type::String }
+
+  describe '#cast' do
+    it { expect(version_type.cast('1.1.2')).to eq VersionRecord::Version.new('1.1.2') }
+    it { expect { version_type.cast('1.1.2.') }.to raise_error ArgumentError }
+  end
+
+  describe '#serialize' do
+    it { expect(version_type.serialize(VersionRecord::Version.new('1.1.2'))).to eq '1.1.2' }
+  end
+end

data/spec/version_record/version_spec.rb

@@ -0,0 +1,157 @@
+describe VersionRecord::Version do
+
+  subject(:version) { VersionRecord::Version.new('1.1.2') }
+
+  describe '.new' do
+    context '2.3.1' do
+      let(:version) { VersionRecord::Version.new('2.3.1') }
+
+      it { expect(version.major).to eq 2 }
+      it { expect(version.minor).to eq 3 }
+      it { expect(version.patch).to eq 1 }
+      it { expect(version.prerelease).to be_nil }
+    end
+
+    context '1.0.0-alpha' do
+      let (:version) { VersionRecord::Version.new('1.0.0-alpha') }
+
+      it { expect(version.major).to eq 1 }
+      it { expect(version.minor).to eq 0 }
+      it { expect(version.patch).to eq 0 }
+      it { expect(version.prerelease).to eq 'alpha' }
+    end
+
+    context '1.0.0.alpha' do
+      let (:version) { VersionRecord::Version.new('1.0.0.alpha') }
+
+      it { expect(version.major).to eq 1 }
+      it { expect(version.minor).to eq 0 }
+      it { expect(version.patch).to eq 0 }
+      it { expect(version.prerelease).to eq 'alpha' }
+    end
+
+    context '1.0.0-alpha.1' do
+      let (:version) { VersionRecord::Version.new('1.0.0-alpha.1') }
+
+      it { expect(version.major).to eq 1 }
+      it { expect(version.minor).to eq 0 }
+      it { expect(version.patch).to eq 0 }
+      it { expect(version.prerelease).to eq 'alpha.1' }
+    end
+
+    context '1.0.0.alpha.1' do
+      let (:version) { VersionRecord::Version.new('1.0.0.alpha.1') }
+
+      it { expect(version.major).to eq 1 }
+      it { expect(version.minor).to eq 0 }
+      it { expect(version.patch).to eq 0 }
+      it { expect(version.prerelease).to eq 'alpha.1' }
+    end
+
+    context '1.0.0-alpha.beta' do
+      let (:version) { VersionRecord::Version.new('1.0.0-alpha.beta') }
+
+      it { expect(version.major).to eq 1 }
+      it { expect(version.minor).to eq 0 }
+      it { expect(version.patch).to eq 0 }
+      it { expect(version.prerelease).to eq 'alpha.beta' }
+    end
+
+    context '1.0.0.alpha.beta' do
+      let (:version) { VersionRecord::Version.new('1.0.0.alpha.beta') }
+
+      it { expect(version.major).to eq 1 }
+      it { expect(version.minor).to eq 0 }
+      it { expect(version.patch).to eq 0 }
+      it { expect(version.prerelease).to eq 'alpha.beta' }
+    end
+
+    context '1.0.0-beta.11' do
+      let (:version) { VersionRecord::Version.new('1.0.0-beta.11') }
+
+      it { expect(version.major).to eq 1 }
+      it { expect(version.minor).to eq 0 }
+      it { expect(version.patch).to eq 0 }
+      it { expect(version.prerelease).to eq 'beta.11' }
+    end
+
+    context '1.0.0.beta.11' do
+      let (:version) { VersionRecord::Version.new('1.0.0.beta.11') }
+
+      it { expect(version.major).to eq 1 }
+      it { expect(version.minor).to eq 0 }
+      it { expect(version.patch).to eq 0 }
+      it { expect(version.prerelease).to eq 'beta.11' }
+    end
+
+    context 'unsupported format' do
+      it { expect { VersionRecord::Version.new('2') }.to      raise_error(ArgumentError) }
+      it { expect { VersionRecord::Version.new('2.1') }.to    raise_error(ArgumentError) }
+      it { expect { VersionRecord::Version.new('2..1') }.to   raise_error(ArgumentError) }
+      it { expect { VersionRecord::Version.new('2.') }.to     raise_error(ArgumentError) }
+      it { expect { VersionRecord::Version.new('.1') }.to     raise_error(ArgumentError) }
+      it { expect { VersionRecord::Version.new('fdsdfa') }.to raise_error(ArgumentError) }
+      it { expect { VersionRecord::Version.new('2.x.1') }.to  raise_error(ArgumentError) }
+      it { expect { VersionRecord::Version.new('a.b.c') }.to  raise_error(ArgumentError) }
+    end
+  end
+
+  describe '#to_s' do
+    context 'without prerelease' do
+      let(:version) { VersionRecord::Version.new('1.1.0') }
+      it { expect(version.to_s).to eq '1.1.0' }
+    end
+
+    context 'with prerelease' do
+      let(:version) { VersionRecord::Version.new('1.1.0.rc1') }
+      it { expect(version.to_s).to eq '1.1.0.rc1' }
+    end
+  end
+
+  describe '#bump' do
+    context 'bump major' do
+      it { expect(version.bump(:major).to_s).to eq '2.0.0' }
+    end
+
+    context 'bump minor' do
+      it { expect(version.bump(:minor).to_s).to eq '1.2.0' }
+      it { expect(version.bump.to_s).to eq '1.2.0' }
+    end
+
+    context 'bump patch' do
+      it { expect(version.bump(:patch).to_s).to eq '1.1.3' }
+    end
+  end
+
+  describe '#<=>' do
+    it { expect(VersionRecord::Version.new('1.0.0')).to be < VersionRecord::Version.new('2.0.0') }
+    it { expect(VersionRecord::Version.new('2.0.0')).to be < VersionRecord::Version.new('2.1.0') }
+    it { expect(VersionRecord::Version.new('2.1.0')).to be < VersionRecord::Version.new('2.1.1') }
+    it { expect(VersionRecord::Version.new('2.1.1')).to eq   VersionRecord::Version.new('2.1.1') }
+    it { expect(VersionRecord::Version.new('2.1.1')).to be > VersionRecord::Version.new('2.1.0') }
+    it { expect(VersionRecord::Version.new('2.1.0')).to be > VersionRecord::Version.new('2.0.0') }
+    it { expect(VersionRecord::Version.new('2.0.0')).to be > VersionRecord::Version.new('1.0.0') }
+    it { expect(VersionRecord::Version.new('3.1.0')).not_to eq nil }
+    it { expect(VersionRecord::Version.new('1.0.9')).to be < VersionRecord::Version.new('1.0.10') }
+    it { expect(VersionRecord::Version.new('1.9.0')).to be < VersionRecord::Version.new('1.10.0') }
+    it { expect(VersionRecord::Version.new('9.0.0')).to be < VersionRecord::Version.new('10.0.0') }
+
+    context 'with prerelease' do
+      it { expect(VersionRecord::Version.new('1.0.0-alpha')).to      be < VersionRecord::Version.new('1.0.0-alpha.1') }
+      it { expect(VersionRecord::Version.new('1.0.0-alpha.1')).to    be < VersionRecord::Version.new('1.0.0-alpha.beta') }
+      it { expect(VersionRecord::Version.new('1.0.0-alpha.beta')).to be < VersionRecord::Version.new('1.0.0-beta') }
+      it { expect(VersionRecord::Version.new('1.0.0-beta')).to       be < VersionRecord::Version.new('1.0.0-beta.2') }
+      it { expect(VersionRecord::Version.new('1.0.0-beta.2')).to     be < VersionRecord::Version.new('1.0.0-beta.11') }
+      it { expect(VersionRecord::Version.new('1.0.0-beta.11')).to    be < VersionRecord::Version.new('1.0.0-rc.1') }
+      it { expect(VersionRecord::Version.new('1.0.0-rc.1')).to       be < VersionRecord::Version.new('1.0.0') }
+      it { expect(VersionRecord::Version.new('1.0.0.beta.9')).to     be < VersionRecord::Version.new('1.0.0.beta.10') }
+      it { expect(VersionRecord::Version.new('1.0.0.beta.1')).to     be > VersionRecord::Version.new('1.0.0.beta') }
+      it { expect(VersionRecord::Version.new('1.0.0.beta')).to       be < VersionRecord::Version.new('1.0.0.beta.1') }
+      it { expect(VersionRecord::Version.new('1.0.0.beta')).to       eq   VersionRecord::Version.new('1.0.0.beta') }
+    end
+  end
+
+  describe '#to_version' do
+    it { expect(version.to_version).to eq version }
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: version_record
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Marcelo Casiraghi
@@ -10,6 +10,34 @@ bindir: bin
 cert_chain: []
 date: 2017-12-28 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -24,6 +52,76 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
 description: 
 email: marcelo@cedarcode.com
 executables: []
@@ -31,7 +129,27 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/version_record.rb
+- lib/version_record/core_ext/string.rb
+- lib/version_record/finder.rb
 - lib/version_record/gem_version.rb
+- lib/version_record/macros.rb
+- lib/version_record/macros/versioned.rb
+- lib/version_record/prerelease.rb
+- lib/version_record/sorting/simple.rb
+- lib/version_record/type/version.rb
+- lib/version_record/version.rb
+- spec/rails_helper.rb
+- spec/spec_helper.rb
+- spec/support/apps/rails5_0.rb
+- spec/support/apps/rails5_1.rb
+- spec/support/model_spawner.rb
+- spec/version_record/finder_spec.rb
+- spec/version_record/macros/versioned_spec.rb
+- spec/version_record/prerelease_spec.rb
+- spec/version_record/sorting/simple_spec.rb
+- spec/version_record/string_spec.rb
+- spec/version_record/type/version_spec.rb
+- spec/version_record/version_spec.rb
 homepage: https://github.com/cedarcode/version_record
 licenses:
 - MIT
@@ -55,5 +173,17 @@ rubyforge_project:
 rubygems_version: 2.6.10
 signing_key: 
 specification_version: 4
-summary: Tools for managing versioned records in ActiveRecord
-test_files: []
+summary: Semantic version management for database records using ActiveRecord
+test_files:
+- spec/rails_helper.rb
+- spec/spec_helper.rb
+- spec/support/apps/rails5_0.rb
+- spec/support/apps/rails5_1.rb
+- spec/support/model_spawner.rb
+- spec/version_record/finder_spec.rb
+- spec/version_record/macros/versioned_spec.rb
+- spec/version_record/prerelease_spec.rb
+- spec/version_record/sorting/simple_spec.rb
+- spec/version_record/string_spec.rb
+- spec/version_record/type/version_spec.rb
+- spec/version_record/version_spec.rb