version_compare 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0ffcd0d56b6b7f030f3021bae075a475cf8c5073
+  data.tar.gz: 8be8c9d13a5ebc97be66ee2b3841259ea3655761
+SHA512:
+  metadata.gz: 7daa0dd6f3c4ea8917ef54cfcd46152f6e85ecd97157c7c471c5f03e1a1e7386f0c7d5563b3ca880370ee19ab49c969eb03ac2623624846635baab6a3739722a
+  data.tar.gz: 31bc14355f927875899dc7ac3070622e75344e81408fe609c91bf8aa7564d194a796b7fd4a38e7bfa152485e4f62cb8c2696fcd9416ab8458d2f22fe886a1514

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 Paul Dobbins
+
+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,145 @@
+# Version Compare
+
+[![Gem Version](https://badge.fury.io/rb/version_compare.png)](http://badge.fury.io/rb/version_compare)
+
+Version Compare allows you to easily compare if one Version is >, >=, ==, !=, <,
+or <= to another Version. It aims to be as light and flexible as possible. Inputs
+can be a String, Integer, Float, Array, or any object that defines `#to_version`
+to return one of the aforementioned types.
+
+In an effort to remain simple, Version Compare only works with up to four
+numeric values separated by periods:
+
+```ruby
+"<major>.<minor>.<tiny>.<patch>"
+```
+
+## Compatibility
+
+Tested with:
+
+* Ruby: MRI 1.9.3
+* Ruby: MRI 2.0.0 +
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "version_compare"
+```
+
+And then execute:
+
+```ruby
+bundle
+```
+
+## Usage
+
+To get started, you can either use `Version.new(<value>)` or `Version(<value>)`.
+To get the latter to work, you'll need to call `include ::Conversions` in the
+class or context you're wanting to use it at.
+
+```ruby
+class MyClass
+  include Conversions
+
+  def my_method
+    Version(1) > Version(2)
+  end
+end
+```
+
+Or, to test on the Rails Console:
+
+```ruby
+[1] pry(main)> include ::Conversions
+=> Object
+[2] pry(main)> Version(1.0) > Version(1)
+=> false
+
+# - OR (without using `include`) -
+
+[1] pry(main)> Conversions.Version(1.0) > Conversions.Version(1)
+=> false
+```
+
+Version Compare uses the `Comparable` mixin for comparisons, so you get all the
+usual operators:
+
+```ruby
+Version(2) > Version(1) # => true
+Version(1.2) > Version(1.2) # => false
+Version("1.2.3") >= Version("1.2") # => true
+Version("1.2.3.4") <= Version("1.2.3.4") # => true
+Version([1, 2]) == Version(["1", "2"]) # => true
+Version("1.2.0.0") == Version(1.2) # => true
+Version("1.0.0.0") != Version(1) # => false
+```
+
+### Wait, so what exactly is this `Version` ... constant?
+
+`Version()` is actually a conversion function. It follows the Ruby convention of
+defining a conversion function that uses the same name as the class it
+represents, such as how `Array()` converts inputs to an `Array` object.
+Just like the standard Ruby conversion functions, `Version()` tries its hardest
+to convert any Version-like input into a new `Version` object. Given a numeric,
+string, or array input (which are all obvious conversions to make), `Version()`
+is essentially the same as `Version.new()`. However, `Version()` is otherwise a
+little more strict in that if you pass in an object that doesn't reasonably look
+like a Version it will raise a `TypeError` exception. Doing the same for
+`Version.new()` will ultimately just `#to_s` the input; and since almost
+every object responds to `#to_s`, the result is that you may end up with a 0
+version. For example:
+
+```ruby
+Version.new(OpenStruct.new(a: 1)).to_s # => "0"
+```
+
+### Can I pass my own custom objects into `Version()`?
+
+Yes! All you have to do is define a `#to_version` implicit conversion method in
+your object. Just have it return either a String, an Integer, a Float, or an
+Array.
+
+```ruby
+class MyObject
+  VERSION = 1.9
+  def to_version
+    Version.new(VERSION.to_s)
+  end
+end
+
+Version(MyObject.new) > Version(2.0) # => false
+```
+
+### Why do you seem to excited about the custom object thing?
+
+Because, it opens up the world! Here's an example:
+
+```ruby
+# Given a Rails app:
+
+# /config/application.rb
+module Dummy
+  class Application < Rails::Application
+    # ...
+
+    VERSION = "1.2".freeze
+
+    def to_version
+      Version.new(VERSION) # Or Version.new([1, 2]) or whatever...
+    end
+  end
+end
+
+# Now, from the context of that Rails app you can call:
+Version(Rails.application) > Version(1.0) # => true
+```
+
+So you see, the sky is the limit...
+
+## Author
+
+- Paul Dobbins

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'VersionCompare'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/version_compare.rb

@@ -0,0 +1,5 @@
+require "version_compare/conversions"
+
+module VersionCompare
+  autoload :Version, "version_compare/version"
+end

data/lib/version_compare/conversions.rb

@@ -0,0 +1,36 @@
+# Conversions is meant to be a common module used to define standard conversion
+# methods. Anytime one of the standard conversion methods are needed, the
+# Conversions module can be included and then used freely.
+#
+module Conversions
+  require_relative "version"
+
+  # The `Version()` conversion method is defined as a module_function so that it
+  # may also be called directly without needing to include the Conversions module
+  # if so desired.
+  # @example
+  #   Conversions.Version(1.2).to_s # => "1.2"
+  module_function
+
+  # Strict conversion method for creating a `Version` object out of anything
+  # that sensibly is a Version.
+  # @param [Object] value the object to be converted
+  # @example
+  #   Version(1) # => #<Version:0x007fd8144ea658 @major=1, @minor=nil, @tiny=nil, @patch=nil>
+  #   Version(1.2) # => #<Version:0x007fd8144ea658 @major=1, @minor=2, @tiny=nil, @patch=nil>
+  #   Version("1.2.3") # => #<Version:0x007fd8144ea658 @major=1, @minor=2, @tiny=3, @patch=nil>
+  #   Version(["1", "2", "3", "4"]) # => #<Version:0x007fd8144f98b0 @major=1, @minor=2, @tiny=3, @patch=4>
+  def Version(value)
+    case value
+    when String,
+         Integer,
+         Float,
+         -> val { val.respond_to?(:to_ary) }
+      Version.new(value)
+    when -> val { val.respond_to?(:to_version) }
+      value.to_version
+    else
+      raise TypeError, "Cannot convert #{value.inspect} to Version"
+    end
+  end
+end

data/lib/version_compare/version.rb

@@ -0,0 +1,56 @@
+class Version
+  include Comparable
+
+  # Version component names
+  NAMES = [:major, :minor, :tiny, :patch].freeze
+
+  attr_accessor *NAMES
+
+  def initialize(value)
+    @major, @minor, @tiny, @patch = begin
+      if value.respond_to?(:to_ary)
+        value.to_ary.map(&:to_i)
+      elsif value.respond_to?(:to_version)
+        value.to_version.to_a
+      else
+        value.to_s.split('.').map(&:to_i)
+      end
+    end
+  end
+
+  # Implicit conversion method
+  def to_version
+    self
+  end
+
+  def to_s
+    [major, minor, tiny, patch].compact.join('.')
+  end
+  alias :to_str :to_s
+
+  def to_f
+    to_s.to_f
+  end
+
+  def to_a
+    NAMES.map { |name| send(name) }.compact
+  end
+  alias :to_ary :to_a
+
+  # Version components comparison method. Uses Comparable to assess whether
+  # This Version's component value or the other Version's component value is
+  # greater or lesser. The first value to be found as greater or lesser
+  # determines which Version object is greater or lesser.
+  #
+  # Missing Version components are treated as 0 values, which effectively gives
+  # them no weight in the comparison.
+  #
+  # @params [Version] other the other Version object we are comparing with
+  def <=>(other)
+    NAMES.each do |name|
+      result = send(name).to_i <=> other.send(name).to_i
+      return result unless result.zero?
+    end
+    0
+  end
+end

data/test/conversions_test.rb

@@ -0,0 +1,101 @@
+require 'test_helper'
+
+describe Conversions do
+  describe "conversion function" do
+    it "works on integers" do
+      assert { Version(1).class == Version }
+    end
+
+    it "works on floats" do
+      assert { Version(1.2).class == Version }
+    end
+
+    it "works on strings" do
+      assert { Version("1.2.3.4").class == Version }
+    end
+
+    it "works on arrays" do
+      assert { Version([1, 2, 3, 4]).instance_of?(Version) }
+      assert { Version([1, 2, 3, 4]) == Version("1.2.3.4") }
+      assert { Version(["1", "2", "3", "4"]) == Version("1.2.3.4") }
+    end
+
+    it "works on Versions" do
+      assert { Version(Version(1.2)).instance_of?(Version) }
+      assert { Version(Version(1.2)) == Version(1.2) }
+    end
+  end
+
+  describe "explicit conversions" do
+    describe "#to_s" do
+      it "returns string regardless of input" do
+        assert { Version(1).to_s == "1" }
+        assert { Version(1.2).to_s == "1.2" }
+        assert { Version("1.2.3").to_s == "1.2.3" }
+      end
+    end
+
+    describe "#to_f" do
+      it "returns float when major only" do
+        assert { Version(1).to_f == 1.0 }
+      end
+
+      it "returns float when major and minor" do
+        assert { Version(1.0).to_f == 1.0 }
+        assert { Version(1.2).to_f == 1.2 }
+      end
+
+      it "returns truncated float when more than just major and minor" do
+        assert { Version("1.0.0").to_f == 1.0 }
+        assert { Version("1.1.9").to_f == 1.1 }
+        assert { Version("1.0.0.0").to_f == 1.0 }
+        assert { Version("1.1.9.9").to_f == 1.1 }
+      end
+    end
+
+    describe "#to_a" do
+      it "returns an array of integers" do
+        assert { Version(1).to_a == [1] }
+        assert { Version(1.0).to_a == [1, 0] }
+        assert { Version("1.2.3").to_a == [1, 2, 3] }
+        assert { Version("1.2.3.4").to_a == [1, 2, 3, 4] }
+        assert { Version(["1", "2", "3", "4"]).to_a == [1, 2, 3, 4] }
+      end
+    end
+  end
+
+  describe "implicit conversions" do
+    describe "string concatination" do
+      it "concatinates" do
+        assert { ("version: " + Version("1.2.3.4")) == "version: 1.2.3.4" }
+      end
+    end
+
+    describe "CustomObjects" do
+      describe "without #to_version" do
+        it "raises TypeError when attempting to convert custom objects that don't implement #to_version" do
+          assert { rescuing { Version(Object.new) }.instance_of?(TypeError) }
+          deny { rescuing { Version.new(Object.new) }.is_a?(StandardError) }
+        end
+      end
+
+      describe "with #to_version" do
+        before do
+          class CustomObject < Object
+            VERSION = 1.9
+            def to_version
+              Version.new(VERSION.to_s)
+            end
+          end
+
+          @obj = CustomObject.new
+        end
+
+        it "returns a Version object" do
+          assert { Version(@obj).instance_of?(Version) }
+          assert { Version.new(@obj).instance_of?(Version) }
+        end
+      end
+    end
+  end
+end

data/test/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.

data/test/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks