greater_less 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1 @@
+language: ruby

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development, :test do
+  gem 'rspec'
+  gem 'shoulda'
+  gem 'rdoc'
+  gem 'bundler'
+  gem 'jeweler'
+  gem "spork"
+end
+
+gem 'simplecov', :require => false, :group => :test

data/Gemfile.lock

@@ -0,0 +1,45 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    jeweler (1.8.3)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.6.5)
+    multi_json (1.2.0)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    shoulda (3.0.1)
+      shoulda-context (~> 1.0.0)
+      shoulda-matchers (~> 1.0.0)
+    shoulda-context (1.0.0)
+    shoulda-matchers (1.0.0)
+    simplecov (0.6.1)
+      multi_json (~> 1.0)
+      simplecov-html (~> 0.5.3)
+    simplecov-html (0.5.3)
+    spork (0.8.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  jeweler
+  rdoc
+  rspec
+  shoulda
+  simplecov
+  spork

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Samuel Esposito
+
+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.rdoc

@@ -0,0 +1,103 @@
+= greater_less
+
+The GreaterLess class can be used to generate objects that represent
+halfopen intervals, but transparently behave as Floats. One easy way to
+integrate this class into your project is by requiring the greater_less
+string extension as follows:
+
+ require 'greater_less/string_extension'
+
+This extension redifines the +#to_f+ method of the String class as follows:
+
+ class String
+   alias :to_f_without_greater_less :to_f
+
+   def to_f
+     if self =~ GreaterLess::GREATER_LESS
+       return GreaterLess.new(self)
+     end
+     self.to_f_without_greater_less
+   end
+ end
+
+Now when a string starts with a greater or less sign (like for instance
+<tt>"> 3.45"</tt>), the +#to_f+ method converts it to a GreaterLess object
+instead of the value +0.0+.
+
+With this extension in place one can simply convert strings like the one
+above to a float like object and compare it to floats as if it were a
+float itself. For instance one can do the following:
+
+ >> value = ">3.45".to_f
+ => > 3.45
+ >> value > 2.45
+ => true
+ >> value >= 2.45
+ => true
+ >> 2.45 > value
+ => false
+ >> 2.45 >= value
+ => false
+ >> value == ">3.45".to_f
+ => true
+ >> value != 2.45
+ => true
+
+It is also possible to compare GreaterLess values with each other, so you
+do not have to worry about what kind of object you are dealing with in your
+code:
+
+ >> value1 = ">3.45".to_f
+ => > 3.45
+ >> value2 = "< 2.45".to_f
+ => < 2.45
+ >> value1 > value2
+ => true
+ >> value2 > value1
+ => false
+
+Finally it is possible to apply simple arithmetics to GreaterLess objects
+like addition, subtraction, multiplication and division:
+
+ >> value = ">3.45".to_f
+ => > 3.45
+ >> value + 2
+ => > 5.45
+ >> value - 2
+ => > 1.4500000000000002
+ >> value * 2
+ => > 1.725
+
+Inverting the object's sign when multiplying with a negative numerical
+or using a GreaterLess object in the denominator is nicely dealt with:
+
+ >> value = ">3.45".to_f
+ => > 3.45
+ >> -1 * value
+ => < -3.45
+ >> 1 / value
+ => < 0.2898550724637681
+ >> -1 / value
+ => > -0.2898550724637681
+
+It makes no sense to apply the operators +, -, * or / on a pair of GreaterLess
+objects, so an exception is raised in these cases.
+
+All other methods are simply passed to the float value the GreaterLess
+object contains, so that it transparently acts like a float.
+
+== Contributing to greater_less
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2012 Samuel Esposito. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "greater_less"
+  gem.homepage = "http://github.com/esposito/greater_less"
+  gem.license = "MIT"
+  gem.summary = %Q{Gem for handling floating point half-open intervals}
+  gem.description = %Q{The GreaterLess Gem allows for making comparisons between floats and half-open intervals and apply simple arithmetics to the intervals preserving their mathematical meaning.}
+  gem.email = "s.esposito@roqua.nl"
+  gem.authors = ["Samuel Esposito"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+# RSpec::Core::RakeTask.new(:rcov) do |spec|
+#   spec.pattern = 'spec/**/*_spec.rb'
+#   spec.rcov = true
+# end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "greater_less #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/greater_less.rb

@@ -0,0 +1,244 @@
+# The GreaterLess class can be used to generate objects that represent
+# halfopen intervals, but transparently behave as Floats. One easy way to
+# integrate this class into your project is by requiring the greater_less
+# string extension as follows:
+#
+#  require 'greater_less/string_extension'
+#
+# This extension redifines the +#to_f+ method of the String class as follows:
+#
+#  class String
+#    alias :to_f_without_greater_less :to_f
+#
+#    def to_f
+#      if self =~ GreaterLess::GREATER_LESS
+#        return GreaterLess.new(self)
+#      end
+#      self.to_f_without_greater_less
+#    end
+#  end
+#
+# Now when a string starts with a greater or less sign (like for instance
+# <tt>"> 3.45"</tt>), the +#to_f+ method converts it to a GreaterLess object
+# instead of the value +0.0+.
+#
+# With this extension in place one can simply convert strings like the one
+# above to a float like object and compare it to floats as if it were a
+# float itself. For instance one can do the following:
+#
+#  >> value = ">3.45".to_f
+#  => > 3.45
+#  >> value > 2.45
+#  => true
+#  >> value >= 2.45
+#  => true
+#  >> 2.45 > value
+#  => false
+#  >> 2.45 >= value
+#  => false
+#  >> value == ">3.45".to_f
+#  => true
+#  >> value != 2.45
+#  => true
+#
+# It is also possible to compare GreaterLess values with each other, so you
+# do not have to worry about what kind of object you are dealing with in your
+# code:
+#
+#  >> value1 = ">3.45".to_f
+#  => > 3.45
+#  >> value2 = "< 2.45".to_f
+#  => < 2.45
+#  >> value1 > value2
+#  => true
+#  >> value2 > value1
+#  => false
+#
+# Finally it is possible to apply simple arithmetics to GreaterLess objects
+# like addition, subtraction, multiplication and division:
+#
+#  >> value = ">3.45".to_f
+#  => > 3.45
+#  >> value + 2
+#  => > 5.45
+#  >> value - 2
+#  => > 1.4500000000000002
+#  >> value * 2
+#  => > 1.725
+#
+# Inverting the object's sign when multiplying with a negative numerical
+# or using a GreaterLess object in the denominator is nicely dealt with:
+#
+#  >> value = ">3.45".to_f
+#  => > 3.45
+#  >> -1 * value
+#  => < -3.45
+#  >> 1 / value
+#  => < 0.2898550724637681
+#  >> -1 / value
+#  => > -0.2898550724637681
+#
+# It makes no sense to apply the operators +, -, * or / on a pair of GreaterLess
+# objects, so an exception is raised in these cases.
+#
+# All other methods are simply passed to the float value the GreaterLess
+# object contains, so that it transparently acts like a float.
+#
+
+class GreaterLess
+  instance_methods.each do |meth|
+    # skipping undef of methods that "may cause serious problems"
+    undef_method(meth) if meth !~ /^(__|object_id|class)/
+  end
+
+  GREATER_LESS = /^[<>] ?/
+
+  #:nodoc:
+  class << self
+    alias :old_new :new
+
+    def new(content, coerce=false)
+      if coerce or content =~ GREATER_LESS
+        old_new(content)
+      else
+        content.to_f
+      end
+    end
+  end
+
+  def initialize(content)
+    if content.is_a? String
+      if content =~ /^>/
+        @sign = ">"
+      elsif content =~ /^</
+        @sign = "<"
+      end
+      @float = content.gsub(/^[<>] ?/, "").to_f
+    elsif content.is_a? Numeric
+      @float = content.to_f
+    else
+      raise "Can't handle #{content.class}!"
+    end
+  end
+
+  def coerce(object)
+    if object.is_a? Numeric and not object.is_a? self.class
+      [GreaterLess.new(object, true), self]
+    else
+      raise "Can't handle #{object.class}!"
+    end
+  end
+
+  def sign
+    @sign
+  end
+
+  def inverted_sign
+    case @sign
+    when ">"
+      "<"
+    when "<"
+      ">"
+    end
+  end
+
+  def value
+    @float
+  end
+
+  #:doc:
+  def ==(numerical)
+    if numerical.is_a? self.class
+      @sign == numerical.sign and @float == numerical.value
+    else
+      false
+    end
+  end
+
+  def >(numerical)
+    if numerical.is_a? self.class
+      @float >= numerical.value and [nil, ">"].include? @sign and [nil, "<"].include? numerical.sign
+    else
+      @float >= numerical and @sign == ">"
+    end
+  end
+
+  def <(numerical)
+    numerical > self
+  end
+
+  def !=(numerical)
+    not self == numerical
+  end
+
+  def >=(numerical)
+    self == numerical or self > numerical
+  end
+
+  def <=(numerical)
+    self == numerical or self < numerical
+  end
+
+  def *(numerical)
+    value, sign = if numerical.is_a? self.class
+      raise "Can't handle #{self.class}!" if @sign
+      [@float * numerical.value, @float > 0 ? numerical.sign : numerical.inverted_sign]
+    else
+      [@float * numerical, numerical > 0 ? @sign : inverted_sign]
+    end
+    GreaterLess.new("#{sign} #{value}")
+  end
+
+  def /(numerical)
+    value, sign = if numerical.is_a? self.class
+      raise "Can't handle #{self.class}!" if @sign
+      [@float / numerical.value, @float > 0 ? numerical.inverted_sign : numerical.sign]
+    else
+      [@float / numerical, numerical > 0 ? @sign : inverted_sign]
+    end
+    GreaterLess.new("#{sign} #{value}")
+  end
+
+  def +(numerical)
+    value, sign = if numerical.is_a? self.class
+      raise "Can't handle #{self.class}!" if @sign
+      [@float + numerical.value, numerical.sign]
+    else
+      [@float + numerical, @sign]
+    end
+    GreaterLess.new("#{sign} #{value}")
+  end
+
+  def -(numerical)
+    self + -numerical
+  end
+
+  def -@
+    GreaterLess.new("#{inverted_sign} -#{value}")
+  end
+
+  #:nodoc:
+  def to_f
+    self
+  end
+
+  def to_s
+    "#{@sign} #{@float}"
+  end
+
+  def inspect
+    self.to_s
+  end
+
+  def is_a?(klass)
+    if klass == self.class
+      true
+    else
+      @float.is_a? klass
+    end
+  end
+
+  def method_missing(*args)
+    @float.send(*args)
+  end
+end

data/lib/greater_less/string_extension.rb

@@ -0,0 +1,10 @@
+class String
+  alias :to_f_without_greater_less :to_f
+
+  def to_f
+    if self =~ GreaterLess::GREATER_LESS
+      return GreaterLess.new(self)
+    end
+    self.to_f_without_greater_less
+  end
+end

data/spec/greater_less_spec.rb

@@ -0,0 +1,284 @@
+require 'spec_helper'
+
+describe GreaterLess do
+
+  context "when the object is initialized with a string" do
+    context "and the string starts with a greater than sign" do
+      subject { GreaterLess.new("> 4.5") }
+
+      it "should differ from its float value" do
+        (subject == 4.5).should be_false
+        (subject != 4.5).should be_true
+        (4.5 == subject).should be_false
+        (4.5 != subject).should be_true
+      end
+
+      it "should be greater than its float value" do
+        (subject >  4.5).should be_true
+        (subject >= 4.5).should be_true
+        (4.5 <  subject).should be_true
+        (4.5 <= subject).should be_true
+      end
+
+      it "should be greater than any value that is less than its float value" do
+        (subject >  4.49).should be_true
+        (subject >= 4.49).should be_true
+        (4.49 <  subject).should be_true
+        (4.49 <= subject).should be_true
+      end
+
+      it "should not be greater than a value greater than its float value" do
+        (subject >  4.51).should be_false
+        (subject >= 4.51).should be_false
+        (4.51 <  subject).should be_false
+        (4.51 <= subject).should be_false
+      end
+
+      it "should not be less than a value that is greater than its float value" do
+        (subject <  4.51).should be_false
+        (subject <= 4.51).should be_false
+        (4.51 >  subject).should be_false
+        (4.51 >= subject).should be_false
+      end
+
+      it "should be greater than a GreaterLess object that has a smaller or equal value and a less sign" do
+        (subject > GreaterLess.new("< 4.49")).should be_true
+        (subject > GreaterLess.new("< 4.5") ).should be_true
+      end
+
+      it "should not be greater than a GreaterLess object that has a bigger value or a greater sign" do
+        (subject > GreaterLess.new("< 4.51")).should be_false
+        (subject > GreaterLess.new("> 4.49")).should be_false
+      end
+    end
+
+    context "and the string starts with a less than sign" do
+      subject { GreaterLess.new("<4.5") }
+
+      it "should differ from its float value" do
+        (subject == 4.5).should be_false
+        (subject != 4.5).should be_true
+        (4.5 == subject).should be_false
+        (4.5 != subject).should be_true
+      end
+
+      it "should be less than its float value" do
+        (subject <  4.5).should be_true
+        (subject <= 4.5).should be_true
+        (4.5 >  subject).should be_true
+        (4.5 >= subject).should be_true
+      end
+
+      it "should be less than any value that is greater than its float value" do
+        (subject <  4.51).should be_true
+        (subject <= 4.51).should be_true
+        (4.51 >  subject).should be_true
+        (4.51 >= subject).should be_true
+      end
+
+      it "should not be less than a value less than its float value" do
+        (subject <  4.49).should be_false
+        (subject <= 4.49).should be_false
+        (4.49 >  subject).should be_false
+        (4.49 >= subject).should be_false
+      end
+
+      it "should not be greater than a value that is less than its float value" do
+        (subject >  4.49).should be_false
+        (subject >= 4.49).should be_false
+        (4.49 <  subject).should be_false
+        (4.49 <= subject).should be_false
+      end
+    end
+
+    context "and the string contains no sign" do
+      subject { GreaterLess.new("4.5") }
+
+      it "should be a float" do
+        subject.class.should == Float
+      end
+    end
+  end
+
+  describe ".initialize" do
+    context "when it receives something different from a string or a numeric" do
+      it "should raise an exception" do
+        expect { GreaterLess.new(Object.new, true) }.to raise_error
+      end
+    end
+  end
+
+  context "when the object is initialized with a string containing a sign" do
+    subject { GreaterLess.new(">4.5") }
+
+    it "should be a float" do
+      subject.should be_a(Float)
+    end
+
+    it "should equal itself" do
+      (subject == subject).should be_true
+    end
+
+    describe "#coerce" do
+      it "should raise an exception if it is called on a GreaterLess object" do
+        expect { subject.coerce(GreaterLess.new("<2.45")) }.to raise_error
+      end
+    end
+
+    describe "#inverted_sign" do
+      it "should return a less sign when the object's sign is a greater sign" do
+        GreaterLess.new("> 1").inverted_sign.should eq("<")
+      end
+
+      it "should return a greater sign when the object's sign is a less sign" do
+        GreaterLess.new("< 1").inverted_sign.should eq(">")
+      end
+    end
+
+    describe "#*" do
+      it "should return a GreaterLess object" do
+        (subject * 4).class.should == GreaterLess
+        (4 * subject).class.should == GreaterLess
+      end
+
+      it "should carry out multiplication on its float value" do
+        (subject * 4).value.should == 18
+        (4 * subject).value.should == 18
+      end
+
+      it "should retain the object's sign when the argument is a positive numeric" do
+        (subject * 4).sign.should == subject.sign
+        (4 * subject).sign.should == subject.sign
+      end
+
+      it "should invert the object's sign when the argument is a negative numeric" do
+        (subject * -4).sign.should == subject.inverted_sign
+        (-4 * subject).sign.should == subject.inverted_sign
+      end
+
+      it "should raise an exception when the argument is a GreaterLess object" do
+        expect { subject * GreaterLess.new("<1.2") }.to raise_error
+      end
+    end
+
+    describe "#/" do
+      it "should return a GreaterLess object" do
+        (subject / 4).class.should == GreaterLess
+        (4 / subject).class.should == GreaterLess
+      end
+
+      it "should carry out division on its float value" do
+        (subject / 4).value.should == 4.5 / 4
+        (4 / subject).value.should == 4 / 4.5
+      end
+
+      it "should retain the object's sign when the denominator is a positive numeric" do
+        (subject / 4).sign.should == subject.sign
+      end
+
+      it "should retain the object's sign when the numerator is a negative numeric" do
+        (-4 / subject).sign.should == subject.sign
+      end
+
+      it "should invert the object's sign when the object itself is the denominator" do
+        (4 / subject).sign.should == subject.inverted_sign
+      end
+
+      it "should invert the object's sign when the denominator is a negative numeric" do
+        (subject / -4).sign.should == subject.inverted_sign
+      end
+
+      it "should raise an exception when the argument is a GreaterLess object" do
+        expect { subject / GreaterLess.new("<1.2") }.to raise_error
+      end
+    end
+
+    describe "#+" do
+      it "should return a GreaterLess object" do
+        (subject + 4).class.should == GreaterLess
+        (4 + subject).class.should == GreaterLess
+      end
+
+      it "should carry out addition on its float value" do
+        (subject + 4).value.should == 8.5
+        (4 + subject).value.should == 8.5
+      end
+
+      it "should retain the object's sign" do
+        (subject + 4).sign.should == subject.sign
+        (4 + subject).sign.should == subject.sign
+      end
+
+      it "should raise an exception when the argument is a GreaterLess object" do
+        expect { subject + GreaterLess.new("<1.2") }.to raise_error
+      end
+    end
+
+    describe "#-" do
+      it "should return a GreaterLess object" do
+        (subject - 4).class.should == GreaterLess
+        (4 - subject).class.should == GreaterLess
+      end
+
+      it "should carry out subtraction on its float value" do
+        (subject - 4).value.should == 0.5
+        (4 - subject).value.should == -0.5
+      end
+
+      it "should retain the object's sign when a numerical is subtracted from it" do
+        (subject - 4).sign.should == subject.sign
+      end
+
+      it "should invert the object's sign when it is subtracted form a numerical" do
+        (4 - subject).sign.should == subject.inverted_sign
+      end
+
+      it "should raise an exception when the argument is a GreaterLess object" do
+        expect { subject - GreaterLess.new("<1.2") }.to raise_error
+      end
+    end
+
+    describe "#-@" do
+      it "should return a GreaterLess object" do
+        (-subject).class.should == GreaterLess
+      end
+
+      it "should negate the object's value" do
+        (-subject).value.should == -subject.value
+      end
+
+      it "should invert the object's sign" do
+        (-subject).sign.should == subject.inverted_sign
+      end
+    end
+
+    describe "#to_f" do
+      it "should return the object itself" do
+        subject.to_f.class.should == GreaterLess
+      end
+    end
+
+    describe "#to_s" do
+      it "should include this sign" do
+        subject.to_s.should == "> 4.5"
+      end
+    end
+
+    describe "#inspect" do
+      it "should include this sign" do
+        subject.inspect.should == "> 4.5"
+      end
+    end
+
+    describe "#is_a?" do
+      it "should acknowledge the GreaterLess class" do
+        subject.is_a?(GreaterLess).should be_true
+      end
+
+      it "should acknowledge the Float class" do
+        subject.is_a?(Float).should be_true
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+if ENV['COVERAGE']
+  require 'simplecov'
+  SimpleCov.start
+end
+
+# --- Instructions ---
+# - Sort through your spec_helper file. Place as much environment loading
+#   code that you don't normally modify during development in the
+#   Spork.prefork block.
+# - Place the rest under Spork.each_run block
+# - Any code that is left outside of the blocks will be ran during preforking
+#   and during each_run!
+# - These instructions should self-destruct in 10 seconds.  If they don't,
+#   feel free to delete them.
+#
+
+
+
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'greater_less'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+
+end

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: greater_less
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Samuel Esposito
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: spork
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: The GreaterLess Gem allows for making comparisons between floats and
+  half-open intervals and apply simple arithmetics to the intervals preserving their
+  mathematical meaning.
+email: s.esposito@roqua.nl
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .rspec
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/greater_less.rb
+- lib/greater_less/string_extension.rb
+- spec/greater_less_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/esposito/greater_less
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1315675163151725512
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: Gem for handling floating point half-open intervals
+test_files: []